Calcule la precisión cada época en PyTorch

Nuestro grupo de especialistas pasados algunos días de trabajo y de recopilar de información, encontramos los datos necesarios, deseamos que resulte útil para ti en tu proyecto.

Solución:

Una mejor manera sería calcular correcto justo después del paso de optimización

for epoch in range(num_epochs):

    correct = 0
    for i, (inputs,labels) in enumerate (train_loader):
        ...
        output = net(inputs)
        ...
        optimizer.step()

        correct += (output == labels).float().sum()

    accuracy = 100 * correct / len(trainset)
    # trainset, not train_loader
    # probably x in your case

    print("Accuracy = ".format(accuracy))

Es x todo el conjunto de datos de entrada? Si es así, es posible que esté dividiendo por el tamaño de todo el conjunto de datos de entrada en correct/x.shape[0] (a diferencia del tamaño del mini lote). Intenta cambiar esto a correct/output.shape[0]

Creo que la respuesta más simple es la del tutorial cifar10:

total = 0
with torch.no_grad():
    net.eval()
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))

asi que:

acc = (true == pred).sum().item()

Si tiene un contador, no olvide dividir eventualmente por el tamaño del conjunto de datos o valores análogos.

He usado:

N = data.size(0) # since usually it's size (batch_size, D1, D2, ...)
correct += (1/N) * correct

---

Código autónomo:

# testing accuracy function
# https://discuss.pytorch.org/t/calculating-accuracy-of-the-current-minibatch/4308/11
# https://stackoverflow.com/questions/51503851/calculate-the-accuracy-every-epoch-in-pytorch

import torch
import torch.nn as nn

D = 1
true = torch.tensor([0,1,0,1,1]).reshape(5,1)
print(f'true.size() = true.size()')

batch_size = true.size(0)
print(f'batch_size = batch_size')
x = torch.randn(batch_size,D)
print(f'x = x')
print(f'x.size() = x.size()')

mdl = nn.Linear(D,1)
logit = mdl(x)
_, pred = torch.max(logit.data, 1)

print(f'logit = logit')

print(f'pred = pred')
print(f'true = true')

acc = (true == pred).sum().item()
print(f'acc = acc')

---

Además, creo que este código es una buena referencia:

def calc_accuracy(mdl, X, Y):
    # reduce/collapse the classification dimension according to max op
    # resulting in most likely label
    max_vals, max_indices = mdl(X).max(1)
    # assumes the first dimension is batch size
    n = max_indices.size(0)  # index 0 for extracting the # of elements
    # calulate acc (note .item() to do float division)
    acc = (max_indices == Y).sum().item() / n
    return acc

---

explicando pred = mdl(x).max(1)vea esto https://discuss.pytorch.org/t/how-does-one-get-the-predicted-classification-label-from-a-pytorch-model/91649

lo principal es que debe reducir/contraer la dimensión donde está el valor bruto/logit de clasificación con un máximo y luego seleccionarlo con un .indices. Por lo general, estas son las dimensiones 1 ya que dim 0 tiene el tamaño del lote, por ejemplo [batch_size,D_classification] donde los datos sin procesar pueden ser de tamaño [batch_size,C,H,W]

Un ejemplo sintético con datos sin procesar en 1D de la siguiente manera:

import torch
import torch.nn as nn

# data dimension [batch-size, D]
D, Dout = 1, 5
batch_size = 16
x = torch.randn(batch_size, D)
y = torch.randint(low=0,high=Dout,size=(batch_size,))

mdl = nn.Linear(D, Dout)
logits = mdl(x)
print(f'y.size() = y.size()')
# removes the 1th dimension with a max, which is the classification layer
# which means it returns the most likely label. Also, note you need to choose .indices since you want to return the
# position of where the most likely label is (not it's raw logit value)
pred = logits.max(1).indices
print(pred)

print('--- preds vs truth ---')
print(f'predictions = pred')
print(f'y = y')

acc = (pred == y).sum().item() / pred.size(0)
print(acc)

producción:

y.size() = torch.Size([16])
tensor([3, 1, 1, 3, 4, 1, 4, 3, 1, 1, 4, 4, 4, 4, 3, 1])
--- preds vs truth ---
predictions = tensor([3, 1, 1, 3, 4, 1, 4, 3, 1, 1, 4, 4, 4, 4, 3, 1])
y = tensor([3, 3, 3, 0, 3, 4, 0, 1, 1, 2, 1, 4, 4, 2, 0, 0])
0.25

---

referencia:

• https://discuss.pytorch.org/t/calculating-accuracy-of-the-current-minibatch/4308/5
• https://discuss.pytorch.org/t/how-does-one-get-the-predicted-classification-label-from-a-pytorch-model/91649/3
• SO: Calcule la precisión cada época en PyTorch

Tienes la opción de sostener nuestra función exponiendo un comentario y dejando una puntuación te damos la bienvenida.

---

---

Utiliza Nuestro Buscador