梯度下降算法原理

梯度下降算法原理

本文主要简略介绍梯度下降算法的原理。梯度下降就像在一个山谷中行走，不断迈出在当前位置下降最快的那一步，直到找到一个最低点也就是收敛点，当然这个点可能是局部最优解而非全局最优解。

平方误差代价函数

我们假设有一个共包含 m 个样本的训练集 { x i , y i } , i = 1 , 2 , . . . , m \{x^i,y^i\},i=1,2,...,m {xi,yi},i=1,2,...,m，x和y的关系如下图所示：

我们假设 h(x)是拟合出的关于x和y关系的曲线，如果y是连续的则为回归问题，如果y是离散的则为分类问题。 函数$h(x)$如下所示，其中$\theta$为参数：
$$h_{\theta }(x)={\theta }_0+{\theta }_1\times x+...$$
则平方误差代价函数为：
$$\begin{gathered} J({\theta }_0,{\theta }_1,...)=\frac{1}{2m}\sum _{i=1}^m(h_{\theta }(x^i)-y^i{)}^2 \\ Task=minize(J) \end{gathered}$$
梯度下降算法所要做的就是将$J({\theta }_0,{\theta }_1,...)$最小化，使假设函数$h(x)$尽可能拟合真实情况。

进行偏微分计算不断更新参数

在初始化了参数 $\theta$ 之后，接下来进行偏微分计算不断 同步更新 $\theta$，此处要注意是同步更新，不能将更新了 ${\theta }_0$ 后的 $J$ 代入对 ${\theta }_1$ 的更新计算中。假设学习速度(learning rate)为 $\alpha$，学习速度的大小选取要适当，过大容易错过收敛点，过小则需要迭代太多次，更新参数的过程如下：
$$\begin{gathered} tem{p}_j={\theta }_j-\alpha \frac{\partial }{\partial {\theta }_j}J({\theta }_0,{\theta }_1,...) \\ {\theta }_j=tem{p}_j \end{gathered}$$
越接近局部最优解时，$\frac{\partial }{\partial {\theta }_j}J({\theta }_0,{\theta }_1,...)$ 的值越小，不断重复这个更新参数的过程直至收敛，这时得到的 $h_{\theta }(x)$ 即为拟合效果较好的函数。

梯度下降代码(Python)

本文代码主要参考了博客梯度下降算法原理讲解——机器学习，代码编写过程中，将所有的公式都转换为矩阵的形式，python中矩阵计算比较方便，同时也会使代码更简洁。
预测函数 $h(x)$ 转化为如下形式：
$$h_{\Theta }(x)={\Theta }_0+{\Theta }_1\times x+...$$
假设 $\theta$ 有两个，为了便于进行矩阵化，给每一个点x增加一维，这一维的值固定为1，这一维将会乘到 ${\Theta }_0$上。则 $x_0^i$ 与 ${\Theta }_0$ 相乘后仍为 ${\Theta }_0$，$x_1^i$ 为原来的 $x^i$。这样就方便我们统一矩阵化的计算：
$$\begin{gathered} (x_1^i,y^i)->(x_0^i,x_1^i,y^i) \\ {h}_{\Theta }(x)=\Theta \times X \end{gathered}$$
代价函数和梯度（偏微分计算）转化为如下形式：
$$\begin{gathered} J(\Theta )=\frac{1}{2m}(h_{\Theta }(x)-Y{)}^T(h_{\Theta }(x)-Y) \\ \nabla J(\Theta )=\frac{1}{m}{X}^T(h_{\Theta }(x)-Y) \end{gathered}$$
Python代码如下：

from numpy import *

# 数据集大小 即20个数据点
m = 20
# x的坐标以及对应的矩阵
X0 = ones((m, 1))  # 生成一个m行1列的向量，也就是x0，全是1
X1 = arange(1, m+1).reshape(m, 1)  # 生成一个m行1列的向量，也就是x1，从1到m
X = hstack((X0, X1))  # 按照列堆叠形成数组，其实就是样本数据
# 对应的y坐标
Y = array([
    3, 4, 5, 5, 2, 4, 7, 8, 11, 8, 12,
    11, 13, 13, 16, 17, 18, 17, 19, 21
]).reshape(m, 1) # m行1列
# 学习速度
alpha = 0.01


# 定义代价函数J
def cost_function(theta, X, Y):
    # h = X*\Theta
    diff = dot(X, theta) - Y  # dot() 数组需要像矩阵那样相乘，就需要用到dot()
    return (1/(2*m)) * dot(diff.transpose(), diff)# h的转置和h相乘


# 定义代价函数对应的梯度函数（偏微分计算）
def gradient_function(theta, X, Y):
    diff = dot(X, theta) - Y
    return (1/m) * dot(X.transpose(), diff)


# 梯度下降迭代
def gradient_descent(X, Y, alpha):
    # reshape成2行1列说明是两个\theta参数，如果\theta参数需要更多此处需要更改
    theta = array([1, 1]).reshape(2, 1)
    gradient = gradient_function(theta, X, Y)
    while not all(abs(gradient) <= 1e-5): # 当梯度小于1e-5时，停止迭代
        theta = theta - alpha * gradient
        gradient = gradient_function(theta, X, Y)
    return theta


optimal = gradient_descent(X, Y, alpha)
print('optimal:', optimal)
print('cost function:', cost_function(optimal, X, Y)[0][0])


# 根据数据画出对应的图像
def plot(X, Y, theta):
    import matplotlib.pyplot as plt
    ax = plt.subplot(111)  # 图像为一行一列分布在第一块
    ax.scatter(X, Y, s=30, c="red", marker="s")
    plt.xlabel("X")
    plt.ylabel("Y")
    x = arange(0, 21, 0.1)  # x的范围
    y = theta[0] + theta[1]*x
    ax.plot(x, y)
    plt.show()


plot(X1, Y, optimal)