Created
October 3, 2016 17:55
-
-
Save ad2476/66b2df7218829077ed285a793630c154 to your computer and use it in GitHub Desktop.
cs295k hw3 conv net for mnist
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import tensorflow as tf | |
import sys | |
from tensorflow.examples.tutorials.mnist import input_data | |
# Initialize weights with a small amount of noise for symmetry breaking, and to prevent 0 gradients. | |
# For ReLU neurons, good practice to initialize with a slightly positive initial bias to avoid "dead neurons" | |
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) | |
# define our convolution with a stride of 1, zero-padded: | |
def conv2d(x, W): | |
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME') | |
# max pooling over 2x2 blocks | |
def max_pool_2x2(x): | |
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], | |
strides=[1, 2, 2, 1], padding='SAME') | |
mnist = input_data.read_data_sets('MNIST_data', one_hot=True) | |
# stuff from before: | |
img = tf.placeholder(tf.float32, [None,784]) # image | |
lab = tf.placeholder(tf.float32,[None,10]) | |
# first layer: convolution followed by pooling | |
# 32 features for each 5x5 filter | |
W_conv1 = weight_variable([5, 5, 1, 32]) | |
b_conv1 = bias_variable([32]) | |
# reshape our image to a 4d tensor: | |
img_tensor = tf.reshape(img, [-1,28,28,1]) | |
# convolve the image with the weights, add bias and compute relu, then max pool: | |
h_conv1 = tf.nn.relu(conv2d(img_tensor, W_conv1) + b_conv1) | |
h_pool1 = max_pool_2x2(h_conv1) | |
# second layer: 64 features for each 5x5 filter | |
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) | |
# densely-connected layer: image reduced to 7x7, use this layer of 1024 neurons | |
# to process the entire image | |
W_fc1 = weight_variable([7 * 7 * 64, 1024]) | |
b_fc1 = bias_variable([1024]) | |
# reshape pooling layer into 2d tensor (a batch of vectors), | |
# apply weights and biases, then relu | |
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) | |
# apply dropout. according to tf, this requires no rescaling aka magic | |
keep_prob = tf.placeholder(tf.float32) # probability output kept during dropout | |
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob) | |
# feed-forward layer for softmax over digits: | |
W_fc2 = weight_variable([1024, 10]) | |
b_fc2 = bias_variable([10]) | |
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2) | |
sess = tf.Session() | |
# train the model | |
cross_entropy = tf.reduce_mean(-tf.reduce_sum(lab * tf.log(y_conv), reduction_indices=[1])) | |
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy) | |
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(lab,1)) | |
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) | |
sess.run(tf.initialize_all_variables()) | |
for i in range(2000): | |
batch = mnist.train.next_batch(50) | |
if i%100 == 0: | |
train_accuracy = accuracy.eval(feed_dict={img:batch[0], lab: batch[1], keep_prob: 1.0}, session=sess) | |
print("step %d, training accuracy %g"%(i, train_accuracy)) | |
train_step.run(feed_dict={img: batch[0], lab: batch[1], keep_prob: 0.5}, session=sess) | |
# evaluate: | |
print("test accuracy %g"%accuracy.eval(feed_dict={img: mnist.test.images, lab: mnist.test.labels, keep_prob: 1.0}, session=sess)) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment