机器学习基础06

1.梯度下降

1.1梯度下降概念

1.2梯度下降公式

1.3学习率

1.4实现梯度下降

1.5API

1.5.1随机梯度下降SGD

1.5.2小批量梯度下降MBGD

1.6梯度下降优化

2.欠拟合过拟合

2.1欠拟合

2.2过拟合

2.3正则化

2.3.1L1正则项（曼哈顿距离）

2.3.2L2正则项（欧氏距离）

3.岭回归（Ridge）

3.1损失函数公式

3.2API

4.拉索回归（Lasso）

4.1损失函数公式

4.2API

1.梯度下降

1.1梯度下降概念

正规方程求解的缺点

①利用正规方程求解的W是最优解的原因是MSE这个损失函数是凸函数。但机器学习的损失函数并非都是凸函数，设置导数为0会得到很多个极值，不能确定唯一解。

②当数据量和特征较多时,矩阵计算量太大.

在机器学习中，梯度表示损失函数对于模型参数的偏导数。具体来说，对于每个可训练参数，梯度告诉我们在当前参数值下，沿着每个参数方向变化时，损失函数的变化率。通过计算损失函数对参数的梯度，梯度下降算法能够根据梯度的信息来调整参数，朝着减少损失的方向更新模型。

1.2梯度下降公式

有损失函数：

梯度下降公式：

得：

1.3学习率

设置大的学习率α;每次调整的幅度就大,设置小的学习率α;每次调整的幅度就小

(1)常见的设定数值：0.1、0.01、0.001、0.0001

(2)随着迭代次数增多学习率逐渐变小,深度学习的优化算法可以调整学习率

1.4实现梯度下降

import matplotlib.pyplot as plt
import numpy as np

# 随机初始化
w= np.random.randint(-10,10,1)
# 学习率
h =0.01
# 收敛条件
diff=0.0001
# 最大更新的次数
time =1000


lt_w =[]
lt_w_new=[]
for i in range(time):
    # 保存原w，用于计算差值
    w_new= w
    lt_w.append(w_new)
    lt_w_new.append(10*w**2-15.9*w+6.5)

    # 更新w
    w= w - h*(20*w_new-15.9)#20*w-15.9是切线
    difference=w_new-w
    print(f'第{i+1}次迭代：','\t','w:',w,'\t','w_new-w:', difference)
    if abs(difference) <=diff:
        break


# 图像示意，散点图为梯度下降
plt.scatter(lt_w,lt_w_new,c='red')

w = np.linspace(-10,10,100)
loss = 10*w**2-15.9*w+6.5
# 曲线图为损失函数
plt.plot(w,loss)

plt.show()

import numpy as np
import matplotlib.pyplot as plt

# 随机初始化
w1 = 10
w2 = 10

# 学习率
h = 0.001
# 收敛条件
diff = 0.0001
# 最大更新的次数
time = 1000

def loss(w1, w2):
    return 4*w1**2 + 9*w2**2 + 2*w1*w2 + 3.5*w1 - 4*w2 + 6

def dloss_w1(w1, w2):
    return 8*w1 + 2*w2 + 3.5

def dloss_w2(w1, w2):
    return 2*w1 + 18*w2 - 4

# 记录每次迭代的w1和w2
w1_history = [w1]
w2_history = [w2]

for i in range(time):
    # 保存原w，用于计算差值
    w1_new = w1
    w2_new = w2

    # 更新w
    w1 = w1 - h * dloss_w1(w1_new, w2_new)
    w2 = w2 - h * dloss_w2(w1_new, w2_new)

    difference1 = w1_new - w1
    difference2 = w2_new - w2

    print(f'第{i+1}次迭代：\tw1: {w1:.6f}, w2: {w2:.6f}, w1_new-w1: {difference1:.6f}, w2_new-w2: {difference2:.6f}')
    
    # 记录每次迭代的w1和w2
    w1_history.append(w1)
    w2_history.append(w2)

    if abs(difference1) <= diff and abs(difference2) <= diff:
        break

print("最终结果：w1 =", w1, "w2 =", w2)

# 绘制三维图
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')

# 创建网格数据
w1_vals = np.linspace(-15, 15, 100)
w2_vals = np.linspace(-15, 15, 100)
w1_grid, w2_grid = np.meshgrid(w1_vals, w2_vals)
loss_grid = loss(w1_grid, w2_grid)

# 绘制损失函数的表面
ax.plot_surface(w1_grid, w2_grid, loss_grid, cmap='viridis', alpha=0.7)

# 绘制梯度下降路径
ax.plot(w1_history, w2_history, [loss(w1, w2) for w1, w2 in zip(w1_history, w2_history)], color='r', marker='.')

# 设置标签
ax.set_xlabel('w1')
ax.set_ylabel('w2')
ax.set_zlabel('Loss')

# 显示图形
plt.show()

1.5API

批量梯度下降BGD(Batch Gradient Descent)

小批量梯度下降MBGD(Mini-BatchGradient Descent)

随机梯度下降SGD(Stochastic Gradient Descent)。

Batch Gradient Descent (BGD):每一次迭代都会使用全部的训练样本计算梯度来更新权重。这意味着每一步梯度更新都是基于整个数据集的平均梯度。这种方法的优点是每次更新的方向是最准确的，但缺点是计算量大且速度慢，尤其是在大数据集上。
Mini-Batch Gradient Descent (MBGD): 这种方法介于批量梯度下降和随机梯度下降之间。它不是用全部样本也不是只用一个样本，而是每次迭代从数据集中随机抽取一小部分样本（例如，从500个样本中选取32个），然后基于这一小批样本的平均梯度来更新权重。这种方法在准确性和计算效率之间取得了一个平衡。
Stochastic Gradient Descent (SGD): 在随机梯度下降中，每次迭代仅使用随机单个样本（或有时称为“例子”）来计算梯度并更新权重。这种方法能够更快地收敛，但由于每次更新都基于单个样本，所以会导致权重更新路径不稳定。

1.5.1随机梯度下降SGD

sklearn.linear_model.SGDRegressor()

参数:
   loss: 损失函数，默认为 ’squared_error’
   fit_intercept: 是否计算偏置， default=True
   eta0: float, default=0.01学习率初始值
    learning_rate: str, default=’invscaling’
‘constant’: eta = eta0 学习率为eta0设置的值，保持不变
‘optimal’: eta = 1.0 / (alpha * (t + t0))
‘invscaling’: eta = eta0 / pow(t, power_t)
‘adaptive’: eta = eta0, 学习率由eta0开始，逐步变小
max_iter: int, default=1000 经过训练数据的最大次数(又名epoch)
shuffle=True 每批次是否洗牌
    penalty: {‘l2’, ‘l1’, ‘elasticnet’, None}, default=’l2’，要使用的正则化项
属性:
      coef_ 回归后的权重系数
      intercept_ 偏置

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

dataset = fetch_california_housing(data_home='./src')

x_train,x_test,y_train,y_test=train_test_split(dataset.data,dataset.target,train_size =0.7,shuffle =True,random_state=200)

transfer = StandardScaler()
x_train=transfer.fit_transform(x_train)
x_test=transfer.transform(x_test)

# 线性回归预估器
estimator = SGDRegressor(loss='squared_error',penalty='l1',max_iter=1000,eta0=0.01,learning_rate ='constant')
estimator.fit(x_train,y_train)

# 模型数据
print('coef:',estimator.coef_)
print('intercept:',estimator.intercept_)

y_predict = estimator.predict(x_test)
print("预测的数据集：\n", y_predict)
print('决定系数 (R^2)：',estimator.score(x_test,y_test))
error = mean_squared_error(y_test,y_predict)
print('均方误差：',error)

1.5.2小批量梯度下降MBGD

sklearn.linear_model.SGDRegressor()

调用partial_fit函数训练直接更新权重,不需要调fit从头开始训练。

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

dataset = fetch_california_housing(data_home='./src')

x_train,x_test,y_train,y_test=train_test_split(dataset.data,dataset.target,train_size =0.7,shuffle =True,random_state=200)

transfer = StandardScaler()
x_train=transfer.fit_transform(x_train)
x_test=transfer.transform(x_test)

# 线性回归预估器
estimator = SGDRegressor(loss='squared_error',penalty='l1',max_iter=1000,eta0=0.01,learning_rate ='constant')

# 小批量梯度下降
batch_size =50 # 批量大小
n_batches = len(x_train)//batch_size 
for epoch in range(estimator.max_iter):
    # 随机打乱样本顺序
    indices = np.random.permutation(len(x_train))
    for i in range(n_batches):
        start_index = i*batch_size
        end_index = (i+1) * batch_size
        batch_indices = indices[start_index:end_index]
        x_batch = x_train[batch_indices]
        y_batch = y_train[batch_indices]
        # 更换模型权重
        estimator.partial_fit(x_batch,y_batch) 
        

# 模型数据
print('coef:',estimator.coef_)
print('intercept:',estimator.intercept_)

y_predict = estimator.predict(x_test)
print("预测的数据集：\n", y_predict)
print('决定系数 (R^2)：',estimator.score(x_test,y_test))
error = mean_squared_error(y_test,y_predict)
print('均方误差：',error)

1.6梯度下降优化

(1)标准化

(2)正则化

2.欠拟合过拟合

分类问题的三种拟合状态：

回归问题的三种拟合状态：

2.1欠拟合

欠拟合是指模型在训练数据上表现不佳，同时在其他数据上也表现不佳。这通常发生在模型过于简单，无法捕捉数据中的复杂模式时。欠拟合模型的表现特征如下：

训练误差较高。
测试误差同样较高。
模型可能过于简化，不能充分学习训练数据中的模式。

2.2过拟合

过拟合是指模型在训练数据上表现得非常好，但在其他数据上表现较差。这通常发生在模型过于复杂，以至于它不仅学习了数据中的真实模式，还学习了噪声和异常值。过拟合模型的表现特征如下：

训练误差非常低。
测试误差较高。
模型可能过于复杂，以至于它对训练数据进行了过度拟合。

2.3正则化

正则化的意义：防止过拟合，增加模型的鲁棒性。

正则化：将原来的损失函数加上一个惩罚项使得计算出来的模型w相对小一些。

常用的惩罚项有L1正则项或者L2正则项:

2.3.1L1正则项（曼哈顿距离）

2.3.2L2正则项（欧氏距离）

3.岭回归（Ridge）

3.1损失函数公式

岭回归是损失函数通过添加所有权重的平方和的乘积(L2)来惩罚模型的复杂度。

均方差除以2是因为方便求导，wj指所有的权重系数, λ指惩罚型系数，又叫正则项力度。

特点:

岭回归不会将权重压缩到零，这意味着所有特征都会保留在模型中，但它们的权重会被缩小。
适用于特征间存在多重共线性的情况。
岭回归产生的模型通常更为平滑，因为它对所有特征都有影响。

3.2API

sklearn.linear_model.Ridge()

参数：

alpha, default=1.0，正则项力度
fit_intercept, 是否计算偏置， default=True
solver, {‘auto’, ‘svd’, ‘cholesky’, ‘lsqr’, ‘sparse_cg’, ‘sag’, ‘saga’, ‘lbfgs’}, default=’auto’

当值为auto,并且数据量、特征都比较大时，内部会随机梯度下降法。

normalize：default=True

数据进行标准化，如果特征工程中已经做过标准化，这里就该设置为False

max_iterint

梯度解算器的最大迭代次数，默认为15000

属性：
coef_ 回归后的权重系数
intercept_ 偏置

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_error

# dataset = fetch_california_housing(data_home='./src')
dataset = load_breast_cancer()

x_train,x_test,y_train,y_test=train_test_split(dataset.data,dataset.target,train_size =0.2,shuffle =True,random_state=200)

transfer = StandardScaler()
x_train=transfer.fit_transform(x_train)
x_test=transfer.transform(x_test)

# 线性回归预估器

estimator = Ridge(alpha =0.1,max_iter=1000)
estimator.fit(x_train,y_train)

# 模型数据
print('coef:',estimator.coef_)
print('intercept:',estimator.intercept_)

y_predict = estimator.predict(x_test)
print("预测的数据集：\n", y_predict)
print('得分：',estimator.score(x_test,y_test))
error = mean_squared_error(y_test,y_predict)
print('均方误差：',error)

4.拉索回归（Lasso）

4.1损失函数公式

Lasso回归是一种线性回归模型，它通过添加所有权重的绝对值之和(L1)来惩罚模型的复杂度。

Lasso回归的目标是最小化以下损失函数：

其中：

n 是样本数量，
p 是特征的数量，
y_i 是第 i 个样本的目标值，
x_i 是第 i 个样本的特征向量，
w是模型的参数向量，
\lambda 是正则化参数，控制正则化项的强度。

特点:

拉索回归可以将一些权重压缩到零，从而实现特征选择。
适用于特征数量远大于样本数量的情况，或者当特征间存在相关性时，可以从中选择最相关的特征。
拉索回归产生的模型可能更简单，因为它会去除一些不重要的特征。

4.2API

sklearn.linear_model.Lasso()

参数:

alpha (float, default=1.0):

控制正则化强度；必须是非负浮点数。较大的 alpha 增加了正则化强度。

fit_intercept (bool, default=True):

是否计算此模型的截距。如果设置为 False，则不会使用截距（即数据应该已经被居中）。

precompute (bool or arraylike, default=False):

如果为 True，则使用预计算的 Gram 矩阵来加速计算。如果为数组，则使用提供的 Gram 矩阵。

copy_X (bool, default=True):

如果为 True，则复制数据 X

max_iter (int, default=1000):

最大迭代次数

tol (float, default=1e4):

精度阈值

warm_start (bool, default=False):

当设置为 True 时，再次调用 fit 方法会重新使用之前调用 fit 方法的结果作为初始估计值，而不是清零它们。

positive (bool, default=False):

当设置为 True 时，强制系数为非负。

random_state (int, RandomState instance, default=None):

随机数生成器的状态。用于随机初始化坐标下降算法中的随机选择。

selection ({'cyclic', 'random'}, default='cyclic'):

如果设置为 'random'，则随机选择坐标进行更新。如果设置为 'cyclic'，则按照循环顺序选择坐标。

from sklearn.datasets import fetch_california_housing
from sklearn.linear_model import Lasso
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
import numpy as np

# 加载波士顿房价数据集
data = fetch_california_housing(data_home="./src")
X, y = data.data, data.target

# 划分训练集和测试集
X_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建Lasso回归模型
lasso = Lasso(alpha=0.1)  # alpha是正则化参数

# 训练模型
lasso.fit(X_train, y_train)

# 得出模型
print("权重系数为：\n", lasso.coef_)  
print("偏置为：\n", lasso.intercept_)

#模型评估
y_predict = lasso.predict(x_test)
print("预测的数据集：\n", y_predict)
error = mean_squared_error(y_test, y_predict)
print("均方误差为：", error)
print(lasso.score(x_test,y_test))