TypeError: linear(): argument 'input' (position 1) must be Tensor, not tuple

TypeError: linear(): argument 'input' (position 1) must be Tensor, not tuple

def train(verbose = False):

net.train()
loss_list = []

for i,data in enumerate(train_dataloader):
   
    inputs = data['inputs']
    groundtruths = data['groundtruths']     
    
    if USE_GPU:
        inputs = Variable(inputs).cuda()
        groundtruths = Variable(groundtruths).cuda()
        
    else:
        inputs = Variable(inputs)
        groundtruths = Variable(groundtruths)
    
    #将参数的grad值初始化为0
    optimizer.zero_grad()

    #获得网络输出结果
    out = net(inputs)

    #根据真值计算损失函数的值
    loss = loss_criterion(out,groundtruths)

    #通过优化器优化网络
    loss.backward()
    optimizer.step()
    loss_list.append(loss.item())
  
return loss_list

def test():

error = 0.0
predictions = []
test_groundtruths = []

# 告诉网络进行测试，不再是训练模式
net.eval() 

for i,data in enumerate(test_dataloader):

    inputs = data['inputs']
    groundtruths = data['groundtruths']     
    
    if USE_GPU:

        inputs = Variable(inputs).cuda()
        groundtruths = Variable(groundtruths).cuda()
        
    else:
        
        inputs = Variable(inputs)
        groundtruths = Variable(groundtruths)

    out = net(inputs)
    error += (error_criterion(out,groundtruths).item()*groundtruths.size(0))

    if USE_GPU:
        predictions.extend(out.cpu().data.numpy().tolist())
        test_groundtruths.extend(groundtruths.cpu().data.numpy().tolist())
        
    else:
        predictions.extend(out.data.numpy().tolist())
        test_groundtruths.extend(groundtruths.data.numpy().tolist())
  
average_error = np.sqrt(error/len(test_data_trans))

return np.array(predictions).reshape((len(predictions))),np.array(test_groundtruths).reshape((len(test_groundtruths))),average_error

def main():

#记录程序开始的时间
train_start = time.time()
loss_recorder = []

print('starting training... ')

for epoch in range(EPOCHES):

    # adjust learning rate
    adjust_lr.step()
    
    loss_list = train(verbose= True)
    
    loss_recorder.append(np.mean(loss_list))
    
    print('epoch = %d,loss = %.5f'%(epoch+1,np.mean(loss_list)))

print ('training time = {}s'.format(int((time.time() - train_start))))

# 记录测试开始的时间
test_start = time.time()
predictions, test_groundtruth, average_error = test()

print(predictions.shape)
print(test_groundtruth.shape)

print('test time = {}s'.format(int((time.time() - test_start)+1.0)))
print('average error = ',  average_error)

result = pd.DataFrame(data = {'Q(t+1)':predictions,'Q(t+1)truth':test_groundtruth})
result.to_csv('D:/python目录/pythonProject/STA-LSTM-main/data/output/out_t+1.csv')

torch.save(net,'D:/python目录/pythonProject/STA-LSTM-main/models/sta_lstm_t+1.pth')

if name == 'main':
main()

这个错误通常是因为输入参数类型错误引起的。在这个函数中，错误发生在`out = net(inputs

你可以检查

for i, data in enumerate(train_dataloader):
    inputs, groundtruths = data[0], data[1]

这样，inputs和groundtruths就被提取出来并赋值给了相应的变量，就可以避免这个错误。

• 这篇文章：【PyTorch】TypeError: stack(): argument 'tensors' (position 1) must be tuple 也许能够解决你的问题，你可以看下

这个错误是因为在 net(inputs) 中，inputs 是一个元组而不是一个 Tensor。根据代码，inputs 是从 train_dataloader 中获取的字典，可能是字典中包含多个输入，然后被转换为元组。在 PyTorch 中，神经网络输入必须是 Tensor 类型。

您需要将 inputs 转换为 Tensor。在这种情况下，如果您只有一个输入，您可以使用以下代码将 inputs 转换为 Tensor：

inputs = data['inputs']
inputs = inputs[0] # 获取第一个输入
groundtruths = data['groundtruths']
    
if USE_GPU:
    inputs = Variable(inputs).cuda()
    groundtruths = Variable(groundtruths).cuda()
else:
    inputs = Variable(inputs)
    groundtruths = Variable(groundtruths)

如果你的数据中有多个输入，则需要将每个输入都转换为 Tensor，并将它们堆叠在一起。例如，如果你的数据中有两个输入（inputs1 和 inputs2），则可以使用以下代码将它们堆叠在一起：

inputs1 = data['inputs1']
inputs2 = data['inputs2']
inputs = torch.stack([inputs1, inputs2], dim=1)
groundtruths = data['groundtruths']
    
if USE_GPU:
    inputs = Variable(inputs).cuda()
    groundtruths = Variable(groundtruths).cuda()
else:
    inputs = Variable(inputs)
    groundtruths = Variable(groundtruths)

这将把 inputs1 和 inputs2 堆叠在一起，形成一个形状为 (batch_size, 2, input_size) 的 Tensor。你可以根据您的实际情况调整。