able to restore model

self_driving.py

@@ -0,0 +1,109 @@
+import tensorflow as tf
+import numpy as np
+from sklearn.externals import joblib
+
+'''
+
+Helpful notes
+
+- Excellent source explaining convoluted neural networks:
+  http://cs231n.github.io/convolutional-networks/
+- Output size of a conv layer is computed by (W−F+2P)/S+1
+  W = input volumne size
+  F = field size of conv neuron
+  S = stride size
+  P = zero padding size
+
+(240-6+2)/2=118
+(320-6+2)/2=158
+
+(28-5+2)/2
+
+'''
+
+input_file_path = '/Users/ryanzotti/Documents/repos/Self_Driving_RC_Car/final_processed_data_3_channels.npz'
+npzfile = np.load(input_file_path)
+
+# training data
+train_predictors = npzfile['train_predictors']
+train_targets = npzfile['train_targets']
+
+# validation/test data
+validation_predictors = npzfile['validation_predictors']
+validation_targets = npzfile['validation_targets']
+
+sess = tf.InteractiveSession()
+
+def next_batch(size, predictors, targets):
+    record_count = predictors.shape[0]
+    shuffle_index = np.arange(record_count)
+    np.random.shuffle(shuffle_index)
+    predictors = predictors[shuffle_index]
+    targets = targets[shuffle_index]
+    return predictors[:size], targets[:size]
+
+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')
+
+x = tf.placeholder(tf.float32, shape=[None, 240, 320, 3])
+y_ = tf.placeholder(tf.float32, shape=[None, 3])
+
+W_conv1 = weight_variable([6, 6, 3, 4])
+b_conv1 = bias_variable([4])
+h_conv1 = tf.nn.relu(conv2d(x, W_conv1) + b_conv1)
+h_pool1 = max_pool_2x2(h_conv1)
+
+W_conv2 = weight_variable([6, 6, 4, 4])
+b_conv2 = bias_variable([4])
+h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
+h_pool2 = max_pool_2x2(h_conv2)
+
+W_conv3 = weight_variable([6, 6, 4, 4])
+b_conv3 = bias_variable([4])
+h_conv3 = tf.nn.relu(conv2d(h_pool2, W_conv3) + b_conv3)
+h_pool3 = max_pool_2x2(h_conv3)
+
+W_conv4 = weight_variable([6, 6, 4, 4])
+b_conv4 = bias_variable([4])
+h_conv4 = tf.nn.relu(conv2d(h_pool3, W_conv4) + b_conv4)
+h_pool4 = max_pool_2x2(h_conv4)
+
+W_fc1 = weight_variable([15 * 20 * 4, 4])
+b_fc1 = bias_variable([4])
+
+h_pool4_flat = tf.reshape(h_pool4, [-1, 15 * 20 * 4])
+h_fc1 = tf.nn.relu(tf.matmul(h_pool4_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([4, 3])
+b_fc2 = bias_variable([3])
+
+saver = tf.train.Saver()
+saver.restore(sess, "/Users/ryanzotti/Documents/repos/Self-Driving-Car/trained_model/model.ckpt")
+
+y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
+
+#prediction=tf.argmax(y_conv,1)
+#digit = prediction.eval(feed_dict={x_: my_image,keep_prob: 1.0}, session=sess)[0]
+
+correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
+accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
+
+print("test accuracy %g"%accuracy.eval(feed_dict={
+    x: validation_predictors, y_: validation_targets, keep_prob: 1.0}))
+
+print('Finished.')