前言

上一篇文章介绍了神经网络需要达到的最终目标，即使所定义的损失函数值达到尽可能的小。那么，是如何达到使得损失函数的值最小的呢？其实，最常使用的核心大招就是“梯度法”进行参数的更新优化，最终达到使得损失函数最小的目的。本文将介绍神经网络中参数的梯度是如何计算的。
在介绍梯度法之前先简单介绍一下所用到的数值微分方面的数学知识，以帮助理解后续梯度法的计算过程，如果知道这一部分知识的同学，可以直接跳过本文的第一节《数值微分》，直接看第二节《梯度法》的内容即可。

一、数值微分

1.导数

导数就是表示某个瞬间的变化量。比如：速度 = 距离 / 时间，如果将距离尽可能的缩短成一个很小的值，这时所使用的时间也是非常小的，这时所计算出来的值即为某一个瞬间的变化量（瞬时速度，数学上也称为加速度）。其数学公式如下：
其中：左边的符号df(x) / dx 表示函数f（x）关于x的导数，即f（x）相对于x的变化程度。上式的导数含义是，x的“微小变化”将导致函数f（x）的值在多大程度上发生变化。其中，表示微小变化的 h无限趋近0，表示为 limh->0 .
python实现的代码如下：

def numerical_diff(f, x):
    """
    :param f: f为x的为函数表达式
    :param x: 函数f在值x处求导数
    :return:  返回函数f在x处的导数值
    """
    h = 1e-5 # h取一个很小的值
    return (f(x+h) - f(x)) / (h)

但是通常为了更好的减小导数的误差，我们采用中心差分的方式进行导数计算，计算函数f在(x + h)和(x - h)之间的差分。因为这种计算方法以x为中心，计算它左右两边的差分，所以也称为中心差分（而(x + h)和x之间的差分称为前向差分）。

def numerical_diff(f, x):
    h = 1e-5 # h取一个很小的值
    return (f(x+h) - f(x-h)) / (2 * h)

下图为真的导数（真的切线）和数值微分（近似切线）的值比较：

如上所示，利用微小的差分求导数的过程称为数值微分（numerical?differentiation）。而基于数学式的推导求导数的过程，则用“ 解析性”（analytic）一词，称为“解析性求解”或者“解析性求导”。比如，y = x2的导数，可以通过dy/dx=2x解析性地求解出来。因此，当x = 2时，y的导数为4。解析性求导得到的导数是不含误差的“真的导数”。

数值微分举例

计算下面二次函数在某些值处的导数：

def numerical_diff(f, x):
    """
    :param f: f为x的为函数表达式
    :param x: 函数f在值x处求导数
    :return:  返回函数f在x处的导数值
    """
    h = 1e-5 # h取一个很小的值
    return (f(x+h) - f(x)) / (h)import numpy as np
import matplotlib.pylab as plt
def numerical_diff(f, x):
    h = 1e-4  # 0.0001
    return (f(x + h) - f(x - h)) / (2 * h)

def function_1(x):
    return 0.01 * x ** 2 + 0.1 * x

x = np.arange(0.0, 20.0, 0.1)
y = function_1(x)
plt.xlabel("x")
plt.ylabel("f(x)")
plt.plot(x, y)
plt.show()

计算一下这个函数在x = 5和x = 10处的导数值，即在这两个点处的斜率。

2.偏导数

接下来，我们来了解一下偏导数。与上述不同的是，这里有两个自变量。

def function_2(x):
    # 传入的x为一个二元输出[x0,x1]
    return x[0]**2 + x[1]**2

偏导数和单变量的导数一样，都是求某个地方的斜率。不过，偏导数需要将多个变量中的某一个变量定为目标变量，并将其他变量固定为某个值。在上例的代码中，为了将目标变量以外的变量固定到某些特定的值上，我们定义了新函数。然后，对新定义的函数应用了之前的求数值微分的函数，得到偏导数。

3.梯度

上述例子中我们分别计算了x0、x1的偏导数，如果我们希望一起计算(x0、x1)的偏导数：

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

求梯度的代码实现如下：

import numpy as np
import matplotlib.pylab as plt

def function_2(x):
    return np.sum(x ** 2)

def numerical_gradient(f, x):
    h = 1e-4  # 0.0001
    grad = np.zeros_like(x)

    for idx in range(x.size):
        # 遍历每一个自变量索引，tmp_val保存当前自变量值
        tmp_val = x[idx]
        x[idx] = float(tmp_val) + h
        fxh1 = f(x)  # 计算f(x+h)

        x[idx] = tmp_val - h
        fxh2 = f(x)  # 计算f(x-h)
        grad[idx] = (fxh1 - fxh2) / (2 * h)

        x[idx] = tmp_val  # 将当前自变量xi值还原，继续计算后续x[i+1]的导数值
    return grad

上图为每一个点的负梯度向量（负梯度方向是梯度法中变量的更新方向）。

我们发现梯度指向函数f(x0,x1)的“最低处”（最小值0）。其次，我们发现离“最低处”越远，箭头越大。虽然图的梯度指向了最低处，但并非任何时候都这样。实际上，梯度指示的方向是各点处的函数值减小最多的方向。

二、梯度法

神经网络必须在学习时找到最优参数（权重和偏置），即使损失函数取最小值时的参数。通过巧妙地使用梯度来寻找函数最小值（或者尽可能小的值）的方法就是梯度法。

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

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

虽然梯度的方向并不一定指向最小值，但沿着它的方向能够最大限度地减小函数的值。因此，在寻找函数的最小值（或者尽可能小的值）的位置的任务中，要以梯度的信息为线索，决定前进的方向。此时梯度法就派上用场了。在梯度法中，函数的取值从当前位置沿着梯度方向前进一定距离，然后在新的地方重新求梯度，再沿着新梯度方向前进，如此反复，不断地沿梯度方向前进。像这样，通过不断地沿梯度方向前进，逐渐减小函数值的过程就是梯度法（ gradient method）。

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

1.学习率

梯度法的数学表达式如下：

η表示更新量，在神经网络的学习中，称为学习率（ learningrate）。学习率决定在一次学习中，应该学习多少，以及在多大程度上更新参数。

学习率需要事先确定为某个值，比如0.01或0.001。一般而言，这个值过大或过小，都无法抵达一个“好的位置”。在神经网络的学习中，一般会一边改变学习率的值，一边确认学习是否正确进行了。

梯度下降法的实现代码如下：

import numpy as np
def function_2(x):
    return np.sum(x ** 2)

def numerical_gradient(f, x):
    # 求每一个参数的梯度值
    h = 1e-4  # 0.0001
    grad = np.zeros_like(x)

    for idx in range(x.size):
        # 遍历每一个自变量索引，tmp_val保存当前自变量值
        tmp_val = x[idx]
        x[idx] = float(tmp_val) + h
        fxh1 = f(x)  # 计算f(x+h)
        x[idx] = tmp_val - h
        fxh2 = f(x)  # 计算f(x-h)
        grad[idx] = (fxh1 - fxh2) / (2 * h)
        x[idx] = tmp_val  # 将当前xi值还原，继续计算后续x[i+1]的导数

    return grad

def gradient_descent(f, init_x, lr=0.01, step_num=100):
    # lr：学习率设为0.01
    # 梯度下降的步数step_num=100
    x = init_x
    for i in range(step_num):
        # 对每个参数进行100次梯度下降计算
        grad = numerical_gradient(f, x)
        x -= lr * grad
    return x

其中：参数 f是要进行最优化的函数， init_x是初始值， lr是学习率learningrate， step_num是梯度法的重复次数。 numerical_gradient(f,x)会求函数的梯度，用该梯度乘以学习率得到的值进行更新操作，由 step_num指定重复的次数。

举例：

设初始值为(-3.0, 4.0)，开始使用梯度法寻找最小值。上述最终计算结果是(-6.1e-10, 8.1e-10)，非常接近(0，0)。实际上，使得函数值f最小的参数就是(0，0)，所以说通过梯度法我们基本得到了正确结果。如果用图来表示梯度法的更新过程即参数（x0,x1）的改变过程，则下图所示。可以发现，原点（0，0）处是最低的地方，函数的取值一点点在向其靠近。

代码如下（示例）：

但是，学习率参数的选取非常重要。学习率过大或者过小都无法得到好的结果。举例：
结果表明，学习率过大的话，会发散成一个很大的值；反过来，学习率过小的话，基本上没怎么更新就结束了。也就是说，设定合适的学习率是一个很重要的问题。
注：像学习率这样的参数称为超参数。这是一种和神经网络的参数（权重和偏置）性质不同的参数。相对于神经网络的权重参数是通过训练数据和学习算法自动获得的，学习率这样的超参数则是人工设定的。一般来说，超参数需要尝试多个值，以便找到一种可以使学习顺利进行的设定。

2.神经网络的梯度计算

神经网络的学习训练过程也是通过求梯度来一步步求得最优参数值的。这里的梯度指损失函数关于权重参数的梯度。比如，有一个只有一个形状为2 × 3的权重W的神经网络，损失函数用L表示。此时，梯度的数学式表示如下所示。

下面先以简单的单层神经网络为例，实现梯度的计算：

import numpy as np

def softmax(x):
    # softmax激活函数
    if x.ndim == 2:
        x = x.T
        x = x - np.max(x, axis=0)
        y = np.exp(x) / np.sum(np.exp(x), axis=0)
        return y.T

    x = x - np.max(x) # 溢出对策
    return np.exp(x) / np.sum(np.exp(x))

def cross_entropy_error(y, t):
    # 交叉熵误差
    if y.ndim == 1:
        t = t.reshape(1, t.size)
        y = y.reshape(1, y.size)
    # 监督数据是one-hot-vector的情况下，转换为正确解标签的索引
    if t.size == y.size:
        t = t.argmax(axis=1)
    batch_size = y.shape[0]
    return -np.sum(np.log(y[np.arange(batch_size), t] + 1e-7)) / batch_size

def numerical_gradient(f, x):
    # 计算所有参数x的梯度
    h = 1e-4  # 0.0001
    grad = np.zeros_like(x)
    it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
    while not it.finished:
        idx = it.multi_index
        tmp_val = x[idx]
        x[idx] = float(tmp_val) + h
        fxh1 = f(x)  # f(x+h)

        x[idx] = tmp_val - h
        fxh2 = f(x)  # f(x-h)
        grad[idx] = (fxh1 - fxh2) / (2 * h)

        x[idx] = tmp_val  # 还原值
        it.iternext()
    return grad

class simpleNet:
    def __init__(self):
        # 2 X 3的单层神经网络为例求梯度
        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)
        # 使用sofmax为激活函数
        y = softmax(z)
        # 使用交叉熵误差
        loss = cross_entropy_error(y, t)
        return loss

x = np.array([0.6, 0.9])
t = np.array([0, 0, 1])

net = simpleNet()
# 损失函数
f = lambda w: net.loss(x, t)
# 损失函数的梯度
dW = numerical_gradient(f, net.W)
print(dW)