计算
对于线性回归，梯度下降法的目标就是找到一个足够好的向量\(\theta\)，使代价函数\(J(\theta) = \sum_{i=1}^{m}(\hat{y}-y_{i})^{2}\)取得最小值。线性回归的代价函数是关于\(\theta\)的多元函数。如下：
\[J(\theta) = \sum_{i=1}^{m}(\hat{y}-y^{i})^{2} = \sum_{i=1}^{m}(\theta x^{(i)}-y^{i})^{2}
\]
\[J(\theta) = \sum_{i=1}^{m}(y^{i} - \theta_{0} - \theta_{1}x^{(i)}_1 - \theta_{2}x^{(i)}_2 - ... - \theta_{n}x^{(i)}_n )^{2}
\]
对代价函数\(J(\theta)\)的每一个\(\theta\)分量求偏导数，
\[\frac{\partial J(\theta)}{\partial \theta_i}= \begin{bmatrix}
\frac{\partial J(\theta)}{\partial \theta_1} \\
\frac{\partial J(\theta)}{\partial \theta_2} \\
\vdots \\
\frac{\partial J(\theta)}{\partial \theta_n}
\end{bmatrix} = 2 \begin{bmatrix}
\sum_{i=1}^{m}(y^{(i)} - X^{(i)}_b\theta) (-1) \\
\sum_{i=1}^{m}(y^{(i)} - X^{(i)}_b\theta) (-X^{(i)}_1) \\
\vdots \\
\sum_{i=1}^{m}(y^{(i)} - X^{(i)}_b\theta) (-X^{(i)}_n)
\end{bmatrix} = 2 \begin{bmatrix}
\sum_{i=1}^{m}(X^{(i)}_b\theta -y^{(i)}) \\
\sum_{i=1}^{m}(X^{(i)}_b\theta -y^{(i)}) (X^{(i)}_1) \\
\vdots \\
\sum_{i=1}^{m}(X^{(i)}_b\theta - y^{(i)}) (X^{(i)}_n)
\end{bmatrix}
\]
这里将J()除以m可以缩小梯度的值：
\[J(\theta) = \frac{1}{m}\sum_{i=1}^{m}(\hat{y}-y^{i})^{2}
\]
此时梯度为：
\[\frac{\partial J(\theta)}{\partial \theta_i}= \frac{2}{m} \begin{bmatrix}
\sum_{i=1}^{m}(X^{(i)}_b\theta -y^{(i)}) \\
\sum_{i=1}^{m}(X^{(i)}_b\theta -y^{(i)}) (X^{(i)}_1) \\
\vdots \\
\sum_{i=1}^{m}(X^{(i)}_b\theta - y^{(i)}) (X^{(i)}_n)
\end{bmatrix}
\]
此处也可以除以2m，因为可以方便求导数，不过，对结果没有什么影响，可以随意
这里的\(J(\theta)\)分为m个部分，因为有m个点。计算梯度的时候需要把m个点的坐标代进去关于\(\theta\)的表达式。这是梯度的标准求法。这个公式，是完整的梯度公式。即，在每个\(\theta\)方向求导数。得到的梯度向量就是下降最快的方向。
随机梯度下降法就是简化了这个\(J(\theta)\)，不需要再把m个点都代入进去，而是随机地抽取一个点，所以计算速度大为提高。
小批量梯度下降法就是中和了这两个算法，每次取batch个点代进去，计算梯度。BGD的梯度最后除以了m，这里的MBGD也可以除以batch。其实除和不除，都能计算出来，因为除的这个batch，在迭代的时候，会和\(\alpha\)相乘，只不过会对\(\alpha\)的取值有所影响。
以下是求梯度的函数，很简单，但是我总是记不住，这里作详细的介绍：
def dJ(theta, X_b, y):
res = np.empty(len(theta))
res[0] = np.sum(X_b.dot(theta) - y)
for i in range(1, len(theta)):
res[i] = (X_b.dot(theta) - y).dot(X_b[:, i])
return res * 2 / len(X_b)
首先上面矩阵中的每个元素其实也需要通过矩阵运算得出
\[\sum_{i=1}^{m}(X^{(i)}_b\theta -y^{(i)}) (X^{(i)}_1) = (X^{(1)}\theta - y^{(1)})X^{(1)}_1 + (X^{(2)}\theta - y^{(2)})X^{(2)}_1 + ... + (X^{(m)}\theta - y^{(m)})X^{(m)}_1
\]
上面的式子可以用用两个向量的内积表示为，此处是内积，不是矩阵乘法:
\[\begin{bmatrix}
\theta_0 + X^{(1)}_1\theta_1 + X^{(1)}_2\theta_2 + X^{(1)}_n\theta_n ... - y^{(1)} \\
\theta_0 + X^{(2)}_1\theta_1 + X^{(2)}_2\theta_2 + X^{(2)}_n\theta_n ... - y^{(2)} \\
\vdots \\
\theta_0 + X^{(m)}_1\theta_1 + X^{(m)}_2\theta_2 + X^{(m)}_n\theta_n ... - y^{(m)}
\end{bmatrix}
\cdot
\begin{bmatrix}
X^{(1)}_1 \\
X^{(2)}_1 \\
\vdots \\
X^{(m)}_1
\end{bmatrix}
\]
上面的式子又等价于：
\[(\begin{bmatrix}
1 & X^{(1)}_{1} & X^{(1)}_{2} & \cdots & X^{(1)}_{n} \\
1 & X^{(2)}_{1} & X^{(2)}_{2} & \cdots & X^{(2)}_{n} \\
\vdots & \vdots & \ddots & \vdots \\
1 & X^{(m)}_{1} & X^{(m)}_{2} & \cdots & X^{(m)}_{n}
\end{bmatrix} \cdot
\begin{bmatrix}
\theta_0 \\
\theta_1 \\
\vdots \\
\theta_n
\end{bmatrix} -
\begin{bmatrix}
y^{(1)} \\
y^{(2)} \\
\vdots \\
y^{(m)}
\end{bmatrix})\cdot
\begin{bmatrix}
X^{(1)}_1 \\
X^{(2)}_1 \\
\vdots \\
X^{(m)}_1
\end{bmatrix}
\]
最终可以表示为，\(X[:,i]\)是python中的切片的写法：
\[(X_b \theta - y)* X[:,i]
\]
因此，除了第一行以外，每一行的偏导数都可以表示为 \((X_b \theta - y)* X[:,i]\)，上面的代码中的循环，就是对除了第一行以外的所有行，每一行都进行一次计算。这里dot()是点乘，向量点乘之后就自动求和了。所以不需要再次求和。
for i in range(1, len(theta)):
res[i] = (X_b.dot(theta) - y).dot(X_b[:, i])
所以其实是两种情况:
\((X_b \theta - y)\) 第一行
\((X_b \theta - y)* X[:,i]\) 之后的所有行
实现
思路：先准备数据集X和y ==> 使用交叉验证选出训练样本 ==> 回归
回归的过程: 将转换为X_b(就是加上X0) ==> 设置初始化 \(\theta\) ==> 进行梯度下降(计算各个方向的偏导数-> 循环计算theta = theta - eta * dj)
class LinearRegression2:
def __init__(self):
self.coef_ = None # 表示参数，theta_[1:]
self.intercept_ = None # 表示截距 ==>theta[0]
self._thera = None # 表示完整的theta==> theta[:]
def fit_gd(self, X_train, y_train, eta=0.01, n_iters=1e4):
"""使用梯度下降法寻找最小的代价函数"""
# 格式化X和theta，加上x0 和 theta0
X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
initial_theta = np.zeros(X_b.shape[1])
# 调用循环的梯度下降
self._thera = self.gradient_descent(X_b, y_train, initial_theta, eta=eta, n_iters=n_iters)
self.intercept_ = self._thera[0]
self.coef_ = self._thera[1:]
return self
def gradient_descent(self, X_b, y, initial_theta, eta, n_iters=1e4, epsilon=1e-8):
theta = initial_theta
i = 0
while i < n_iters:
i += 1
lastTheta = theta # 记录上一个参数向量
dj = self.dj(theta, X_b, y)
theta = theta - eta * dj
if np.absolute(self.J(lastTheta, X_b, y) - self.J(theta, X_b, y)) < epsilon:
break
return theta
def dj(self, theta, X_b, y):
"""计算代价函数的偏导数"""
# res 是 长度为len的一维数组
res = np.zeros((len(theta))) ##### zeros(5) == zeros((5,)) != zeros((5,1))
res[0] = np.sum(X_b.dot(theta) - y) # 需要将向量求和。没有办法，这里只能手动分开求解。因为这里X是从列方向分割，没有X0
for i in range(1, len(theta)):
res[i] = (X_b.dot(theta) - y).dot(X_b[:, i])
return res * 2 / len(X_b)
def J(self, theta, X_b, y):
"""计算代价函数"""
return np.sum((y - X_b.dot(theta)) ** 2) / len(y)
调用效果如下：
np.random.seed(666)
x = 2 * np.random.random(size=100)
y = x * 3. + 4. + np.random.normal(size=100)
X = x.reshape(-1, 1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_ratio=0.2, seed=666)
line = LinearRegression2()
line.fit_gd(X_train, y_train)
###
4.085675667692203
[ 2.97732994]
使用向量实现
博客没法显示全公式。。就用图片凑合吧.\(X_b\theta -y\)是列向量
即，最后的公式为：
\[J(\theta) = \frac{2}{m}X^T_b \cdot (X_b\theta-y)
\]
使用python的numpy实现：
def dJ(theta, X_b, y):
return X_b.T.dot(X_b.dot(theta) - y) * 2. / len(y)
其中，\(X_b\)是在原始数据的每一列前面加了一列后的矩阵，y是训练数据中给定的\(y\_train\)。
小结
不管是用向量计算还是用手动计算。都需要先把训练数据\(X\)转换为\(X_b\)
一般来说，\(X\)都是ndarray类型的二维数组，使用hstack([ist1, list2])函数可以将两个数组摊在一起。将\(X\)转换为\(X_b\)的代码为：
X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
大体思路就是:
- 调用
fit()方法拟合，该方法中产生\(X_b\)，并初始化\(\theta\)。最后使调用梯度下降方法gradient_descent()来找到最优的\(\theta\)gradient_descent() 循环调用dj()计算对\(\theta\)的偏导数,并每一次都对\(\theta\)的值进行更新。gradient_descent() 中会调用J()来判断梯度的增量是否已经足够小。数据标准化
在这里使用波士顿房价数据测试，发现一些很有意思的东西，如下。为什么会这样？，因为数据没有归一化，在数据集中存在一下特别大和特别小的数字，导致在计算梯度时，可能会导致梯度的跨度太大，而无法收敛。也有可能时计算式出现了过大的数inf。
linear.fit_gd(X, y, n_iters=1e4, eta=0.001)
print(linear.coef_)
###
[nan nan nan nan nan nan nan nan nan nan nan nan nan]
只要将学习系数设定的足够小，就不会报错。
linear.fit_gd(X, y, n_iters=1e4, eta=0.0000001)
使用sklearn的StandardScaler归一化数据。注意归一化需要将所有的X都归一化，包括用来训练的x_train和用来测试的x_test
from sklearn.preprocessing import StandardScaler
standardScaler = StandardScaler()
standardScaler.fit(X) # 导入数据
X_standard = standardScaler.transform(X) # 转换数据
所以，到目前为止，要预测一个波士顿房价数据的完整过程是这样的：
from sklearn import datasets
# 加载数据集
X = datasets.load_boston().data
y = datasets.load_boston().target
# 剔除噪音
X = X[y < 50]
y = y[y < 50]
# 数据归一化处理
from sklearn.preprocessing import StandardScaler
standardScaler = StandardScaler()
standardScaler.fit(X)
X_standard = standardScaler.transform(X)
# 交叉验证
X_train_standard, X_test_standard, y_train, y_test = train_test_split(X_standard, y, test_ratio=0.2, seed=666)
# 回归，拟合
linear = LinearRegression2()
linear.fit_gd(X_train_standard, y_train, n_iters=3e5)
# 使用score计算拟合的效果
print(linear.score(X_test_standard, y_test))
随机梯度下降法
原本的梯度下降法：
\[\frac{\partial J(\theta)}{\partial \theta_i}= \frac{2}{m} \begin{bmatrix}
\sum_{i=1}^{m}(X^{(i)}_b\theta -y^{(i)}) \\
\sum_{i=1}^{m}(X^{(i)}_b\theta -y^{(i)}) (X^{(i)}_1) \\
\vdots \\
\sum_{i=1}^{m}(X^{(i)}_b\theta - y^{(i)}) (X^{(i)}_n)
\end{bmatrix}
\]
随机梯度下降法：
\[\text { 2. }\left(\begin{array}{c}{\left(X_{b}^{(i)} \theta-y^{(i)}\right) \cdot X_{0}^{(i)}} \\
{\left(X_{b}^{(i)} \theta-y^{(i)}\right) \cdot X_{1}^{(i)}} \\
{\left(X_{b}^{(i)} \theta-y^{(i)}\right) \cdot X_{2}^{(i)}} \\
{\cdots} \\
{\left(X_{b}^{(i)} \theta-y^{(i)}\right) \cdot X_{n}^{(i)}}\end{array}\right)=2 \cdot\left(X_{b}^{(i)}\right)^{T} \cdot\left(X_{b}^{(i)} \theta-y^{(i)}\right)
\]
原本的计算偏导数的函数用这个替代。里只有一个样本哦，所有的误差和X都是一个同一个样本的。而原来的函数，每计算一次偏导数都要对n个特征，每个循环m次，共mn次计算。计算量确实是大大提高，但是，不能保证每次都找到最好的梯度。使用随机产生的梯度。相比较原来的函数，去掉了步长。
学习率：
\[\eta=\frac{t_{0}}{i_{-} i t e r s+t_{1}}
\]
去掉了参数中的步长
n_iters 表示遍历所有样本的轮数
学习率需要不断缩小，因为，算出来的梯度不能保证是越来越小的（因为随机）
class StochasticDescent:
"""随机梯度下降法"""
def __init__(self):
self.coef_ = None # 表示参数，theta_[1:]
self.intercept_ = None # 表示截距 ==>theta[0]
self._thera = None # 表示完整的theta==> theta[:]
def fit_SGD(self, X_train, y_train, eta=0.01, n_iters=1):
"""使用梯度下降法寻找最小的代价函数"""
# 格式化X和theta，加上x0 和 theta0
X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
initial_theta = np.zeros(X_b.shape[1])
# 调用循环的梯度下降
self._thera = self.sgd(X_b, y_train, initial_theta, n_iters, 5, 50)
self.intercept_ = self._thera[0]
self.coef_ = self._thera[1:]
return self
def sgd(self, X_b, y_train, initial_theta, n_iters, t0=5, t1=50):
"""随机梯度下降, niters是轮数"""
def get_study_rate(i_iters):
"""把学习率和迭代次数联系起来"""
return t0 / (t1 + i_iters)
def dJ_sgd(X_b_i, theta, y):
"""计算随机一个元素的梯度"""
return 2 * X_b_i.T.dot(X_b_i.dot(theta) - y)
m = len(X_b)
theta = initial_theta
for n in range(int(n_iters)):
indexes = np.random.permutation(m)
X_b_new = X_b[indexes, :]
y_new = y[indexes]
for i in range(m):
sgd = dJ_sgd(X_b_new[i], theta, y_new[i])
theta = theta - get_study_rate(m * n + i) * sgd
return theta
sklearn 中的随机梯度下降
SGDRegressor位于线性模型下，SGDRegressor(max_iter=50)可以传入参数 max_iter指定迭代的次数。
from sklearn.linear_model import SGDRegressor
sgd_reg = SGDRegressor(max_iter=50)
sgd_reg.fit(X, y)
调试梯度下降法
对每个\(\theta\)分量，都要微积分，最后，用算出来的微积分向量，作为梯度。
计算量巨大，调试成功后，要关闭
分子的两个顺序不能错，我把顺序搞错了，结果导数算反了。。。
\[\frac{d J}{d \theta}=\frac{J(\theta+\varepsilon)-J(\theta-\varepsilon)}{2 \varepsilon}
\]
关键代码在这：
def dj_debug(self, X_b, theta, y, epsilon=0.001):
res = np.zeros((len(theta), ))
for i in range(len(theta)):
theta_1 = theta.copy()
theta_2 = theta.copy()
theta_1[i] += epsilon
theta_2[i] -= epsilon
res[i] = (self.J(theta_1, X_b, y) - self.J(theta_2, X_b, y)) / (2 * epsilon)
return res
完整代码：
class aDebugGradient:
"""随机梯度下降法"""
def __init__(self):
self.coef_ = None # 表示参数，theta_[1:]
self.intercept_ = None # 表示截距 ==>theta[0]
self._thera = None # 表示完整的theta==> theta[:]
def fit_debug(self, X_train, y_train, eta=0.01, n_iters=1e4):
"""使用梯度下降法寻找最小的代价函数"""
# 格式化X和theta，加上x0 和 theta0
X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
initial_theta = np.zeros(X_b.shape[1])
# 调用循环的梯度下降
self._thera = self.gradient_Descent(self.dj_debug, X_b, y_train, initial_theta, eta, n_iters)
self.intercept_ = self._thera[0]
self.coef_ = self._thera[1:]
return self
def J(self, theta, X_b, y):
return np.sum((y - X_b.dot(theta)) ** 2) / len(y)
def dj_debug(self, X_b, theta, y, epsilon=0.001):
res = np.zeros((len(theta), ))
for i in range(len(theta)):
theta_1 = theta.copy()
theta_2 = theta.copy()
theta_1[i] += epsilon
theta_2[i] -= epsilon
res[i] = (self.J(theta_1, X_b, y) - self.J(theta_2, X_b, y)) / (2 * epsilon)
return res
def dJ_math(self, X_b, theta, y):
return X_b.T.dot(X_b.dot(theta) - y) * 2. / len(y)
def gradient_Descent(self, dj, X_b, y_train, initial_theta, eta, n_iters, epsilon=1e-8):
"""梯度下降"""
theta = initial_theta
for i in range(int(n_iters)):
gradient = dj(X_b, theta, y_train) # 计算得到梯度
last_theta = theta
theta = theta - eta * gradient
if np.absolute(self.J(theta, X_b, y_train) - self.J(last_theta, X_b, y_train)) < epsilon:
break
return theta
最后，，，这垃圾公式真是烦死人！！！