赞
踩
train_data: (train_num, 3072)
loss+=margin; dW[:, i]+=X[i].T; dW[:, correct]-=X[i].T
loss /= num_train; loss += 0.5 * reg * np.sum(W * W)
dW /= num_train; dW += reg * W
scores = X.dot(W) # (num_train, num_class) # 之前的correct类的下标是一个一个获取的,这里直接作为列向量 correct_class_scores = scores[range(num_train), list(y)].reshape(-1,1) #(num_train, 1) # score和correct相减的时候会进行广播,这里要注意正确类别的margin也变成了1,而在上面的流程中是不计算的 margins = np.maximum(0, scores - correct_class_scores +1) # (num_train, num_class) # 将正确类别的margin置为0 margins[range(num_train), list(y)] = 0 loss = np.sum(margins) / num_train + 0.5 * reg * np.sum(W * W) # 用coeff_mat和训练数据矩阵相乘来得到梯度 coeff_mat = np.zeros((num_train, num_classes)) # 那些需要更新参数的位置的系数就是1,上面的流程中是dW[:, i]+=X[i].T,这里系数为1,然后下面再进行矩阵相乘,效果一样 coeff_mat[margins > 0] = 1 coeff_mat[range(num_train), list(y)] = 0 # 正确类别的梯度的是其他类别之和 coeff_mat[range(num_train), list(y)] = -np.sum(coeff_mat, axis=1) dW = (X.T).dot(coeff_mat) dW = dW/num_train + reg*W
为什么在梯度检查的时候会出现个别较大的差错? 因为svm loss不是完全可导的,就像relu函数在0附近一样,越靠近0,分析梯度和数值梯度的差就越多。
将参数W进行可视化的结果是什么样的? W: (3072, 10), 重新reshape到(32, 32, 3, 10)最后的10代表10个分类器,前面的就是每个分类器可视化的结果,它像是每个类别的所有图像的一个模板(取了平均值,因为只有数值相近的时候平方才最大),如果某个类别的分数较高,那么它就越接近这个类图片的模板。
大体上和线性svm分类差不多,只是loss函数不一样。
# 第i个数据 for i in xrange(num_train): scores = X[i].dot(W) shift_scores = scores - max(scores) # 这条数据计算出来的损失 loss_i = - shift_scores[y[i]] + np.log(sum(np.exp(shift_scores))) loss += loss_i # 对于这条数据得到的score,每个类别的score都计算导数 # 单个的score计算导数相当于更新这个类别对应的那个分类器的导数所以有[:, j] for j in xrange(num_classes): softmax_output = np.exp(shift_scores[j])/sum(np.exp(shift_scores)) # 如果这个类别是正确的类别 if j == y[i]: dW[:,j] += (-1 + softmax_output) *X[i] else: dW[:,j] += softmax_output *X[i] loss /= num_train loss += 0.5* reg * np.sum(W * W) dW = dW/num_train + reg* W
num_classes = W.shape[1] num_train = X.shape[0] # 计算得到每个训练数据每个类别的score scores = X.dot(W) # (num_train, 10) # 下面的reshape是为了让计算得到的max在和score相减的时候进行广播,每行的max都是一样的 shift_scores = scores - np.max(scores, axis = 1).reshape(-1,1) # (num_train, 10) # 下面的reshape是为了能够进行广播 softmax_output = np.exp(shift_scores)/np.sum(np.exp(shift_scores), axis = 1).reshape(-1,1) # (num_train, 10) loss = -np.sum(np.log(softmax_output[range(num_train), list(y)])) # 正确类别的占比的负数 loss /= num_train loss += 0.5* reg * np.sum(W * W) dS = softmax_output.copy() # 正确类别的减一,其他的直接和X矩阵相乘 dS[range(num_train), list(y)] += -1 dW = (X.T).dot(dS) dW = dW/num_train + reg* W
在刚初始化的时候,为什么希望计算出来的loss接近-log(0.1)? 因为刚初始化的时候,每个类别的概率都应该相同,所以正确类别的概率应该是0.1,那么loss就应该是-log(0.1)。
Dropout(Improving neural networks by preventing co-adaptation of feature detectors)是一个regularization技术,随机让某些神经元进行失效来获得更好的效果。
def dropout_forward(x, dropout_param): """ Inputs: - x: 输入的数据,可以是任何的shape - dropout_param: dict包含如下的键: - p: dropout概率,每个神经元被失活的概率 - mode: 'test'/'train'如果是'test'则不进行失活 - seed: 随机数生成种子,这个是为了梯度检验用,正常使用中不应该指定这个参数 Outputs: - out: 输出数据shape同x - cache: (dropout_param, mask) 在'train'mode中,mask作用于输入x得到输出,在'test'mode中mask为None """ p, mode = dropout['p'], dropout_param['mode'] if 'seed' in deopout_param: np.random.seed(dropout_param['seed']) mask = None out = None if mode == 'train': # 注意/(1-p) 前向传播的时候均值得稳定 mask = (np.random.rand(*x.shape)>=p)/(1-p) out = x*mask elif mode == 'test': out = x cache = (dropout_param, mask) out = out.astype(x.dtype, copy=False) return out, cache
def dropout_backward(dout, cache): """ Inputs: - dout: 反向传播回来的导数 - cache: (dropout_param, mask) Output: - dx: 导数 """ dropout_param, mask = cache mode = dropout_param['mode'] dx = None if mode == 'train': # dloss/dx = dloss/dout * dout/dx = dloss/dout * mask # 被失活的神经元的mask处为0,其余为1 dx = dout * mask elif mode == 'test': dx = dout return dx
Dropout可以有效地抑制过拟合,一般来说神经元失活的概率越大在训练集上和在验证集上的区别就越小,但是较大的失活概率会导致神经网络的容量下降,更难拟合数据。
在前向传播的过程中注意保存中间数据,为了反向传播的时候方便计算。
def max_pool_forward_naive(x, pool_param): """MaxPool前向传播的一个简单实现版本 Inputs: - x: (N, C, H, W) - pool_param: 包含最大池化参数的字典 - 'pool_height': 池化区域的高度 - 'pool_width': 池化区域的宽度 - 'stride': 相邻池化区域的距离 Returns: - out: 输出的数据 - cache: (x, pool_param) """ out = None N, C, H, W = x.shape HH, WW, stride = pool_param['pool_height'], pool_param['pool_width'] H_out = (H-HH)/stride+1 W_out = (W-WW)/stride+1 out = np.zeros((N, C, H_out, W_out)) # 先确定每个做最大池化的区域 for i in xrange(H_out): for j in xrange(W_out): # 取出这个区域的数据 x_masked = x[:, :, i*stride:i*stride+HH, j*stride:j*stride+WW] # (N, C, HH, WW) # 取最大值 (N, C) out[:, :, i, j] = np.max(x_masked, axis=(2,3)) cache = (x, pool_param) return out, cache
def max_pool_backward_naive(dout, cache): """MaxPool反向传播的一个简单版本 Inputs: - dout: 反向传播过来的导数 - cache: (x, pool_param) Returns: - dx: 导数 """ dx = None x, pool_param = cache N, C, H, W = x.shape HH, WW, stride = pool_param['pool_height'], pool_param['pool_width'], pool_param['stride'] H_out = (H-HH)/stride+1 W_out = (W-WW)/stride+1 # 最大值处的导数能够进行传播,其余的地方导数为0 dx = np.zeros_like(x) # 先确定之前池化的每个区域 for i in xrange(H_out): for j in xrange(W_out): # 取出池化这个区域的数据 x_masked = x[:, :, i*stride:i*stride+HH, j*stride:j*stride+WW] # (N, C, HH, WW) # 取得最大值 (N,C) max_x_masked = np.max(x_masked, axis=(2,3)) # 得到最大值的mask (N, C, HH, WW) 最大值为1 其余为0 temp_binary_mask = (x_masked == (max_x_masked)[:,:,None,None]) # 最大值处的导数能够进行传播,其余的地方导数为0 dx[:, :, i*stride:i*stride+HH, j*stride:j*stride+WW] += temp_binary_mask * (dout[:,:,i,j])[:,:,None,None]
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。