机器学习--梯度下降法

注意，可能会有一些错误，欢迎大家批评指正QWQ。

1. 基本原理

假设有一个函数，想要寻找的它的极值，该如何得出呢？
最直观上可以直接使用公式得出。

但是有时用公式计算的速度可能并不快，比如使用正规方程解出当前样本的最佳拟合直线，这个的计算量就很大，而且有时有些函数可能没法找到一个合适的公式来直接得出，这时就需要用到梯度下降法了。

高等数学中有这么一句话，沿着梯度方向下降/上升的速度最快。
举个例子，比如二次函数，随意找一个点，沿着它的梯度方向(这里也就是导数)肯定是最快的。

同时，可以发现，如果沿着梯度的反方向前进的话就可以逐渐的逼近极值。

所以就可以大概的理解梯度下降的思路了，对于一个、可导函数想要寻找它的极值，就可以从任意一点，然后沿着梯度的反方向移动，逐渐的逼近极值，最终找到极值。

2. 梯度下降法

接下来以线性回归为例实现一下梯度下降法

首先先回顾一下线性回归要求什么？
对于一个n维的样本空间和m个样本，我们需要拟合出一个直线
$\hat{y}={\theta }_0+x_1{\theta }_1..+x_n{\theta }_n$
使$\sum _{i=1}^m(\hat{y}-y_i{)}^2$最小。
把$\hat{y}$代入算式中得到$\sum _{i=1}^m({\theta }_0+X_1^i{\theta }_1..+X_n^i{\theta }_n-y_i{)}^2$
设他为$J({\theta }_0...{\theta }_n)$得到一个函数，也叫损失函数
$$J({\theta }_0...{\theta }_n)=\sum _{i=1}^m({\theta }_0+X_1^i{\theta }_1..+X_n^i{\theta }_n-y_i{)}^2$$
注意这里X和y都是已知的，只有${\theta }_i$是未知的，所以他是一个关于$\theta$的n + 1元函数。
而我们的目标就是让这个函数尽可能的小。

2.1 求某个点的损失函数值

注意，在下面的 sum表示对向量/矩阵中的所有元素进行求和

首先来设一个列向量$\theta =({\theta }_0,{\theta }_1..,{\theta }_n{)}^T$
然后我们把样本矩阵加上一列1，即变成
$$X=\begin{array}{c}\left(\begin{array}{cccc}1& x_1^1& ...& x_1^n\\ 1& x_2^1& ...& x_2^n\\ ...& & & \\ 1& x_m^1& ...& x_m^n\end{array}\right)\end{array}$$
这样就可以方便表示参数${\theta }_0$

接着把所有的预期值写成一个向量$y=(y_1,y_2...,y_m{)}^T$
然后就可以把损失函数写成这个样子
$$J({\theta }_0...{\theta }_n)=sum[(X\ast \theta -y{)}^2]$$
这样就方便求出函数的值了，但这求出的是所有样本的损失的和，所以可以除一个m来表示单个的损失
$$J({\theta }_0...{\theta }_n)=\frac{1}{m}sum[(X\ast \theta -y{)}^2]$$

np.sum((X.dot(theta) - y) ** 2) / len(X)

2.2 求某个点的梯度

对于梯度，很自然就有这个梯度计算公式。
$$D=\begin{array}{c}\left(\begin{array}{c}\frac{\partial J({\theta }_0..{\theta }_n)}{\partial {\theta }_0}\\ \frac{\partial J({\theta }_0..{\theta }_n)}{\partial {\theta }_1}\\ ...\\ \frac{\partial J({\theta }_0..{\theta }_n)}{\partial {\theta }_n}\end{array}\right)\end{array}$$
求出就可以得到
$$D=\frac{1}{m}\begin{array}{c}\left(\begin{array}{c}2\ast \sum _{i=1}^m({\theta }_0+X_1^i{\theta }_1..+X_n^i{\theta }_n-y_i)\\ 2\ast \sum _{i=1}^m({\theta }_0+X_1^i{\theta }_1..+X_n^i{\theta }_n-y_i)\ast X_1^{(i)}\\ ...\\ 2\ast \sum _{i=1}^m({\theta }_0+X_1^i{\theta }_1..+X_n^i{\theta }_n-y_i)\ast X_n^{(i)}\end{array}\right)\end{array}$$
观察可以发现，只有D的第一个元素形式有点不同。
令$X_0^{(i)}=1$
得$$D=\frac{1}{m}\begin{array}{c}\left(\begin{array}{c}2\ast \sum _{i=1}^m({\theta }_0+X_1^i{\theta }_1..+X_n^i{\theta }_n-y_i)\ast X_0^{(i)}\\ 2\ast \sum _{i=1}^m({\theta }_0+X_1^i{\theta }_1..+X_n^i{\theta }_n-y_i)\ast X_1^{(i)}\\ ...\\ 2\ast \sum _{i=1}^m({\theta }_0+X_1^i{\theta }_1..+X_n^i{\theta }_n-y_i)\ast X_n^{(i)}\end{array}\right)\end{array}$$
可以发现最后一列$X_0^{(i)}...X_1^{(i)}...$就是$X$矩阵的某一列。于是就可以想到这其实也是一个矩阵的乘法
于是很容易得到$D=\frac{2}{m}\ast X^T\ast (X\ast \theta -y)$
然后就求出D了

X.T.dot(X.dot(theta) - y) * 2 / len(X)

2.3 梯度下降的过程

首先需要确定几个参数，一个是初始的$\theta$一个是最大的循环次数$maxloop$(也就是向着极值移动的次数)，还有一个就是精度$eps$，最后一个就是步长$sep$(每次向着极值移动的距离)。

1. 初始化计数器
2. 计算当前位置($\theta$)的梯度
3. 把$\theta$向着梯度反方向移动$sep$倍
4. 计算移动后的$\theta$和移动前的$\theta$，算他们差的绝对值，如果小于eps就直接结束并且当前的$\theta$就是答案，某则继续
5. 把计数器加一，如果当前计数器等于最大循环次数就直接退出，否则更新$\theta$然后回到1

2.4 整体代码实现

import numpy as np


class LinearRegression:
    def __init__(self, X, y):
        self.__X = np.hstack([np.ones((len(X), 1)), X])# 这里直接加上一列
        self.__y = y
        self.theta_ = None

    def DLossFun(self, theta: np.array):
        return self.__X.T.dot(self.__X.dot(theta) - self.__y) * 2 / len(self.__X)

    def GetLossValue(self, theta: np.array):
        return np.sum((self.__y - self.__X.dot(theta)) ** 2) / len(self.__X)
        
    def fitByGradintDescent(self, init: np.array, maxloop: int=10000, sep: float=0.001, eps: float=1e-6):
        tmp = init
        cnt = 0 # 计数器
        while True:
            next = tmp - self.DLossFun(tmp) * sep # 计算接下来前到的地方
            if abs(self.GetLossValue(next) - self.GetLossValue(tmp)) < eps:
                self.theta_ = next
                break
            cnt += 1 # 计数器加一
            if cnt > maxloop: return # 大于最大循环次数就退出 
            tmp = next # 更新tmp

3. 一些细节问题

首先，关于几个参数，有一些需要注意的问题

• sep
  对于sep如果设置过大，很有可能会导致偏移极值，而不是靠近极值。
  如果过小就会导致靠近的速度过慢。
• eps
  eps是精度也就是当当前的点逐渐逼近极值时逐渐的前近距离越来越小，直到值的变化小于eps时就可以判定达到极值，显然eps越小就越接近极值

3.1 数据规模与归一化

使用梯度下降法时，有时数据本身很大，就会导致在计算时速度过慢，甚至导致浮点数溢出。此时就需要对数据进行归一化

4. 随机梯度下降

4.1 原理

对于之前的梯度下降，每次计算梯度时，都十分耗费时间，假设一个m*n的样本那么每次计算的复杂度就是$O((n+1)\ast (m+1)\ast n\ast m)$大概就是$O(n^2{m}^2)$级别的，当样本数和特征数比较大时仍然很费时间。

观察梯度向量：
$$D=\frac{2}{m}\begin{array}{c}\left(\begin{array}{c}({\theta }_0+X_1^k{\theta }_1..+X_n^k{\theta }_n-y_k)\ast X_0^{(k)}\\ ({\theta }_0+X_1^k{\theta }_1..+X_n^k{\theta }_n-y_k)\ast X_1^{(k)}\\ ...\\ ({\theta }_0+X_1^k{\theta }_1..+X_n^k{\theta }_n-y_k)\ast X_n^{(k)}\end{array}\right)\end{array}$$
可以发现，前面乘了$\frac{1}{m}$，而后面又是对m个样本求和。
也就是说可以对直接让m次求和把$\frac{1}{m}$抵消了。
当然这样求出来的就不是梯度了，也就是不是沿着梯度方向(甚至方向相反)，但这样每次随机的取出一个样本来计算就可以在一定程度上代替梯度。
$$D=2\ast X^{(k)}\cdot (X^{(k)}\ast \theta -y_k)$$
值得注意的是，这里 $\cdot$ 表示点乘

这样，复杂度就大大地降低，下降到了$O(n)$级别。

但是，在这样随机的选取一个样本然后计算的过程中还是会有一些问题。

1. 每次都随机不能保证能把样本都取一遍
2. 每次前进的距离不能都相同
3. 不能以两次的值的差的距离作为结束条件

针对于1，可以把样本进行打乱，然后再对其进行遍历取值。
针对于2，这里就需要进行设置一个函数来控制每次前进的长度，可以想到，如果每次前进的步长都一样的话及时到达终点也有可能在跑出去，也就是每次前进的步长应该越来越小。
也就是随着梯度下降的过程进行，每次前进的步长越来越小，整体前进的方向越来越稳定。
针对于3，则需要设置一个次数，表示样本被遍历的次数，遍历完后就默认已经达到了极值。

4.2 代码

求D的部分

def StochasticDLossFun(self, theta: np.array, index: int):
    tmp = self.__X[index].reshape(-1, 1) * (self.__X[index].dot(theta) - self.__y[index])
    return tmp

随机梯度下降部分
length表示样本数，t1表示步长函数的分母上的常数，t0表示分子上的常数，n_iters表示样本被遍历的次数。

def search(self, init_theta: np.array, length: int, t1: float=50.0, t0: float=5.0, n_iters:int=5):
    tmp = init_theta
    cnt = 0
    def temper(x: int):
        return t0 / (x + t1)

    for i in range(n_iters):
        indexes = np.arange(length)
        np.random.shuffle(indexes)
        for j in indexes:
            tmp = tmp - self.DFun(theta=tmp, index=j) * temper(cnt)
            cnt += 1
    self.ans_ = tmp
    return