Refractor

Author: Lukas Herman

1_MLP.py

@@ -24,19 +24,21 @@
 
 mnist = input_data.read_data_sets('data', one_hot=True)
 
+
 def get_dict(train=True, batch=True):
     if train:
         if batch:
             batch_x, batch_y = mnist.train.next_batch(batch_size)
-            return {x:batch_x, y_:batch_y}
+            return {x: batch_x, y_: batch_y}
         else:
-            return {x:mnist.train.images, y_:mnist.train.labels}
+            return {x: mnist.train.images, y_: mnist.train.labels}
     else:
         if batch:
             batch_x, batch_y = mnist.test.next_batch(batch_size)
-            return {x:batch_x, y_:batch_y}
+            return {x: batch_x, y_: batch_y}
         else:
-            return {x:mnist.test.images, y_:mnist.test.labels}
+            return {x: mnist.test.images, y_: mnist.test.labels}
+
 
 with tf.name_scope('ActualValue'):
     y_ = tf.placeholder(tf.float32, shape=[None, n_classes], name='y_')
@@ -54,13 +56,13 @@ def get_dict(train=True, batch=True):
 
 with tf.name_scope('Train'):
     loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_,
-                            logits=y), name='loss')
+                                                                  logits=y), name='loss')
     train = tf.train.AdamOptimizer().minimize(loss)
 
 with tf.name_scope('Accuracy'):
     correct_predictions = tf.equal(tf.argmax(y, axis=1), tf.argmax(y_, axis=1))
     accuracy = tf.reduce_mean(tf.cast(correct_predictions, tf.float32),
-                name='accuracy')
+                              name='accuracy')
 
 # Add scalar summaries
 tf.summary.scalar('Loss', loss)
@@ -76,7 +78,7 @@ def get_dict(train=True, batch=True):
     test_writer = tf.summary.FileWriter(test_dir)
 
     sess.run(init_op)
-    for n_train in range(1, n_trains+1):
+    for n_train in range(1, n_trains + 1):
         print("Training {}...".format(n_train))
         _ = sess.run([train], feed_dict=get_dict(train=True, batch=True))
         if n_train % 100 == 0:

1_MLP/train/events.out.tfevents.1494774884.lukas-K43SJ

@@ -0,0 +1,130 @@
+import tensorflow as tf
+from tensorflow.examples.tutorials.mnist import input_data
+from layers import layers
+import config
+
+train_dir = config.TRAIN_DIR
+test_dir = config.TEST_DIR
+n_trains = config.N_TRAINS
+batch_size = config.BATCH_SIZE
+
+width = config.WIDTH
+height = config.HEIGHT
+channels = config.CHANNELS
+flat = config.FLAT
+n_classes = config.N_CLASSES
+
+k = 500
+l = 250
+m = 125
+num_imgs = 3
+
+mnist = input_data.read_data_sets('data', one_hot=True)
+
+
+def get_dict(train=True, batch=True):
+    if train:
+        if batch:
+            batch_x, _ = mnist.train.next_batch(batch_size)
+            return {x: batch_x}
+        else:
+            return {x: mnist.train.images}
+    else:
+        if batch:
+            batch_x, _ = mnist.test.next_batch(batch_size)
+            return {x: batch_x}
+        else:
+            return {x: mnist.test.images}
+
+
+with tf.name_scope('InputLayer'):
+    x = tf.placeholder(tf.float32, shape=[None, flat], name='x')
+
+with tf.name_scope('ActualValue'):
+    y_ = tf.placeholder(tf.float32, shape=[None, n_classes], name='y_')
+
+
+def train_rbm(y):
+    with tf.name_scope('Train'):
+        loss = tf.reduce_mean(tf.pow(y - x, 2), name='loss')
+        train = tf.train.AdamOptimizer().minimize(loss)
+
+    with tf.name_scope('Accuracy'):
+        accuracy = 1 - loss
+
+    # Add image summaries
+    x_img = tf.reshape(x, [-1, height, width, channels])  # input
+    y_img = tf.reshape(y, [-1, height, width, channels])  # reconstructed
+    tf.summary.image('InputImage', x_img, max_outputs=num_imgs)
+    tf.summary.image('OutputImage', y_img, max_outputs=num_imgs)
+
+    # Add scalar summaries
+    tf.summary.scalar('Loss', loss)
+    tf.summary.scalar('Accuracy', accuracy)
+
+    init_op = tf.global_variables_initializer()
+    summary_op = tf.summary.merge_all()
+
+    with tf.Session() as sess:
+        # Open protocol for writing files
+        train_writer = tf.summary.FileWriter(train_dir)
+        train_writer.add_graph(sess.graph)
+        test_writer = tf.summary.FileWriter(test_dir)
+
+        sess.run(init_op)
+        for n_train in range(1, n_trains + 1):
+            print("Training {}...".format(n_train))
+            _ = sess.run([train], feed_dict=get_dict(train=True, batch=True))
+            if n_train % 100 == 0:
+                # Train
+                s = sess.run(summary_op, feed_dict=get_dict(train=True, batch=False))
+                train_writer.add_summary(s, n_train)
+                # Test
+                s = sess.run(summary_op, feed_dict=get_dict(train=False, batch=False))
+                test_writer.add_summary(s, n_train)
+
+with tf.name_scope('NetworkModel'):
+    y1 = layers.rbm_layer(x, flat, k)
+    y2 = layers.rbm_layer(y1, k, l)
+    y3 = layers.rbm_layer(y2, l, m)
+    y = layers.output_layer(y3, m, n_classes)
+
+# Train First
+train(y1)
+train(y2)
+train(y3)
+
+with tf.name_scope('Train'):
+    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_,
+                                                                  logits=y), name='loss')
+    train = tf.train.AdamOptimizer().minimize(loss)
+
+with tf.name_scope('Accuracy'):
+    correct_predictions = tf.equal(tf.argmax(y, axis=1), tf.argmax(y_, axis=1))
+    accuracy = tf.reduce_mean(tf.cast(correct_predictions, tf.float32),
+                              name='accuracy')
+
+# Add scalar summaries
+tf.summary.scalar('Loss', loss)
+tf.summary.scalar('Accuracy', accuracy)
+
+init_op = tf.global_variables_initializer()
+summary_op = tf.summary.merge_all()
+
+with tf.Session() as sess:
+    # Open protocol for writing files
+    train_writer = tf.summary.FileWriter(train_dir)
+    train_writer.add_graph(sess.graph)
+    test_writer = tf.summary.FileWriter(test_dir)
+
+    sess.run(init_op)
+    for n_train in range(1, n_trains + 1):
+        print("Training {}...".format(n_train))
+        _ = sess.run([train], feed_dict=get_dict(train=True, batch=True))
+        if n_train % 100 == 0:
+            # Train
+            s = sess.run(summary_op, feed_dict=get_dict(train=True, batch=False))
+            train_writer.add_summary(s, n_train)
+            # Test
+            s = sess.run(summary_op, feed_dict=get_dict(train=False, batch=False))
+            test_writer.add_summary(s, n_train)

1_MLP/train/events.out.tfevents.1494775035.lukas-K43SJ

@@ -1,31 +1,35 @@
 import tensorflow as tf
 
+
 def conv_layer(input, side, channels_in, channels_out, stride=2, name='conv_layer'):
     with tf.name_scope(name):
         w = tf.Variable(tf.truncated_normal([side, side, channels_in,
-                        channels_out]), name='W')
+                                             channels_out]), name='W')
         b = tf.Variable(tf.truncated_normal([channels_out]),
                         name='B')
 
-        conv =  tf.nn.conv2d(input, w, [1, 1, 1, 1], padding='SAME')
+        conv = tf.nn.conv2d(input, w, [1, 1, 1, 1], padding='SAME')
         act = tf.nn.relu(conv + b)
 
         tf.summary.histogram('weights', w)
         tf.summary.histogram('biases', b)
         return tf.nn.max_pool(act, [1, 2, 2, 1], [1, stride, stride, 1],
                               padding='SAME')
 
+
 def fc_layer(input, channels_in, channels_out, name='fc_layer'):
     with tf.name_scope(name):
         w = tf.Variable(tf.truncated_normal([channels_in, channels_out]),
                         name='W')
         b = tf.Variable(tf.truncated_normal([channels_out]),
                         name='B')
         pkeep = tf.constant(0.75, dtype=tf.float32, name='pkeep')
-
+        dropout = tf.nn.dropout(input, pkeep)
         tf.summary.histogram('weights', w)
         tf.summary.histogram('biases', b)
-        return tf.nn.relu(tf.matmul(input, w) + b)
+
+        return tf.nn.relu(tf.matmul(dropout, w) + b)
+
 
 def output_layer(input, channels_in, channels_out, name='output_layer'):
     with tf.name_scope(name):
@@ -38,6 +42,7 @@ def output_layer(input, channels_in, channels_out, name='output_layer'):
         tf.summary.histogram('biases', b)
         return tf.matmul(input, w) + b
 
+
 def ae_layer(input, channels_in, channels_out, name='ae_layer'):
     with tf.name_scope(name):
         w = tf.Variable(tf.truncated_normal([channels_in, channels_out]),
@@ -49,15 +54,16 @@ def ae_layer(input, channels_in, channels_out, name='ae_layer'):
         tf.summary.histogram('biases', b)
         return tf.nn.sigmoid(tf.matmul(input, w) + b)
 
+
 def rbm_layer(input, channels_in, channels_out, name='rbm_layer'):
     with tf.name_scope(name):
         # Encoder Variables
-        w = tf.Variable(tf.truncated_normal([channels_in, channels_out]))
-        _b = tf.Variable(tf.truncated_normal([channels_out]))
+        w = tf.Variable(tf.truncated_normal([channels_in, channels_out]),
+                        name='W')
+        _b = tf.Variable(tf.truncated_normal([channels_out]), name='_B')
 
         # reconstructor Varables
-        b = tf.Variable(tf.truncated_normal([channels_in]))
-
+        b = tf.Variable(tf.truncated_normal([channels_in]), name='B')
 
         _y = tf.nn.sigmoid(tf.matmul(input, w) + _b)
         y = tf.nn.sigmoid(tf.matmul(_y, tf.transpose(w)) + b)