Python Pytorch TypeError：只能将单个元素的整数张量转换为索引

我正在尝试使用pytorch进行nlp二元分类，我需要帮助完成神经网络的训练和验证。我是新手，这是我第一次使用pytorch，请参阅下面的代码和错误

X_train_tensor = torch.from_numpy(np.asarray(X_train)).type(torch.FloatTensor).to(device)
y_train_tensor = torch.from_numpy(np.asarray(y_train)).type(torch.FloatTensor).unsqueeze(1).to(device)

X_valid_tensor = torch.from_numpy(np.asarray(X_valid)).type(torch.FloatTensor).to(device)
y_valid_tensor = torch.from_numpy(np.asarray(y_valid)).type(torch.FloatTensor).unsqueeze(1).to(device)



X_train_tensor.size()

输出：火炬尺寸（[5438768]）

输出：火炬尺寸（[5438,1]）

输出错误：TypeError：只有单个元素的整数张量可以转换为索引

请帮我解决这个问题

TypeError                                 Traceback (most recent call last)
<ipython-input-46-bfd7a45f13aa> in <module>
      5 for epoch in range(10):
      6 
----> 7     train_loss, train_acc = train(model, X_train_tensor, y_train_tensor, y_valid_tensor)
      8     valid_acc = evaluate(model, X_valid_tensor, y_valid_tensor)
      9 

<ipython-input-44-689c66e0e9ed> in train(model, *var)
      6     model.train()
      7 
----> 8     for x in range(X_train_tensor):
      9 
     10         optimizer.zero_grad()

TypeError: only integer tensors of a single element can be converted to an index

TypeError回溯（最近一次调用）
在里面
5表示范围内的历元（10）：
6.
---->7列车损失，列车acc=列车（模型，X列车张量，y列车张量，y有效张量）
8 valid\u acc=评估（模型，X\u valid\u张量，y\u valid\u张量）
9
列车内（型号，*var）
6型列车（）
7.
---->范围内x为8（x列张量）：
9
10优化器零度梯度（）
TypeError：只能将单个元素的整数张量转换为索引

您的代码似乎有几个错误。要解决此问题，请将范围内x（x列张量）的

更改为范围内x（x列张量）的
。注意类似的问题（例如，
model（X\u train\u tensor）
似乎在循环中是无意的。谢谢，伙计，我更正了代码，但出现了以下错误：-->train\u loss，train\u acc=train（model）.RuntimeError:CUDA error:device side assert triggered。我知道这是一个错误的语法，但在这种情况下，我如何将train_loss和train_acc分开？请阅读kaggle注释中的代码。OK：帮助我在我的计算机上完成此操作笔记本？就像我说的，
predictions=model（X\u train\u tensor）
似乎不正确。如果您只是一次性传递整个培训数据集，为什么要在for循环中迭代
x
？最好只遍历一次代码并修复此类语句的所有实例。我正在通过x进行交互，因为我想看到培训数据集中每个功能的损失和acc，所以我要更改这一点，然后执行see发生了什么
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3, weight_decay=5e-4)


def binary_acc(preds, y_valid):
    
    y_valid_tag = torch.round(preds)

    correct_results = (y_valid_tag == y_valid).float()
    acc = correct_results.sum() / len(correct_results)
    
    return acc


def train(model, *var):
    
    epoch_loss = 0
    epoch_acc = 0
    
    model.train()
    
    for x in range(X_train_tensor):
    
        optimizer.zero_grad() 
    
        predictions = model(X_train_tensor)
        loss = criterion(predictions, y_train_tensor) 
        acc = binary_acc(predictions, y_valid_tensor)
    
        loss.backward()
        optimizer.step()
    
        epoch_loss += loss.item()
        epoch_acc += acc.item()
    
    return epoch_loss / len(X_train_tensor), epoch_acc / len(X_train_tensor)




def evaluate(model, *var):

    epoch_acc = 0
    
    model.eval()
    
    with torch.no_grad():
        for X in range(X_valid_tensor):
            predictions = model(X_train_tensor)
            acc = binary_acc(predictions, y_valid_tensor)
        
            epoch_acc += acc.item()
        
    return epoch_acc / len(X_valid_tensor)




loss=[]
acc=[]
val_acc=[]

for epoch in range(10):
    
    train_loss, train_acc = train(model, X_train_tensor, y_train_tensor, y_valid_tensor)
    valid_acc = evaluate(model, X_valid_tensor, y_valid_tensor)
    
    print(f'\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc*100:.2f}%')
    print(f'\t Val. Acc: {valid_acc*100:.2f}%')
    
    loss.append(train_loss)
    acc.append(train_acc)
    val_acc.append(valid_acc)

TypeError                                 Traceback (most recent call last)
<ipython-input-46-bfd7a45f13aa> in <module>
      5 for epoch in range(10):
      6 
----> 7     train_loss, train_acc = train(model, X_train_tensor, y_train_tensor, y_valid_tensor)
      8     valid_acc = evaluate(model, X_valid_tensor, y_valid_tensor)
      9 

<ipython-input-44-689c66e0e9ed> in train(model, *var)
      6     model.train()
      7 
----> 8     for x in range(X_train_tensor):
      9 
     10         optimizer.zero_grad()

TypeError: only integer tensors of a single element can be converted to an index