from torch import nn,optim
import torch
from torch.utils.data import Dataset,DataLoader,TensorDataset
from sklearn.datasets import make_regression
def demo1():
class mynn(nn.Module):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# 初始化隐藏层1
self.hidden1 = nn.Sequential(nn.Linear(5, 4), nn.ReLU())
# 初始化隐藏层2
self.hidden2 = nn.Sequential(nn.Linear(4, 3), nn.ReLU())
# 初始化隐藏层3
self.hidden3 = nn.Sequential(nn.Linear(3, 2), nn.ReLU())
# 初始化输出层
self.out = nn.Sequential(nn.Linear(2, 1), nn.Sigmoid())
# 初始化W
# 使用Kaiming Normal初始化隐藏层的权重
nn.init.kaiming_normal_(self.hidden1[0].weight)
nn.init.kaiming_normal_(self.hidden2[0].weight)
nn.init.kaiming_normal_(self.hidden3[0].weight)
# 使用Xavier Normal初始化输出层的权重
nn.init.xavier_normal_(self.out[0].weight)
# 设置隐藏层的偏置为5.5
self.hidden1[0].bias.data = torch.tensor(5.5)
self.hidden2[0].bias.data = torch.tensor(5.5)
self.hidden3[0].bias.data = torch.tensor(5.5)
# 设置输出层的偏置为5.5
self.out[0].bias.data = torch.tensor(5.5)
def forward(self,x):
x=self.hidden1(x)
x=self.hidden2(x)
x=self.hidden3(x)
x=self.out(x)
return x
class mydatasets(Dataset):
def __init__(self,x,y):
super().__init__()
self.len=len(x)
self.x=x
self.y=y
def __len__(self):
return self.len
def __getitem__(self, index):
idx=min(self.len,index)
x=self.x[idx]
y=self.y[idx]
return x,y
def create_data():
x,y,coef=make_regression(n_samples=100,n_features=5,bias=0.5,coef=True,noise=5)
x=torch.tensor(x,dtype=torch.float32)
y=torch.tensor(y,dtype=torch.float32)
y=torch.unsqueeze(y,dim=1)
return x,y,coef
# 创建数据集
x,y,coef=create_data()
# 创建模型实例
model1=mynn()
# 创建优化器
sgd1=optim.SGD(model1.parameters(),lr=0.1,momentum=0.5)
# 训练轮数
epoch=100
# 损失函数
loss_func=nn.MSELoss()
# 创建数据集对象
datasets1=mydatasets(x,y)
datasets2=TensorDataset(x,y)
# 创建数据加载器
dataLoader1=DataLoader(dataset=datasets1,batch_size=16)
dataLoader2=DataLoader(dataset=datasets2,batch_size=16)
for i in range(epoch):
for x_train,y_train in dataLoader2:
y_pre=model1.forward(x_train)
loss=loss_func(y_pre,y_train)
sgd1.zero_grad()
loss.backward()
sgd1.step()
# 打印输出层的权重
print(model1.out[0].weight)
# 打印回归系数
print(coef)
# 打印y的形状
print(y.shape)
# 梯度下降优化
# - 学习率太小，每次训练之后的效果太小，增加时间和算力成本。
# - 学习率太大，大概率会跳过最优解，进入无限的训练和震荡中。
# - 解决的方法就是，学习率也需要随着训练的进行而变化。
# 传统下降方式
# 小批量 批量 随机梯度
# - **收敛速度慢**：BGD和MBGD使用固定学习率，太大会导致震荡，太小又收敛缓慢。
# - **局部最小值和鞍点问题**：SGD在遇到局部最小值或鞍点时容易停滞，导致模型难以达到全局最优。
# - **训练不稳定**：SGD中的噪声容易导致训练过程中不稳定，使得训练陷入震荡或不收敛。
# 传统的梯度下降优化算法中，可能会碰到以下情况:
# 碰到平缓区域，梯度值较小，参数优化变慢 碰到 “鞍点” ，梯度为 0，参数无法优化 碰到局部最小值 对于这些问题, 出现了一些对梯度下
# 降算法的优化方法,例如：Momentum、AdaGrad、RMSprop、Adam 等.
# **移动平均数**，指的是计算最近邻的 N 个数来获得平均数。 一组数据中的一个区域的平均数 跟中心数据n邻居算
# **指数移动加权平均**(Exponential Moving Average简称EMA)则是参考各数值，并且各数值的权重都不同，距离越远的数字对平均数计算的贡献就越小（权重较小），距离越近则对平均数的计算贡献就越大（权重越大）。
# 在移动平均数 分出的几个区域的基础上 某一个区域的平均在与其他区域的平均数平均 但邻近的权重大 相当于两层移动平均数
# 考虑全局的同时 对邻近的又有大的权重
# 在梯度更新中 为之前的梯度和本次梯度的关系 本次梯度 为 历史梯度和本次梯度的关系 本次梯度=历史梯度的权重*历史梯度+ 本地梯度的权重*本地梯度 权重为负关系 历史梯度的权重越大平均数越平缓
# 本次的梯度和上次的梯度变化不会太大 同时也能反映出整个梯度变化的规律 在下降 遇到grad为0的点也不会停
# #### 3.4.2 Momentum 能沟穿过平滑区域 在不平滑的区域加速收敛：
# **a.特点**
# 动量（Momentum）是对梯度下降的优化方法，可以更好地应对梯度变化和梯度消失问题，从而提高训练模型的效率和稳定性。
# - **惯性效应：** 该方法加入前面梯度的累积，这种惯性使得算法沿着当前的方向继续更新。如遇到鞍点，也不会因梯度逼近零而停滞。
# - **减少震荡：** 该方法平滑了梯度更新，减少在鞍点附近的震荡，帮助优化过程稳定向前推进。
# - **加速收敛：** 该方法在优化过程中持续沿着某个方向前进，能够更快地穿越鞍点区域，避免在鞍点附近长时间停留。
# 本次的梯度上次有关 上次又跟上上次有关..... 而且都乘了0.几 越远关系越小
# 当处于鞍点位置时，由于当前的梯度为 0，参数无法更新。但是 Momentum 动量梯度下降算法已经在先前积累了一些梯度值，很有可能使得跨过鞍点。
# 由于 mini-batch 普通的梯度下降算法，每次选取少数的样本梯度确定前进方向，可能会出现震荡，使得训练时间变长。Momentum 使用移动加权平均，
# 平滑了梯度的变化，使得前进方向更加平缓，有利于加快训练过程。一定程度上有利于降低 “峡谷” 问题的影响。
# 峡谷问题：就是会使得参数更新出现剧烈震荡.
# Momentum 算法可以理解为是对梯度值的一种调整，我们知道梯度下降算法中还有一个很重要的学习率，Momentum 并没有学习率进行优化。
# W更新公式变为 w新=w旧-lr*(g当前*权重1+g上次*权重2)
# api 就是sgd=optm.SGD()
# optimizer = optim.SGD(model.parameters(), lr=0.6, momentum=0.9)
# 学习率和动量值可以根据实际情况调整,momentum 参数指定了动量系数,默认为0。动量系数通常设置为 0 到0.5 之间的一个值，但也可以根据具体的应用场景调整
# AdaGrad 学习率优化 w少的用 每次梯度更新的时候lr都不一样
# AdaGrad（Adaptive Gradient Algorithm）为每个参数引入独立的学习率，它根据历史梯度的平方和来调整这些学习率，这样就使得参数具有较大的历史梯度的学习率减小，
# 而参数具有较小的历史梯度的学习率保持较大，从而实现更有效的学习。AdaGrad避免了统一学习率的不足，更多用于处理稀疏数据和梯度变化较大的问题。
# 历史梯度大学习率小 历史梯度小学习率大 总的来说越往后lr越小
# **优点**：
# - 自适应学习率：由于每个参数的学习率是基于其梯度的累积平方和 来动态调整的，这意味着学习率会随着时间步的增加而减少，对梯度较大且变化频繁的方向非常有用，防止了梯度过大导致的震荡。
# - 适合稀疏数据：AdaGrad 在处理稀疏数据时表现很好，因为它能够自适应地为那些较少更新的参数保持较大的学习率。
# **缺点**：
# 1. 学习率过度衰减：随着时间的推移，累积的时间步梯度平方值越来越大，导致学习率逐渐接近零，模型会停止学习。
# 2. 不适合非稀疏数据：在非稀疏数据的情况下，学习率过快衰减可能导致优化过程早期停滞 W多 分母大 每次学习率就变得更小
# AdaGrad是一种有效的自适应学习率算法，然而由于学习率衰减问题，我们会使用改 RMSProp 或 Adam 来替代。
# api
# optimizer = optim.Adagrad(model.parameters(), lr=0.9) # 设置学习率
# #### RMSProp AdaGrad的优化 减缓了AdaGrad的变小的过程
# RMSProp（Root Mean Square Propagation）在时间步中，不是简单地累积所有梯度平方和，而是使用指数加权平均来逐步衰减过时的梯度信息。这种方法专门用于解决AdaGrad在训练过程中学习率过度衰减的问题。
# 这次的学习率为 AdaGrad的分母不在是简单的历史梯度平方和 而是本次的梯度和上次梯度的平方和权重加
# optimizer = optim.RMSprop(model.parameters(), lr=0.7, momentum=0.9) # 设置学习率和动量
# #### 3.4.5 Adam
# Adam（Adaptive Moment Estimation）算法将动量法和RMSProp的优点结合在一起： W 和lr一起改
# - **动量法**：通过一阶动量（即梯度的指数加权平均）来加速收敛，尤其是在有噪声或梯度稀疏的情况下。
# - **RMSProp**：通过二阶动量（即梯度平方的指数加权平均）来调整学习率，使得每个参数的学习率适应其梯度的变化。
# - Momentum 使用指数加权平均计算当前的梯度值、AdaGrad、RMSProp 使用自适应的学习率，Adam 结合了 Momentum、RMSProp 的优点，
# 使用：移动加权平均的梯度和移动加权平均的学习率。使得能够自适应学习率的同时，也能够使用 Momentum 的优点。
# **优点**
# 1. 高效稳健：Adam结合了动量法和RMSProp的优势，在处理非静态、稀疏梯度和噪声数据时表现出色，能够快速稳定地收敛。
# 2. 自适应学习率：Adam通过一阶和二阶动量的估计，自适应调整每个参数的学习率，避免了全局学习率设定不合适的问题。
# 3. 适用大多数问题：Adam几乎可以在不调整超参数的情况下应用于各种深度学习模型，表现良好。
# **缺点**
# 1. 超参数敏感：尽管Adam通常能很好地工作，但它对初始超参数（如 $$ \beta_1$$、$$ \beta_2$$ 和 $$\eta$$）仍然较为敏感，有时需要仔细调参。
# 2. 过拟合风险：由于Adam会在初始阶段快速收敛，可能导致模型陷入局部最优甚至过拟合。因此，有时会结合其他优化算法（如SGD）使用。
# api
# optimizer = optim.Adam(model.parameters(), lr=0.05) # 设置学习率 两个权重一般默认
# 过拟合和欠拟合的解决
# 欠拟合 多训练几次 增加层数或者节点数量 增加数据量
# 1. **增加特征**：通过特征工程添加更多有意义的特征，使模型能够更好地理解数据。
# 2. **减少正则化强度**：适当减小 L1、L2 正则化强度，允许模型有更多自由度来拟合数据。
# 3. **训练更长时间**：如果是因为训练不足导致的欠拟合，可以增加训练的轮数或时间.
# 过拟合 损失函数加惩罚项
# 避免模型参数过大是防止过拟合的关键步骤之一。以下是一些常见的方法和策略。
# ### 3.1 L2正则化
# L2 正则化通过在损失函数中添加权重参数的平方和来实现，目标是**惩罚**过大的参数值。 岭回归
# 保证梯度变小的同时 w的值也要变小 单个w的值不会到0
# 梯度更新的时候 梯度就不在单是损失函数的梯度 还有惩罚项的梯度
# api 加载优化器里面的
# optimizer = optim.SGD(model.parameters(), lr=0.01, weight_decay=0.001) # L2 正则化,weight_decay就是L2正则化前面的参数λ 惩罚力度
# ### L1正则化 L2的平方和变为绝对值和
# L1 正则化通过在损失函数中添加权重参数的绝对值之和来约束模型的复杂度。单个w的值会到0 可以减少特征 减少模型复杂度
# Dropout 是一种在训练过程中随机丢弃部分神经元的技术。它通过减少神经元之间的依赖来防止模型过于复杂，从而避免过拟合。
# 实际上减少了模型的复杂度
def dropout():
dropout = nn.Dropout(p=0.5) # 每一个神经元有50%的概率没丢弃 实际上是把传入的数据设为0 计算变简单了
x = torch.randint(0, 10, (5, 6), dtype=torch.float)
print(x)
# 开始dropout
print(dropout(x))
# ### 简化模型
# 数据增强
# 早停 训练 到满足一下条件就停止 收敛了就行
# 模型继承 多个模型 进行投票决定
# 交叉验证 K折
# 数据预处理
if __name__=="__main__":
demo1()
