【深度学习】4-4 误差反向传播法 - 算法的具体实现

神经网络学习的全貌图

前提
神经网络中有合适的权重和偏置，调整权重和偏置以便拟合训练数据的过程称为学习。神经网络的学习分为下面4个步骤：

步骤1(mini-batch)
从训练数据中随机选择一部分数据
步骤2(计算梯度)
计算损失函数关于各个权重参数的梯度
步骤3(更新参数)
将权重参数沿梯度方向进行微小的更新
步骤4(重复)
重复步骤1、步骤2、步骤3。

为什么要使用误差反向传播法，是因为误差反向传播法可以快速高效计算梯度。

对应误差反向传播法的神经网络的实现

现在来进行神经网络的实现。这里我们要把2层神经网络实现为TwoLayerNet.
这个类的实现和之前学习算法的实现有很多共通的部分，不同点主要在于使用了层。通过使用层，获得识别结果的处理(predict())和计算梯度的处理(gradient())只需通过层之间的传递就能完成，下面是TwoLayerNet的代码：

import sys, os
sys.path.append(os.pardir)
import numpy as np
from common.layers import *
from common.gradient import numerical_gradient
from collections import OrderedDict

class TwoLayerNet:
	# 参数介绍
	# input_size 输人层的神经元数
	# hidden_size 隐藏层的神经元数
	# output_size 输出层的神经元数
	# weight_init_std  初始化权重时的高斯分布的规模
	def __init__(self, input_size, hidden_size, output_size, weight_init_std = 0.01):
		# 初始化权重
		self.params = {
    
    }
		self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
		self.params['b1'] = np.zeros(hidden_size)
		self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
		self.params['b2'] = np.zeros(output_size)

		# 生成层
		self.layers = OrderedDict()
		self.layers['Affine1'] = Affine(self.params['W1'], self.params['b1'])
		self.layers['Relu1'] = Relu()
		self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])
	
		self.lastLayer = SoftmaxWithLoss()
	
	def predict(self, x):
		for layer in self.layers.values():
			x = layer.forward(x)
		return x

	def loss(self, x, t):
		y  = self.predict(x)
		return self.lastLayer.forward(y,t)

	def accuracy(self, x, t):
		y = self.predict(x)
		y = np.argmax(y, axis=1)
		if t.ndim !=1 : t = np.argmax(t,axis=1)
		accuracy = np.sum(y == t) / float(x.shape[0])
		return accuracy

	def numerical_gradient(self, x, t):
		loss_W = lambda W: self.loss(x, t)

		grads = {
    
    }
		grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
		grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
		grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
		grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
		return grads

	def gradient(self, x, t):
		# forward
		self.loss(x,t)
		# backward
		dout = 1
		dout = self.lastLayer.backward(dout)

		layers = list(self.layers.values())
		layers.reverse()
		for layer in layers:
			dout = layer.backward(dout)

		# 设定
		grads = {
    
    }
		grads['W1'] = self.layers['Affine1'].dW
		grads['b1'] = self.layers['Affine1'].db
		grads['W2'] = self.layers['Affine2'].dW
		grads['b2'] = self.layers['Affine2'].db

		return grads

这里将神经网络的层保存为OrderedDict这一点非常重要。OrderedDict是有序字典，“有序”是指它可以记住向字典里添加元素的顺序。因此，神经网络的正向传播只需按照添加元素的顺序调用各层的forward()方法就可以完成处理，而反向传播只需要按相反的顺序调用各层即可。因为Affine层和ReLU层的内部会正确处理正向传播和反向传播，所以这里要做的事情仅仅是以正确的顺序连接各层，再按顺序(或者逆序)调用各层。

这个用层进行模块化的实现具有很大优点。因为想另外构建一个神经网络时，只需像组装乐高积木那样添加必要的层就可以了。之后，通过各个层内部实现的正向传播和反向传播，就可以正确计算进行识别处理或学习所需的梯度。

数值微分的计算很耗费时间，而且如果有误差反向传播法的话，就没有必要使用数值微分的实现了。那么数值微分有什么用呢？实际上，在确认误差反向传播法的实现是否正确时，是需要用到数值微分的。

实际上虽然数值微分计算很慢，但是一般情况下不容易出错。而误差反向传播法的实现很复杂，容易出错。。所以，经常会比较数值微分的结果和误差反向传播法的结果，以确认误差反向传播法的实现是否正确。确认数值微分求出的梯度结果和误差反向传播法求出的结果是否一致(严格地讲，是非常相近)的操作称为梯度确认(gradient check)。

其代码实现如下：

import sys, os
sys.path.append(os.pardir)
import numpy as np
from dataset.mnist import load_mnist
from two_layer_net import TwoLayerNet

# 读入数据
(x_train, t_train), (x_test, t_test) = load_mnist(normalize = True, one_hot_label = True)
network = TwoLayerNet(input_size = 784, hidden_size=50, output_size=10)
x_batch = x_train[:3]
t_batch = t_train[:3]

grad_numerical = network.numerical_gradient(x_batch, t_batch)
grad_backprop = network.gradient(x_batch, t_batch)

# 求各个权重的绝对误差的平均值
for key in grad_numerical.keys():
	diff = np.average(np.abs(grad_backprop[key] - grad_numerical[key]))
	print(key + ":" + str(diff))

这里误差的计算方法是求各个权重参数中对应元素的差的绝对值，并计算其平均值。

数值微分和误差反向传播法的计算结果之间的误差为0是很少见的。这是因为计算机的计算精度有限(比如，32位浮点数)。受到数值精度的限制，刚才的误差一般不会为0，但是如果实现正确的话，可以期待这个误差是一个接近0的很小的值。如果这个值很大，就说明误差反向传播法的实现存在错误。

使用误差反向传播法的学习

下面来看一下使用了误差反向传播法的神经网络的学习的实现。
和之前的实现相比，不同之处在于通过误差反向传播法求梯度这一点

import sys, os
sys.path.append(os.pardir)
import numpy as np
from dataset.mnist import load_mnist
from two_layer_net import TwoLayerNet

# 读入数据
(x_train, t_train), (x_test, t_test) = load_mnist(normalize = True, one_hot_label = True)

network = TwoLayerNet(input_size = 784, hidden_size=50, output_size=10)

iters_num = 10000
train_size = x_train.shape[0]
batch_size = 100
learnint_rate = 0.1
train_loss_list = []
train_acc_list = []
test_acc_list = []

iter_per_epoch = max(train_size / batch_size, 1)

for i in range(iters_num):
	batch_mask = np.random.choice(train_size, batch_size)
	x_batch = x_train[batch_mask]
	t_batch = t_train[batch_mask]

	# 通过误差反向传播法求梯度
	grad = netework.gradient(x_batch, t_batch)

	# 更新
	for key in ('W1', 'b1', 'W2', 'b2'):
		network.params[key] -= learning_rate * grad[key]

	loss = network.loss(x_batch, t_batch)
	train_loss_list.append(loss)

	if i % iter_per_epoch = 0:
		train_acc = network.accuracy(x_train, t_train)
		test_acc = network.accuracy(x_test, t_test)
		test_acc_list.append(test_acc)
		print(train_acc, test_acc)