6梯度下降
1.概念
引入梯度下降的原因：1.并不是所有的机器学习都是凸函数，并且可能存在多个极值，不能确定唯一解；2.特征和数据量较多时，矩阵计算量太大（逆矩阵运算的时间复杂度是（
O(n\^3)
））
**梯度下降：**梯度表示损失函数对于模型参数的偏导数。对于每个可训练的参数，梯度告诉我们在当前参数下，沿着每个参数方向变化时，损失函数的变化率。通过计算损失函数对参数的梯度，算法可以根据梯度信息来调整参数从而沿着减少损失的方向更新模型进行调优。
在
\\bar e={\\frac{1}{n}}\\sum_{i=1}\^{n}x_{i}\^{2}w\^{2}-{\\frac{2}{n}}\\sum_{i=1}\^{n} x_{i}y_{i}w+{\\frac{1}{n}}\\sum_{i=1}\^{n} y_{i}\^{2}
中损失函数对于参数w的梯度就是此时w的切线斜率。
梯度下降法是通过不断地优化从而得到最优解。（优化算法都是期望以最快的速度把模型参数w求解出来）
2.步骤
①.Random随机生成初始w，随机生成一组正态分布的数值
w_0,w_1,w_2....w_n
②.求梯度g，即损失函数在此w点上的切线斜率（求导）
③.g<0,表示切线斜率为负数，表示在导数为0的w值的左边，那么就应该把w往右调大不断逼近导数为0的w值；g>0，表示切线斜率为正，表示在导数为0的w值的右边，将w往左调小不断逼近导数为0的w值
④.判断是否收敛，如果收敛就跳出迭代，否则重复②-④。判断收敛的标准是：随着迭代看loss的值变化多少，如果很小甚至不再变化，则认为达到迭代。（迭代次数可以固定）
3.公式
w\^{n+1}=w\^n-α\*gradient
新值=旧值-学习率\*导数
**学习率：**学习率很小可以保证收敛，但是会增加计算；学习率较大，训练会震荡收敛；学习率过大，系统会来回震荡无法收敛
一般将学习率设置成一个小数，0.1,0.01,0.001,0.0001等，可以根据情况进行调整。一般学习率在整体迭代过程中不变，也可以设置成随着迭代次数增多学习率逐渐变小以更精准地得到最优解。
按照步骤来计算w的值
假设要求的损失函数的抛物线公式为：
\\bar e=10w\^{2}-15.9w+6.5
那么切线公式为：
e'=20w-15.9
w0=0.2，假设学习率为0.01（w0表示第0次w的值）
w1=w0-0.01*e'(w0)=0.2-0.01 *（20 * 0.2-15.9）=0.319
w2=w1-0.01 * e'(w1)=0.319-0.01 * (20 * 0.319-15.9)=0.4142
以此类推
w在最低点的左边还是右边：导数为负值，则w在最低值的左边，应该往右移动（减去一个负数=加上一个正数=往右移动）；导数为正值，则w在最低值的右边，应该往左移动（加上一个负数=往左移动）
4.代码实现梯度下降
①.损失函数为一个特征的抛物线：
loss(w_1)=(w_1-3.5)\^2-4.5w_1+10
python
#自己实现一维梯度下降算法（一个w）
import numpy as np
import matplotlib.pyplot as plt
w=np.linspace(-10,10,100)
#print(w)
def loss(w):
return (w-3.5)**2-4.5*w+10
def dloss(w):
return 2*(w-3.5)-4.5
#print(loss)
plt.plot(w,loss(w))
plt.show()
#梯度下降
#学习率
learning_rate=0.1
#初始化一个w值
np.random.seed(1)
w=np.random.randint(-10,20)#随机给一个w值：-5
print(w)
e=loss(w)#初始化的w为-5时的loss值
x=[w]
y=[e]
#第1次梯度下降
w=w-learning_rate*dloss(w)
e=loss(w)
x.append(w)
y.append(e)
#第2次梯度下降
w=w-learning_rate*dloss(w)
e=loss(w)
x.append(w)
y.append(e)
#第3次梯度下降
w=w-learning_rate*dloss(w)
e=loss(w)
x.append(w)
y.append(e)
plt.scatter(x,y)#画点
plt.show()
python
#自己实现一维梯度下降算法（一个w）-循环
import numpy as np
import matplotlib.pyplot as plt
#假设有一个函数是y=wx 通过损失函数的思路已经得出了损失函数
def loss(w):
return (w-3.5)**2-4.5*w+10
#得出导函数
def dloss(w):
return x*(w-3.5)-4.5
def train():
#初始化随机给一个w值
w=-10#np.random.randint(-10,20)
#初始化学习率
lr=0.1
#更新次数
epoch=1000
#梯度下降更新w
t0,t1=1,100
for i in range(0,epoch):
#print(i)
lr=t0/(t1+i)
w=w-lr*dloss(w)
print(f"第{i}次w更新后的值：{w},更新后损失函数的值{loss(w)}")
train()
②.损失函数为两个特征的抛物线：
loss(w_1,w_2)=(w_1-3.5)\^2+(w_2-2)\^2+3w_1w_2-4.5w_1+2w_2+20
分别对w1，w2求导
对w_1求导，就是把w_2看成一个常数: loss(w1)'=2(w_1-3.5)+0+3w_2-4.5=2w_1+3w_2-11.5
对w_2求导，就是把w_1看成一个常数: loss(w2)'=0+2(w_2-2)+3w_1+2=2w_2+3w_1-2
参照一维求梯度下降的算法：
python
#自己实现二维梯度下降算法（两个w）
import numpy as np
#假设有一个函数是y=wx 通过损失函数的思路已经得出了损失函数
def loss(w1,w2):
return (w1-3.5)**2+(w2-2)**2+3*w1*w2-4.5*w1+2*w2+20
#得出导函数
def dloss_w1(w1,w2):
return 2*(w1-3.5)+3*w2-4.5
def dloss_w1(w1,w2):
return 2*(w2-2)+3*w1+2
#梯度下降算法
def train():
#初始化随机给一个w1，w2值
w1=10#np.random.randint(-10,20)
w2=10
#初始化学习率
lr=0.1
#更新次数
epoch=1000
#梯度下降更新w
t0,t1=1,100
for i in range(0,epoch):
#更新w1，w2
lr=t0/(t1+i)
w1_=w1
w2_=w2
w1=w1-lr*dloss(w1_,w2_)
w2=w2-lr*dloss(w1_,w2_)
print(i,w1,w2,loss(w1_,w2_))
#print(f"第{i}次w更新后的值：{w1,w2},更新后损失函数的值{loss(w)}")
train()5.API
①.Batch Gradient Descent (BGD) :批量梯度下降，每一次迭代都使用全部的训练样本来计算梯度更新权重。优点：更新方向最准确；缺点：计算量大且速度慢。
②.Mini-Batch Gradient Descent (MBGD) : 小批量梯度下降，每一次迭代都从数据集中随机抽取一小部分样本，然后基于这一批样本的平均梯度来更新权重。保证了准确性和计算效率。
③.Stochastic Gradient Descent (SGD) : 随机梯度下降，每一次迭代都只使用随机单个样本来计算梯度并更新权重。优点：更快地收敛；缺点：权重更新路径不稳定
6.批量梯度下降BGD
用于最小化损失函数（目标函数）,每次迭代都使用所有的训练样本 来计算损失函数的梯度并更新模型。
更新规则
①.数据集（包含m个训练样本）
\\{(x\^{(i)}, y\^{(i)})\\}_{i=1}\^{m}
其中 x\^{(i)} 是输入特征，y\^{(i)} 是对应的标签。目标是最小化损失函数J(\\theta)相对于模型参数\\theta 的值。
损失函数可以定义为：
J(\\theta) = \\frac{1}{2m} \\sum_{i=1}\^{m} (h_\\theta(x\^{(i)}) - y\^{(i)})\^2
其中 h_\\theta(x\^{(i)}) 是模型对第 i 个样本的预测输出。
批量梯度下降的更新规则为：
\\theta_j := \\theta_j - \\alpha \\frac{1}{m} \\sum_{i=1}\^{m} (h_\\theta(x\^{(i)}) - y\^{(i)}) \\cdot x_j\^{(i)} ， 对于 j = 0, 1, \\ldots, n （其中 n 是特征的数量），并且 \\alpha 是学习率。
特点
最准确，计算量大，收敛到最小值的速度较慢，内存需求大
使用场景
小数据集，不需要实时更新模型
注意事项
选择合适的学习率：太小收敛速度会很慢，太大可能会不收敛
数据预处理：标准化或归一化，提高批量梯度下降的效率
监控损失函数：定期检查损失函数的变化趋势，确保方向正确
7.随机梯度下降SGD
SGD每一步更新参数时仅使用单个训练样本，使得它更加灵活且计算效率更高，特别是处理大规模数据集时
步骤：
①.初始化参数：
选择一个初始点作为参数向量 \\theta的初始值
②.选择样本：
随机选取一个训练样本 (x\^{(i)}, y\^{(i)})
③.计算梯度：
使用所选样本 (x\^{(i)}, y\^{(i)})来近似计算损失函数 J(\\theta) 的梯度 \\nabla J(\\theta)
④.更新参数：
根据梯度的方向来更新参数 \\theta
更新公式为：\\theta := \\theta - \\alpha \\cdot \\nabla J(\\theta)
其中 α是学习率，决定了每次迭代时参数更新的步长。
5.重复②-④，直到完成一个完整的epoch，即所有的样本都被访问过一次
6.重复，直到满足最大迭代次数或者梯度变化足够小
7.输出最小化损失函数后的最优参数
\\theta\^\*
数学公式：
假设我们有一个包含 m个样本的数据集 \\{(x\^{(i)}, y\^{(i)})\\}，J(\\theta) = \\frac{1}{2}(h_\\theta(x\^{(i)}) - y\^{(i)})\^2
其中 h_\\theta(x\^{(i)}) = \\theta\^T x\^{(i)}是模型对第 i个样本的预测值。
梯度 \\nabla J(\\theta) 对于每个参数 \\theta_j 的偏导数可以表示为：\\frac{\\partial J(\\theta)}{\\partial \\theta_j} = (h_\\theta(x\^{(i)}) - y\^{(i)})x_j\^{(i)}
更新规则：
参数\\theta的更新规则为：\\theta_j := \\theta_j - \\alpha \\cdot \\frac{\\partial J(\\theta)}{\\partial \\theta_j}
注意事项：
选择合适的学习率：太小收敛速度会很慢，太大可能会不收敛
随机性：随机选择一个样本，避免陷入局部最小值
停止条件：达到最大迭代次数或者梯度的范围小于某个阈值
优点：快速迭代并适应较大的数据集
缺点：每次只使用一个样本进行更新，梯度可能较为嘈杂，更新中可能会出现较大的波动。可以通过减少学习率（例如采用学习衰减策略）来解决
eg1
python
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import SGDRegressor
from sklearn.metrics import mean_squared_error
# 加载数据集
data=fetch_california_housing(data_home="./src")
# print(data.data.shape)
# # print(data.target[0:10])
# print(data.feature_names)
# print(data.target_names)
x=data.data
y=data.target
# 数据标准化
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.2)
stander=StandardScaler()
x_train=stander.fit_transform(x_train)
# 生成SGD随机梯度下降模型
sgd_model=SGDRegressor(loss="squared_error",alpha=0.01,fit_intercept=True,max_iter=1000,shuffle=True,random_state=666)
# 训练
sgd_model.fit(x_train,y_train)
# 评估
x_test=stander.transform(x_test)
print(sgd_model.score(x_test,y_test))
# 训练的结果
print(sgd_model.coef_)#w
# 预测
# y=sgd_model.predict([[1,2,3,4,5,6,7,7]])
# print(y)
# 算均方差
y_predict=sgd_model.predict(x_test)
e=mean_squared_error(y_predict,y_test)
print(e)8.小批量梯度下降MBGD
在每个迭代步骤中使用一小部分训练样本来计算损失函数的梯度，并进行更新。能减少计算资源的需求，保持一定程度的梯度准确性。
更新规则
假设我们有一个包含 m 个训练样本的数据集 \\{(x\^{(i)}, y\^{(i)})\\}_{i=1}\^{m}，其中 x\^{(i)} 是输入特征，y\^{(i)} 是对应的标签。我们将数据集划分为多个小批量，
每个小批量包含b个样本，其中b称为批量大小（batch size）（一般是2的n次方），通常 b远小于m。
损失函数可以定义为：
J(\\theta) = \\frac{1}{2m} \\sum_{i=1}\^{m} (h_\\theta(x\^{(i)}) - y\^{(i)})\^2，其中 h_\\theta(x\^{(i)}) 是模型对第 i 个样本的预测输出。
小批量梯度下降的更新规则为：
\\theta_j := \\theta_j - \\alpha \\frac{1}{b} \\sum_{i \\in B} (h_\\theta(x\^{(i)}) - y\^{(i)}) \\cdot x_j\^{(i)}
对于 j = 0, 1, \\ldots, n （其中 n 是特征的数量），并且 \\alpha 是学习率，B表示当前小批量中的样本索引集合。
特点
计算效率：相比于BGD，减少了计算成本
梯度估计：相比于SGD，提供了更准确的梯度估计，可以更稳定地接近最小值
内存需求：相比于BGD，降低了内存需求
收敛速度与稳定性：保持较快的收敛速度的同时保持相对较高的稳定性
使用场景
中等规模数据集：高效、良好的收敛性
在线学习：可以有效地处理新到来的数据流式批次
分布式环境：多台机器
注意事项
选择合适的批量大小
选择合适的学习率：太小收敛速度会很慢，太大可能会不收敛
数据预处理：标准化或归一化，提高批量小梯度下降的效率
监控损失函数：定期检查损失函数的变化趋势，确保方向正确
eg2
调用partial_fit函数训练会直接更新权重,而不需要调fit从头开始训练
python
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import SGDRegressor
from sklearn.metrics import mean_squared_error
import math
import random
# 加载数据集
data=fetch_california_housing(data_home="./src")
# print(data.data.shape)
# # print(data.target[0:10])
# print(data.feature_names)
# print(data.target_names)
x=data.data
y=data.target
# 数据标准化
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.2)
stander=StandardScaler()
x_train=stander.fit_transform(x_train)
def train():
# 配置一些训练参数
eta0=0.001
epoch=1000
batch_size=16
n_sample=len(x_train)#样本数量,假设是20000个
model=SGDRegressor()
for epoch_i in range(epoch):
n_batch=math.ceil(n_sample/batch_size)
for i in range(n_batch):
start=i*batch_size
end=min((i+1)*batch_size,n_sample)
x_train[start:end]
model.partial_fit(x_train[start:end],y_train[start:end])
# 一轮训练结束
y_pred=model.predict(stander.transform(x_test))
mse=mean_squared_error(y_pred,y_test)
print(f"第{epoch_i}轮,mse:{mse}")
train()
9.优化
①.数据预处理：标准化
②.正则化：防止过拟合