cs231n：assignment2——python文件：cnn.py
来源：互联网 发布：ug数控编程 编辑：程序博客网 时间：2024/06/11 12:58
视频里 Andrej Karpathy上课的时候说,这次的作业meaty but educational,确实很meaty,作业一般是由.ipynb文件和.py文件组成,这次因为每个.ipynb文件涉及到的.py文件较多,且互相之间有交叉,所以每篇博客只贴出一个.ipynb或者一个.py文件.(因为之前的作业由于是一个.ipynb文件对应一个.py文件,所以就整合到一篇博客里)
还是那句话,有错误希望帮我指出来,多多指教,谢谢
cnn.py内容：
import numpy as npfrom 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 0 0
- cs231n：assignment2——python文件：cnn.py
- cs231n：assignment2——python文件：layers.py
- cs231n：assignment2——python文件：layer_utils.py
- cs231n：assignment2——python文件：fc_net.py
- cs231n：assignment2——python文件：optim.py
- 深度学习小白——CS231n Assignment2（CNN）
- cs231n：assignment2——Q2: Batch Normalization
- cs231n：assignment2——Q3: Dropout
- [CS231n-assignment2] Python从零实现的CNN在CIFAR-10上的实验报告
- cs231n：assignment2——Q1: Fully-connected Neural Network
- cs231n：assignment2——Q4: ConvNet on CIFAR-10
- 深度学习小白——CS231n Assignment2(FC)
- [CS231n@Stanford] Assignment2-Q1 (python) Fully-connected Neural Network实现
- CS231n Assignment2--Q1
- CS231n Assignment2--Q2
- CS231n Assignment2--Q3
- CS231n Assignment2--Q4
- #cs231n#Assignment2：FullyConnectedNets.ipynb
- OpenCV 获取摄像头并显示摄像头视频
- Boost库的编译及在vs2010下的环境配置
- RxJava2 基础详解
- linux学习笔记day01
- 单片机enc28j60的ARP实验
- cs231n：assignment2——python文件：cnn.py
- Android课堂笔记——Menu
- 命名空间的定义与使用
- Hibernate关联关系映射
- C++ static关键字：
- matlab中ordfilt2函数
- 32位程序访问64位 system32文件夹时注意事项
- AndroidStudio快速写增强型for循环
- [JavaEE - JPA] 4. EntityManager相关核心概念
