You've written a lot of code in this assignment to provide a whole host of neural network functionality. Dropout, Batch Norm, and 2D convolutions are some of the workhorses of deep learning in computer vision. You've also worked hard to make your code efficient and vectorized.
For the last part of this assignment, though, we're going to leave behind your beautiful codebase and instead migrate to one of two popular deep learning frameworks: in this instance, TensorFlow (or PyTorch, if you switch over to that notebook)
TensorFlow is a system for executing computational graphs over Tensor objects, with native support for performing backpropogation for its Variables. In it, we work with Tensors which are n-dimensional arrays analogous to the numpy ndarray.
TensorFlow has many excellent tutorials available, including those from Google themselves.
Otherwise, this notebook will walk you through much of what you need to do to train models in TensorFlow. See the end of the notebook for some links to helpful tutorials if you want to learn more or need further clarification on topics that aren't fully explained here.
In [1]:
import tensorflow as tf
import numpy as np
import math
import timeit
import matplotlib.pyplot as plt
%matplotlib inline
In [2]:
from cs231n.data_utils import load_CIFAR10
def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=10000):
"""
Load the CIFAR-10 dataset from disk and perform preprocessing to prepare
it for the two-layer neural net classifier. These are the same steps as
we used for the SVM, but condensed to a single function.
"""
# Load the raw CIFAR-10 data
cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'
X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)
# Subsample the data
mask = range(num_training, num_training + num_validation)
X_val = X_train[mask]
y_val = y_train[mask]
mask = range(num_training)
X_train = X_train[mask]
y_train = y_train[mask]
mask = range(num_test)
X_test = X_test[mask]
y_test = y_test[mask]
# Normalize the data: subtract the mean image
mean_image = np.mean(X_train, axis=0)
X_train -= mean_image
X_val -= mean_image
X_test -= mean_image
return X_train, y_train, X_val, y_val, X_test, y_test
# Invoke the above function to get our data.
X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()
print('Train data shape: ', X_train.shape)
print('Train labels shape: ', y_train.shape)
print('Validation data shape: ', X_val.shape)
print('Validation labels shape: ', y_val.shape)
print('Test data shape: ', X_test.shape)
print('Test labels shape: ', y_test.shape)
. Remember that our image data is initially N x H x W x C, where:
This is the right way to represent the data when we are doing something like a 2D convolution, which needs spatial understanding of where the pixels are relative to each other. When we input image data into fully connected affine layers, however, we want each data example to be represented by a single vector -- it's no longer useful to segregate the different channels, rows, and columns of the data.
The first step to training your own model is defining its architecture.
Here's an example of a convolutional neural network defined in TensorFlow -- try to understand what each line is doing, remembering that each layer is composed upon the previous layer. We haven't trained anything yet - that'll come next - for now, we want you to understand how everything gets set up.
In that example, you see 2D convolutional layers (Conv2d), ReLU activations, and fully-connected layers (Linear). You also see the Hinge loss function, and the Adam optimizer being used.
Make sure you understand why the parameters of the Linear layer are 5408 and 10.
In TensorFlow, much like in our previous notebooks, we'll first specifically initialize our variables, and then our network model.
In [9]:
# clear old variables
tf.reset_default_graph()
# setup input (e.g. the data that changes every batch)
# The first dim is None, and gets sets automatically based on batch size fed in
X = tf.placeholder(tf.float32, [None, 32, 32, 3]) # NxHxWxC == NHWC format, not shape, not type, maybe structure
y = tf.placeholder(tf.int64, [None])
is_training = tf.placeholder(tf.bool)
def simple_model(X,y):
# define our weights (e.g. init_two_layer_convnet)
# setup variables
Wconv1 = tf.get_variable("Wconv1", shape=[7, 7, 3, 32])
bconv1 = tf.get_variable("bconv1", shape=[32])
W1 = tf.get_variable("W1", shape=[5408, 10])
b1 = tf.get_variable("b1", shape=[10])
# define our graph (e.g. two_layer_convnet)
a1 = tf.nn.conv2d(X, Wconv1, strides=[1,2,2,1], padding='VALID') + bconv1
h1 = tf.nn.relu(a1)
h1_flat = tf.reshape(h1,[-1,5408])
y_out = tf.matmul(h1_flat,W1) + b1
return y_out
y_out = simple_model(X,y)
# define our loss
total_loss = tf.losses.hinge_loss(tf.one_hot(y,10),logits=y_out)
mean_loss = tf.reduce_mean(total_loss)
# define our optimizer
optimizer = tf.train.AdamOptimizer(5e-4) # select optimizer and set learning rate
train_step = optimizer.minimize(mean_loss)
In [14]:
# # NHWC format for xy data, input and output data
# xN, xH, xW, xC = None, 32, 32, 3
# # kN, kH, kW, kC = number conv kernel, conv kernel height, conv kernel width, conv kernel channel
# # Wconv1 = tf.get_variable("Wconv1", shape=[7, 7, 3, 32]) # kHxkWxkCxkN, HWCN format for conv kernel/ conv neuron
# kH, kW, kC, kN = 7, 7, 3, 32
# # conv stride, conv pad
# stride, pad = [1, 2, 2, 1], 'VALID'
# # stride = [sN, sH, sW, sC] probablly the same as NHWC format of the input data x or X
# # NHWC is the default tensor data format
# # striding the conv kernel/ filter on the input tensor data padded or not padded
# # usually stride[0] == stride[3]
# # conv stride we should notice that this is a 2d conv meaning the kernel moving in height and width direction
# # for padding we should notice that we want the conv output shape be shrining/ reducing the dimensionality
# # validating our convolution output size for dimension reduction, shrinking the input
# # or the same shape/ size for conv output compared to the conv input
# # with valid, we should expect PAD=0, therefore the conv output shape/ size can be calculated as below
# yH = ((xH - kH)/ stride) + 1 # one conv direction in height
# yW = ((xW - kW)/stride) + 1 # one conv direction in width
# yC = kN # number of conv neurons or kernels or filters
# yN = xN # number of input dimensions/ features
# # tf.get_variable(caching_device=, collections=, custom_getter=, dtype=, initializer=, name=,
# # partitioner=, regularizer=, shape=, trainable=, use_resource=, validate_shape=)
# # Wconv = tf.get_variable(name='Wconv', dtype=tf.float64, shape=[kH, kW, kC, kN], trainable=True)
# # bconv = tf.get_variable(dtype=tf.float64, name='bconv', shape=[kN], trainable=True)
# # After convolution, we should flatten the yShape to feed it into the fc layer or fully-connected layer
# # If we don't apply the pooling to the conv output, we should flatten the tensor output of conv to feed it into the
# # FC layer parameters for W and b
# # xN, xD, xK = minibatch size/ number of input sampels, number of FC input dimensions, number of FC neurons
# # xN, xD, xK =
# # W = tf.get_variable(dtype=, name=, shape=[yH*yW*yC, K], trainable=True)
# # xD = yH
# # NHWC
# yH*yW*yC = xD
In [28]:
# # NHWC format for x, k, y
# xN, xH, xW, xC = None, 32, 32, 3
# # kH, kW, kC, kN = 7, 7, 3, 32
# kH, kW, kC, kN = 8, 8, 3, 32
# # yN, yH, yW, yC = None, 13, 13, 32
# # stride, padding = [1, 2, 2, 1], 'VALID'
# sN, sH, sW, sC = 1, 2, 2, 1
# # p = 0
# ### stride = [sN, sH, sW, sC] for NHWC format
# yH = ((xH - kH)/ sH) + 1 # one conv direction in height
# yW = ((xW - kW)/ sW) + 1 # one conv direction in width
# yC = kN
# # yC = kN # number of conv neurons or kernels or filters
# # yN = xN # number of input dimensions/ features
# # yH*yW*yC = xD
# # C = 10 # number of output classes
# yH, yW, yC, int(yH* yW* yC)
# # pooling: is also a type of convolution inspired by complex cells, a filter but not filter bank
# # designed/ defined for more robustness/ onvariancy or equivariancy??
# pH, pW, pC, pN = 2, 2, 1, 1
# sN, sH, sW, sC = 1, 1, 1, 1
# # pad = 0
Out[28]:
In [23]:
# clear old variables
tf.reset_default_graph()
# setup input (e.g. the data that changes every batch)
# The first dim is None, and gets sets automatically based on batch size fed in
X = tf.placeholder(tf.float32, [None, 32, 32, 3]) # NxHxWxC == NHWC format, not shape, not type, maybe structure
y = tf.placeholder(tf.int64, [None])
is_training = tf.placeholder(tf.bool)
def simple_model(X,y):
# define our weights (e.g. init_two_layer_convnet)
# setup variables
Wconv1 = tf.get_variable("Wconv1", shape=[7, 7, 3, 32])
bconv1 = tf.get_variable("bconv1", shape=[32])
W1 = tf.get_variable("W1", shape=[13*13*32, 10]) # 5408 = 13 * 13 * 32
b1 = tf.get_variable("b1", shape=[10])
# define our graph (e.g. two_layer_convnet)
a1 = tf.nn.conv2d(X, Wconv1, strides=[1,2,2,1], padding='VALID') + bconv1
h1 = tf.nn.relu(a1)
h1_flat = tf.reshape(name='h1_flat', shape=[-1, 13*13*13], tensor=h1) # 5408 = 13 * 13 * 32
y_out = tf.matmul(h1_flat,W1) + b1
return y_out
y_out = simple_model(X,y)
# define our loss
total_loss = tf.losses.hinge_loss(tf.one_hot(y,10),logits=y_out)
mean_loss = tf.reduce_mean(total_loss)
# define our optimizer
optimizer = tf.train.AdamOptimizer(5e-4) # select optimizer and set learning rate
train_step = optimizer.minimize(mean_loss)
TensorFlow supports many other layer types, loss functions, and optimizers - you will experiment with these next. Here's the official API documentation for these (if any of the parameters used above were unclear, this resource will also be helpful).
While we have defined a graph of operations above, in order to execute TensorFlow Graphs, by feeding them input data and computing the results, we first need to create a tf.Session object. A session encapsulates the control and state of the TensorFlow runtime. For more information, see the TensorFlow Getting started guide.
Optionally we can also specify a device context such as /cpu:0 or /gpu:0. For documentation on this behavior see this TensorFlow guide
You should see a validation loss of around 0.4 to 0.6 and an accuracy of 0.30 to 0.35 below
In [24]:
def run_model(session, predict, loss_val, Xd, yd,
epochs=1, batch_size=64, print_every=100,
training=None, plot_losses=False):
# have tensorflow compute accuracy
correct_prediction = tf.equal(tf.argmax(predict,1), y)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# shuffle indicies
train_indicies = np.arange(Xd.shape[0])
np.random.shuffle(train_indicies)
training_now = training is not None
# setting up variables we want to compute (and optimizing)
# if we have a training function, add that to things we compute
variables = [mean_loss,correct_prediction,accuracy]
if training_now:
variables[-1] = training
# counter
iter_cnt = 0
for e in range(epochs):
# keep track of losses and accuracy
correct = 0
losses = []
# make sure we iterate over the dataset once
for i in range(int(math.ceil(Xd.shape[0]/batch_size))):
# generate indicies for the batch
start_idx = (i*batch_size)%Xd.shape[0]
idx = train_indicies[start_idx:start_idx+batch_size]
# create a feed dictionary for this batch
feed_dict = {X: Xd[idx,:],
y: yd[idx],
is_training: training_now }
# get batch size
actual_batch_size = yd[idx].shape[0]
# have tensorflow compute loss and correct predictions
# and (if given) perform a training step
loss, corr, _ = session.run(variables,feed_dict=feed_dict)
# aggregate performance stats
losses.append(loss*actual_batch_size)
correct += np.sum(corr)
# print every now and then
if training_now and (iter_cnt % print_every) == 0:
print("Iteration {0}: with minibatch training loss = {1:.3g} and accuracy of {2:.2g}"\
.format(iter_cnt,loss,np.sum(corr)/actual_batch_size))
iter_cnt += 1
total_correct = correct/Xd.shape[0]
total_loss = np.sum(losses)/Xd.shape[0]
print("Epoch {2}, Overall loss = {0:.3g} and accuracy of {1:.3g}"\
.format(total_loss,total_correct,e+1))
if plot_losses:
plt.plot(losses)
plt.grid(True)
plt.title('Epoch {} Loss'.format(e+1))
plt.xlabel('minibatch number')
plt.ylabel('minibatch loss')
plt.show()
return total_loss,total_correct
with tf.Session() as sess:
with tf.device("/cpu:0"): #"/cpu:0" or "/gpu:0"
sess.run(tf.global_variables_initializer())
print('Training')
run_model(sess,y_out,mean_loss,X_train,y_train,1,64,100,train_step,True)
print('Validation')
run_model(sess,y_out,mean_loss,X_val,y_val,1,64)
In this section, we're going to specify a model for you to construct. The goal here isn't to get good performance (that'll be next), but instead to get comfortable with understanding the TensorFlow documentation and configuring your own model.
Using the code provided above as guidance, and using the following TensorFlow documentation, specify a model with the following architecture:
In [5]:
# clear old variables
tf.reset_default_graph()
# define our input (e.g. the data that changes every batch)
# The first dim is None, and gets sets automatically based on batch size fed in
X = tf.placeholder(tf.float32, [None, 32, 32, 3])
y = tf.placeholder(tf.int64, [None])
is_training = tf.placeholder(tf.bool)
# define model
def complex_model(X,y,is_training):
# 7x7 conv layer, 32 filter, stride 1, pad=?, input data size?, output size?, num channels in conv== input channel
# in.shape= NxCxHxW,
# conv kernel/ filter/ receptive field/ synaptic field = 32xCx7x7
# stride = 1, pad = 'SAME' or 'VALID' or 'FULL'??
# out.shape equation Nx32xOHxOW
# OH = (H + 2*pad - kH)/ stride + 1
# OW = (W + 2*pad - kW)/ stride + 1
Wconv = tf.get_variable(dtype=, name=, shape=, trainable=is_training)
tf.nn.conv2d(data_format=,filter=,filter_sizes=,input=,input_sizes=,name=,out_backprop=,output_shape=,padding=,strides=,use_cudnn_on_gpu=,value=)
# non-linearity/ activation function/ activation layer/ rectified linear unit (ReLU)
tf.nn.relu(biases=, features=, name=, weights=, x=)
# Spatial batch normalization with trainable/learnable parameters with scale and centering
# mean, scale/ std/ variance, gamma, beta, running average, running variance, momentum
tf.nn.batch_normalization(mean=, name=, offset=, scale=, variance=, variance_epsilon=, x=)
# 2x2 max pooling layer with stride 2
# average pooling or max pooling
# pooling is a convolution as well
# max pooling is a non-linear convolutional operation
# average pooling is a linear convolutional operation
# There is a big difference between the first convoltion and pooling which is also a convolution.
# simple cell and complex cell idea is the inspiration behind these twp convolutional approach
# complex cell is the inpirational idea/ idea/ inspiration behind pooling
# Since pooling is also a convolutional approach:
# receptive field/ synaptic field/ number of synapses/ conv input/ kernel size: kN, kC, kH, kW
# conv size: kN x kC x kH x kW, conv stride, conv pad, conv out, conv input
# This convlution operation mimiking complex cell receptive field/ functionality very loosely/ vaguely is pooling.
# pool input, pool kernel size, pool stride, pool pad, pool output
# Pooling is intended to bring robustness/ reliability to the features and downsample the input/ less input samples
tf.nn.pool(data_format=, dilation_rate=, input=, name=, padding=, pooling_type=, strides=, window_shape=)
# After conv, bn, pool, we have a fully connected layer/ dense which is the same as affine layer.
# AT this point, we should flatten the tensor output of the pooling layer;
# we should feed into a fully connected layer with many neurons/ hidden units
# This is an affine layer/ fully connected layer with 1024 units/
out_pool.reshape(N, -1)
# Create a variable W or weights or synaptic weights or pre-synaptic weights to post synaptic weights and number of neurons
# Create biases as well the same as number of neurons in the fully connected layer
# number of neurons to number of output classes which is another fully connected layer
# create the weights and biases
pass
y_out = complex_model(X,y,is_training)
To make sure you're doing the right thing, use the following tool to check the dimensionality of your output (it should be 64 x 10, since our batches have size 64 and the output of the final affine layer should be 10, corresponding to our 10 classes):
In [6]:
# Now we're going to feed a random batch into the model
# and make sure the output is the right size
x = np.random.randn(64, 32, 32,3)
with tf.Session() as sess:
with tf.device("/cpu:0"): #"/cpu:0" or "/gpu:0"
tf.global_variables_initializer().run()
ans = sess.run(y_out,feed_dict={X:x,is_training:True})
%timeit sess.run(y_out,feed_dict={X:x,is_training:True})
print(ans.shape)
print(np.array_equal(ans.shape, np.array([64, 10])))
You should see the following from the run above
(64, 10)
True
Now, we're going to try and start the model under the GPU device, the rest of the code stays unchanged and all our variables and operations will be computed using accelerated code paths. However, if there is no GPU, we get a Python exception and have to rebuild our graph. On a dual-core CPU, you might see around 50-80ms/batch running the above, while the Google Cloud GPUs (run below) should be around 2-5ms/batch.
In [ ]:
try:
with tf.Session() as sess:
with tf.device("/gpu:0") as dev: #"/cpu:0" or "/gpu:0"
tf.global_variables_initializer().run()
ans = sess.run(y_out,feed_dict={X:x,is_training:True})
%timeit sess.run(y_out,feed_dict={X:x,is_training:True})
except tf.errors.InvalidArgumentError:
print("no gpu found, please use Google Cloud if you want GPU acceleration")
# rebuild the graph
# trying to start a GPU throws an exception
# and also trashes the original graph
tf.reset_default_graph()
X = tf.placeholder(tf.float32, [None, 32, 32, 3])
y = tf.placeholder(tf.int64, [None])
is_training = tf.placeholder(tf.bool)
y_out = complex_model(X,y,is_training)
You should observe that even a simple forward pass like this is significantly faster on the GPU. So for the rest of the assignment (and when you go train your models in assignment 3 and your project!), you should use GPU devices. However, with TensorFlow, the default device is a GPU if one is available, and a CPU otherwise, so we can skip the device specification from now on.
Now that you've seen how to define a model and do a single forward pass of some data through it, let's walk through how you'd actually train one whole epoch over your training data (using the complex_model you created provided above).
Make sure you understand how each TensorFlow function used below corresponds to what you implemented in your custom neural network implementation.
First, set up an RMSprop optimizer (using a 1e-3 learning rate) and a cross-entropy loss function. See the TensorFlow documentation for more information
In [ ]:
# Inputs
# y_out: is what your model computes
# y: is your TensorFlow variable with label information
# Outputs
# mean_loss: a TensorFlow variable (scalar) with numerical loss
# optimizer: a TensorFlow optimizer
# This should be ~3 lines of code!
mean_loss = None
optimizer = None
pass
In [ ]:
# batch normalization in tensorflow requires this extra dependency
extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(extra_update_ops):
train_step = optimizer.minimize(mean_loss)
In [ ]:
sess = tf.Session()
sess.run(tf.global_variables_initializer())
print('Training')
run_model(sess,y_out,mean_loss,X_train,y_train,1,64,100,train_step)
In [ ]:
print('Validation')
run_model(sess,y_out,mean_loss,X_val,y_val,1,64)
tf.layers. For each network architecture that you try, you should tune the learning rate and regularization strength. When doing this there are a couple important things to keep in mind:
If you are feeling adventurous there are many other features you can implement to try and improve your performance. You are not required to implement any of these; however they would be good things to try for extra credit.
If you do decide to implement something extra, clearly describe it in the "Extra Credit Description" cell below.
At the very least, you should be able to train a ConvNet that gets at >= 70% accuracy on the validation set. This is just a lower bound - if you are careful it should be possible to get accuracies much higher than that! Extra credit points will be awarded for particularly high-scoring models or unique approaches.
You should use the space below to experiment and train your network. The final cell in this notebook should contain the training and validation set accuracies for your final trained network.
Have fun and happy training!
In [ ]:
# Feel free to play with this cell
def my_model(X,y,is_training):
pass
tf.reset_default_graph()
X = tf.placeholder(tf.float32, [None, 32, 32, 3])
y = tf.placeholder(tf.int64, [None])
is_training = tf.placeholder(tf.bool)
y_out = my_model(X,y,is_training)
mean_loss = None
optimizer = None
pass
# batch normalization in tensorflow requires this extra dependency
extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(extra_update_ops):
train_step = optimizer.minimize(mean_loss)
In [ ]:
# Feel free to play with this cell
# This default code creates a session
# and trains your model for 10 epochs
# then prints the validation set accuracy
sess = tf.Session()
sess.run(tf.global_variables_initializer())
print('Training')
run_model(sess,y_out,mean_loss,X_train,y_train,10,64,100,train_step,True)
print('Validation')
run_model(sess,y_out,mean_loss,X_val,y_val,1,64)
In [ ]:
# Test your model here, and make sure
# the output of this cell is the accuracy
# of your best model on the training and val sets
# We're looking for >= 70% accuracy on Validation
print('Training')
run_model(sess,y_out,mean_loss,X_train,y_train,1,64)
print('Validation')
run_model(sess,y_out,mean_loss,X_val,y_val,1,64)
Tell us here
In [ ]:
print('Test')
run_model(sess,y_out,mean_loss,X_test,y_test,1,64)