Pytorch TypeError: Nur ganzzahlige Tensoren eines einzelnen Elements können in einen Index konvertiert werden ⇐ Python

[Anonymous]

Ich versuche, Pytorch in einem Fall für die NLP -Binärklassifizierung zu verwenden, und ich brauche Hilfe, um das neuronale Netzwerk zu beenden und zu validieren. Ich bin Neuling und dies ist mein erstes Mal, dass ich PyTorch verwende. Siehe den Code unten und den Fehler ... < /p>

Code: Select all

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()
< /code>
out: fackel.size ([5438, 768]) < /p>
y_train_tensor.size()
< /code>
out: fackel.size ([5438, 1]) < /p>
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)

Der Ausgangsfehler: TypeError: Nur ganzzahlige Tensoren eines einzelnen Elements können in einen Index konvertiert werden.
Bitte helfen Sie mir, dies zu beheben

Code: Select all

TypeError                                 Traceback (most recent call last)
 in 
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

 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