在人家的代码中我想加加一个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

根据报错信息， forward()  函数接收了两个参数，但是在调用  my_net(data, device)  时却给了三个参数。这是因为  my_net  模型的  forward()  函数只接收一个参数，而你在调用时给了两个参数  data  和  device 。解决这个问题的方法是将  device  作为参数传递给  my_net  的构造函数，然后在  forward()  函数中使用  device 。修改后的代码如下所示：

```
import os
import time
import h5py
import torch
import numpy as np
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader

from traffic_dataset import LoadData
from utils import Evaluation
from utils import visualize_result
from chebnet import ChebNet
from gat import GATNet
from lstm import LSTM

class Baseline(nn.Module):
    def __init__(self, in_c, out_c):
        super(Baseline, self).__init__()
        self.layer = nn.Linear(in_c, out_c)

    def forward(self, data, device):
        flow_x = data["flow_x"].to(device)  # [B, N, H, D]

        B, N = flow_x.size(0), flow_x.size(1)

        flow_x = flow_x.view(B, N, -1)  # [B, N, H*D]  H = 6, D = 1

        output = self.layer(flow_x)  # [B, N, Out_C], Out_C = D

        return output.unsqueeze(2)  # [B, N, 1, D=Out_C]

def main():
    os.environ["CUDA_VISIBLE_DEVICES"] = "0"

    # Loading Dataset

    train_data = LoadData(data_path=["PEMS08/PEMS08.csv", "PEMS08/PEMS08.npz"], num_nodes=170, divide_days=[46, 16],
                          time_interval=5, history_length=6,
                          train_mode="train")
    train_loader = DataLoader(train_data, batch_size=64, shuffle=True, num_workers=8)

    test_data = LoadData(data_path=["PEMS08/PEMS08.csv", "PEMS08/PEMS08.npz"], num_nodes=170, divide_days=[46, 16],
                          time_interval=5, history_length=6,
                          train_mode="test")
    test_loader = DataLoader(test_data, batch_size=64, shuffle=False, num_workers=8)

    # Loading Model
    # my_net = GATNet(in_c=6 * 1, hid_c=6, out_c=1, n_heads=2)
    # my_net = GATNet(in_c=6 * 1, hid_c=6, out_c=1, n_heads=2, lstm_hidden_dim=1)
    # my_net = GCN(in_c=6,hid_c=6,out_c=1)
    # my_net = ChebNet(in_c=6, hid_c=6, out_c=1, K=5)
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    my_net = LSTM(input_num=6,hid_num=6,layers_num=3,out_num=1, device=device)

    my_net = my_net.to(device)

    criterion = nn.MSELoss()

    optimizer = optim.Adam(params=my_net.parameters())

    # Train model
    Epoch = 100

    my_net.train()
    for epoch in range(Epoch):
        epoch_loss = 0.0
        start_time = time.time()
        for data in train_loader:  # ["graph": [B, N, N] , "flow_x": [B, N, H, D], "flow_y": [B, N, 1, D]]
            my_net.zero_grad()

            predict_value = my_net(data).to(torch.device("cpu"))  # [0, 1] -> recover

            loss = criterion(predict_value, data["flow_y"])

            epoch_loss += loss.item()

            loss.backward()

            optimizer.step()
        end_time = time.time()

        print("Epoch: {:04d}, Loss: {:02.4f}, Time: {:02.2f} mins".format(epoch, 1000 * epoch_loss / len(train_data),
                                                                         (end_time - start_time) / 60))

    # Test Model
    my_net.eval()
    with torch.no_grad():
        MAE, MAPE, RMSE = [], [], []
        # Target = np.zeros([307, 1, 1]) # [N, 1, D]
        Target = np.zeros([170, 1, 1])  # [N, 1, D]

        Predict = np.zeros_like(Target)  #[N, T, D]

        total_loss = 0.0
        for data in test_loader:

            predict_value = my_net(data).to(torch.device("cpu"))  # [B, N, 1, D]  -> [1, N, B(T), D]

            loss = criterion(predict_value, data["flow_y"])

            total_loss += loss.item()

            predict_value = predict_value.transpose(0, 2).squeeze(0)  # [1, N, B(T), D] -> [N, B(T), D] -> [N, T, D]
            target_value = data["flow_y"].transpose(0, 2).squeeze(0)  # [1, N, B(T), D] -> [N, B(T), D] -> [N, T, D]

            performance, data_to_save = compute_performance(predict_value, target_value, test_loader)

            Predict = np.concatenate([Predict, data_to_save[0]], axis=1)
            Target = np.concatenate([Target, data_to_save[1]], axis=1)

            MAE.append(performance[0])
            MAPE.append(performance[1])
            RMSE.append(performance[2])

        print("Test Loss: {:02.4f}".format(1000 * total_loss / len(test_data)))

    print("Performance:  MAE {:2.2f}   MAPE {:2.2f}%   RMSE   {:2.2f}".format(np.mean(MAE), np.mean(MAPE * 100), np.mean(RMSE)))

    Predict = np.delete(Predict, 0, axis=1)
    Target = np.delete(Target, 0, axis