python手写神经网络之手动微分与梯度校验——《深度学习入门——基于Python的理论与实现（第五章）》

下面内容&＃xff0c;算是一个debug过程&＃xff0c;但是也算是一个学习过程&＃xff0c;了解梯度校验的过程和影响微分梯度计算的因素。

下边是根据书本模仿的两层网络&＃xff0c;并非抄原代码&＃xff0c;所以有所不同&＃xff0c;但是我主观觉得差不多&＃xff08;有几个接口暂不列出&＃xff09;&＃xff0c;但是代码不是敲出来不报错就行了&＃xff0c;这个既然是两种梯度&＃xff0c;那就肯定是用来梯度校验的&＃xff0c;既然是梯度校验&＃xff0c;那当然得真校验一把才行啊。

两层网络&＃xff08;784&＃xff0c;50&＃xff0c;10&＃xff09;。网络全随机&＃xff0c;不训练&＃xff0c;从mnist拿一个batch&＃xff0c;做一次analytic grad&＃xff0c;一次numerical grad&＃xff0c;对比绝对值差距&＃xff0c;校验反向传播。结果&＃xff0c;一试&＃xff0c;果然不正常了。

class TwoLayerNet():def __init__(self,input_size,hidden_size,output_size,weight_init_std&＃61;0.01):self.params &＃61; {}self.params[&＃39;W1&＃39;] &＃61; np.random.randn(input_size,hidden_size) * weight_init_stdself.params[&＃39;b1&＃39;] &＃61; np.random.randn(hidden_size)self.params[&＃39;W2&＃39;] &＃61; np.random.randn(hidden_size,output_size)self.params[&＃39;b2&＃39;] &＃61; np.random.randn(output_size)self.layers &＃61; OrderedDict()self.layers[&＃39;Affine1&＃39;] &＃61; Affine(self.params[&＃39;W1&＃39;],self.params[&＃39;b1&＃39;])self.layers[&＃39;relu1&＃39;] &＃61; ReluLayer()self.layers[&＃39;Affine2&＃39;] &＃61; Affine(self.params[&＃39;W2&＃39;],self.params[&＃39;b2&＃39;])self.final_layer &＃61; SoftmaxWithLoss()def predict(self,x):for layer in self.layers.values():x &＃61; layer.forward(x)return xdef loss(self,x,t):#one-hoty &＃61; self.predict(x)loss &＃61; self.final_layer.forward(y,t)return lossdef accuracy(self,x,t):y &＃61; self.predict(x)y &＃61; np.argmax(axis&＃61;1)if t.ndim !&＃61; 1:#one-hot to numt &＃61; np.argmax(t,axis&＃61;1)acc &＃61; np.sum(y&＃61;&＃61;t) / y.shape[0]#there s no need to cast to float float(y.shape[0])return accdef numerical_gradient(self,x,t):grads &＃61; {}# f &＃61; lambda x:self.loss(x,t)#这样写&＃xff0c;求的是对x的导数loss_W &＃61; lambda W:self.loss(x,t)#grads[&＃39;W1&＃39;] &＃61; numerical_gradient(loss_W,self.params[&＃39;W1&＃39;])grads[&＃39;b1&＃39;] &＃61; numerical_gradient(loss_W,self.params[&＃39;b1&＃39;])grads[&＃39;W2&＃39;] &＃61; numerical_gradient(loss_W,self.params[&＃39;W2&＃39;])grads[&＃39;b2&＃39;] &＃61; numerical_gradient(loss_W,self.params[&＃39;b2&＃39;])return gradsdef gradient(self,x,t):#backpropagationgrads &＃61; {}loss &＃61; self.loss(x,t) # 也许这里是省略了&＃xff0c;看最后怎么用吧dout &＃61; 1.0dout &＃61; self.final_layer.backward(dout)layers &＃61; list(self.layers.values())layers.reverse()#reverse in placefor layer in layers:dout &＃61; layer.backward(dout)grads[&＃39;W1&＃39;] &＃61; self.layers[&＃39;Affine1&＃39;].dWgrads[&＃39;b1&＃39;] &＃61; self.layers[&＃39;Affine1&＃39;].dbgrads[&＃39;W2&＃39;] &＃61; self.layers[&＃39;Affine2&＃39;].dWgrads[&＃39;b2&＃39;] &＃61; self.layers[&＃39;Affine2&＃39;].dbreturn grads

用书中代码的两层网络&＃xff0c;一般校验结果在1e-6~1e-10的级别。发现自己的偶尔在1e-6左右&＃xff0c;经常在0.01这个级别&＃xff0c;两层网络&＃xff0c;grad从1.0起&＃xff0c;能到0.01差距&＃xff0c;可以说非常大了&＃xff0c;但是死活看不出哪有问题。

有些代码虽然写的不一样&＃xff0c;但是看不出实际问题&＃xff0c;比如他的softmax内部是转置做的&＃xff0c;再转回来&＃xff0c;我是直接做的&＃xff0c;axis都能对应上。

跟踪数据&＃xff0c;发现softmaxBP的梯度还相似&＃xff0c;一到Affine层马上就不同了&＃xff0c;跟起来发现变量太多&＃xff0c;所以逐步排除随机性&＃xff0c;保持一致性&＃xff0c;查找原因。

排除随机变量&＃xff1a;

seed固定&＃xff0c;mnist中data固定&＃xff0c;网络层参数定义顺序固定&＃xff0c;batch_size改成1&＃xff0c;便于观察

不同点——loss&＃xff1a;

首先&＃xff0c;FP的loss就不同&＃xff0c;虽然BP是初始化1.0&＃xff0c;但是还是先排查一下原因&＃xff0c;首先&＃xff0c;网络未经训练&＃xff0c;所有层输出概率接近0.1&＃xff0c;其次&＃xff0c;使用softmax&＃xff0c;那么-tlog(y)就是-log(0.1)&＃xff0c;也就是2.3&＃xff0c;利用书本代码&＃xff0c;是可以得到2.3的loss的&＃xff0c;但是我的代码没得到。

CE的实现

前者把one-hot转成了下标&＃xff0c;后者我的实现继续用one-hot&＃xff0c;但是t的其他下标都是0&＃xff0c;所以应该结果相同。

-np.sum(np.log(y[np.arange(batch_size), t] &＃43; 1e-7)) / batch_size

return -np.sum(t*np.log(y&＃43;1e-7)) / float(batch_size)

他的代码中&＃xff0c;softmax之后&＃xff0c;y是平均的&＃xff0c;而我的y直接就不对了&＃xff0c;[1]特别大&＃xff0c;84%的概率

书上给出的向量化操作

def softmax(x):if x.ndim &＃61;&＃61; 2:x &＃61; x.Tx &＃61; x - np.max(x, axis&＃61;0)y &＃61; np.exp(x) / np.sum(np.exp(x), axis&＃61;0)return y.T x &＃61; x - np.max(x) # 溢出对策return np.exp(x) / np.sum(np.exp(x))

自己实现的softmax&＃xff0c;因为当时的章节没提到向量化&＃xff0c;所以自己做了几个版本的改进&＃xff0c;速度倒是上去了&＃xff0c;但是不明白为什么会有差别

def softmax_old(a):exp_a &＃61; np.exp(a)sum_exp_a &＃61; np.sum(exp_a)y &＃61; exp_a / sum_exp_areturn y
def softmax_no_batch(a):#accords to bookmax_a &＃61; np.max(a)exp_a &＃61; np.exp(a - max_a)sum_exp_a &＃61; np.sum(exp_a)y &＃61; exp_a / sum_exp_areturn y
def softmax(a):#书上没有给出向量化的代码&＃xff0c;这是自己简单写的&＃xff0c;原来代码是错的&＃xff0c;不针对batch数据if a.ndim &＃61;&＃61; 1:return softmax_no_batch(a)y &＃61; np.zeros_like(a,dtype&＃61;np.float64)for i in range(a.shape[0]):y_i &＃61; softmax_no_batch(a[i])y[i] &＃43;&＃61; np.array(y_i)return ydef softmax_batch(a):#自己做一版直接的向量化,效率会geng好么&＃xff1f;numpy,whateverif a.ndim &＃61;&＃61; 1:return 0max_a &＃61; np.max(a,axis&＃61;1)max_a &＃61; max_a.reshape(max_a.size,1)#根据batch分别做# exp_a_input &＃61; a - max_a#for debugexp_a &＃61; np.exp(a - max_a)#sum_exp_a &＃61; np.sum(exp_a,axis&＃61;1)sum_exp_a &＃61; sum_exp_a.reshape(sum_exp_a.size,1)#应该还有一个直接增维的y &＃61; exp_a / sum_exp_areturn y

我目前用的softmax_batch版本,肉眼区别除了我分步骤&＃xff0c;主要就是他先转换了轴&＃xff0c;盲猜是向量化的减法默认的轴错了&＃xff1f;但是实际看了一下&＃xff0c;在softmax之前&＃xff0c;应该已经不正常了&＃xff0c;因为有一个分类特别高&＃xff0c;占比84%&＃xff0c;或者说&＃xff0c;其他都是负数&＃xff0c;他是8.04&＃xff0c;所以问题应该出在前向传播&＃xff0c;affine层和relu层。

但是隐藏层最不好跟&＃xff0c;因为逻辑是不透明的&＃xff0c;也不可能肉眼比数据&＃xff0c;一层50&＃xff0c;一层10&＃xff0c;看不过来。直接就到结果&＃xff0c;结果就是每个类的得分不平均。

但是affine层和relu层是最不容易出错的&＃xff0c;relu层就是一个mask和max操作&＃xff0c;affine层就是一个乘法&＃xff0c;最后发现&＃xff0c;我的W2在初始化的时候&＃xff0c;没有*weight_init_std&＃xff0c;所以是我的W2的scale大了&＃xff1f;

做如下纠正

可见&＃xff0c;量级是纠正了&＃xff0c;不会有一个类直接0.84的那种贫富差距了&＃xff0c;但是和概率预期不一样&＃xff0c;应该全接近0.1&＃xff0c;尤其是&＃xff0c;同样的seed下&＃xff0c;书本代码就能接近0.1

下标5对应label&＃xff0c;cross entropy应该是-log(0.026)&＃xff0c;

所以说&＃xff0c;至少cross entropy&＃xff0c;我的实现没错。

目前的问题仍然是&＃xff0c;隐藏层输出的结果&＃xff0c;不均匀&＃xff0c;而同样初始化下&＃xff0c;书本代码是均匀的&＃xff01;

然后又试了一个土法&＃xff0c;肉眼观察&＃xff0c;发现了大问题&＃xff1a;我的b是np.random.randn()产生的&＃xff0c;更可怕的是&＃xff0c;b没有乘以weight_init_std&＃xff0c;也就是说b的初始化量级比w还大得多&＃xff0c;书的原码其实是用的zeros&＃xff01;

找到问题所在&＃xff0c;下面打算循序渐进&＃xff0c;逐步缩放b&＃xff0c;看一下softmax是否会逐渐变得平均。

b先缩小10倍&＃xff0c;已经是肉眼可见的有变均匀的趋势了

缩小100倍&＃xff0c;同w&＃xff0c;已经足够平均了

改成0初始化&＃xff0c;确实更均匀了点

总结&＃xff1a;局限性

这是训练前的网络&＃xff0c;这样的结果只是一个数学期望的不同&＃xff0c;并不是说那样的初始化就一定不行&＃xff08;但是从逻辑上&＃xff0c;确实很不行&＃xff09;。只是为了解决网络差别&＃xff0c;我的核心问题是两个网络的梯度校验结果偏差很大。

回到正题&＃xff1a;我是做梯度校验的

现在&＃xff0c;解决了b的初始化问题&＃xff0c;直接做一遍梯度校验&＃xff0c;貌似就没问题了&＃xff0c;1e-10的量级。成功了。

{&＃39;W1&＃39;: 4.646074148956723e-10, &＃39;b1&＃39;: 3.3745217775269993e-09, &＃39;W2&＃39;: 7.674316464682633e-09, &＃39;b2&＃39;: 1.7980201277717489e-07}

这本书我个人认为有很多不严谨的地方或者叫照顾不到的地方&＃xff0c;他的宏观的东西一般都不会错&＃xff0c;但是微观的东西&＃xff0c;你却未必真的能理解&＃xff0c;顺序本身没错&＃xff0c;只是有很多细节&＃xff0c;需要你自己想到&＃xff01;&＃xff08;比如微分计算&＃xff0c;我提过https://blog.csdn.net/huqinweI987/article/details/102858397&＃xff09;&＃xff0c;这里也是&＃xff0c;这不是网络训练后的样子&＃xff0c;一点初始化的小差别&＃xff08;也许是本来合理的操作&＃xff0c;比如b的不同初始化&＃xff0c;但是却会直接引起梯度校验结果不符合预期&＃xff0c;但是b的不同本身也不算错误&＃xff0c;网络训练后是可能纠正的&＃xff0c;那时候运行同样的代码&＃xff0c;可能结果就符合预期了&＃xff0c;是不是很神奇&＃xff08;迷茫&＃xff09;&＃xff1f;&＃xff09;

不过这个顺序也有他的道理&＃xff0c;大规模网络训练很慢&＃xff0c;梯度校验本来就是验证你的反向传播是否正确的&＃xff0c;如果你不确定反向传播是否正确&＃xff0c;却拿它来训练网络&＃xff0c;那怎么能得到一个正确的网络&＃xff0c;从而让你再去校验呢&＃xff1f;一来逻辑悖论&＃xff0c;二来本末倒置&＃xff0c;本来就是应该预先检查&＃xff01;

回顾&反思&＃xff1a;

让b维持randn初始化&＃xff0c;不用zeros&＃xff0c;发现偏差也比最初小了&＃xff08;因为排查问题的时候&＃xff0c;我先解决W2的标准化&＃xff0c;后解决概率期望问题&＃xff0c;所以忽略了W2带来的改善&＃xff0c;其实这是最核心的问题&＃xff09;&＃xff0c;所以问题分两方面&＃xff0c;一方面&＃xff0c;b的初始化确实影响精度&＃xff0c;另一方面&＃xff0c;我前边能初始1e-2~1e-5的量级&＃xff0c;还是代码错了&＃xff0c;核心问题就是W2的标准化&＃xff08;*0.01&＃xff09;。

上&＃xff1a;randn初始化b&＃xff1b;中&＃xff1a;zeros初始化b&＃xff1b;下&＃xff1a;去掉W2的标准化

{&＃39;W1&＃39;: 2.3271566726132363e-09, &＃39;b1&＃39;: 1.6902964365753116e-08, &＃39;W2&＃39;: 3.4771239819206885e-07, &＃39;b2&＃39;: 7.405936823164441e-07}

{&＃39;W1&＃39;: 4.646074148956723e-10, &＃39;b1&＃39;: 3.3745217775269993e-09, &＃39;W2&＃39;: 7.674316464682633e-09, &＃39;b2&＃39;: 1.7980201277717489e-07}

{&＃39;W1&＃39;: 0.0030875882040971845, &＃39;b1&＃39;: 0.02242550602948008, &＃39;W2&＃39;: 0.002463212042766619, &＃39;b2&＃39;: 0.006945896231676416}

额外的&＃xff0c;为什么b影响梯度准确性&＃xff1f;&＃xff08;当然&＃xff0c;这不影响实质&＃xff0c;这个量级已经足够验证梯度了&＃xff09;因为无论b是什么&＃xff0c;导数都不会变&＃xff0c;但是微分呢&＃xff0c;如果b的scale比较大&＃xff0c;那么可以预见&＃xff0c;n维的向量&＃xff0c;未经标准化&＃xff08;相对来说&＃xff0c;毕竟初始化的也是标准分布&＃xff0c;但是不够小&＃xff0c;相对来说不够标准化&＃xff09;&＃xff08;说人话&＃xff0c;同样h&＃61;1e-7&＃xff0c;可能一个维度tmp_val接近0以至于损失了精度&＃xff0c;一个维度tmp_val非常大&＃xff09;却用着同样大小的h&＃xff0c;每个维度都会因为没有标准化和计算精度损失而逐步放大偏差。但是这不是出现前边错误的根本&＃xff0c;错误的根本还是w的初始化问题&＃xff0c;因为b只影响一条曲线在纵轴的“高低”&＃xff0c;而w是影响斜率&＃xff0c;从而更大幅度的影响横轴在某个点时&＃xff0c;y在纵轴的“高低”。

下边是微分代码&＃xff0c;按维度改变每x向量的每一个值&＃xff0c;把每个维度的微分都记录下来&＃xff0c;就是最终的结果。而analytic gradient梯度&＃xff0c;直接用人的经验去写反向传播代码完成。

def _numerical_gradient_no_batch(f, x):h &＃61; 1e-4 # 0.0001grad &＃61; np.zeros_like(x)for idx in range(x.size):tmp_val &＃61; x[idx]x[idx] &＃61; float(tmp_val) &＃43; hfxh1 &＃61; f(x) # f(x&＃43;h)x[idx] &＃61; float(tmp_val) - hfxh2 &＃61; f(x) # f(x-h)grad[idx] &＃61; (fxh1 - fxh2) / (2 * h)x[idx] &＃61; tmp_val # 还原值return graddef numerical_gradient(f, X):if X.ndim &＃61;&＃61; 1:return _numerical_gradient_no_batch(f, X)else:grad &＃61; np.zeros_like(X)for idx, x in enumerate(X):grad[idx] &＃61; _numerical_gradient_no_batch(f, x)return grad

所以&＃xff0c;还是要自己多动手&＃xff0c;尤其不要照抄代码&＃xff0c;要手动实现&＃xff0c;看看你想的方法对不对&＃xff0c;错哪了&＃xff0c;不然就成了背代码了&＃xff0c;还很难背&＃xff0c;你以后实际运用还会出错。之前都在说w怎么初始化&＃xff0c;b怎么初始化&＃xff0c;但是到底有多少影响&＃xff0c;不自己跟踪过输出&＃xff0c;很难有一个宏观概念&＃xff0c;可能大家都是随便一初始化&＃xff0c;然后用框架产生梯度&＃xff0c;也不用校验&＃xff0c;然后w和b经过训练也收敛了&＃xff0c;所以就认识不到这一步。况且&＃xff0c;这已经是最简单的网络了&＃xff0c;复杂的网络想跟踪问题会更麻烦&＃xff0c;有可能需要逐层跟踪输出分布&＃xff0c;反向传播也一样。

其他不同点&＃xff0c;但是暂时也没影响&＃xff1a;

比如softmax内部的实现&＃xff0c;比如affine层他保留了original shape&＃xff0c;反向传播时要拿这个shape还原&＃xff0c;而我因为没碰到不匹配的情况&＃xff0c;没实现这个操作。

后续&＃xff1a;根据验证结果使用反向传播&＃xff0c;loss和前边的呼应

验证完了&＃xff0c;自然是可以用效率更高的反向传播gradient()&＃xff0c;而摒弃numerical_gradient()了。

训练过程就是用上前边的gradient方法直接反向传播&＃xff0c;然后更新参数

loss_history &＃61; []
accuracy_history &＃61; []#iterate train
for i in range(iterations):mask &＃61; np.random.choice(x_train.shape[0],batch_size)x_batch &＃61; x_train[mask]t_batch &＃61; t_train[mask]grads &＃61; net.gradient(x_batch,t_batch)for k in net.params:net.params[k] -&＃61; lr * grads[k]if i % print_iterations &＃61;&＃61; 0:loss &＃61; net.loss(x_batch,t_batch)#暂时用batch来打印一下loss_history.append(loss)accuracy &＃61; net.accuracy(x_batch,t_batch)accuracy_history.append(accuracy)

因为我的cross entropy是除以batch size的&＃xff0c;所以很容易通过曲线看到&＃xff0c;batch的loss&＃xff0c;初始值&＃xff0c;和前边的计算是一致的-log(0.1)&＃61;2.3。

本文代码

https://github.com/huqinwei/python_deep_learning_introduction/blob/master/chap05_NN-2layer_grad_check.py

https://github.com/huqinwei/python_deep_learning_introduction/blob/master/chap05_NN_2layer_train.py

更多本书相关代码

https://github.com/huqinwei/python_deep_learning_introduction/