added channels_last option for pytorch in mdl dataloader, added padding to classifier, added seed for reproducibility

Author: lavaman131

lab2/solutions/PT_Part2_Debiasing_Solution.ipynb

@@ -10,51 +10,63 @@
 
 cwd = os.path.dirname(__file__)
 
+
 def load_training_data():
     with open(os.path.join(cwd, "data", "irish.abc"), "r") as f:
         text = f.read()
     songs = extract_song_snippet(text)
     return songs
 
+
 def extract_song_snippet(text):
-    pattern = '(^|\n\n)(.*?)\n\n'
+    pattern = "(^|\n\n)(.*?)\n\n"
     search_results = re.findall(pattern, text, overlapped=True, flags=re.DOTALL)
     songs = [song[1] for song in search_results]
     print("Found {} songs in text".format(len(songs)))
     return songs
 
+
 def save_song_to_abc(song, filename="tmp"):
     save_name = "{}.abc".format(filename)
     with open(save_name, "w") as f:
         f.write(song)
     return filename
 
+
 def abc2wav(abc_file):
-    path_to_tool = os.path.join(cwd, 'bin', 'abc2wav')
+    path_to_tool = os.path.join(cwd, "bin", "abc2wav")
     cmd = "{} {}".format(path_to_tool, abc_file)
     return os.system(cmd)
 
+
 def play_wav(wav_file):
     return Audio(wav_file)
 
+
 def play_song(song):
     basename = save_song_to_abc(song)
-    ret = abc2wav(basename+'.abc')
-    if ret == 0: #did not suceed
-        return play_wav(basename+'.wav')
+    ret = abc2wav(basename + ".abc")
+    if ret == 0:  # did not suceed
+        return play_wav(basename + ".wav")
     return None
 
+
 def play_generated_song(generated_text):
     songs = extract_song_snippet(generated_text)
     if len(songs) == 0:
-        print("No valid songs found in generated text. Try training the \
+        print(
+            "No valid songs found in generated text. Try training the \
             model longer or increasing the amount of generated music to \
-            ensure complete songs are generated!")
+            ensure complete songs are generated!"
+        )
 
     for song in songs:
         play_song(song)
-    print("None of the songs were valid, try training longer to improve \
-        syntax.")
+    print(
+        "None of the songs were valid, try training longer to improve \
+        syntax."
+    )
+
 
 def test_batch_func_types(func, args):
     ret = func(*args)
@@ -64,25 +76,50 @@ def test_batch_func_types(func, args):
     print("[PASS] test_batch_func_types")
     return True
 
+
 def test_batch_func_shapes(func, args):
     dataset, seq_length, batch_size = args
     x, y = func(*args)
     correct = (batch_size, seq_length)
-    assert x.shape == correct, "[FAIL] test_batch_func_shapes: x {} is not correct shape {}".format(x.shape, correct)
-    assert y.shape == correct, "[FAIL] test_batch_func_shapes: y {} is not correct shape {}".format(y.shape, correct)
+    assert (
+        x.shape == correct
+    ), "[FAIL] test_batch_func_shapes: x {} is not correct shape {}".format(
+        x.shape, correct
+    )
+    assert (
+        y.shape == correct
+    ), "[FAIL] test_batch_func_shapes: y {} is not correct shape {}".format(
+        y.shape, correct
+    )
     print("[PASS] test_batch_func_shapes")
     return True
 
+
 def test_batch_func_next_step(func, args):
     x, y = func(*args)
-    assert (x[:,1:] == y[:,:-1]).all(), "[FAIL] test_batch_func_next_step: x_{t} must equal y_{t-1} for all t"
+    assert (
+        x[:, 1:] == y[:, :-1]
+    ).all(), "[FAIL] test_batch_func_next_step: x_{t} must equal y_{t-1} for all t"
     print("[PASS] test_batch_func_next_step")
     return True
 
+
 def test_custom_dense_layer_output(y):
     # define the ground truth value for the array
-    true_y = np.array([[0.27064407,  0.1826951,  0.50374055]],dtype='float32')
-    assert tf.shape(y).numpy().tolist() == list(true_y.shape), "[FAIL] output is of incorrect shape. expected {} but got {}".format(true_y.shape, y.numpy().shape)
-    np.testing.assert_almost_equal(y.numpy(), true_y, decimal=7, err_msg="[FAIL] output is of incorrect value. expected {} but got {}".format(true_y, y.numpy()), verbose=True)
+    true_y = np.array([[0.27064407, 0.1826951, 0.50374055]], dtype="float32")
+    assert tf.shape(y).numpy().tolist() == list(
+        true_y.shape
+    ), "[FAIL] output is of incorrect shape. expected {} but got {}".format(
+        true_y.shape, y.numpy().shape
+    )
+    np.testing.assert_almost_equal(
+        y.numpy(),
+        true_y,
+        decimal=7,
+        err_msg="[FAIL] output is of incorrect value. expected {} but got {}".format(
+            true_y, y.numpy()
+        ),
+        verbose=True,
+    )
     print("[PASS] test_custom_dense_layer_output")
     return True

mitdeeplearning/lab1.py

@@ -10,98 +10,114 @@
 
 IM_SHAPE = (64, 64, 3)
 
+
 def plot_image_prediction(i, predictions_array, true_label, img):
-  predictions_array, true_label, img = predictions_array[i], true_label[i], img[i]
-  plt.grid(False)
-  plt.xticks([])
-  plt.yticks([])
+    predictions_array, true_label, img = predictions_array[i], true_label[i], img[i]
+    plt.grid(False)
+    plt.xticks([])
+    plt.yticks([])
+
+    plt.imshow(np.squeeze(img), cmap=plt.cm.binary)
 
-  plt.imshow(np.squeeze(img), cmap=plt.cm.binary)
+    predicted_label = np.argmax(predictions_array)
+    if predicted_label == true_label:
+        color = "blue"
+    else:
+        color = "red"
 
-  predicted_label = np.argmax(predictions_array)
-  if predicted_label == true_label:
-    color = 'blue'
-  else:
-    color = 'red'
+    plt.xlabel(
+        "{} {:2.0f}% ({})".format(
+            predicted_label, 100 * np.max(predictions_array), true_label
+        ),
+        color=color,
+    )
 
-  plt.xlabel("{} {:2.0f}% ({})".format(predicted_label,
-                                100*np.max(predictions_array),
-                                true_label),
-                                color=color)
 
 def plot_value_prediction(i, predictions_array, true_label):
-  predictions_array, true_label = predictions_array[i], true_label[i]
-  plt.grid(False)
-  plt.xticks([])
-  plt.yticks([])
-  thisplot = plt.bar(range(10), predictions_array, color="#777777")
-  plt.ylim([0, 1])
-  predicted_label = np.argmax(predictions_array)
+    predictions_array, true_label = predictions_array[i], true_label[i]
+    plt.grid(False)
+    plt.xticks([])
+    plt.yticks([])
+    thisplot = plt.bar(range(10), predictions_array, color="#777777")
+    plt.ylim([0, 1])
+    predicted_label = np.argmax(predictions_array)
 
-  thisplot[predicted_label].set_color('red')
-  thisplot[true_label].set_color('blue')
+    thisplot[predicted_label].set_color("red")
+    thisplot[true_label].set_color("blue")
 
 
 class TrainingDatasetLoader(object):
-    def __init__(self, data_path):
-
-        print ("Opening {}".format(data_path))
+    def __init__(self, data_path, channels_last=True):
+        print("Opening {}".format(data_path))
         sys.stdout.flush()
 
-        self.cache = h5py.File(data_path, 'r')
+        self.cache = h5py.File(data_path, "r")
 
-        print ("Loading data into memory...")
+        print("Loading data into memory...")
         sys.stdout.flush()
-        self.images = self.cache['images'][:]
-        self.labels = self.cache['labels'][:].astype(np.float32)
+        self.images = self.cache["images"][:]
+        self.channels_last = channels_last
+        self.labels = self.cache["labels"][:].astype(np.float32)
         self.image_dims = self.images.shape
         n_train_samples = self.image_dims[0]
 
         self.train_inds = np.random.permutation(np.arange(n_train_samples))
 
-        self.pos_train_inds = self.train_inds[ self.labels[self.train_inds, 0] == 1.0 ]
-        self.neg_train_inds = self.train_inds[ self.labels[self.train_inds, 0] != 1.0 ]
+        self.pos_train_inds = self.train_inds[self.labels[self.train_inds, 0] == 1.0]
+        self.neg_train_inds = self.train_inds[self.labels[self.train_inds, 0] != 1.0]
 
     def get_train_size(self):
         return self.train_inds.shape[0]
 
     def get_train_steps_per_epoch(self, batch_size, factor=10):
-        return self.get_train_size()//factor//batch_size
+        return self.get_train_size() // factor // batch_size
 
     def get_batch(self, n, only_faces=False, p_pos=None, p_neg=None, return_inds=False):
         if only_faces:
-            selected_inds = np.random.choice(self.pos_train_inds, size=n, replace=False, p=p_pos)
+            selected_inds = np.random.choice(
+                self.pos_train_inds, size=n, replace=False, p=p_pos
+            )
         else:
-            selected_pos_inds = np.random.choice(self.pos_train_inds, size=n//2, replace=False, p=p_pos)
-            selected_neg_inds = np.random.choice(self.neg_train_inds, size=n//2, replace=False, p=p_neg)
+            selected_pos_inds = np.random.choice(
+                self.pos_train_inds, size=n // 2, replace=False, p=p_pos
+            )
+            selected_neg_inds = np.random.choice(
+                self.neg_train_inds, size=n // 2, replace=False, p=p_neg
+            )
             selected_inds = np.concatenate((selected_pos_inds, selected_neg_inds))
 
         sorted_inds = np.sort(selected_inds)
-        train_img = (self.images[sorted_inds,:,:,::-1]/255.).astype(np.float32)
-        train_label = self.labels[sorted_inds,...]
-        return (train_img, train_label, sorted_inds) if return_inds else (train_img, train_label)
+        train_img = (self.images[sorted_inds, :, :, ::-1] / 255.0).astype(np.float32)
+        train_label = self.labels[sorted_inds, ...]
+
+        if not self.channels_last:
+            train_img = np.ascontiguousarray(
+                np.transpose(train_img, (0, 3, 1, 2))
+            )  # [B, H, W, C] -> [B, C, H, W]
+        return (
+            (train_img, train_label, sorted_inds)
+            if return_inds
+            else (train_img, train_label)
+        )
 
     def get_n_most_prob_faces(self, prob, n):
         idx = np.argsort(prob)[::-1]
-        most_prob_inds = self.pos_train_inds[idx[:10*n:10]]
-        return (self.images[most_prob_inds,...]/255.).astype(np.float32)
+        most_prob_inds = self.pos_train_inds[idx[: 10 * n : 10]]
+        return (self.images[most_prob_inds, ...] / 255.0).astype(np.float32)
 
     def get_all_train_faces(self):
-        return self.images[ self.pos_train_inds ]
+        return self.images[self.pos_train_inds]
 
 
-def get_test_faces():
+def get_test_faces(channels_last=True):
     cwd = os.path.dirname(__file__)
-    images = {
-        "LF": [],
-        "LM": [],
-        "DF": [],
-        "DM": []
-    }
+    images = {"LF": [], "LM": [], "DF": [], "DM": []}
     for key in images.keys():
         files = glob.glob(os.path.join(cwd, "data", "faces", key, "*.png"))
         for file in sorted(files):
-            image = cv2.resize(cv2.imread(file), (64,64))[:,:,::-1]/255.
+            image = cv2.resize(cv2.imread(file), (64, 64))[:, :, ::-1] / 255.0
+            if not channels_last:
+                image = np.transpose(image, (2, 0, 1))
             images[key].append(image)
 
     return images["LF"], images["LM"], images["DF"], images["DM"]

mitdeeplearning/lab2.py

@@ -48,7 +48,6 @@ def plot_value_prediction(i, predictions_array, true_label):
 
 class DatasetLoader(tf.keras.utils.Sequence):
     def __init__(self, data_path, batch_size, training=True):
-
         print("Opening {}".format(data_path))
         sys.stdout.flush()