深度学习入门：神经网络的学习

1 从数据中学习

1.1 数据驱动

神经网络的特征就是可以从数据中学习。所谓“从数据中学习”，是指可以由数据自动决定权重参数的值。

1.2 训练数据和测试数据

机器学习中，一般将数据分为训练数据和测试数据两部分来进行学习和实验等。首先，使用训练数据进行学习，寻找最优的参数；然后，使用测试数据评价训练得到的模型的实际能力。为什么需要将数据分为训练数据和测试数据呢？因为我们追求的是模型的泛化能力。为了正确评价模型的泛化能力，就必须划分训练数据和测试数据。另外，训练数据也可以称为监督数据。泛化能力是指处理未被观察过的数据（不包含在训练数据中的数据）的能力。获得泛化能力是机器学习的最终目标。只对某个数据集过度拟合的状态称为过拟合（over fitting）。避免过拟合也是机器学习的一个重要课题。

2损失函数

神经网络的学习通过某个指标表示现在的状态。然后，以这个指标为基准，寻找最优权重参数。神经网络以某个指标为线索寻找最优权重参数。神经网络的学习中所用的指标称为损失函数（loss function）。这个损失函数可以使用任意函数，但一般用均方误差和交叉熵误差等。

损失函数是表示神经网络性能的“恶劣程度”的指标，即当前的神经网络对监督数据在多大程度上不拟合，在多大程度上不一致。以“性能的恶劣程度”为指标可能会使人感到不太自然，但是如果给损失函数乘上一个负值，就可以解释为“在多大程度上不坏”，即“性能有多好”。并且，“使性能的恶劣程度达到最小”和“使性能的优良程度达到最大”是等价的，不管是用“恶劣程度”还是“优良程度”，做的事情本质上都是一样的。

2.1 均方误差

这里，yk是表示神经网络的输出，tk表示监督数据，k表示数据的维数。

def mean_squared_error(y, t):
 return 0.5 * np.sum((y-t)**2)

比如，在3.6节手写数字识别的例子中，yk、tk是由如下10个元素构成的数据。

>>> y = [0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]
>>> t = [0, 0, 1, 0, 0, 0, 0, 0, 0, 0]

数组元素的索引从第一个开始依次对应数字“0”“1”“2”…… 这里，神经网络的输出y是softmax函数的输出。由于softmax函数的输出可以理解为概率，因此上例表示“0”的概率是0.1，“1”的概率是0.05，“2”的概率是0.6等。t是监督数据，将正确解标签设为1，其他均设为0。这里，标签“2”为1，表示正确解是“2”。将正确解标签表示为1，其他标签表示为0的表示方法称为one-hot表示。

2.2 交叉熵误差

def cross_entropy_error(y, t):
 delta = 1e-7
 return -np.sum(t * np.log(y + delta))

这里，参数y和t是NumPy数组。函数内部在计算np.log时，加上了一个微小值delta。这是因为，当出现np.log(0)时，np.log(0)会变为负无限大的-inf，这样一来就会导致后续计算无法进行。作为保护性对策，添加一个微小值可以防止负无限大的发生。

2.3 mini-batch学习

前面介绍的损失函数的例子中考虑的都是针对单个数据的损失函数。如果要求所有训练数据的损失函数的总和，以交叉熵误差为例

这里,假设数据有N个，tnk表示第n个数据的第k个元素的值（ynk是神经网络的输出，tnk是监督数据）。式子虽然看起来有一些复杂，其实只是把求单个数据的损失函数的式（4.2）扩大到了N份数据，不过最后还要除以N进行正规化。通过除以N，可以求单个数据的“平均损失函数”。通过这样的平均化，可以获得和训练数据的数量无关的统一指标。比如，即便训练数据有1000个或10000个，也可以求得单个数据的平均损失函数。

2.4 mini-batch版交叉熵误差的实现

def cross_entropy_error(y, t):
 if y.ndim == 1:
 t = t.reshape(1, t.size)  #reshape为一行n（t.size / y.size）列的形状是为了batch_size可以取1
 y = y.reshape(1, y.size)  
 batch_size = y.shape[0]
 return -np.sum(t * np.log(y + 1e-7)) / batch_size

这里，y是神经网络的输出，t是监督数据。y的维度为1时，即求单个数据的交叉熵误差时，需要改变数据的形状。并且，当输入为mini-batch时，要用batch的个数进行正规化，计算单个数据的平均交叉熵误差。
此外，当监督数据是标签形式（非one-hot表示，而是像“2”“7”这样的标签）时，交叉熵误差可通过如下代码实现。

def cross_entropy_error(y, t):
 if y.ndim == 1:
 t = t.reshape(1, t.size)
 y = y.reshape(1, y.size)
 batch_size = y.shape[0]
 return -np.sum(np.log(y[np.arange(batch_size), t] + 1e-7)) / batch_size

实现的要点是，由于one-hot表示中t为0的元素的交叉熵误差也为0，因此针对这些元素的计算可以忽略。换言之，如果可以获得神经网络在正确解标签处的输出，就可以计算交叉熵误差。因此，t为one-hot表示时通过t * np.log(y)计算的地方，在t为标签形式时，用np.log(y[np.arange(batch_size), t])实现相同的处理（为了便于观察，这里省略了微小值1e-7）。作为参考，简单介绍一下np.log( y[np.arange(batch_size), t] )。np.arange (batch_size)会生成一个从0到batch_size-1的数组。比如当batch_size为5时，np.arange(batch_size)会生成一个NumPy 数组[0, 1, 2, 3, 4]。因为t中标签是以[2, 7, 0, 9, 4]的形式存储的，所以y[np.arange(batch_size), t]能抽出各个数据的正确解标签对应的神经网络的输出（在这个例子中，y[np.arange(batch_size), t] 会生成 NumPy 数 组 [y[0,2],y[1,7], y[2,0], y[3,9], y[4,4]]）。（取第一条数据索引位置为2的输出，第二条数据索引位置为7的输出…）

2.5 为何要设定损失函数

在进行神经网络的学习时，不能将识别精度作为指标。因为如果以识别精度为指标，则参数的导数在绝大多数地方都会变为0。

假设某个神经网络正确识别出了100笔训练数据中的32笔，此时识别精度为32 %。如果以识别精度为指标，即使稍微改变权重参数的值，识别精度也仍将保持在32 %，不会出现变化。也就是说，仅仅微调参数，是无法改善识别精度的。即便识别精度有所改善，它的值也不会像32.0123 . . . %这样连续变化，而是变为33 %、34 %这样的不连续的、离散的值。而如果把损失函数作为指标，则当前损失函数的值可以表示为0.92543 . . . 这样的值。并且，如果稍微改变一下参数的值，对应的损失函数也会像0.93432 . . . 这样发生连续性的变化。识别精度对微小的参数变化基本上没有什么反应，即便有反应，它的值也是不连续地、突然地变化。作为激活函数的阶跃函数也有同样的情况。出于相同的原因，如果使用阶跃函数作为激活函数，神经网络的学习将无法进行。而sigmoid函数，不仅函数的输出（竖轴的值）是连续变化的，曲线的斜率（导数）也是连续变化的。也就是说，sigmoid函数的导数在任何地方都不为0。这对神经网络的学习非常重要。得益于这个斜率不会为0的性质，神经网络的学习得以正确进行。

3 数值微分

3.1 数值微分

数值微分（导数定义法）含有误差。为了减小这个误差，我们可以计算函数f在(x + h)和(x − h)之间的差分。因为这种计算方法以x为中心，计算它左右两边的差分，所以也称为中心差分（而(x + h)和x之间的差分称为前向差分）。

def numerical_diff(f, x):
 h = 1e-4 # 0.0001
 return (f(x+h) - f(x-h)) / (2*h)

3.3 偏导数

def function(x):
 return x[0]**2 + x[1]**2
 # 或者return np.sum(x**2)

问题1：求x0 = 3, x1 = 4时，关于x0的偏导数 。

>>> def function_tmp1(x0):
return x0*x0 + 4.0**2.0

>>> numerical_diff(function_tmp1, 3.0)
6.00000000000378

问题2：求x0 = 3, x1 = 4时，关于x1的偏导数 。

>>> def function_tmp2(x1):
return 3.0**2.0 + x1*x1

>>> numerical_diff(function_tmp2, 4.0)
7.999999999999119

在这些问题中，我们定义了一个只有一个变量的函数，并对这个函数进行了求导。例如，问题1中，我们定义了一个固定x1 = 4的新函数，然后对只有变量x0的函数应用了求数值微分的函数。从上面的计算结果可知，问题1的答案是6.00000000000378，问题2的答案是7.999999999999119，和解析解的导数基本一致。像这样，偏导数和单变量的导数一样，都是求某个地方的斜率。不过，偏导数需要将多个变量中的某一个变量定为目标变量，并将其他变量固定为某个值。在上例的代码中，为了将目标变量以外的变量固定到某些特定的值上，我们定义了新函数。然后，对新定义的函数应用了之前的求数值微分的函数，得到偏导数。

4 梯度

由全部变量的偏导数汇总而成的向量称为梯度（gradient）。

def numerical_gradient(f, x):
 h = 1e-4 # 0.0001
 grad = np.zeros_like(x) # 生成和x形状相同的数组

 for idx in range(x.size):
     tmp_val = x[idx]
     
     # f(x+h)的计算
     x[idx] = tmp_val + h
     fxh1 = f(x)
     
     # f(x-h)的计算
     x[idx] = tmp_val - h
     fxh2 = f(x)
     
     grad[idx] = (fxh1 - fxh2) / (2*h)
     x[idx] = tmp_val # 还原值

 return grad

与上面例子类似，计算fxh1，fxh2时另外一个x不变，则为计算x[idx]的偏导数

>>> numerical_gradient(function_2, np.array([3.0, 4.0]))
array([ 6., 8.])A
>>> numerical_gradient(function_2, np.array([0.0, 2.0]))
array([ 0., 4.])
>>> numerical_gradient(function_2, np.array([3.0, 0.0]))
array([ 6., 0.])

4.1 梯度法

这里需要注意的是，梯度表示的是各点处的函数值减小最多的方向。因此，无法保证梯度所指的方向就是函数的最小值或者真正应该前进的方向。实际上，在复杂的函数中，梯度指示的方向基本上都不是函数值最小处。

函数的极小值、最小值以及被称为鞍点（saddle point）的地方，梯度为 0。极小值是局部最小值，也就是限定在某个范围内的最小值。鞍点是从某个方向上看是极大值，从另一个方向上看则是极小值的点。虽然梯度法是要寻找梯度为 0的地方，但是那个地方不一定就是最小值（也有可能是极小值或者鞍点）。此外，当函数很复杂且呈扁平状时，学习可能会进入一个（几乎）平坦的地区，陷入被称为“学习高原”的无法前进的停滞期。

虽然梯度的方向并不一定指向最小值，但沿着它的方向能够最大限度地减小函数的值。因此，在寻找函数的最小值（或者尽可能小的值）的位置的任务中，要以梯度的信息为线索，决定前进的方向。像这样，通过不断地沿梯度方向前进，逐渐减小函数值的过程就是梯度法（gradient method）。

根据目的是寻找最小值还是最大值，梯度法的叫法有所不同。严格地讲，寻找最小值的梯度法称为梯度下降法（gradient descent method），寻找最大值的梯度法称为梯度上升法（gradient ascent method）。但是通过反转损失函数的符号，求最小值的问题和求最大值的问题会变成相同的问题，因此“下降”还是“上升”的差异本质上并不重要。一般来说，神经网络（深度学习）中，梯度法主要是指梯度下降法。

η表示更新量，在神经网络的学习中，称为学习率（learning rate）。学习率决定在一次学习中，应该学习多少，以及在多大程度上更新参数。
学习率需要事先确定为某个值，比如0.01或0.001。一般而言，这个值过大或过小，都无法抵达一个“好的位置”。在神经网络的学习中，一般会一边改变学习率的值，一边确认学习是否正确进行了。

def gradient_descent(f, init_x, lr=0.01, step_num=100):
 x = init_x
 for i in range(step_num):
 grad = numerical_gradient(f, x)
 x -= lr * grad
 return x

问题：请用梯度法求 的最小值。

>>> def function_2(x):
… return x[0]**2 + x[1]**2
…
>>> init_x = np.array([-3.0, 4.0])
>>> gradient_descent(function_2, init_x=init_x, lr=0.1, step_num=100)
array([ -6.11110793e-10, 8.14814391e-10])

学习率过大的例子：lr=10.0
>>> init_x = np.array([-3.0, 4.0])
>>> gradient_descent(function_2, init_x=init_x, lr=10.0, step_num=100)
array([ -2.58983747e+13, -1.29524862e+12])
学习率过小的例子：lr=1e-10
>>> init_x = np.array([-3.0, 4.0])
>>> gradient_descent(function_2, init_x=init_x, lr=1e-10, step_num=100)
array([-2.99999994, 3.99999992])

实验结果表明，学习率过大的话，会发散成一个很大的值；反过来，学习率过小的话，基本上没怎么更新就结束了。也就是说，设定合适的学习率是一个很重要的问题。

像学习率这样的参数称为超参数。这是一种和神经网络的参数（权重和偏置）性质不同的参数。相对于神经网络的权重参数是通过训练数据和学习算法自动获得的，学习率这样的超参数则是人工设定的。一般来说，超参数需要尝试多个值，以便找到一种可以使学习顺利进行的设定。

4.2 神经网络的梯度

神经网络的学习也要求梯度。这里所说的梯度是指损失函数关于权重参数的梯度。比如，有一个只有一个形状为2 × 3的权重W的神经网络，损失函数用L表示。此时，梯度可以表示为：

我们以一个简单的神经网络为例，来实现求梯度的代码。为此，我们要实现一个名为simpleNet的类

import sys, os
sys.path.append(os.pardir)
import numpy as np
from common.functions import softmax, cross_entropy_error
from common.gradient import numerical_gradient
class simpleNet:
 def __init__(self):
 self.W = np.random.randn(2,3) # 用高斯分布进行初始化

 def predict(self, x):
 return np.dot(x, self.W)
 def loss(self, x, t):
 z = self.predict(x)
 y = softmax(z)
 loss = cross_entropy_error(y, t)
 return loss

它有两个方法，一个是用于预测的predict(x)，另一个是用于求损失函数值的loss(x,t)。这里参数x接收输入数据，t接收正确解标签。

>>> net = simpleNet()
>>> print(net.W) # 权重参数
[[ 0.47355232 0.9977393 0.84668094],
[ 0.85557411 0.03563661 0.69422093]])
>>>
>>> x = np.array([0.6, 0.9])
>>> p = net.predict(x)
>>> print§
[ 1.05414809 0.63071653 1.1328074]
>>> np.argmax§ # 最大值的索引
2
>>>
>>> t = np.array([0, 0, 1]) # 正确解标签
>>> net.loss(x, t)
0.92806853663411326

接下来求梯度。和前面一样，我们使用numerical_gradient(f, x)求梯度（这里定义的函数f(W)的参数W是一个伪参数。因为numerical_gradient(f, x)会在内部执行f(x),为了与之兼容而定义了f(W)）。

>>> def f(W):
… return net.loss(x, t)
…
>>> dW = numerical_gradient(f, net.W)
>>> print(dW)
[[ 0.21924763 0.14356247 -0.36281009]
[ 0.32887144 0.2153437 -0.54421514]]

numerical_gradient(f, x) 的参数f是函数，x是传给函数f的参数。因此，这里参数x取net.W，并定义一个计算损失函数的新函数f，然后把这个新定义的函数传递给numerical_gradient(f, x)。numerical_gradient(f, net.W)的结果是dW，一个形状为2 × 3的二维数组。观察一下dW的内容，例如，会发现 中的 的值大约是0.2，这表示如果将w11增加h，那么损失函数的值会增加0.2h。再如， 对应的值大约是−0.5，这表示如果将w23增加h，损失函数的值将减小0.5h。因此，从减小损失函数值的观点来看，w23应向正方向更新，w11应向负方向更新。至于更新的程度，w23比w11的贡献要大。

5 学习算法的实现

前提

神经网络存在合适的权重和偏置，调整权重和偏置以便拟合训练数据的过程称为“学习”。神经网络的学习分成下面4个步骤。

步骤1（mini-batch）

从训练数据中随机选出一部分数据，这部分数据称为mini-batch。我们的目标是减小mini-batch的损失函数的值。

步骤2（计算梯度）

为了减小mini-batch的损失函数的值，需要求出各个权重参数的梯度。梯度表示损失函数的值减小最多的方向。

步骤3（更新参数）

将权重参数沿梯度方向进行微小更新。

步骤4（重复）

重复步骤1、步骤2、步骤3。

经网络的学习按照上面4个步骤进行。这个方法通过梯度下降法更新参数，不过因为这里使用的数据是随机选择的mini batch数据，所以又称为随机梯度下降法（stochastic gradient descent）。“随机”指的是“随机选择的”的意思，因此，随机梯度下降法是“对随机选择的数据进行的梯度下降法”。深度学习的很多框架中，随机梯度下降法一般由一个名为SGD的函数来实现。SGD来源于随机梯度下降法的英文名称的首字母。

5.1 2层神经网络的类

下面，我们来实现手写数字识别的神经网络。这里以2层神经网络（隐藏层为1层的网络）为对象，使用MNIST数据集进行学习。首先，我们将这个2层神经网络实现为一个名为TwoLayerNet的类，实现过程如下所示。

import sys, os
sys.path.append(os.pardir)
from common.functions import *
from common.gradient import numerical_gradient
class TwoLayerNet:
 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)


 def predict(self, x):
 W1, W2 = self.params['W1'], self.params['W2']
 b1, b2 = self.params['b1'], self.params['b2']
 a1 = np.dot(x, W1) + b1
 z1 = sigmoid(a1)
 a2 = np.dot(z1, W2) + b2
 y = softmax(a2)
 return y
 # x:输入数据, t:监督数据

 def loss(self, x, t):
 y = self.predict(x)
 return cross_entropy_error(y, t)
 def accuracy(self, x, t):
 y = self.predict(x)
 y = np.argmax(y, axis=1)
 t = np.argmax(t, axis=1)
 accuracy = np.sum(y == t) / float(x.shape[0])
 return accuracy
 # x:输入数据, t:监督数据

 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

5.2 mini-batch的实现与基于测试数据的评价

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_
laobel = True)
train_loss_list = []

train_acc_list = []
test_acc_list = []
# 平均每个epoch的重复次数

iter_per_epoch = max(train_size / batch_size, 1)

# 超参数

iters_num = 10000
batch_size = 100
learning_rate = 0.1
network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)
for i in range(iters_num):
 # 获取mini-batch
 batch_mask = np.random.choice(train_size, batch_size)
 x_batch = x_train[batch_mask]
 t_batch = t_train[batch_mask]
 # 计算梯度

 grad = network.numerical_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)
 # 计算每个epoch的识别精度

 if i % iter_per_epoch == 0:

 train_acc = network.accuracy(x_train, t_train)

 test_acc = network.accuracy(x_test, t_test)

 train_acc_list.append(train_acc)

 test_acc_list.append(test_acc)

 print("train acc, test acc | " + str(train_acc) + ", " + str(test_acc))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_
laobel = True)
train_loss_list = []

train_acc_list = []
test_acc_list = []
# 平均每个epoch的重复次数

iter_per_epoch = max(train_size / batch_size, 1)

# 超参数

iters_num = 10000
batch_size = 100
learning_rate = 0.1
network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)
for i in range(iters_num):
 # 获取mini-batch
 batch_mask = np.random.choice(train_size, batch_size)
 x_batch = x_train[batch_mask]
 t_batch = t_train[batch_mask]
 # 计算梯度

 grad = network.numerical_gradient(x_batch, t_batch)
 # grad = network.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)
 # 计算每个epoch的识别精度

 if i % iter_per_epoch == 0:

 train_acc = network.accuracy(x_train, t_train)

 test_acc = network.accuracy(x_test, t_test)

 train_acc_list.append(train_acc)

 test_acc_list.append(test_acc)

 print("train acc, test acc | " + str(train_acc) + ", " + str(test_acc))

epoch是一个单位。一个 epoch表示学习中所有训练数据均被使用过一次时的更新次数。比如，对于 10000笔训练数据，用大小为 100笔数据的mini-batch进行学习时，重复随机梯度下降法 100次，所有的训练数据就都被“看过”了A。此时，100次就是一个 epoch。

在上面的例子中，每经过一个epoch，就对所有的训练数据和测试数据计算识别精度，并记录结果。之所以要计算每一个epoch的识别精度，是因为如果在for语句的循环中一直计算识别精度，会花费太多时间。并且，也没有必要那么频繁地记录识别精度（只要从大方向上大致把握识别精度的推移就可以了）。因此，我们才会每经过一个epoch就记录一次训练数据的识别精度。