Added softmax and cnn image classification processors

Author: Vineet John

tensorflow-mnist/processors/cnn_processor.py

@@ -0,0 +1,84 @@
+import tensorflow as tf
+from tensorflow.examples.tutorials.mnist import input_data
+
+from processors.processor import Processor
+from utils import log_helper
+
+log = log_helper.get_logger("CNNProcessor")
+
+
+class CNNProcessor(Processor):
+
+    def process(self):
+        log.info("CNNProcessor begun")
+
+        # Import data
+        data_dir = "/tmp/tensorflow/mnist/input_data"
+        mnist = input_data.read_data_sets(data_dir, one_hot=True)
+
+        x = tf.placeholder(tf.float32, [None, 784])
+        y_ = tf.placeholder(tf.float32, [None, 10])
+
+        sess = tf.InteractiveSession()
+
+        W_conv1 = weight_variable([5, 5, 1, 32])
+        b_conv1 = bias_variable([32])
+
+        x_image = tf.reshape(x, [-1, 28, 28, 1])
+
+        h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
+        h_pool1 = max_pool_2x2(h_conv1)
+
+        W_conv2 = weight_variable([5, 5, 32, 64])
+        b_conv2 = bias_variable([64])
+
+        h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
+        h_pool2 = max_pool_2x2(h_conv2)
+
+        W_fc1 = weight_variable([7 * 7 * 64, 1024])
+        b_fc1 = bias_variable([1024])
+
+        h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])
+        h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
+
+        keep_prob = tf.placeholder(tf.float32)
+        h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
+
+        W_fc2 = weight_variable([1024, 10])
+        b_fc2 = bias_variable([10])
+
+        y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
+
+        cross_entropy = tf.reduce_mean(
+            tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
+        train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
+        correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
+        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
+        sess.run(tf.global_variables_initializer())
+        for i in range(1001):
+            batch = mnist.train.next_batch(50)
+            if i % 100 == 0:
+                train_accuracy = accuracy.eval(feed_dict={
+                    x: batch[0], y_: batch[1], keep_prob: 1.0})
+                print("step %d, training accuracy %g" % (i, train_accuracy))
+            train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
+
+        print("test accuracy %g" % accuracy.eval(feed_dict={
+            x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
+
+        log.info("CNNProcessor concluded")
+
+def weight_variable(shape):
+    initial = tf.truncated_normal(shape, stddev=0.1)
+    return tf.Variable(initial)
+
+def bias_variable(shape):
+    initial = tf.constant(0.1, shape=shape)
+    return tf.Variable(initial)
+
+def conv2d(x, W):
+    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
+
+def max_pool_2x2(x):
+    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
+                          strides=[1, 2, 2, 1], padding='SAME')

tensorflow-mnist/processors/mnist_processor.py

@@ -0,0 +1,45 @@
+import tensorflow as tf
+from tensorflow.examples.tutorials.mnist import input_data
+
+from processors.processor import Processor
+from utils import log_helper
+
+log = log_helper.get_logger("CNNProcessor")
+
+
+class SoftmaxRegressionProcessor(Processor):
+
+    def process(self):
+        log.info("CNNProcessor begun")
+
+        # Import data
+        data_dir = "/tmp/tensorflow/mnist/input_data"
+        mnist = input_data.read_data_sets(data_dir, one_hot=True)
+
+        # Create the model
+        x = tf.placeholder(tf.float32, [None, 784])
+        W = tf.Variable(tf.zeros([784, 10]))
+        b = tf.Variable(tf.zeros([10]))
+        y = tf.matmul(x, W) + b
+
+        # Define loss and optimizer
+        y_ = tf.placeholder(tf.float32, [None, 10])
+
+        cross_entropy = tf.reduce_mean(
+            tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))
+        train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
+
+        sess = tf.InteractiveSession()
+        tf.global_variables_initializer().run()
+        # Train
+        for _ in range(1000):
+            batch_xs, batch_ys = mnist.train.next_batch(100)
+            sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
+
+        # Test trained model
+        correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
+        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
+        print(sess.run(accuracy, feed_dict={x: mnist.test.images,
+                                            y_: mnist.test.labels}))
+
+        log.info("CNNProcessor concluded")

tensorflow-mnist/processors/softmax_regression_processor.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env bash
 
 CODEDIR=$(dirname "$0")"/../"
-DATADIR=$(dirname "$0")"/../data/"
 
 # Run Gaussian Mixture Model processor
-/usr/bin/python3 "$CODEDIR"/tensorflow_mnist.py
+/usr/bin/python3 "$CODEDIR"/tensorflow_mnist.py

tensorflow-mnist/scripts/run-tensorflow-mnist.sh

@@ -2,18 +2,28 @@
 
 import sys
 
-from processors.mnist_processor import MnistProcessor
+from processors.cnn_processor import CNNProcessor
+from processors.softmax_regression_processor import SoftmaxRegressionProcessor
 from utils.options import Options
 
 
 def main(argv):
+    processor = None
     options = parse_args(argv)
-    processor = MnistProcessor(options)
-    processor.process()
+
+    if options.mode == "softmax":
+        processor = SoftmaxRegressionProcessor(options)
+    elif options.mode == "cnn":
+        processor = CNNProcessor(options)
+
+    if processor:
+        processor.process()
 
 
 def parse_args(argv):
     parser = ArgumentParser(prog="tensorflow_mnist")
+    parser.add_argument('--mode', metavar='Run mode', type=str, required=True)
+
     return parser.parse_args(argv, namespace=Options)