在人家的代码中我想加加一个LSTM模型测试一下结果，但是加上之后出现了问题。

2242253525

这个是LSTM模型

1. import torch
   
2. import torch.nn as nn
   
3. from torch.autograd import Variable
   
4. import numpy as np
   
5. 
   
6. class LSTM(nn.Module):
   
7.     def __init__(self, input_num, hid_num, layers_num, out_num, batch_first=True):
   
8.         super().__init__()
   
9.         self.l1 = nn.LSTM(input_size=input_num,hidden_size=hid_num,num_layers=layers_num,batch_first=batch_first)
   
10.         self.out = nn.Linear(hid_num,out_num)
    
11. 
    
12.     def forward(self,data):
    
13.         flow_x = data['flow_x'] #B*T*D
    
14.         l_out,(h_n, c_n) = self.l1(flow_x,None) #None表示第一次 hidden_state是0
    
15.         print(l_out[:, -1, :])
    
16.         out = self.out(l_out[:, -1, :])
    
17.         return out

复制代码

这个是我的代码

1. import os
   
2. import time
   
3. import h5py
   
4. import torch
   
5. import numpy as np
   
6. import torch.nn as nn
   
7. import torch.optim as optim
   
8. import torch.nn.functional as F
   
9. from torch.utils.data import DataLoader
   
10. 
    
11. from traffic_dataset import LoadData
    
12. from utils import Evaluation
    
13. from utils import visualize_result
    
14. from chebnet import ChebNet
    
15. from gat import GATNet
    
16. from lstm import LSTM
    
17. 
    
18. class Baseline(nn.Module):
    
19.     def __init__(self, in_c, out_c):
    
20.         super(Baseline, self).__init__()
    
21.         self.layer = nn.Linear(in_c, out_c)
    
22. 
    
23.     def forward(self, data, device):
    
24.         flow_x = data["flow_x"].to(device)  # [B, N, H, D]
    
25. 
    
26.         B, N = flow_x.size(0), flow_x.size(1)
    
27. 
    
28.         flow_x = flow_x.view(B, N, -1)  # [B, N, H*D]  H = 6, D = 1
    
29. 
    
30.         output = self.layer(flow_x)  # [B, N, Out_C], Out_C = D
    
31. 
    
32.         return output.unsqueeze(2)  # [B, N, 1, D=Out_C]
    
33. 
    
34. 
    
35. def main():
    
36.     os.environ["CUDA_VISIBLE_DEVICES"] = "0"
    
37. 
    
38.     # Loading Dataset
    
39. 
    
40.     train_data = LoadData(data_path=["PEMS08/PEMS08.csv", "PEMS08/PEMS08.npz"], num_nodes=170, divide_days=[46, 16],
    
41.                           time_interval=5, history_length=6,
    
42.                           train_mode="train")
    
43.     train_loader = DataLoader(train_data, batch_size=64, shuffle=True, num_workers=8)
    
44. 
    
45.     test_data = LoadData(data_path=["PEMS08/PEMS08.csv", "PEMS08/PEMS08.npz"], num_nodes=170, divide_days=[46, 16],
    
46.                          time_interval=5, history_length=6,
    
47.                          train_mode="test")
    
48.     test_loader = DataLoader(test_data, batch_size=64, shuffle=False, num_workers=8)
    
49. 
    
50.     # Loading Model
    
51.     # my_net = GATNet(in_c=6 * 1, hid_c=6, out_c=1, n_heads=2)
    
52.     # my_net = GATNet(in_c=6 * 1, hid_c=6, out_c=1, n_heads=2, lstm_hidden_dim=1)
    
53.     # my_net = GCN(in_c=6,hid_c=6,out_c=1)
    
54.     # my_net = ChebNet(in_c=6, hid_c=6, out_c=1, K=5)
    
55.     my_net = LSTM(input_num=6,hid_num=6,layers_num=3,out_num=1)
    
56. 
    
57.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
58. 
    
59.     my_net = my_net.to(device)
    
60. 
    
61.     criterion = nn.MSELoss()
    
62. 
    
63.     optimizer = optim.Adam(params=my_net.parameters())
    
64. 
    
65.     # Train model
    
66.     Epoch = 100
    
67. 
    
68.     my_net.train()
    
69.     for epoch in range(Epoch):
    
70.         epoch_loss = 0.0
    
71.         start_time = time.time()
    
72.         for data in train_loader:  # ["graph": [B, N, N] , "flow_x": [B, N, H, D], "flow_y": [B, N, 1, D]]
    
73.             my_net.zero_grad()
    
74. 
    
75.             predict_value = my_net(data, device).to(torch.device("cpu"))  # [0, 1] -> recover
    
76. 
    
77.             loss = criterion(predict_value, data["flow_y"])
    
78. 
    
79.             epoch_loss += loss.item()
    
80. 
    
81.             loss.backward()
    
82. 
    
83.             optimizer.step()
    
84.         end_time = time.time()
    
85. 
    
86.         print("Epoch: {:04d}, Loss: {:02.4f}, Time: {:02.2f} mins".format(epoch, 1000 * epoch_loss / len(train_data),
    
87.                                                                           (end_time-start_time)/60))
    
88. 
    
89.     # Test Model
    
90.     my_net.eval()
    
91.     with torch.no_grad():
    
92.         MAE, MAPE, RMSE = [], [], []
    
93.         # Target = np.zeros([307, 1, 1]) # [N, 1, D]
    
94.         Target = np.zeros([170, 1, 1]) # [N, 1, D]
    
95. 
    
96.         Predict = np.zeros_like(Target)  #[N, T, D]
    
97. 
    
98.         total_loss = 0.0
    
99.         for data in test_loader:
    
100. 
     
101.             predict_value = my_net(data, device).to(torch.device("cpu"))  # [B, N, 1, D]  -> [1, N, B(T), D]
     
102. 
     
103.             loss = criterion(predict_value, data["flow_y"])
     
104. 
     
105.             total_loss += loss.item()
     
106. 
     
107.             predict_value = predict_value.transpose(0, 2).squeeze(0)  # [1, N, B(T), D] -> [N, B(T), D] -> [N, T, D]
     
108.             target_value = data["flow_y"].transpose(0, 2).squeeze(0)  # [1, N, B(T), D] -> [N, B(T), D] -> [N, T, D]
     
109. 
     
110.             performance, data_to_save = compute_performance(predict_value, target_value, test_loader)
     
111. 
     
112.             Predict = np.concatenate([Predict, data_to_save[0]], axis=1)
     
113.             Target = np.concatenate([Target, data_to_save[1]], axis=1)
     
114. 
     
115.             MAE.append(performance[0])
     
116.             MAPE.append(performance[1])
     
117.             RMSE.append(performance[2])
     
118. 
     
119.         print("Test Loss: {:02.4f}".format(1000 * total_loss / len(test_data)))
     
120. 
     
121.     print("Performance:  MAE {:2.2f}   MAPE {:2.2f}%  RMSE  {:2.2f}".format(np.mean(MAE), np.mean(MAPE * 100), np.mean(RMSE)))
     
122. 
     
123.     Predict = np.delete(Predict, 0, axis=1)
     
124.     Target = np.delete(Target, 0, axis=1)
     
125. 
     
126.     result_file = "GAT_result.h5"
     
127.     file_obj = h5py.File(result_file, "w")
     
128. 
     
129.     file_obj["predict"] = Predict
     
130.     file_obj["target"] = Target
     
131. 
     
132. 
     
133. def compute_performance(prediction, target, data):
     
134.     try:
     
135.         dataset = data.dataset  # dataloader
     
136.     except:
     
137.         dataset = data  # dataset
     
138. 
     
139.     prediction = LoadData.recover_data(dataset.flow_norm[0], dataset.flow_norm[1], prediction.numpy())
     
140.     target = LoadData.recover_data(dataset.flow_norm[0], dataset.flow_norm[1], target.numpy())
     
141. 
     
142.     mae, mape, rmse = Evaluation.total(target.reshape(-1), prediction.reshape(-1))
     
143. 
     
144.     performance = [mae, mape, rmse]
     
145.     recovered_data = [prediction, target]
     
146. 
     
147.     return performance, recovered_data
     
148. 
     
149. 
     
150. if __name__ == '__main__':
     
151.     main()
     
152.     # visualize_result(h5_file="GAT_result.h5",
     
153.     #                  nodes_id=120,
     
154.     #                  time_se=[0, 24 * 12 * 2],
     
155.     #                  visualize_file="gat_node_120")
     
156. 
     

复制代码

这个是我最后报错的情况

1. Traceback (most recent call last):
   
2.   File "D:\traffic\traffic_prediction\traffic_prediction.py", line 196, in <module>
   
3.     main()
   
4.   File "D:\traffic\traffic_prediction\traffic_prediction.py", line 120, in main
   
5.     predict_value = my_net(data, device).to(torch.device("cpu"))  # [0, 1] -> recover
   
6.   File "D:\anaconda\envs\traffic_pred\lib\site-packages\torch\nn\modules\module.py", line 1102, in _call_impl
   
7.     return forward_call(*input, **kwargs)
   
8. TypeError: forward() takes 2 positional arguments but 3 were given
   
9. 
   
10. 进程已结束,退出代码1
    

复制代码

我想知道的是，我应该如何做才能解决这个问题，希望有人教我一下，本人没有学过类似的东西，第一次接触。

isdkz

问题在于您的LSTM类中的forward方法需要一个参数，但您在main函数中调用my_net(data, device)时传递了两个参数。解决这个问题的方法是将数据和设备作为一个元组传递给my_net，如下所示：

1. predict_value = my_net((data, device)).to(torch.device("cpu"))
   

复制代码

然后在LSTM类中的forward方法中进行解包：

1. def forward(self, data_device_tuple):
   
2.     data, device = data_device_tuple
   
3.     flow_x = data['flow_x'].to(device)
   
4.     ...
   

复制代码

这样就可以解决这个问题了。

2242253525

没有解决，不过应该是我数据处理的问题，很难过，但是没有办法。