Did I store the training loss and validation loss in a wrong way? Because the training loss is greater than the validation loss somehow.
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset)
model.train()
total_loss = 0
for batch, (X, y) in enumerate(dataloader):
X, y = X.to(device), y.to(device)
# Compute prediction error
pred = model(X)
loss = loss_fn(pred, y)
total_loss += loss.item()
# Backpropagation
optimizer.zero_grad()
loss.backward()
optimizer.step()
if batch % 100 == 0:
loss, current = loss.item(), batch * len(X)
#print(f"loss: {loss:>7f} [{current:>5d}/{size:>5d}]")
average_loss = total_loss / (batch + 1)
train_losses.append(np.array(average_loss).mean())
##Define a test function
def test(dataloader, model, loss_fn):
size = len(dataloader.dataset)
num_batches = len(dataloader)
model.eval()
test_loss, correct = 0, 0
with torch.no_grad():
for X, y in dataloader:
X, y = X.to(device), y.to(device)
pred = model(X)
val_loss = loss_fn(pred, y).item()
test_loss += loss_fn(pred, y).item()
correct += (pred.argmax(1) == y).type(torch.float).sum().item()
test_loss /= num_batches
correct /= size
accuracy = round(100*correct,2)
val_losses.append(np.array(val_loss).mean())
print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
return accuracy
for t in range(epochs):
print(f"Epoch {t+1}\n-------------------------------")
train(train_dataloader, model, loss_fn, optimizer)
test(test_dataloader, model, loss_fn)
print("Done!")
plt.plot(range(1, epochs+1), train_losses, label='Training Loss')
plt.plot(range(1, epochs+1), val_losses, label='Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training and Validation Loss (lr = 0.001)')
plt.legend()
plt.show()
train_losses = []
val_losses = []
Here is the loss graph:
I'm not sure if this is a hypeparameter issue or I store the training loss and validation loss inappropriately.
