梯度下降算法超详细解释（从下山比喻、数学推导到代码实现）梯度下降算法针对的是最小优化问题(即求最小值问题)，目的是使目标

如对博文有任何疑问，请留言。

1. 方向导数

方向导数：类比于函数的偏导数是函数沿坐标轴方向的变化率，方向导数是函数沿某一射线方向的变化率。

定理：如果函数 $f(x,y)$ 在点 $P_0(x_0,y_0)$ 可微分，那么函数在该点沿任一方向 $l$ 的方向导数存在，且有

\left. \frac{\partial f}{\partial l} \right|_{(x_0,y_0)} =f_x(x_0,y_0)\cos\alpha + f_y(x_0,y_0)\cos\beta\tag{1}

其中 $\cos\rho$ 和 $\cos\beta$ 是方向 $l$ 的方向余弦。

2. 梯度

梯度：梯度是一个向量（矢量），表示某一函数在该点处的方向导数沿着该方向取得最大值，即函数在该点处沿着该方向（梯度的方向）变化最快，变化率最大（为梯度的模）。

另一种理解：在微积分里，对多元函数的参数求偏导，把求得的各个参数的偏导以向量的形式写出来，就是梯度。

定义：设二元函数 $z=f(x,y)$ 在平面区域D上具有一阶连续偏导数，则对与于每一个点 P(x,y) 都可定出一个向量 $\left \lbrace \frac{\partial f}{\partial x} ,\frac{\partial f}{\partial y}\right \rbrace=f_x(x,y)\vec i + f_y(x,y)\vec j$ ，该函数就称为函数 $z=f(x,y)$ 在点 P(x,y) 的梯度，记作 $gradf(x,y)$ 或 $\nabla f(x,y)$ ，既有：

gradf(x,y) = \nabla f(x,y)=\left \lbrace \frac{\partial f}{\partial x} ,\frac{\partial f}{\partial y}\right \rbrace=f_x(x,y)\vec i + f_y(x,y)\vec j \tag{2}

注意，梯度是在多元函数中的，如果要拓展到一元函数，则要这样理解：它是一个标量，并且在某点的梯度等于这一点的导数。

3. 梯度下降算法数学推导

梯度下降算法针对的是最小优化问题(即求最小值问题)，目的是使目标函数沿最快路径下降到最小值。

通俗的解释，是模拟下山，每次沿着当前位置最陡峭最易下山的方向前进一小步，然后继续沿下一个位置最陡方向前进一小步。这样一步一步走下去，一直走到觉得我们已经到了山脚。在这里插入图片描述

虽然这样很好理解，但这只是给不懂梯度下降算法的小白讲的形象比喻，最终要落实到算法上代码上，具体的过程是怎么样的呢？还得靠数学推导。

算法作用于损失函数(也称目标函数、代价函数、误差函数)，是为了找到使损失函数取最小值的权重( $w$ )和偏置( $b$ )。

设损失函数为 $l(x,w,b,y)$ ，要寻找最优的 $w$ 和 $b$ ，为便于计算，抽象出函数描述 $f(w,b)$ ，这里 $f=l$ ，只是描述形式不同。同时设 $\theta = (w,b)^T$ ， $T$ 为转置符号，此时 $\theta$ 是一个二维列向量。

则损失函数为 $f(\theta)$ ，将其进行一阶泰勒展开，得：

f(\theta)\approx f(\theta_0)+(\theta-\theta_0)·\nabla f(\theta_0) \tag{3}

为什么要一阶泰勒展开呢，因为这样可以“以直代曲”，数学术语叫“局部线性近似”，就是在很小的区间内，直线与曲线近似重合，对曲线不易做的计算，可以对直线计算作为代替。

$\theta-\theta_0$ 就是这个很小的区间，可以表示为 $\Delta \theta$ ，但它仍然是一个矢量，将其分解为模和单位向量的形式，即长度和方向的形式：

\Delta \theta=\theta-\theta_0=\rho \vec v \tag{4}

这里的 $\rho$ 就是前面下山比喻中每次走的一小步的距离(步长)， $\vec v$ 就是走的方向，这里注意 $\rho$ 是距离(长度)，所以 $\rho$ > 0。

则损失函数 $f(\theta)$ 的一阶泰勒展开式可描述为：

f(\theta)\approx f(\theta_0)+\rho \vec v·\nabla f(\theta_0) \tag{5}

其中 $f(\theta_0)$ 是现在的损失函数的值， $f(\theta)$ 是即将要更新的损失函数的值，前面说过我们的目的是为了找到使损失函数取最小值的权重( $w$ )和偏置( $b$ )，所以我们每次更新要保证 $f(\theta)<f(\theta_0)$ ，即：

f(\theta)-f(\theta_0)\approx \rho \vec v·\nabla f(\theta_0)<0 \tag{6}

又因为 $\rho$ > 0，所以有：

\vec v·\nabla f(\theta_0)<0 \tag{7}

这里注意， $\vec v$ 是一个向量， $\nabla f(\theta_0)$ 是函数 $f(w,b)$ 在点 $(w_0,b_0)$ 处的梯度，它也是一个向量。要两个向量的乘积小于0，则需要他们的夹角大于90°。再次想到我们的目的，使目标函数沿最快路径下降到最小值，既然要最快， $f(\theta)$ 与 $f(\theta_0)$ 的距离（即 $|f(\theta)-f(\theta_0)|$ ）就要越大越好，根据公式 $f(\theta)-f(\theta_0)\approx \rho \vec v·\nabla f(\theta_0)<0$ ，就是结果越小越好（因为结果是负值）。再回到 $\vec v$ 和 $\nabla f(\theta_0)$ 两个向量的乘积上，就是他们的夹角为180°时， $\vec v·\nabla f(\theta_0)$ 的结果最小（这里也是为什么要沿着梯度反方向更新自变量的原因），此时结果为：

\vec v·\nabla f(\theta_0)= -||\vec v||·||\nabla f(\theta_0)||=-||\nabla f(\theta_0)|| \tag{8}

则 $\vec v$ 描述为：

\vec v=-\frac{\nabla f(\theta_0)}{||\nabla f(\theta_0)||} \tag{9}

带入 $\theta-\theta_0=\rho \vec v$ 得：

\theta=\theta_0-\rho \frac{\nabla f(\theta_0)}{||\nabla f(\theta_0)||} \tag{10}

因为 $\rho$ 和 $\frac{1}{||\nabla f(\theta_0)||}$ 都是标量，所以可以设 $\alpha=\frac{\rho}{||\nabla f(\theta_0)||}$ ，则上式（梯度下降算法中 $\theta$ 的更新表达式）可描述为：

\theta=\theta_0-\alpha\nabla f(\theta_0) =\theta_0-\alpha \frac{\partial}{\partial \theta_0}f(\theta) \tag{11}

这里的 $\alpha$ 就是我们常说的学习速率。

另外，这个公式还有一种比较专业的描述方法：

\theta \leftarrow \theta_0-\alpha \frac{\partial}{\partial \theta_0}f(\theta) \tag{12}

这个公式就是最终往代码里写的形式，只不过要结合你的 $f$ (损失函数)的具体形式进一步计算偏导，再落实到代码。

实际使用该算法时，有时将公式写成分量的形式，即将 $\theta = (w,b)^T，\theta_0 = (w_0,b_0)^T$ 代入上式得：

(w,b)^T=(w_0,b_0)^T-\alpha \left ( \frac{\partial f}{\partial x} ,\frac{\partial f}{\partial y} \right )^T \tag{13}

即：

\begin{aligned} w=w_0-\alpha \frac{\partial f}{\partial w_0} \\ b=b_0-\alpha \frac{\partial f}{\partial b_0} \end{aligned} \tag{14}

它们的意思是一样的，只是表示方法不同。但分量形式不常用，多用向量形式。

以上是梯度下降算法自变量更新的数学推导，那么什么时候停止更新呢，你肯定会说当然是找到使损失函数取最小值的权重( $w$ )和偏置( $b$ )时，没错这也是我们前面算法目的中的描述。但是怎样知道找到了损失函数的最小值呢，实际应用中不会真的一直迭代到损失函数的最小值，而是在精度和训练时间都可接受的范围内，尽可能的接近最小值，在资源消耗和精度要求间权衡。具体结束条件通常为：

$||\nabla f(\theta_0)||$ 的值足够小。（也可以说是损失函数不再明显的减小，但同时也要兼顾损失函数的值，否则就要检查初始参数和训练数据等），实际编程时，考虑到程序性能，不一定以直接判断损失函数的值为依据，也可以间接判断(比如误差值)。
迭代次数达到预定值。

这里讲的是梯度下降算法的核心思想，最后实际应用还要落实到具体算法，梯度下降算法家族包括批量梯度下降法（Batch Gradient Descent，BGD，也叫最速梯度下降法）、随机梯度下降法（Stochastic Gradient Descent，SGD）、小批量梯度下降法（Mini-Batch Gradient Descent，MBGD）三种。它们的算法原理相同，只是在输入数据时采取不同的策略。

4. 批量梯度下降法代码实现

4.1 选择损失函数与模型

损失函数选择均方差损失函数(MSE)，其表达式为：

L(\theta;x,y) = \frac{1}{M} \sum^M_{i=1} (\hat y(x_i,\theta) - y_i)^2 \tag{15}

其中：

$\hat y$ — — 预测函数，

$x, y$ — — 分别是训练数据的输入值与标签值，

$\theta$ — — 是 $w$ 和 $b$ 组成的向量，

$M$ — — 是训练数据个数。

预测模型(函数)选择线性回归模型，表达式为：

\hat y(x,\theta)=\sum_{j=0}^n\theta_jx_j \tag{16}

其中：

$x$ — — 是预测输入数据点，

$\theta$ — — 是学习得到的权重( $w$ )和偏置(b)。

$n$ — — 是输入数据的维数。

4.2 从公式到代码

首先确定目的，是为了找到使损失函数取最小值的权重( $w$ )和偏置( $b$ )。我们找到了吗？我们找到了。他们的计算式就是公式 $(12)$ ，所以我们的代码核心部分就是实现公式 $(12)$ ，对于这个公式，重要的部分是 $\frac{\partial}{\partial \theta_0}f(\theta)$ ，损失函数对 $\theta$ 的偏导数，我们的损失函数已由公式 $(15)$ 给出，即 $f(\theta) = L(\theta;x,y)$ ，公式 $(15)$ 对 $\theta$ 求偏导得：

\begin{aligned} \frac{\partial}{\partial \theta_0}f(\theta) &= \frac{\partial}{\partial \theta_0}(\hat y(x,\theta_0) - y)^2 \\ &= 2·(\hat y(x,\theta_0) - y)·\frac{\partial}{\partial \theta_0}(\hat y(x,\theta_0) - y)\\ &= 2·(\hat y(x,\theta_0) - y)·\frac{\partial}{\partial \theta_0}\left(\sum_{j=0}^n\theta_jx_j - y\right)\\ &= 2·(\hat y(x,\theta_0) - y)·x \tag{17} \\ \end{aligned}

将公式 $(17)$ 代入公式 $(12)$ 得：

\theta \leftarrow \theta_0-\alpha·2·(\hat y(x,\theta_0) - y)·x \tag{18}

其中 $\hat y$ 是预测函数， $\theta_0$ 代表当前值， $\theta$ 是下一次的更新值， $x,y$ 是训练数据的输入值与标签值， $\alpha$ 是学习率，由于 $2$ 是常数， $\alpha$ 是标量，可以将 $2$ 并入 $\alpha$ ，则实际上的 $\alpha$ 为 $\frac{2\rho}{||\nabla f(\theta_0)||}$ ，可见学习率可以表达梯度下降迭代步长的变化，实际应用中常常人为赋值或使用特定策略赋值，而不是使用原公式。

至此，公式 $(18)$ 可描述为：

\theta \leftarrow \theta_0-\alpha·(\hat y(x,\theta_0) - y)·x \tag{19}

这是最后写入程序的公式。

为了编程方便，将公式分解，令：

hypothesis = \hat y(x,\theta_0) \tag{20}

error = \hat y(x,\theta_0) - y = hypothesis - y\tag{21}

gradient = (\hat y(x,\theta_0) - y)·x = (error·x)/m \tag{22}

\theta = \theta_0-\alpha·gradient \tag{23}

关于 gradient 的计算，这里说明一下，梯度下降算法家族的三个算法的不同之处就在这里。

批量梯度下降法(BGD)：每次迭代计算梯度，使用整个数据集( $m=M$ )，也就是每次计算 gradient 都用上所有数据点，然后求均值。

随机梯度下降法(SGD)：每次迭代计算梯度，从整个数据集中随机选取一个数据点( $m=1$ )。

小批量梯度下降法(MBGD)：每次迭代计算梯度，从整个数据集中选取一个小批量数据( $1<m<M$ )。

以下根据公式 $(20)、(21)、(22)、(23)$ 编写代码，实现批量梯度下降法：

def batchGradientDescent(x, y, theta, alpha, m, maxInteration):
    '''批梯度下降算法简单实现
    x: 输入
    y: 输出
    theta: w 和 b 组成的向量
    alpha: 学习率
    m: 批数据数量
    maxInteration：最大迭代次数
    '''
    x_train = x.transpose() # 转置
    for i in range(0, maxInteration):
        # 预测值
        hypothesis = np.dot(x, theta)
        # 预测误差
        error = hypothesis - y
        # 下降梯度
        gradient = np.dot(x_train, error) / m
        # 更新theta
        theta = theta - alpha * gradient
    return theta

同理，随机梯度下降代码为：

def stochasticGradientDescent(x, y, theta, alpha, maxInteration):
    '''批梯度下降算法简单实现
    x: 输入
    y: 输出
    theta: w 和 b 组成的向量
    alpha: 学习率
    m: 批数据数量
    maxInteration：最大迭代次数
    '''
    data = []
    for i in range(4):
        data.append(i)
    for i in range(0, maxInteration):
        hypothesis = np.dot(x, theta)
        # 预测误差
        error = hypothesis - y
        # 选取一个随机数
        index = random.sample(data, 1)  # 从列表data中随机选取一个数据
        index1 = index[0]
        # 下降梯度
        gradient = error[index1] * x[index1]
        # 求导之后得到theta
        theta = theta - alpha * gradient
    return theta

小批量梯度下降：

def miniBatchGradientDescent(x, y, theta, alpha, m, batch_size, epochs):
    '''
    x: 输入
    y: 输出
    theta: w 和 b 组成的向量
    alpha: 学习率
    m: 数据集的数据量
    batch_size：一个批次的数据量
    epochs：数据集最大迭代次数
    '''
    for epoch in range(epochs):
        # 生成索引列表
        indexs_list = np.arange(m)
        # 按批次迭代
        for batch in range(m // batch_size):
            # 生成批次数据索引
            index_list = indexs_list[batch*batch_size : batch*batch_size+batch_size]
            # 获取批次数据
            x_batch = x[index_list]
            y_batch = y[index_list]
            # 预测值
            hypothesis = np.dot(x_batch, theta)
            # 预测误差
            error = hypothesis - y_batch
            # 下降梯度
            gradient = np.dot(x_batch.T, error) / m
            # 更新theta
            theta = theta - alpha * gradient
    return theta

5 总结及其他的一些说明

梯度下降运行步骤：

用随机值初始化权重和偏差
把输入传入网络，得到输出值(预测值)
计算预测值和真实值(标签值)之间的误差
对每一个产生误差的神经元，调整相应的（权重和偏差）值以减小误差
重复迭代，直至得到网络权重和偏差的最佳值

批量梯度下降法(BGD)：每次迭代计算梯度，使用整个数据集。每次更新都会朝着正确的方向进行，最后能够保证收敛于极值点，凸函数收敛于全局极值点，非凸函数可能会收敛于局部极值点，缺陷就是学习时间太长，消耗大量内存。

随机梯度下降法(SGD)：每次迭代计算梯度，从整个数据集中随机选取一个数据，所以每次迭代的时间非常快。但收敛时震荡，不稳定，在最优解附近波动，难以判断是否已经收敛。

小批量梯度下降法(MBGD)：这个是 BGD 和 SGD 的折中方法， BGD 每次使用整体数据，收敛太慢， SGD 每次只使用一条数据，虽然收敛快但震荡厉害，所以出现了折中的 MBGD，每次使用 n 条数据，如果 n(batch size) 选择的合适，不仅收敛速度比SGD更快、更稳定，而且在最优解附近的震荡也不会很大，甚至得到比 BGD 更好的解。

batch size 的选择，一般取2的幂次时能充分利用矩阵运算操作，因此可以在2的幂次中挑选最优取值。例如16、32、64、128、256等等。

另外，还有一种小批量随机梯度下降法，即在小批量梯度下降法中，获取批次数据时，不是按原有输入顺序选取数据，而是先把原有输入数据打乱，再选取批次数据，代码如下：

def mini_batch_stochastic_gradient_descent(x, y, theta, alpha, m, batch_size, epochs):
    '''
    x: 输入
    y: 输出
    theta: w 和 b 组成的向量
    alpha: 学习率
    m: 数据集的数据量
    batch_size：一个批次的数据量
    epochs：数据集最大迭代次数
    '''
    for epoch in range(epochs):
        # 生成索引列表
        data_index = np.arange(m)
        # 打乱样本顺序
        np.random.shuffle(data_index)
        # 按批次迭代
        for batch in range(m // batch_size):
            # 生成批次数据索引
            batch_index = data_index[batch*batch_size : batch*batch_size+batch_size]
            # 获取批次数据
            x_batch = x[batch_index]
            y_batch = y[batch_index]
            # 预测值
            hypothesis = np.dot(x_batch, theta)
            # 预测误差
            error = hypothesis - y_batch
            # 下降梯度
            gradient = np.dot(x_batch.T, error) / m
            # 更新theta
            theta = theta - alpha * gradient
    return theta

参考：梯度（数学名词）_百度百科

简单的梯度下降算法，你真的懂了吗？

解梯度下降法的三种形式BGD、SGD以及MBGD