When loading a checkpoint and recalculating the validation loss with which I had saved it, the validation loss values do not agree. Here is an example with an LSTM on MNIST (I know one would usually use CNNs on MNIST, but it’s a simple toy model that does its job here):
class LSTM(nn.Module):
    def __init__(self, input_size, num_layers, hidden_size, num_classes, sequence_length, bidirectional):
        super(LSTM, self).__init__()
        self.input_size = input_size
        self.num_layers = num_layers
        self.hidden_size = hidden_size
        self.num_classes = num_classes
        self.sequence_length = sequence_length
        self.bidirectional = bidirectional

        if self.bidirectional == True:
            self.num_directions = 2
        else:
            self.num_directions = 1

        self.LSTM = nn.LSTM(
                        input_size=self.input_size,
                        hidden_size=self.hidden_size,
                        num_layers=self.num_layers,
                        batch_first=True, 
                        dropout=0,
                        bidirectional=self.bidirectional
        )
        self.dropout = nn.Dropout(p=0.2, inplace=False)
        self.fc = nn.Linear(in_features=self.num_directions*self.hidden_size*self.sequence_length, out_features=self.num_classes)

    def forward(self, x):
        """Standard forward pass."""
        # Initialize hidden state:
        h0 = torch.zeros(self.num_layers * self.num_directions, x.size(0), self.hidden_size).to(device)
        c0 = torch.zeros(self.num_layers * self.num_directions, x.size(0), self.hidden_size).to(device)
        # Forward prop:
        out, (hidden_state, cell_state) = self.LSTM(x, (h0, c0))
        out = self.dropout(out)
        out = out.reshape(out.shape[0], -1)
        out = self.fc(out)
        return out

So initializing the model:
model = LSTM(
               input_size=28, 
               num_layers=3, 
               hidden_size=256, 
               num_classes=10, 
               sequence_length=28, 
               bidirectional=False
).to(device)

My training loop looks like this:
val_losses = []

for epoch in range(num_epochs): 
     val_loss_per_batch = []
     # do the training stuff ... 
     with torch.no_grad(): 
         model.eval()
         for val_batch_idx, (val_images, val_labels) in enumerate(val_loader):
              val_images = val_images.to(device)
              val_images = torch.squeeze(input = val_images, dim = 1) # shape: (batch_size, 28, 28), otherwise RNN throws error
              val_labels = val_labels.to(device)
              val_output = model(val_images)
              val_loss_per_batch.append(loss_sum(val_output, val_labels).detach().cpu().item())
     val_losses.apend(np.sum(val_loss_per_batch)/val_loader.dataset.__len__())

And here is what loss_sum looks like:
loss_sum = nn.CrossEntropyLoss(reduction='sum')

(I use reduction = 'sum' because if I used the mean to calculate the loss for each batch, and then again took the mean of all batches, the mean of all batches would be slightly biased, since the batches do not all have the same size, i.e. the smallest batch would be weighted more in the mean. But I believe this to be a technical detail.)
After training for a small number of epochs, I save a checkpoint:
checkpoint = {'state_dict' : model.state_dict(), 'optimizer': optimizer.state_dict()}
torch.save(checkpoint, 'checkpoint.pth.tar')

And then when I want to load the checkpoint:
model = LSTM(...) # initialization just as above
checkpoint = torch.load('checkpoint.pth.tar')
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])

model.to(device)
model.eval()

Now I do the whole thing as in the loop, i.e. with torch.no_grad: ..., but I get another validation loss than when I had saved the checkpoint! And when I load the checkpoint again, I get different values all the time. This is how my val_loader looks like:
val_loader = DataLoader(dataset=val_subset, shuffle=True, batch_size=1024)

I already tried shuffle = False, but to no avail. Can anybody confirm this weird behavior? And does anybody know why it occurs?