神经网络中如何优化模子和超参数调优（案例为tensor的预测） ...

总结：

初级：简单修改一下超参数，结果一般般但是够用，偶然候乃至直接不敷用
中级：optuna得出最好的超参数之后，再多一些epoch让train和testloss团体下降，然后结果就很不错。
高级：在中级的底子上，更换更适合的损失函数之后，在train的时间backward反向传播这个loss,optuna也更改这个loss标准，现在结果有质的改变。

问题：

迩来在做cfd领域，需要流场进行预测，然后流场提取出来再深度学习就是一个多维度tensor,而神经网络的目的就是通过模子预测让预测的tensor与实际的tensor的结果尽大概的靠近，具体来说就是让每个值之间的毛病尽大概小。
目前环境：现在模子大概以及确定，但是结果一般般，这时间就需要进行下面的调优方法。
优化方法：

一、初级优化：

简单修改一下超参数，结果一般般但是够用，偶然候乃至直接不敷用

二、中级优化：optuna调参，然后epoch加多

optuna得出最好的超参数之后，再多一些epoch让train和testloss团体下降，然后结果就很不错。

三、高级优化：

在中级的底子上，现在更换更适合的损失函数之后，在train的时间backward反向传播这个loss,optuna也更改这个loss标准，现在结果有质的改变。

也就是下面这三行代码

1. smooth_l1 = F.smooth_l1_loss(out.view(shape1, shape2), y.view(shape1, shape2))#！！！！！！！！！！！！！
2. smooth_l1.backward() #用这个smooth_l1_loss反向传播#！！！！！！！！！！！！！！！！！！！！！！！！！
3. return test_smooth_l1  #test中的最后一个epoch的test_smooth_l1！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

复制代码

通过上面预测的数据和实际的数据进行的对比，可以发现预测的每个结果与实际的结果的毛病在大约0.01范围之内（实际数据在[-4,4]之间）。

确定损失函数：

要让两个矩阵的值尽大概靠近，选择符合的损失函数（loss function）是关键。常见的用于这种目的的损失函数包罗以下几种：

• 均方毛病（Mean Squared Error, MSE）：对预测值与真实值之间的平方毛病求均匀。MSE对大毛病比力敏感，能够明显惩罚偏离较大的预测值。
  
  1. import torch.nn.functional as F loss = F.mse_loss(predicted, target)

  复制代码
  
  
• 均匀绝对毛病（Mean Absolute Error, MAE）：对预测值与真实值之间的绝对毛病求均匀。MAE对异常值不如MSE敏感，适用于数据中存在异常值的环境。
  
  1. import torch loss = torch.mean(torch.abs(predicted - target))

  复制代码
  
  
• 平滑L1损失（Smooth L1 Loss）：又称Huber Loss，当毛病较小时，平滑L1损失类似于L1损失，当毛病较大时，类似于L2损失。适合在有噪声的数据集上使用。
  
  1. import torch.nn.functional as F loss = F.smooth_l1_loss(predicted, target)

  复制代码
  总结如下：
  

•     MSE：适用于需要明显惩罚大毛病的环境。
  
•      MAE：适用于数据中存在异常值，并且你渴望对异常值不那么敏感的环境。
  
•      Smooth L1 Loss：适用于既有肯定抗噪声能力又能对大毛病适当惩罚的环境。
  

      这里根据任务选择Smooth L1 Loss。

具体做法：

目前这个经过optuna调优，然后先下面处置惩罚（思想是将loss的反向传播和optuna优化标准全换为更适合这个任务的smooth_l1_loss函数）

• 1.  loss将mse更换为smooth_l1_loss，
  
• 2.  l2.backward()更换为smooth_l1.backward()，
  
• 3.  return test_l2更改为return test_smooth_l1  
  

结果：point_data看着值很靠近，每个值毛病0.01范围内。阐明用这个上面这个方法是对的。试了一下图也有优化。并step_loss现在极低。

下面代码中加感叹号的行都是上面思路修改我的项目中对应的代码行，重要！！！

1. import optuna
2. import time
3. import torch.optim as optim
4. # 求解loss的两个参数
5. shape1 =  -1   
6. shape2 = data.shape[1]* 3
8. def objective1(trial):
9.     batch_size = trial.suggest_categorical('batch_size', [32])
10.     learning_rate = trial.suggest_float('learning_rate', 1e-6, 1e-2,log=True)
11.     layers = trial.suggest_categorical('layers', [2,4,6])
12.     width = trial.suggest_categorical('width', [10,20,30])#新加的
13.     weight_decay = trial.suggest_float('weight_decay', 1e-6, 1e-2,log=True)#新加的
14.    
15.     #再加个优化器
16.     optimizer_name = trial.suggest_categorical('optimizer', ['Adam', 'SGD', 'RMSprop'])
17.     # loss_function_name = trial.suggest_categorical('loss_function', ['LpLoss', 'MSELoss'])
18.    
19.    
20.     """ Read data """
21.     # data是[1991, 80, 40, 30]，而data_cp是为归一化的[2000, 80, 40, 30]
22.     train_a = data[ntest:-1,:,:]#data:torch.Size：50:, 80, 40, 30。train50对应的是predict50+9+1
23.     train_u = data_cp[ntest+10:,:,:]#torch.Size([50, 64, 64, 10])#data_cp是未归一化的，第11个对应的是data的第data的第1个,两者差10
24.     # print(train_a.shape)
25.     # print(train_u.shape)
26.    
27.     test_a = data[:ntest,:,:]#选取最后200个当测试集
28.     test_u = data_cp[10:ntest+10,:,:]
29.     # print(test_a.shape)
30.     # print(test_u.shape)#torch.Size([40, 80, 40, 3])
31.     train_loader = torch.utils.data.DataLoader(torch.utils.data.TensorDataset(train_a, train_u),
32.                                                batch_size=batch_size, shuffle=True)
33.     test_loader = torch.utils.data.DataLoader(torch.utils.data.TensorDataset(test_a, test_u),
34.                                               batch_size=batch_size, shuffle=False)
35.     #没有随机的train_loader，用于后面预测可视化
36.     data_loader_noshuffle = torch.utils.data.DataLoader(torch.utils.data.TensorDataset(data[:,:,:], data_cp[9:,:,:]),
37.                                                batch_size=batch_size, shuffle=False)
38.    
39.    
40.     # %%
41.     """ The model definition """
42.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
43.     model = WNO1d(width=width, level=level, layers=layers, size=h, wavelet=wavelet,
44.                   in_channel=in_channel, grid_range=grid_range).to(device)
45.     # print(count_params(model))
46.    
47.     # optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=1e-6)
48.         #调参数用，优化器选择
49.     if optimizer_name == 'Adam':
50.         optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)
51.     elif optimizer_name == 'SGD':
52.         optimizer = optim.SGD(model.parameters(), lr=learning_rate, weight_decay=weight_decay, momentum=0.9)
53.     else:  # RMSprop
54.         optimizer = optim.RMSprop(model.parameters(), lr=learning_rate, weight_decay=weight_decay)
55.         
56.     scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=step_size, gamma=gamma)
57.    
58.     train_loss = torch.zeros(epochs)
59.     test_loss = torch.zeros(epochs)
60.     myloss = LpLoss(size_average=False)
61.    
65.     """ Training and testing """
66.     for ep in range(epochs):
67.         model.train()
68.         t1 = default_timer()
69.         train_mse = 0
70.         train_l2 = 0
71.         for x, y in train_loader:
72.             x, y = x.to(device), y.to(device)
73.    
74.             optimizer.zero_grad()
75.             out = model(x)
76.    
77.             mse = F.mse_loss(out.view(shape1, shape2), y.view(shape1, shape2))
78.             # # 训练时使用 Smooth L1 Loss
79.             smooth_l1 = F.smooth_l1_loss(out.view(shape1, shape2), y.view(shape1, shape2))#！！！！！！！！！！！！！
81.             l2 = myloss(out.view(shape1, shape2), y.view(shape1, shape2))
82.             # l2.backward()
83.             smooth_l1.backward() #用这个smooth_l1_loss反向传播#！！！！！！！！！！！！！！！！！！！！！！！！！
85.             optimizer.step()
86.             train_mse += mse.item()
87.             train_l2 += l2.item()
88.    
89.         scheduler.step()
90.         model.eval()
91.         test_l2 = 0.0
92.         test_smooth_l1 =0
93.         with torch.no_grad():
94.             for x, y in test_loader:
95.                 x, y = x.to(device), y.to(device)
96.    
97.                 out = model(x)
98.                 test_l2 += myloss(out.view(shape1, shape2), y.view(shape1, shape2)).item()
99.                 test_smooth_l1  +=F.smooth_l1_loss(out.view(shape1, shape2), y.view(shape1, shape2)).item()#！！！！！！！！！！！！！！！！！！
100.         train_mse /= ntrain#len(train_loader)
101.         train_l2 /= ntrain
102.         test_l2 /= ntest
103.         test_smooth_l1 /= ntest#！！！！！！！！！！！！！！！！！！！
104.         
105.         train_loss[ep] = train_l2
106.         test_loss[ep] = test_l2
107.    
108.         t2 = default_timer()
109.         print('Epoch-{}, Time-{:0.4f}, [step_loss:] -> Train-MSE-{:0.4f}，test_smooth_l1-{:0.4f} Train-L2-{:0.4f}, Test-L2-{:0.4f}'
110.               .format(ep, t2-t1, train_mse,test_smooth_l1, train_l2, test_l2))#！！！！！！！！！！！！！！！！1
111.    
113.     if trial.should_prune():
114.         raise optuna.exceptions.TrialPruned()
116.     """防止打印信息错位"""
117.     print(f"Trial {trial.number} finished with value: {test_l2}")
119.     return test_smooth_l1  #test中的最后一个epoch的test_smooth_l1！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
121.    
122.     """ For saving the trained model and prediction data """

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。