updated eval.py to have correct signature for test

Author: rkargon

eval.py

@@ -12,34 +12,50 @@
     FROM_GAMES, DATASETS
 
 
-def test_model(sess, model, dataset_iter, color_map, output_dir):
+def test_model(sess, model, dataset_iter, use_patches=False, color_map=None, output_dir=None):
     total_accuracy = 0
     class_correct_counts = np.zeros(model.num_classes)
     class_total_counts = np.zeros(model.num_classes)
     i = 0
-    for image, labels in dataset_iter():
-        i += 1
+    for image, labels, img_id in dataset_iter():
         start_time = time.time()
         h, w, _ = image.shape
-
-        input_image = np.append(image, np.zeros(shape=[h, w, model.num_classes], dtype=np.float32), axis=2)
-        feed_dict = {model.inpt: [input_image], model.output: [labels]}
-        logits, error = sess.run([model.logits[1], model.loss], feed_dict=feed_dict)
-        predicted_labels = np.argmax(logits[0], axis=2)
-        true_labels = labels[::4, ::4]
-
-        correct_labels = np.equal(predicted_labels, true_labels)
-        accuracy = np.mean(correct_labels)
-        total_accuracy += accuracy
-
-        for c in range(model.num_classes):
-            current_class_labels = np.equal(true_labels, c)
-            class_total_counts[c] += np.sum(current_class_labels)
-            class_correct_counts[c] += np.sum(np.equal(true_labels, c) * correct_labels)
-
-        print "Error: %f Accuracy: %f (time: %.1fs)" % (error, accuracy, time.time() - start_time)
-
-    print "%d Images, Total Accuracy: %f" % (i, total_accuracy/i)
+        if use_patches:
+            patch_size = CNNModel.PATCH_SIZE
+            for y in range(patch_size, h - patch_size):
+                for x in range(patch_size, w - patch_size):
+                    patch = get_patch(image, center=(y, x), patch_size=patch_size)
+                    patch_labels = get_patch(labels, center=(y, x), patch_size=patch_size)
+                    input_patch = np.append(patch, np.zeros(shape=[patch_size, patch_size, model.num_classes],
+                                                            dtype=np.float32), axis=2)
+                    feed_dict = {model.inpt: [input_patch], model.output: [patch_labels]}
+                    logits, error = sess.run([model.logits[1], model.loss], feed_dict=feed_dict)
+                    predicted_label = np.argmax(logits[patch_size/2, patch_size/2, :])
+                    true_label = patch_labels[patch_size/2, patch_size/2]
+
+                    class_total_counts[true_label] += 1
+                    if true_label == predicted_label:
+                        class_correct_counts[true_label] += 1
+        else:
+            i += 1
+            input_image = np.append(image, np.zeros(shape=[h, w, model.num_classes], dtype=np.float32), axis=2)
+            feed_dict = {model.inpt: [input_image], model.output: [labels]}
+            logits, error = sess.run([model.logits[1], model.loss], feed_dict=feed_dict)
+            predicted_labels = np.argmax(logits[0], axis=2)
+            true_labels = labels[::4, ::4]
+
+            correct_labels = np.equal(predicted_labels, true_labels)
+            accuracy = np.mean(correct_labels)
+            total_accuracy += accuracy
+
+            for c in range(model.num_classes):
+                current_class_labels = np.equal(true_labels, c)
+                class_total_counts[c] += np.sum(current_class_labels)
+                class_correct_counts[c] += np.sum(np.equal(true_labels, c) * correct_labels)
+
+        print "Image: %s Error: %f Accuracy: %f (time: %.1fs)" % (img_id, error, accuracy, time.time() - start_time)
+
+    print "%d Images, Total Accuracy: %f" % (i, total_accuracy / i)
     print "Per Class accuracy:", class_correct_counts / class_total_counts
     print np.sum(class_correct_counts / class_total_counts)
 

model.py

@@ -6,6 +6,8 @@
 
 
 class CNNModel:
+    PATCH_SIZE = 67
+
     def __init__(self, hidden_size_1, hidden_size_2, batch_size, num_classes, learning_rate, num_layers):
         # TODO fix padding
         self.hidden_size_1 = hidden_size_1

preprocessing.py

@@ -195,9 +195,10 @@ def stanford_bgrounds_dataset(data_dir, train_fraction=None, num_train=None):
     for label_f, image_f in train_files:
         if os.path.basename(label_f).split('.')[0] != os.path.basename(image_f).split('.')[0]:
             print "UNEQUAL IMAGE NAMES!", label_f, image_f
+        img_id = os.path.basename(label_f).split('.')[0]
         image = image_to_np_array(image_f)
         labels = text_labels_to_np_array(label_f)
-        yield image, labels
+        yield image, labels, img_id
 
 
 # list of datasets for which we have iterators

train.py

@@ -13,14 +13,14 @@
 def train(sess, model, dataset_iter, num_epochs, patch_size, patches_per_image=1000, save_path=None):
     for i in range(num_epochs):
         print 'Running epoch %d/%d...' % (i + 1, num_epochs)
-        for image, labels in dataset_iter():
+        for image, labels, img_id in dataset_iter():
             start_time = time.time()
             h, w, _ = image.shape
 
             input_image = np.append(image, np.zeros(shape=[h, w, model.num_classes], dtype=np.float32), axis=2)
             feed_dict = {model.inpt: [input_image], model.output: [labels]}
             loss, _ = sess.run([model.loss, model.train_step], feed_dict=feed_dict)
-            print "Average error for this image: %f (time: %.1fs)" % (loss, time.time() - start_time)
+            print "Average error for this image (%s): %f (time: %.1fs)" % (img_id, loss, time.time() - start_time)
 
         if save_path is not None:
             print "Epoch %i finished, saving trained model to %s..." % (i + 1, save_path)