传送门： https://www.cnblogs.com/greentomlee/p/12314064.html
github: https://github.com/Leezhen2014/python_deep_learning
在第二篇中介绍了用数值微分的形式计算神经网络的梯度，数值微分的形式比较简单也容易实现，但是计算上比较耗时。本章会介绍一种能够较为高效的计算出梯度的方法：基于图的误差反向传播。
根据 deep learning from scratch 这本书的介绍，在误差反向传播方法的实现上有两种方法：一种是基于数学式的（第二篇就是利用的这种方法），一种是基于计算图的。这两种方法的本质是一样的，有所不同的是表述方法。计算图的方法可以参考feifei li负责的斯坦福大学公开课CS231n 或者theano的tutorial/Futher readings/graph Structures.
之前我们的误差传播是基于数学式的，可以看出对代码编写者来说很麻烦；
这次我们换成基于计算图的；
Backward是神经网络训练过程中包含的一个过程，在这个过程中会通过反馈调节网络中各个节点的权重，以此达到最佳权重参数。在反馈中，loss value是起点，是衡量与label之间差距的值。Loss value 自然是loss function计算得出的。
TODO:
本章会讲解常见的两种loss function
然后会介绍梯度，梯度是用于修改节点权重的。
最后会实现backward，用mnist数据集训练;
4.1 损失函数
损失函数的种类有很多， 本案只介绍两种损失函数： 均方差、交叉熵；
然后会将交叉熵改写成n-batch的交叉熵；
均方误差（mean squared error）
实现如下：
1 def mean_squared_error(y, t): 2 return 0.5*np.sum((y-t)**2)
交叉熵误差（cross entropy error）
交叉熵的公式和实现如下：
1 def cross_entropy_error(y,t): 2 delta = 1e-7 3 return -np.sum(t*np.log(y+delta))
mini-batch版本的损失函数
上述的两个损失函数都是针对于1-batch做的损失函数；如果输入的数据是n-batch的话，上述的损失函数不太适用了；
需要对损失函数做一下修改，以交叉熵为例，n-batch的交叉熵公式和代码实现如下：
1 def cross_entropy_error(y,t): 2 # batch版本的交叉熵 3 if y.ndim == 1: 4 t = t.reshape(1, t.size) 5 y = y.reshape(1, y.size) 6 batch_size = y.shape[0] # batch 7 8 delta = 1e-7 9 return -np.sum(t*np.log(y+delta))/batch_size 10
4.2 梯度
本节介绍梯度法的实现，不涉及神经网络的反馈算法。本节内容是为下一节反馈算法做铺垫。
神经网络学习的本质是根据数据的label和预测值的误差，即loss value，然后根据误差修改权重信息。
数据的label和预测值的误差可以使用损失函数来衡量，获得loss value。
修改权重的信息可以用求数学统计求极值的方式获得。
已知导数为0的点为极值点，可以通过求导数
一次性找到极值点。但是这种方法在数据样本或者W的规模相当大的情况下是无法计算的，在具有多个变量的情况下会计算多次的偏导数，可以想象到是一件耗时耗力的事情。
梯度法来恰恰可以弥补上述的缺陷。
4.2.1 实现梯度的计算
梯度法优势在于可以一次计算出多个变量的偏导数，并汇总成向量，像
这种汇总而成的向量，称为梯度（注： 来自 deep learning from scratch）。
接下来就是梯度的实现了，计算机是无法直接求出偏导数或者导数的，不过根据数学知识可以得到偏导数的近似值，因此可以：
对应的实现程序如下：
1 def numerical_gradient_1d(f, x): 2 ''' 3 数值微分，求f(x)的梯度 4 :param f: 函数 5 :param x: 梯度值 6 :return: df在x处的导数 7 ''' 8 h = 1e-4 # 0.0001 9 grad = np.zeros_like(x) 10 11 for idx in range(x.size): 12 tmp_val = x[idx] # 缓存原来的值 13 x[idx] = float(tmp_val) + h 14 fxh1 = f(x) # f(x+h) 15 16 x[idx] = tmp_val - h 17 fxh2 = f(x) # f(x-h) 18 grad[idx] = (fxh1 - fxh2) / (2*h) 19 20 x[idx] = tmp_val # 原来的值 21 22 return grad
以上是1D的梯度下降，我们可以扩展成2D的梯度下降函数numerical_gradient_2d：
1 def numerical_gradient_2d(f, X): 2 if X.ndim == 1: 3 return _numerical_gradient_1d(f, X) 4 else: 5 grad = np.zeros_like(X) 6 7 for idx, x in enumerate(X): 8 grad[idx] = _numerical_gradient_1d(f, x) 9 10 return grad 11
1 2 def numerical_gradient(f, x): 3 ''' 4 数值微分，求f(x)的梯度 5 :param f: 6 :param x: 7 :return: 8 ''' 9 h = 1e-4 # 0.0001 10 grad = np.zeros_like(x) 11 12 it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite']) 13 while not it.finished: 14 idx = it.multi_index 15 tmp_val = x[idx] 16 x[idx] = tmp_val + h 17 fxh1 = f(x) # f(x+h) 18 19 x[idx] = tmp_val - h 20 fxh2 = f(x) # f(x-h) 21 grad[idx] = (fxh1 - fxh2) / (2*h) 22 23 x[idx] = tmp_val # 恢复成原来的值 24 it.iternext() 25 26 return grad 27
4.2.2 验证梯度计算方法是否有用
作为一个严谨的程序员，自己 写的每一个模块至少需要做一次验证，以减少后期出现bug的调试；
在此，简单的验证 
的在点
上的梯度；
根据数学知识，可以知道梯度为：
那么
下面开始验证
片段1： function的实现：
1 def function(x): 2 return x[0]**2 + x[1]**2
function的坐标图如下, 可见整个函数的最小值在（0，0）处，因此点（3，4）的梯度方向应该指向（0，0），即：梯度值应该为正数。
1 from matplotlib import pyplot as plot # 用来绘制图形 2 import numpy as np # 用来处理数据 3 from mpl_toolkits.mplot3d import Axes3D # 用来给出三维坐标系。 4 figure = plot.figure() 5 6 # 画出三维坐标系： 7 axes = Axes3D(figure) 8 X = np.arange(-10, 10, 0.25) 9 Y = np.arange(-10, 10, 0.25) 10 X, Y = np.meshgrid(X, Y) # 限定图形的样式是网格线的样式： 11 Z = function([X,Y]) 12 axes.plot_surface(X, Y, Z, cmap='rainbow') # 绘制曲面，采用彩虹色着色： 13 # 图形可视化： 14 plot.show() 15 16 if __name__ == '__main__': 17 # show() 18 print(numerical_gradient(function, np.array([3.0,4.0])))
对应的输出：
[6. 8.]
验证正确, 说明grad的书写没有问题。
4.2.3梯度法的实现
神经网络学习的主要任务是在学习过程中寻找最优参数，这些参数使得loss function 取得最小值。这里的神经网络可以用g(x)表示。
一般来说，神经网络的参数空间较大，损失函数也较为复杂，往往会通过梯度来寻找g(x)的最小值。但需要注意：梯度表示的各个点处函数值减小最多的方向，无法保证是真正的应该进行梯度下降的方向。
尽管如此，沿着梯度的方向依旧是可以最大限度的找到减小损失函数的值。通过不断的向梯度的方向迈进，便会使得loss function逐渐减小(这个过程被称为 梯度法，gradient method)。
梯度法是解决机器学习中优化问题的常用方法，根据优化的目标可以分为： 梯度下降法和梯度上升法。
用数学表达为:
利用上面的公式和numerical_gradient，梯度法的实现如下：
1 def gradient_descent(f, init_x, learning_rate=0.01, step_num=200): 2 ''' 3 通过一步一步的迭代，优化目标函数，找出使得目标函数最小的点 4 :param f: 目标函数 5 :param init_x: 初始位置 6 :param learning_rate: 学习率 7 :param step_num: 迭代次数 8 :return: 9 ''' 10 x = init_x 11 for i in range(step_num): 12 grad = numerical_gradient(f,x) 13 x = x - learning_rate*grad # 公式的实现 14 return x 15 16 if __name__ == '__main__': 17 # show() 18 #print(numerical_gradient(function, np.array([3.0,4.0]))) 19 min_value = gradient_descent(function, init_x=np.array([3.0,4.0])) 20 print(min_value)
4.3 学习算法的实现
本节会阐述学习算法的伪代码，具体实现会在3.4给出。
神经网络的学习中使用到了梯度法（见3.2节），根据梯度法我们可以了解到神经网络学习的过程：可以按照以下4个步骤进行：
Step1：获取minibatch:
从数据集中选取一部分数据，这部分数据称为mini-batch，现在的目标就是减小minibatch 的loss fucntion value。
Step2：计算梯度值
为了减小loss function的值，求出各个权重参数的梯度。梯度是表示损失函数值减小最多的方向。
Step3：更新参数
梯度表示的是损失函数减小的方向；因此将权重参数沿着梯度所指的方向进行微小的更新。
Step4：迭代重复
重复Step1,2,3
以上使用的是梯度下降的方法，由于是随机选择的mini-batch数据（也就是说随机选择的初始点），所以称为 随机梯度下降（stochastic gradient descent）注：见Deep Learning from Scratch
4.4 基于mnist数据集的神经网络的训练
本节整合前面的代码，实现一个两层的神经网络。用mnist数据集训练，来了解整个学习的过程。整个过程会尽量简化.
为了简化起见，网络输入层是784*1，有两个隐含层,神经元的数量分别是50和10; 由于输出层和上一层的输出数量一致,因此用恒等函数即可， 损失函数使用交叉熵。
网络结构如下：
网络结构的实现：
1 # -*- coding: utf-8 -*-
2 # @File : two_layer_net.py
3 # @Author: lizhen
4 # @Date : 2020/1/28
5 # @Desc : 使用梯度的网络
6
7 from src.common.functions import *
8 from src.common.gradient import numerical_gradient
9 import numpy as np
10
11 class TwoLayerNet:
12
13 def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):
14
15 self.params = {}
16 self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
17 self.params['b1'] = np.zeros(hidden_size)
18 self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
19 self.params['b2'] = np.zeros(output_size)
20
21 def predict(self, x):
22 W1, W2 = self.params['W1'], self.params['W2']
23 b1, b2 = self.params['b1'], self.params['b2']
24
25 a1 = np.dot(x, W1) + b1
26 z1 = sigmoid(a1)
27 a2 = np.dot(z1, W2) + b2
28 y = softmax(a2)
29
30 return y
31
32 # x:输入参数, t:label
33 def loss(self, x, t):
34 y = self.predict(x)
35
36 return cross_entropy_error(y, t)
37
38 def accuracy(self, x, t):
39 y = self.predict(x)
40 y = np.argmax(y, axis=1)
41 t = np.argmax(t, axis=1)
42
43 accuracy = np.sum(y == t) / float(x.shape[0])
44 return accuracy
45
46 # x:输入参数, t:label
47 def numerical_gradient(self, x, t):
48 loss_W = lambda W: self.loss(x, t)
49
50 grads = {}
51 grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
52 grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
53 grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
54 grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
55
56 return grads
57
58 def gradient(self, x, t):
59 W1, W2 = self.params['W1'], self.params['W2']
60 b1, b2 = self.params['b1'], self.params['b2']
61 grads = {}
62
63 batch_num = x.shape[0]
64
65 # forward
66 a1 = np.dot(x, W1) + b1
67 z1 = sigmoid(a1)
68 a2 = np.dot(z1, W2) + b2
69 y = softmax(a2)
70
71 # backward
72 dy = (y - t) / batch_num
73 grads['W2'] = np.dot(z1.T, dy)
74 grads['b2'] = np.sum(dy, axis=0)
75
76 dz1 = np.dot(dy, W2.T)
77 da1 = sigmoid_grad(a1) * dz1
78 grads['W1'] = np.dot(x.T, da1)
79 grads['b1'] = np.sum(da1, axis=0)
80
81 return grads
训练代码：
1 # -*- coding: utf-8 -*-
2 # @File : train_neuralnet.py
3 # @Author: lizhen
4 # @Date : 2020/2/2
5 # @Desc : 第三篇的实现： 利用梯度
6
7 import numpy as np
8 import matplotlib.pyplot as plt
9 from src.datasets.mnist import load_mnist
10 from src.test.two_layer_net import TwoLayerNet
11
12 # 获取训练数据
13 (x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)
14
15 network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)
16
17 iters_num = 10000 # 迭代次数
18 train_size = x_train.shape[0]
19 batch_size = 100
20 learning_rate = 0.1
21
22 train_loss_list = []
23 train_acc_list = []
24 test_acc_list = []
25
26 iter_per_epoch = max(train_size / batch_size, 1)
27
28 for i in range(iters_num):
29 batch_mask = np.random.choice(train_size, batch_size)
30 x_batch = x_train[batch_mask]
31 t_batch = t_train[batch_mask]
32
33 # 计算梯度
34 grad = network.numerical_gradient(x_batch, t_batch)
35 # grad = network.gradient(x_batch, t_batch) # 较快
36
37 # 更新权重
38 for key in ('W1', 'b1', 'W2', 'b2'):
39 network.params[key] -= learning_rate * grad[key]
40
41 loss = network.loss(x_batch, t_batch)
42 train_loss_list.append(loss)
43
44 if i % iter_per_epoch == 0:
45 train_acc = network.accuracy(x_train, t_train)
46 test_acc = network.accuracy(x_test, t_test)
47 train_acc_list.append(train_acc)
48 test_acc_list.append(test_acc)
49 print("train acc, test acc , loss | " + str(train_acc) + ", " + str(test_acc)+", "+str(loss))
50
51
52 # 绘制图
53 markers = {'train': 'o', 'test': 's'}
54 x = np.arange(len(train_acc_list))
55 plt.plot(x, train_acc_list, label='train acc')
56 plt.plot(x, test_acc_list, label='test acc', linestyle='--')
57
58 plt.xlabel("epochs")
59 plt.ylabel("accuracy")
60 plt.ylim(0, 1.0)
61 plt.legend(loc='lower right')
62 plt.show()
63
64 # plt.plot(train_loss_list,label='loss value')
65 # plt.show()
输出：
Loss 曲线图和acc变化曲线如下
2020年2月3日星期一
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/289020.html