神经网络训练惩罚函数问题

lqhenwunai

用pytorch随机生成一个张量，并用Calc_bond_length函数作为惩罚函数，然后进行神经网络训练。但是以下代码不能实现目的，所打印的input tensor在循环中没有变化。试了几种不同的网络结构，input tenso在循环中都没有变化。问题在哪里？

1. def Calc_bond_length(geom,thresh1,thresh2):
   
2.         ThreeN = len(geom)
   
3.         NAtom  = int(ThreeN/3)
   
4. 
   
5.         geom = geom.view(NAtom,3)
   
6.         bond_length=[]
   
7.         for i in range(NAtom):
   
8.                 for j in range(i+1,NAtom):
   
9.                         diff = geom[i,:]-geom[j,:]
   
10.                         diff = torch.linalg.norm(diff)
    
11.                         bond_length.append(diff)
    
12. 
    
13.         dist_max = np.max(bond_length)
    
14.         dist_min = np.min(bond_length)
    
15. 
    
16.         if dist_max > thresh2 or dist_min < thresh1:
    
17.                 return ConvertTensor(9,True)
    
18.         else:
    
19.                 return ConvertTensor(0,True)
    
20. 
    
21. 
    
22.         def train(self,thresh1,thresh2,maxit=1000):
    
23. 
    
24.                 for i in range(maxit):
    
25.                         self.optimizer.zero_grad()
    
26.                         input_tensor = self.RandomInput        
    
27.                         print(input_tensor)
    
28. 
    
29.                         gen_tensor   = self.forward(input_tensor)
    
30.        
    
31.                         punish = 0
    
32.                         punish = Calc_bond_length(gen_tensor,thresh1,thresh2)       
    
33.                
    
34. 
    
35.                         loss    = punish
    
36.                
    
37.                         self.info.counter += 1
    
38.                         if self.info.counter%10==0:
    
39.                                 self.info.progress.append(loss.item())
    
40.        
    
41.        
    
42.                         loss.backward()
    
43.                         self.optimizer.step()
    
44. 
    
45.                         if loss.item()<2:
    
46.                                 print("break")
    
47.                                 break
    
48. 
    
49. 
    
50.                 return loss,gen_tensor

复制代码

FishC

在你的代码中，循环中的`gen_tensor`是神经网络的输出，而`input_tensor`是随机生成的张量，并没有在循环中变化。这就是为什么打印出来的`input_tensor`没有变化的原因。

如果想要在每次循环中改变输入张量，可以将生成随机张量的代码放在循环内部。另外，别忘了在循环开始之前调用`self.optimizer.zero_grad()`来清除梯度。

下面是修改后的代码：

1. def train(self, thresh1, thresh2, maxit=1000):
   
2.     for i in range(maxit):
   
3.         self.optimizer.zero_grad()
   
4.         
   
5.         input_tensor = self.RandomInput()
   
6.         gen_tensor = self.forward(input_tensor)
   
7.         
   
8.         punish = Calc_bond_length(gen_tensor, thresh1, thresh2)
   
9.         
   
10.         loss = punish
    
11.         
    
12.         self.info.counter += 1
    
13.         if self.info.counter % 10 == 0:
    
14.             self.info.progress.append(loss.item())
    
15.    
    
16.         loss.backward()
    
17.         self.optimizer.step()
    
18.         
    
19.         if loss.item() ...

复制代码

希望对你有所帮助！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

lqhenwunai

FishC 发表于 2024-3-25 08:54
在你的代码中，循环中的`gen_tensor`是神经网络的输出，而`input_tensor`是随机生成的张量，并没有在循环中 ...

哦，我说错了，是gen_tensor在循环中不发生改变。

FishC

lqhenwunai 发表于 2024-03-25 09:01
哦，我说错了，是gen_tensor在循环中不发生改变。

如果`gen_tensor`在循环中没有变化，可能是因为你没有使用梯度下降优化算法来更新神经网络的参数。在训练步骤中，你需要计算损失函数并调用`backward()`方法计算梯度，然后调用优化器的`step()`方法来更新参数。请确保你的代码中包含了这些步骤。

在你的代码中，我看不到你定义的优化器。你需要在模型的初始化函数中创建一个优化器，例如使用随机梯度下降优化算法（SGD）：

1. self.optimizer = torch.optim.SGD(self.parameters(), lr=0.01)

复制代码

另外，请确保在每次循环中都调用`self.optimizer.zero_grad()`来清除梯度。

最后，检查一下训练循环中的损失函数计算是否正确，并确认`Calc_bond_length`函数返回的`punish`张量是可微分的（即可以进行反向传播）。

如果你的代码已经包含了这些步骤，但仍然没有更新`gen_tensor`，那可能是模型架构或数据流的问题。你可以检查模型的前向传播是否正确，以及数据输入是否正确传递给了模型。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

lqhenwunai

FishC 发表于 2024-3-25 09:01
如果`gen_tensor`在循环中没有变化，可能是因为你没有使用梯度下降优化算法来更新神经网络的参数。在训 ...

下面是我的网络类定义。不知道有没有什么问题。
另外怎么查看网络参数有没有更新？

1. class Generator(nn.Module):
   
2.         """ Architecture of the Generator, uses res-blocks """
   
3. 
   
4.         def __init__(self,para):
   
5.                 super().__init__()
   
6.                
   
7.                 self.info = para
   
8.                 self.info.counter = 0
   
9.                 self.info.progress = []
   
10. 
    
11.                 self.model  = self.G_model()
    
12.                 self.optimizer = para.optimizer(self.parameters(),lr=para.lr)
    
13.                 self.flag_network = para.Gflag_network # =1, use network, =2 not use network       
    
14. 
    
15.                 self.RandomInput  = self.Gen_Random_input()
    
16.                 #self.model.apply(weight_init)
    
17.                 print("Generator model")
    
18.                 print(self.model)
    
19. 
    
20.         ##################################################3
    
21.         def G_model(self):
    
22.                 info       = self.info
    
23. 
    
24.                 model_flag = info.model_flag
    
25.                 Nlayer     = info.Nlayer
    
26.                 NAtom      = info.NAtom
    
27.                 increment  = info.increment
    
28.                 activation_func = info.activation_func
    
29.                 inp_dim         = NAtom*3
    
30.         #-----------------------------------------------
    
31.         #----------------------------------------------
    
32.                 if model_flag==2:#increase then decrease
    
33.                         module_list=[]
    
34.                         for i in range(Nlayer):
    
35.                                 module_list.append(nn.Linear(inp_dim,inp_dim+increment))
    
36.                                 module_list.append(activation_func)
    
37.                                 inp_dim+=increment
    
38.        
    
39.                         for i in range(Nlayer):
    
40.                                 module_list.append(nn.Linear(inp_dim,inp_dim-increment))
    
41.                                 module_list.append(activation_func)
    
42.                                 inp_dim-=increment
    
43. 
    
44.                         module_list.append(nn.Linear(inp_dim,inp_dim))       
    
45.                         model = nn.Sequential(*module_list)
    
46.         #-----------------------------------------------------
    
47. 
    
48. 
    
49.                 return model
    
50.         #-----------------------------------------------
    
51.         #######################################################
    
52. 
    
53. 
    
54.         def forward(self,input_tensor,flag=1):
    
55. 
    
56.                 #use random input
    
57.                 if flag==1:
    
58.                         out=self.model(input_tensor)
    
59.                
    
60.                 if flag==2: #not use any network
    
61.                         out = input_tensor
    
62.                
    
63.                 return out
    
64. 
    
65. 
    
66.         def Gen_Random_input(self):
    
67.                 NAtom = self.info.NAtom
    
68.                 mean  = self.info.configs[0].mean
    
69.                 std   = self.info.configs[0].std
    
70.                 inp   = torch.randn(NAtom*3)
    
71.                 input_tensor = inp*std + mean
    
72.                 input_tensor.requires_grad_(True)       
    
73.                 return input_tensor
    
74.        
    
75.         def train(self,thresh1,thresh2,maxit=1000):
    
76. 
    
77.                 for i in range(maxit):
    
78.                         self.optimizer.zero_grad()
    
79.                         input_tensor = self.RandomInput        
    
80.                         print(input_tensor)
    
81. 
    
82.                         gen_tensor   = self.forward(input_tensor, self.flag_network)
    
83.        
    
84.                         punish = 0
    
85.                         punish = Calc_bond_length(gen_tensor,thresh1,thresh2)       
    
86.                
    
87.         #                targets = torch.ones_like(gen_tensor)
    
88.         #                loss    = self.info.loss_func(gen_tensor,targets)+punish
    
89.                         loss    = punish
    
90.                
    
91.                         self.info.counter += 1
    
92.                         if self.info.counter%10==0:
    
93.                                 self.info.progress.append(loss.item())
    
94.        
    
95.        
    
96.                         loss.backward()
    
97.                         self.optimizer.step()
    
98. 
    
99.                         if loss.item()<2:
    
100.                                 print("break")
     
101.                                 break
     
102. 
     
103. 
     
104.                 return loss,gen_tensor

复制代码

FishC

lqhenwunai 发表于 2024-03-25 09:04
下面是我的网络类定义。不知道有没有什么问题。
另外 ...

在你的代码中，定义了一个`Generator`类作为神经网络模型。看起来你的模型定义是正确的，但有几个问题需要注意：

1. 在`G_model`函数中，你创建了一个`module_list`变量，并将线性层和激活函数按顺序添加到其中。然而，在增加层之后，你忘记对应的循环结构中有两个缩进错误，导致这些层不会与主模块列表一起添加。你需要将这两个循环的缩进位置调整到与前面的循环相同。

2. 在`forward`函数中，你在使用随机输入时有一个小错误。条件`if flag==1`下的代码块应该位于此之后，而不是包含在其中。你需要将`out = self.model(input_tensor)`和`return out`移动到适当的位置。

3. 关于如何检查网络参数是否已更新，你可以使用`state_dict()`方法打印模型的参数字典。该方法返回一个Python字典对象，其中包含模型的所有参数及其对应的张量值。你可以在训练循环中适当的位置调用`print(self.state_dict())`来查看模型参数是否发生变化。

修正后的代码如下所示（已标注修复部分）：

1. class Generator(nn.Module):
   
2.     """ Architecture of the Generator, uses res-blocks """
   
3. 
   
4.     def __init__(self, para):
   
5.         super().__init__()
   
6.         self.info = para
   
7.         self.info.counter = 0
   
8.         self.info.progress = []
   
9. 
   
10.         self.model = self.G_model()
    
11.         self.optimizer = para.optimizer(self.parameters(), lr=para.lr)
    
12.         self.flag_network = para.Gflag_network  # =1, use network, =2 not use network
    
13.         self.RandomInput = self.Gen_Random_input()
    
14. 
    
15.         print("Generator model")
    
16.         print(self.model)
    
17. 
    
18.     def G_model(self):
    
19.         info = self.info
    
20.         model_flag = info.model_flag
    
21.         Nlayer = info.Nlayer
    
22.         NAtom = info.NAtom
    
23.         increment = info.increment
    
24.         activation_func = info.activation_func
    
25.         inp_dim = NAtom * 3
    
26. 
    
27.         module_list = []  # Fixed: Initialize an empty list outside the loop
    
28. 
    
29.         if model_flag == 2:  # increase then decrease
    
30.             for i in range(Nlayer):
    
31.                 module_list.append(nn.Linear(inp_dim, inp_dim + increment))
    
32.                 module_list.append(activation_func)
    
33.                 inp_dim += increment
    
34. 
    
35.             for i in range(Nlayer):  # Fixed: Correct indentation
    
36.                 module_list.append(nn.Linear(inp_dim, inp_dim - increment))
    
37.                 module_list.append(activation_func)
    
38.                 inp_dim -= increment
    
39. 
    
40.         module_list.append(nn.Linear(inp_dim, inp_dim))
    
41. 
    
42.         model = nn.Sequential(*module_list)
    
43.         return model
    
44. 
    
45.     def forward(self, input_tensor, flag=1):
    
46.         if flag == 1:
    
47.             out = self.model(input_tensor)  # Moved from "if flag==1" condition
    
48.         elif flag == 2:
    
49.             out = input_tensor
    
50. 
    
51.         return out
    
52. 
    
53.     def Gen_Random_input(self):
    
54.         NAtom = self.info.NAtom
    
55.         mean = self.info.configs.mean
    
56.         std = self.info.configs.std
    
57.         inp = torch.randn(NAtom * 3)
    
58.         input_tensor = inp * std + mean
    
59.         input_tensor.requires_grad_(True)
    
60.         return input_tensor
    
61. 
    
62.     def train(self, thresh1, thresh2, maxit=1000):
    
63.         for i in range(maxit):
    
64.             self.optimizer.zero_grad()
    
65.             input_tensor = self.RandomInput
    
66.             print(input_tensor)
    
67.             gen_tensor = self.forward(input_tensor, self.flag_network)
    
68. 
    
69.             punish = Calc_bond_length(gen_tensor, thresh1, thresh2)
    
70.             loss = punish
    
71. 
    
72.             self.info.counter += 1
    
73.             if self.info.counter % 10 == 0:
    
74.                 self.info.progress.append(loss.item())
    
75. 
    
76.             loss.backward()
    
77.             self.optimizer.step()
    
78. 
    
79.             # Check if the model parameters have been updated
    
80.             print(self.state_dict())
    
81. 
    
82.             if loss.item():
    
83.                 ...

复制代码

希望这些修改能够解决你的问题！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。