视频里 Andrej Karpathy上课的时候说,这次的作业meaty but educational,确实很meaty,作业一般是由.ipynb文件和.py文件组成,这次因为每个.ipynb文件涉及到的.py文件较多,且互相之间有交叉,所以每篇博客只贴出一个.ipynb或者一个.py文件.(因为之前的作业由于是一个.ipynb文件对应一个.py文件,所以就整合到一篇博客里)
还是那句话,有错误希望帮我指出来,多多指教,谢谢
cnn.py内容：
import numpy as np
from cs231n.layers import *
from cs231n.fast_layers import *
from cs231n.layer_utils import *
class ThreeLayerConvNet(object):
"""
A three-layer convolutional network with the following architecture:
conv - relu - 2x2 max pool - affine - relu - affine - softmax
The network operates on minibatches of data that have shape (N, C, H, W)
consisting of N images, each with height H and width W and with C input
channels.
"""
def __init__(self, input_dim=(3, 32, 32), num_filters=32, filter_size=7,
hidden_dim=100, num_classes=10, weight_scale=1e-3, reg=0.0,
dtype=np.float32):
"""
Initialize a new network.
Inputs:
- input_dim: Tuple (C, H, W) giving size of input data
- num_filters: Number of filters to use in the convolutional layer
- filter_size: Size of filters to use in the convolutional layer
- hidden_dim: Number of units to use in the fully-connected hidden layer
- num_classes: Number of scores to produce from the final affine layer.
- weight_scale: Scalar giving standard deviation for random initialization
of weights.
- reg: Scalar giving L2 regularization strength
- dtype: numpy datatype to use for computation.
"""
self.params = {}
self.reg = reg
self.dtype = dtype
############################################################################
# TODO: Initialize weights and biases for the three-layer convolutional #
# network. Weights should be initialized from a Gaussian with standard #
# deviation equal to weight_scale; biases should be initialized to zero. #
# All weights and biases should be stored in the dictionary self.params. #
# Store weights and biases for the convolutional layer using the keys 'W1' #
# and 'b1'; use keys 'W2' and 'b2' for the weights and biases of the #
# hidden affine layer, and keys 'W3' and 'b3' for the weights and biases #
# of the output affine layer. #
############################################################################
self.params['W1'] = weight_scale * np.random.randn(num_filters,\
input_dim[0],\
filter_size,\
filter_size)
self.params['b1'] = np.zeros(num_filters)
self.params['W2'] = weight_scale * np.random.randn(\
num_filters * input_dim[1] * input_dim[2] / 4, \
hidden_dim)
self.params['b2'] = np.zeros(hidden_dim)
self.params['W3'] = weight_scale * np.random.randn(hidden_dim, num_classes)
self.params['b3'] = np.zeros(num_classes)
############################################################################
# END OF YOUR CODE #
############################################################################
for k, v in self.params.iteritems():
self.params[k] = v.astype(dtype)
def loss(self, X, y=None):
"""
Evaluate loss and gradient for the three-layer convolutional network.
Input / output: Same API as TwoLayerNet in fc_net.py.
"""
W1, b1 = self.params['W1'], self.params['b1']
W2, b2 = self.params['W2'], self.params['b2']
W3, b3 = self.params['W3'], self.params['b3']
# pass conv_param to the forward pass for the convolutional layer
filter_size = W1.shape[2]
conv_param = {'stride': 1, 'pad': (filter_size - 1) / 2}
# pass pool_param to the forward pass for the max-pooling layer
pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}
scores = None
############################################################################
# TODO: Implement the forward pass for the three-layer convolutional net, #
# computing the class scores for X and storing them in the scores #
# variable. #
############################################################################
a1, cache1= conv_relu_pool_forward(X, W1, b1, conv_param, pool_param)
a1_reshape = a1.reshape(a1.shape[0], -1)
a2, cache2 = affine_relu_forward(a1_reshape, W2, b2)
scores, cache3 = affine_forward(a2, W3, b3)
############################################################################
# END OF YOUR CODE #
############################################################################
if y is None:
return scores
loss, grads = 0, {}
############################################################################
# TODO: Implement the backward pass for the three-layer convolutional net, #
# storing the loss and gradients in the loss and grads variables. Compute #
# data loss using softmax, and make sure that grads[k] holds the gradients #
# for self.params[k]. Don't forget to add L2 regularization! #
############################################################################
loss_without_reg, dscores = softmax_loss(scores, y)
loss = loss_without_reg + \
0.5 * self.reg * (np.sum(W1**2) + np.sum(W2**2) + np.sum(W3**2))
da2, grads['W3'], grads['b3'] = affine_backward(dscores, cache3)
grads['W3'] += self.reg * cache3[1]
da1, grads['W2'], grads['b2'] = affine_relu_backward(da2, cache2)
grads['W2'] += self.reg * cache2[0][1]
da1_reshape = da1.reshape(*a1.shape)
dx, grads['W1'], grads['b1'] = conv_relu_pool_backward(da1_reshape, cache1)
grads['W1'] += self.reg * cache1[0][1]
############################################################################
# END OF YOUR CODE #
############################################################################
return loss, grads
################################################################################
# add by xieyi #
################################################################################
class ConvNetArch_1(object):
"""
A arbitrary number of hidden layers convolutional network with the following
architecture:
[conv-relu-pool]xN - [conv - relu] - [affine]xM - [softmax or SVM]
[conv-relu-pool]XN - [affine]XM - [softmax or SVM]
' - [conv - relu] - ' can be trun on/off by parameter 'connect_conv'
both architecture can do with or without batch normalization
The network operates on minibatches of data that have shape (N, C, H, W)
consisting of N images, each with height H and width W and with C input
channels.
The learnable parameters of the model are stored in the dictionary self.params
that maps parameter names to numpy arrays.
"""
def __init__(self, conv_dims, hidden_dims, input_dim=(3, 32, 32), connect_conv = 0,
use_batchnorm=False, num_classes=10, loss_fuction='softmax',
weight_scale=1e-3, reg=0.0, dtype=np.float32):
"""
Initialize a new network.
Inputs:
- input_dim: Tuple (C, H, W) giving size of input data
- conv_dims: List of tuple[(filters_num, filter_size)*N] Number of filters
and filter_size in convolutional layers
- connect_conv: Whether or not the conv - relu should implement to connect
[conv-relu-pool]xN and [affine]xM
- hidden_dims: Number of units to use in the fully-connected hidden layer
- num_classes: Number of scores to produce from the final affine layer.
- loss_fuction: type of loss function
- weight_scale: Scalar giving standard deviation for random initialization
of weights.
- reg: Scalar giving L2 regularization strength
- dtype: numpy datatype to use for computation.
"""
self.num_conv_layers = len(conv_dims)
self.num_fc_layers = len(hidden_dims)
self.use_connect_conv = connect_conv>0
self.use_batchnorm = use_batchnorm
self.loss_fuction = loss_fuction
self.reg = reg
self.dtype = dtype
self.params = {}
############################################################################
# Initialize weights and biases for the convolutional #
# network. Weights should be initialized from a Gaussian with standard #
# deviation equal to weight_scale; biases should be initialized to zero. #
# All weights and biases should be stored in the dictionary self.params. #
# Store weights and biases for the convolutional layer using the keys 'CW1'#
# and 'cb1'; use keys 'FW1' and 'fb1' for the weights and biases of the #
# hidden fully connectedNet layers, 'CCW' and 'ccb' for connect_conv layer #
############################################################################
# initialize conv_layers:
for i in xrange(self.num_conv_layers):
if i==0:
self.params['CW1'] = weight_scale * np.random.randn(\
conv_dims[i][0],\
input_dim[0],\
conv_dims[i][1],\
conv_dims[i][1])
self.params['cb1'] = np.zeros(conv_dims[i][0])
#print self.params['CW1'].shape,self.params['cb1'].shape
if use_batchnorm:
self.params['cgamma1'] = np.ones(conv_dims[i][0])
self.params['cbeta1'] = np.zeros(conv_dims[i][0])
else:
self.params['CW'+str(i+1)] = weight_scale * np.random.randn(\
conv_dims[i][0],\
conv_dims[i-1][0],\
conv_dims[i][1],\
conv_dims[i][1])
self.params['cb'+str(i+1)] = np.zeros(conv_dims[i][0])
if use_batchnorm:
self.params['cgamma'+str(i+1)] = np.ones(conv_dims[i][0])
self.params['cbeta'+str(i+1)] = np.zeros(conv_dims[i][0])
if self.use_connect_conv:
self.params['CCW'] = weight_scale * np.random.randn(\
connect_conv[0],\
conv_dims[-1][0],\
connect_conv[1],\
connect_conv[1])
self.params['ccb'] = np.zeros(connect_conv[0])
if self.use_batchnorm:
self.params['ccgamma'] = np.ones(connect_conv[0])
self.params['ccbeta'] = np.zeros(connect_conv[0])
#initialize affine layers:
for i in xrange(self.num_fc_layers):
if i == 0:
#initialize first affine layers
if self.use_connect_conv:
self.params['FW'+str(i+1)] = weight_scale * np.random.randn(
connect_conv[0]*input_dim[1]*input_dim[2]/4**self.num_conv_layers,
hidden_dims[i])
else:
self.params['FW'+str(i+1)] = weight_scale * np.random.randn(
conv_dims[-1][0]*input_dim[1]*input_dim[2]/4**self.num_conv_layers,
hidden_dims[i])
self.params['fb'+str(i+1)] = np.zeros(hidden_dims[i])
#initialize first batch normalize layers
if self.use_batchnorm:
self.params['fgamma'+str(i+1)] = np.ones(hidden_dims[i])
self.params['fbeta'+str(i+1)] = np.zeros(hidden_dims[i])
elif i == self.num_fc_layers-1:
#initialize last affine layers
self.params['FW'+str(i+1)] = \
weight_scale * np.random.randn(hidden_dims[i-1], num_classes)
self.params['fb'+str(i+1)] = np.zeros(num_classes)
if self.use_batchnorm:
self.params['fgamma'+str(i+1)] = np.ones(num_classes)
self.params['fbeta'+str(i+1)] = np.zeros(num_classes)
else:
#initialize affine layers
self.params['FW'+str(i+1)] = \
weight_scale * np.random.randn(hidden_dims[i-1], hidden_dims[i])
self.params['fb'+str(i+1)] = np.zeros(hidden_dims[i])
#initialize batch normalize layers
if self.use_batchnorm:
self.params['fgamma'+str(i+1)] = np.ones(hidden_dims[i])
self.params['fbeta'+str(i+1)] = np.zeros(hidden_dims[i])
# pass conv_params to the forward pass for the convolutional layer
self.conv_params = []
self.conv_params = [{'stride': 1, 'pad': (conv_dims[i][1] - 1) / 2}\
for i in xrange(self.num_conv_layers)]
if self.use_connect_conv:
self.conv_params.append({'stride': 1, 'pad': (connect_conv[1] - 1) / 2})
# pass pool_param to the forward pass for the max-pooling layer
self.pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}
# With batch normalization we need to keep track of running means and
# variances, so we need to pass a special bn_param object to each batch
# normalization layer. You should pass self.bn_params[0] to the forward pass
# of the first batch normalization layer, self.bn_params[1] to the forward
# pass of the second batch normalization layer, etc.
self.sbn_params = []
if self.use_batchnorm:
self.sbn_params = [{'mode': 'train'} for i in xrange(self.num_conv_layers)]
if self.use_connect_conv:
self.sbn_params.append({'mode': 'train'})
self.bn_params = []
if self.use_batchnorm:
self.bn_params = [{'mode': 'train'} for i in xrange(self.num_fc_layers)]
# Cast all parameters to the correct datatype
for k, v in self.params.iteritems():
self.params[k] = v.astype(dtype)
def loss(self, X, y=None):
"""
Evaluate loss and gradient for the three-layer convolutional network.
Input / output: Same API as TwoLayerNet in fc_net.py.
"""
X = X.astype(self.dtype)
mode = 'test' if y is None else 'train'
# Set train/test mode for batchnorm params since they
# behave differently during training and testing.
if self.use_batchnorm:
for bn_param in self.bn_params:
bn_param['mode'] = mode
for bn_param in self.sbn_params:
bn_param['mode'] = mode
# bn_param[mode] = mode
# the original CODE is right above, BUT I think it's wrong
if self.use_connect_conv:
self.sbn_params[-1]['mode'] = mode
scores = None
############################################################################
# Implement the forward pass for the three-layer convolutional net, #
# computing the class scores for X and storing them in the scores #
# variable. #
############################################################################
a = X
cache = []
#conv_forward:
for i in xrange(self.num_conv_layers):
if self.use_batchnorm:
a_temp, cache_temp = conv_bn_relu_pool_forward(a,\
self.params['CW'+str(i+1)], \
self.params['cb'+str(i+1)], \
self.params['cgamma'+str(i+1)], \
self.params['cbeta'+str(i+1)], \
self.conv_params[i], \
self.pool_param,\
self.sbn_params[i])
a = a_temp
cache.append(cache_temp)
else:
a_temp, cache_temp = conv_relu_pool_forward(a,\
self.params['CW'+str(i+1)], \
self.params['cb'+str(i+1)], \
self.conv_params[i], \
self.pool_param)
a = a_temp
cache.append(cache_temp)
#connect_conv_forward
if self.use_connect_conv:
if self.use_batchnorm:
# conv_forward:
a_temp, cache_temp = conv_forward_fast(a, \
self.params['CCW'], \
self.params['ccb'], \
self.conv_params[-1])
a = a_temp
cache.append(cache_temp)
# spatial_batchnorm_forward:
a_temp, cache_temp = spatial_batchnorm_forward(a, \
self.params['ccgamma'], \
self.params['ccbeta'], \
self.sbn_params[-1])
a = a_temp
cache.append(cache_temp)
# Rulu forward:
a_temp, cache_temp = relu_forward(a)
a = a_temp
cache.append(cache_temp)
else:
a_temp, cache_temp = conv_relu_forward(a, \
self.params['CCW'], \
self.params['ccb'], \
self.conv_params[-1])
a = a_temp
cache.append(cache_temp)
#affine forward:
N = X.shape[0]
x_temp_shape = a.shape
for i in xrange(self.num_fc_layers):
a_temp, cache_temp = affine_forward(a.reshape(N, -1), \
self.params['FW'+str(i+1)], \
self.params['fb'+str(i+1)])
a = a_temp
cache.append(cache_temp)
if self.use_batchnorm:
a_temp, cache_temp = batchnorm_forward(a, \
self.params['fgamma'+str(i+1)], \
self.params['fbeta'+str(i+1)],
self.bn_params[i])
a = a_temp
cache.append(cache_temp)
scores = a
############################################################################
# END OF YOUR CODE #
############################################################################
if mode == 'test':
return scores
loss, grads = 0, {}
############################################################################
# Implement the backward pass for the three-layer convolutional net, #
# storing the loss and gradients in the loss and grads variables. Compute #
# data loss using softmax or svm_loss, and make sure that grads[k] holds #
# the gradients for self.params[k]. Don't forget to add L2 regularization! #
############################################################################
# compute loss:
if self.loss_fuction=='softmax':
loss_without_reg, dscores = softmax_loss(scores, y)
elif self.loss_fuction=='svm_loss':
loss_without_reg, dscores = svm_loss(scores, y)
loss = loss_without_reg
for i in xrange(self.num_conv_layers):
loss += 0.5*self.reg*np.sum(self.params['CW'+str(i+1)]**2)
if self.use_connect_conv:
loss += 0.5*self.reg*np.sum(self.params['CCW']**2)
for i in xrange(self.num_fc_layers):
loss += 0.5*self.reg*np.sum(self.params['FW'+str(i+1)]**2)
#### compute fully-connected layers grads{}
dout = dscores
for i in reversed(xrange(self.num_fc_layers)):
if self.use_batchnorm:
dout_temp, grads['fgamma'+str(i+1)], grads['fbeta'+str(i+1)] = \
batchnorm_backward(dout, cache.pop(-1))
dout = dout_temp
dout_temp, grads['FW'+str(i+1)], grads['fb'+str(i+1)] = \
affine_backward(dout, cache.pop(-1))
dout = dout_temp
# compute connect conv_layer grads{}
dout = dout.reshape(x_temp_shape)
if self.use_connect_conv:
if self.use_batchnorm:
dout_temp = relu_backward(dout, cache.pop(-1))
dout = dout_temp
dout_temp, grads['ccgamma'], grads['ccbeta'] = \
spatial_batchnorm_backward(dout, cache.pop(-1))
dout = dout_temp
dout_temp, grads['CCW'], grads['ccb'] = \
conv_backward_fast(dout, cache.pop(-1))
dout = dout_temp
else:
dout_temp, grads['CCW'], grads['ccb'] = \
conv_relu_backward(dout, cache.pop(-1))
dout = dout_temp
# compute conv_layers grads{}
for i in reversed(xrange(self.num_conv_layers)):
if self.use_batchnorm:
dout_temp, grads['CW'+str(i+1)], grads['cb'+str(i+1)], \
grads['cgamma'+str(i+1)], grads['cbeta'+str(i+1)] = \
conv_bn_relu_pool_backward(dout, cache.pop(-1))
dout = dout_temp
else:
dout_temp, grads['CW'+str(i+1)], grads['cb'+str(i+1)] = \
conv_relu_pool_backward(dout, cache.pop(-1))
dout = dout_temp
############################################################################
# END OF YOUR CODE #
############################################################################
return loss, grads
