item0522


#include <cstdio>
#include <cstdlib>

int main()
{
	int b(3);
	int arr[] = {6, 7, 8, 9, 10};
	int* p = arr;
	*(p++) += 123;
	printf("%d, %d\n", *p, *(++p));

	return EXIT_SUCCESS;
}

//考点:

//C语言中printf函数计算参数是从右至左压栈的

from torch import nn, optim from torch.utils.data import Dataset, DataLoader import torch # 数据集类 class MyDataset(Dataset): def __init__(self, file): with open(file, 'r', encoding='utf-8') as f: self.data = f.readlines() self.data = [line.strip().split(',') for line in self.data] def __getitem__(self, index): x = int(self.data[index][0]) # 输入数据 y = int(self.data[index][1]) # 目标数据 return torch.tensor(x, dtype=torch.float32), torch.tensor(y, dtype=torch.float32) def __len__(self): return len(self.data) # 模型 class MyModel(nn.Module): def __init__(self): super(MyModel, self).__init__() self.net = nn.Sequential( nn.Linear(10, 10), ) def forward(self, x): return self.net(x) if __name__ == '__main__': dataset = MyDataset('train_data.txt') model = MyModel() print(model) data = DataLoader(dataset, batch_size=10, shuffle=True) model = MyModel().to('cuda') criterion = nn.MSELoss() optimizer = optim.SGD(model.parameters(), lr=0.1) n_epochs = 10 for epoch in range(n_epochs): model.train() # 训练模式 for x, y in data: x, y = x.to('cuda'), y.to('cuda') optimizer.zero_grad() # 设置梯度为零 pred = model(x) print(f"x:{x}") print(f"y:{y}") print(f"pred:{pred}") loss = criterion(pred, y) # 计算损失 loss.backward() # 计算梯度(反向梯度) optimizer.step() # 更新模型参数 # print(f'[{epoch + 1}/{n_epochs}], Loss: {loss.item():.4f}') 以上是我的代码x:tensor([40., 10., 45., 15., 35., 50., 55., 20., 25., 30.], device='cuda:0') y:tensor([ 80., 20., 90., 30., 70., 100., 110., 40., 50., 60.], device='cuda:0') pred:tensor([-40.9228, -23.0146, -22.7525, 10.2778, -19.8213, 5.3241, 2.2468, 24.8815, -11.1552, 1.0356], device='cuda:0', grad_fn=<ViewBackward0>) x:tensor([15., 30., 25., 45., 55., 40., 20., 50., 10., 35.], device='cuda:0') y:tensor([ 30., 60., 50., 90., 110., 80., 40., 100., 20., 70.], device='cuda:0') pred:tensor([24211.5664, 8633.0283, 22586.9766, 3976.1594, 17981.4492, 18973.1211, 21626.9746, 3057.3142, 12259.4131, 11827.8213], device='cuda:0', grad_fn=<ViewBackward0>) x:tensor([25., 45., 50., 55., 30., 10., 20., 35., 40., 15.], device='cuda:0') y:tensor([ 50., 90., 100., 110., 60., 20., 40., 70., 80., 30.], device='cuda:0') pred:tensor([-5092356.5000, -1805359.6250, -4746004.5000, -818315.3125, -3763448.5000, -3978626.5000, -4545977.0000, -622681.5000, -2577487.2500, -2476017.2500], device='cuda:0', grad_fn=<ViewBackward0>) x:tensor([55., 10., 45., 20., 30., 35., 50., 25., 40., 15.], device='cuda:0') y:tensor([110., 20., 90., 40., 60., 70., 100., 50., 80., 30.], device='cuda:0') pred:tensor([1.0268e+09, 3.6404e+08, 9.5698e+08, 1.6502e+08, 7.5886e+08, 8.0224e+08, 9.1664e+08, 1.2557e+08, 5.1973e+08, 4.9926e+08], device='cuda:0', grad_fn=<ViewBackward0>) x:tensor([55., 20., 45., 35., 50., 15., 30., 10., 25., 40.], device='cuda:0') y:tensor([110., 40., 90., 70., 100., 30., 60., 20., 50., 80.], device='cuda:0') pred:tensor([-2.3151e+11, -8.2080e+10, -2.1577e+11, -3.7208e+10, -1.7110e+11, -1.8088e+11, -2.0667e+11, -2.8312e+10, -1.1718e+11, -1.1257e+11], device='cuda:0', grad_fn=<ViewBackward0>) x:tensor([50., 25., 30., 35., 15., 40., 20., 55., 10., 45.], device='cuda:0') y:tensor([100., 50., 60., 70., 30., 80., 40., 110., 20., 90.], device='cuda:0') pred:tensor([4.7832e+13, 1.6958e+13, 4.4579e+13, 7.6873e+12, 3.5350e+13, 3.7371e+13, 4.2700e+13, 5.8494e+12, 2.4211e+13, 2.3257e+13], device='cuda:0', grad_fn=<ViewBackward0>) x:tensor([35., 10., 45., 20., 15., 50., 55., 30., 25., 40.], device='cuda:0') y:tensor([ 70., 20., 90., 40., 30., 100., 110., 60., 50., 80.], device='cuda:0') pred:tensor([-1.0547e+16, -3.7394e+15, -9.8300e+15, -1.6951e+15, -7.7949e+15, -8.2405e+15, -9.4156e+15, -1.2898e+15, -5.3386e+15, -5.1283e+15], device='cuda:0', grad_fn=<ViewBackward0>) x:tensor([20., 55., 50., 40., 35., 10., 30., 25., 15., 45.], device='cuda:0') y:tensor([ 40., 110., 100., 80., 70., 20., 60., 50., 30., 90.], device='cuda:0') pred:tensor([2.0787e+18, 7.3698e+17, 1.9374e+18, 3.3408e+17, 1.5363e+18, 1.6241e+18, 1.8557e+18, 2.5421e+17, 1.0522e+18, 1.0107e+18], device='cuda:0', grad_fn=<ViewBackward0>) x:tensor([45., 30., 25., 10., 35., 15., 40., 55., 50., 20.], device='cuda:0') y:tensor([ 90., 60., 50., 20., 70., 30., 80., 110., 100., 40.], device='cuda:0') pred:tensor([-4.0529e+20, -1.4369e+20, -3.7773e+20, -6.5136e+19, -2.9953e+20, -3.1665e+20, -3.6181e+20, -4.9563e+19, -2.0514e+20, -1.9706e+20], device='cuda:0', grad_fn=<ViewBackward0>) x:tensor([20., 50., 10., 25., 40., 55., 30., 35., 15., 45.], device='cuda:0') y:tensor([ 40., 100., 20., 50., 80., 110., 60., 70., 30., 90.], device='cuda:0') pred:tensor([7.9816e+22, 2.8298e+22, 7.4388e+22, 1.2828e+22, 5.8988e+22, 6.2360e+22, 7.1252e+22, 9.7607e+21, 4.0400e+22, 3.8808e+22], device='cuda:0', grad_fn=<ViewBackward0>)这是运行结果,但是训练的效果远不达预期,还越来越远,这是什么情况?
08-11
在 PyTorch 线性回归模型训练过程中,如果损失逐渐增大且预测值偏离预期,通常表明训练过程出现了不稳定或发散的情况。以下是可能的原因及对应的优化方法: ### 1. 学习率设置不当 学习率是影响模型收敛性的关键超参数。若学习率过高,模型参数更新幅度过大,可能导致损失函数值在优化过程中震荡甚至发散;若学习率过低,则训练过程缓慢,可能无法有效降低损失。可以通过尝试更小的学习率,或者使用学习率调度器(如 `torch.optim.lr_scheduler`)动态调整学习率,以找到合适的更新步长[^1]。 ### 2. 数据未归一化或标准化 输入特征或目标变量的尺度差异较大时,可能导致梯度更新不稳定,进而影响模型的收敛。可以对输入数据进行归一化(如 Min-Max Scaling)或标准化(如 Z-Score),使得不同特征具有相似的量纲,从而改善训练过程的稳定性。 ### 3. 梯度爆炸问题 在某些情况下,特别是在使用较大模型或复杂损失函数时,梯度可能会变得非常大,导致参数更新剧烈,损失发散。可以在优化器中添加梯度裁剪(Gradient Clipping)机制,限制梯度的最大值,防止参数更新过大。例如,在 PyTorch 中可以使用 `torch.nn.utils.clip_grad_norm_` 或 `torch.nn.utils.clip_grad_value_` 方法。 ### 4. 初始化不当 权重初始化方式不当也可能导致训练不稳定。例如,权重初始化过大可能导致激活值和梯度迅速增长,进而导致损失发散。可以尝试使用更合理的初始化方法,如 `torch.nn.init.xavier_uniform_` 或 `torch.nn.init.kaiming_normal_`,以提高训练稳定性。 ### 5. 模型复杂度过高或过低 如果模型过于复杂(例如,使用了不必要的多层网络),可能导致训练过程难以收敛;而模型过于简单则可能无法拟合数据,导致预测值偏离预期。对于线性回归任务,建议使用单层线性模型,避免引入不必要的非线性层或过多参数。 ### 示例代码:使用梯度裁剪和学习率调度器优化训练 ```python import torch import torch.nn as nn import torch.optim as optim # 定义线性回归模型 class LinearRegression(nn.Module): def __init__(self): super(LinearRegression, self).__init__() self.linear = nn.Linear(1, 1) # 输入和输出均为一维 def forward(self, x): return self.linear(x) # 初始化模型、损失函数和优化器 model = LinearRegression() criterion = nn.MSELoss() optimizer = optim.SGD(model.parameters(), lr=0.01) # 添加学习率调度器 scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=5) # 模拟训练过程 for epoch in range(100): inputs = torch.randn(100, 1) # 模拟输入数据 targets = 13 * inputs + 2 + torch.randn(inputs.shape) # 模拟目标数据 # 前向传播 outputs = model(inputs) loss = criterion(outputs, targets) # 反向传播 optimizer.zero_grad() loss.backward() # 应用梯度裁剪 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) # 参数更新 optimizer.step() # 更新学习率 scheduler.step(loss) if (epoch + 1) % 10 == 0: print(f'Epoch [{epoch+1}/100], Loss: {loss.item():.4f}') ``` ### 6. 检查数据质量和随机种子 确保输入数据和目标变量没有异常值或错误。可以设置随机种子(如 `torch.manual_seed(42)`)以保证实验的可重复性,并有助于调试训练不稳定的问题。 ### 7. 使用更稳定的优化器 默认的随机梯度下降(SGD)优化器可能在某些情况下不够稳定。可以尝试使用自适应优化器,如 `Adam` 或 `RMSprop`,它们通常在实践中表现更稳定,收敛速度更快。例如: ```python optimizer = optim.Adam(model.parameters(), lr=0.01) ``` 通过以上方法,可以有效解决 PyTorch 线性回归模型训练过程中损失发散和预测值偏离预期的问题,提高模型训练的稳定性和收敛性。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值