updated ch 10 and add code-of-conduct

Author: nfmcclure

10_Taking_TensorFlow_to_Production/01_Implementing_Unit_Tests/01_implementing_unit_tests.py

@@ -5,9 +5,9 @@
 # Here, we will show how to implement different unit tests
 #  on the MNIST example
 
+import sys
 import numpy as np
 import tensorflow as tf
-from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets
 from tensorflow.python.framework import ops
 ops.reset_default_graph()
 
@@ -16,15 +16,10 @@
 
 # Load data
 data_dir = 'temp'
-mnist = read_data_sets(data_dir)
-
-# Convert images into 28x28 (they are downloaded as 1x784)
-train_xdata = np.array([np.reshape(x, (28,28)) for x in mnist.train.images])
-test_xdata = np.array([np.reshape(x, (28,28)) for x in mnist.test.images])
-
-# Convert labels into one-hot encoded vectors
-train_labels = mnist.train.labels
-test_labels = mnist.test.labels
+mnist = tf.keras.datasets.mnist
+(train_xdata, train_labels), (test_xdata, test_labels) = mnist.load_data()
+train_xdata = train_xdata / 255.0
+test_xdata = test_xdata / 255.0
 
 # Set model parameters
 batch_size = 100
@@ -67,8 +62,7 @@
 resulting_width = image_width // (max_pool_size1 * max_pool_size2)
 resulting_height = image_height // (max_pool_size1 * max_pool_size2)
 full1_input_size = resulting_width * resulting_height * conv2_features
-full1_weight = tf.Variable(tf.truncated_normal([full1_input_size, fully_connected_size1],
-                          stddev=0.1, dtype=tf.float32))
+full1_weight = tf.Variable(tf.truncated_normal([full1_input_size, fully_connected_size1], stddev=0.1, dtype=tf.float32))
 full1_bias = tf.Variable(tf.truncated_normal([fully_connected_size1], stddev=0.1, dtype=tf.float32))
 full2_weight = tf.Variable(tf.truncated_normal([fully_connected_size1, target_size],
                                                stddev=0.1, dtype=tf.float32))
@@ -103,7 +97,8 @@ def my_conv_net(input_data):
     # Add dropout
     final_model_output = tf.nn.dropout(final_model_output, dropout)
 
-    return(final_model_output)
+    return final_model_output
+
 
 model_output = my_conv_net(x_input)
 test_model_output = my_conv_net(eval_input)
@@ -115,11 +110,13 @@ def my_conv_net(input_data):
 prediction = tf.nn.softmax(model_output)
 test_prediction = tf.nn.softmax(test_model_output)
 
+
 # Create accuracy function
 def get_accuracy(logits, targets):
     batch_predictions = np.argmax(logits, axis=1)
     num_correct = np.sum(np.equal(batch_predictions, targets))
-    return(100. * num_correct/batch_predictions.shape[0])
+    return 100. * num_correct/batch_predictions.shape[0]
+
 
 # Create an optimizer
 my_optimizer = tf.train.MomentumOptimizer(learning_rate, 0.9)
@@ -129,23 +126,26 @@ def get_accuracy(logits, targets):
 init = tf.global_variables_initializer()
 sess.run(init)
 
+
 # Check values of tensors!
 class drop_out_test(tf.test.TestCase):
     # Make sure that we don't drop too much
     def dropout_greaterthan(self):
         with self.test_session():
-          self.assertGreater(dropout.eval(), 0.25)
+            self.assertGreater(dropout.eval(), 0.25)
+
 
 # Test accuracy function
 class accuracy_test(tf.test.TestCase):
     # Make sure accuracy function behaves correctly
     def accuracy_exact_test(self):
         with self.test_session():
-            test_preds = [[0.9, 0.1],[0.01, 0.99]]
+            test_preds = [[0.9, 0.1], [0.01, 0.99]]
             test_targets = [0, 1]
             test_acc = get_accuracy(test_preds, test_targets)
             self.assertEqual(test_acc.eval(), 100.)
 
+
 # Test tensorshape
 class shape_test(tf.test.TestCase):
     # Make sure our model output is size [batch_size, num_classes]
@@ -154,37 +154,46 @@ def output_shape_test(self):
             numpy_array = np.ones([batch_size, target_size])
             self.assertShapeEqual(numpy_array, model_output)
 
-# Perform unit tests
-tf.test.main()
-
-# Start training loop
-train_loss = []
-train_acc = []
-test_acc = []
-for i in range(generations):
-    rand_index = np.random.choice(len(train_xdata), size=batch_size)
-    rand_x = train_xdata[rand_index]
-    rand_x = np.expand_dims(rand_x, 3)
-    rand_y = train_labels[rand_index]
-    train_dict = {x_input: rand_x, y_target: rand_y, dropout: dropout_prob}
-    
-    sess.run(train_step, feed_dict=train_dict)
-    temp_train_loss, temp_train_preds = sess.run([loss, prediction], feed_dict=train_dict)
-    temp_train_acc = get_accuracy(temp_train_preds, rand_y)
-    
-    if (i+1) % eval_every == 0:
-        eval_index = np.random.choice(len(test_xdata), size=evaluation_size)
-        eval_x = test_xdata[eval_index]
-        eval_x = np.expand_dims(eval_x, 3)
-        eval_y = test_labels[eval_index]
-        test_dict = {eval_input: eval_x, eval_target: eval_y, dropout: 1.0}
-        test_preds = sess.run(test_prediction, feed_dict=test_dict)
-        temp_test_acc = get_accuracy(test_preds, eval_y)
-        
-        # Record and print results
-        train_loss.append(temp_train_loss)
-        train_acc.append(temp_train_acc)
-        test_acc.append(temp_test_acc)
-        acc_and_loss = [(i+1), temp_train_loss, temp_train_acc, temp_test_acc]
-        acc_and_loss = [np.round(x,2) for x in acc_and_loss]
-        print('Generation # {}. Train Loss: {:.2f}. Train Acc (Test Acc): {:.2f} ({:.2f})'.format(*acc_and_loss))
+
+def main(argv):
+    # Start training loop
+    train_loss = []
+    train_acc = []
+    test_acc = []
+    for i in range(generations):
+        rand_index = np.random.choice(len(train_xdata), size=batch_size)
+        rand_x = train_xdata[rand_index]
+        rand_x = np.expand_dims(rand_x, 3)
+        rand_y = train_labels[rand_index]
+        train_dict = {x_input: rand_x, y_target: rand_y, dropout: dropout_prob}
+
+        sess.run(train_step, feed_dict=train_dict)
+        temp_train_loss, temp_train_preds = sess.run([loss, prediction], feed_dict=train_dict)
+        temp_train_acc = get_accuracy(temp_train_preds, rand_y)
+
+        if (i + 1) % eval_every == 0:
+            eval_index = np.random.choice(len(test_xdata), size=evaluation_size)
+            eval_x = test_xdata[eval_index]
+            eval_x = np.expand_dims(eval_x, 3)
+            eval_y = test_labels[eval_index]
+            test_dict = {eval_input: eval_x, eval_target: eval_y, dropout: 1.0}
+            test_preds = sess.run(test_prediction, feed_dict=test_dict)
+            temp_test_acc = get_accuracy(test_preds, eval_y)
+
+            # Record and print results
+            train_loss.append(temp_train_loss)
+            train_acc.append(temp_train_acc)
+            test_acc.append(temp_test_acc)
+            acc_and_loss = [(i + 1), temp_train_loss, temp_train_acc, temp_test_acc]
+            acc_and_loss = [np.round(x, 2) for x in acc_and_loss]
+            print('Generation # {}. Train Loss: {:.2f}. Train Acc (Test Acc): {:.2f} ({:.2f})'.format(*acc_and_loss))
+
+
+if __name__ == '__main__':
+    cmd_args = sys.argv
+    if len(cmd_args) > 1 and cmd_args[1] == 'test':
+        # Perform unit tests
+        tf.test.main(argv=cmd_args[1:])
+    else:
+        # Run TF App
+        tf.app.run(main=None, argv=cmd_args)

10_Taking_TensorFlow_to_Production/02_Using_Multiple_Devices/02_using_multiple_devices.py

@@ -60,4 +60,4 @@
             flat_d = tf.reshape(d, [-1])
 
         combined = tf.multiply(c, flat_d)
-    print(sess.run(combined))
+    print(sess.run(combined))

10_Taking_TensorFlow_to_Production/03_Parallelizing_TensorFlow/03_parallelizing_tensorflow.py

@@ -14,7 +14,7 @@
 server = tf.train.Server(cluster, job_name="local", task_index=0)
 server = tf.train.Server(cluster, job_name="local", task_index=1)
 # Finish and add
-#server.join()
+# server.join()
 
 # Have each worker do a task
 # Worker 0 : create matrices
@@ -39,4 +39,4 @@
 
 with tf.Session(server.target) as sess:
     result = sess.run(summed_out)
-    print('Summed Values:{}'.format(result))
+    print('Summed Values:{}'.format(result))

10_Taking_TensorFlow_to_Production/04_Production_Tips/04_production_tips_for_tf.py

@@ -63,10 +63,11 @@
 #  to handle running and loading of arguments
 
 # At the beginning of the file, define the flags.
-tf.app.flags.DEFINE_string("worker_locations", "", "List of worker addresses.")
-tf.app.flags.DEFINE_float('learning_rate', 0.01, 'Initial learning rate.')
-tf.app.flags.DEFINE_integer('generations', 1000, 'Number of training generations.')
-tf.app.flags.DEFINE_boolean('run_unit_tests', False, 'If true, run tests.')
+tf.flags.DEFINE_string("worker_locations", "", "List of worker addresses.")
+tf.flags.DEFINE_float('learning_rate', 0.01, 'Initial learning rate.')
+tf.flags.DEFINE_integer('generations', 1000, 'Number of training generations.')
+tf.flags.DEFINE_boolean('run_unit_tests', False, 'If true, run tests.')
+FLAGS = tf.flags.FLAGS
 
 # Need to define a 'main' function for the app to run
 def main(_):
@@ -77,7 +78,10 @@ def main(_):
 
 # Run the TensorFlow app
 if __name__ == "__main__":
+    # The following is looking for a "main()" function to run and will pass.
     tf.app.run()
+    # Can modify this to be more custom:
+    tf.app.run(main=my_main_function(), argv=my_arguments)
 
 
 # Use of TensorFlow's built in logging:

10_Taking_TensorFlow_to_Production/05_Production_Example/05_production_ex_eval.py

@@ -15,33 +15,33 @@
 from tensorflow.python.framework import ops
 ops.reset_default_graph()
 
-tf.app.flags.DEFINE_string("storage_folder", "temp", "Where to store model and data.")
-tf.app.flags.DEFINE_string('model_file', False, 'Model file location.')
-tf.app.flags.DEFINE_boolean('run_unit_tests', False, 'If true, run tests.')
-FLAGS = tf.app.flags.FLAGS
+tf.flags.DEFINE_string("storage_folder", "temp", "Where to store model and data.")
+tf.flags.DEFINE_bool('model_file', False, 'Model file location.')
+tf.flags.DEFINE_bool('run_unit_tests', False, 'If true, run tests.')
+FLAGS = tf.flags.FLAGS
 
 
 # Create a text cleaning function
 def clean_text(text_string):
     text_string = re.sub(r'([^\s\w]|_|[0-9])+', '', text_string)
     text_string = " ".join(text_string.split())
     text_string = text_string.lower()
-    return(text_string)
+    return text_string
 
 
 # Load vocab processor
 def load_vocab():
     vocab_path = os.path.join(FLAGS.storage_folder, "vocab")
     vocab_processor = tf.contrib.learn.preprocessing.VocabularyProcessor.restore(vocab_path)
-    return(vocab_processor)
+    return vocab_processor
 
 
 # Process input data:
 def process_data(input_data, vocab_processor):
     input_data = clean_text(input_data)
     input_data = input_data.split()
     processed_input = np.array(list(vocab_processor.transform(input_data)))
-    return(processed_input)
+    return processed_input
 
 
 # Get input function
@@ -52,7 +52,7 @@ def get_input_data():
     """
     input_text = input("Please enter a text message to evaluate: ")
     vocab_processor = load_vocab()
-    return(process_data(input_text, vocab_processor))
+    return process_data(input_text, vocab_processor)
 
 
 # Test clean_text function
@@ -95,6 +95,7 @@ def main(args):
             # Print output (Or save to file or DB connection?)
             print('Probability of Spam: {:.4}'.format(probability_prediction[1]))
 
+
 # Run main module/tf App
 if __name__ == "__main__":
     if FLAGS.run_unit_tests: