Hi, I've implemented the following train function. I think there are some issues with the accuracy calculations. I might be due to appending issues or might be a division issuse. And also look for other potential issues and feel free to modify the code. Even come with a much more optimized way. here is the code: def train_model(model, device, train_loader, test_loader, epochs = None, learning_rate = None, optimization_technique = None,  patience=None, scheduler_patience=None,num_batches = None, **kwargs):

    criterion = nn.CrossEntropyLoss()
    #optimizer = optim.SGD(model.parameters(), lr=learning_rate, weight_decay=5e-4)
    optimizer = optim.Adam(model.parameters(), lr=learning_rate) # ,momentum = 0.9)
   
    if optimization_technique == 'learning_rate_scheduler' and scheduler_patience:
        scheduler = ReduceLROnPlateau(optimizer, 'min', patience=scheduler_patience, verbose=True)

    train_losses = []
    train_accuracies = []
    test_losses = []
    test_accuracies = []

    best_loss = float('inf')
    stopping_counter = 0

#     with_dropout = model.classifier[6]
#     without_dropout = nn.Sequential(*[layer for layer in model.classifier if layer != with_dropout])

    for epoch in range(epochs):
        running_train_loss = 0.0
        running_train_acc = 0
        num_batches_train = 0
        
        #for X_batch, y_batch in itertools.islice(train_loader, 0, num_batches):
        for X_batch, y_batch in train_loader:
            
            # Move batch to device
            X_batch, y_batch = X_batch.to(device, non_blocking=True), y_batch.to(device, non_blocking=True)

            optimizer.zero_grad()
            y_pred = model(X_batch)
            loss = criterion(y_pred, y_batch)
            loss.backward()
            optimizer.step()

            running_train_loss += loss.item()
            running_train_acc += torch.sum(torch.eq(y_pred.argmax(dim=1), y_batch)).item()
            num_batches_train += 1

        train_losses.append(running_train_loss / num_batches_train)
        train_accuracies.append(running_train_acc / len(train_loader.dataset))

        # Testing segment
        running_test_loss = 0.0
        running_test_acc = 0
        num_batches_test = 0
        

        with torch.no_grad():
            for X_batch, y_batch in test_loader:
            #for X_batch, y_batch in itertools.islice(test_loader, 0, num_batches):
                
            
                # Move batch to device
                X_batch, y_batch = X_batch.to(device, non_blocking=True), y_batch.to(device, non_blocking=True)

                y_pred = model(X_batch)
                loss = criterion(y_pred, y_batch)

                running_test_loss += loss.item()
                running_test_acc += torch.sum(torch.eq(y_pred.argmax(dim=1), y_batch)).item()
#                 running_test_acc += accuracy_score(y_batch.cpu().numpy(), y_pred.argmax(dim=1).cpu().numpy())
                num_batches_test += 1

        test_losses.append(running_test_loss / num_batches_test)
        test_accuracies.append(running_test_acc / len(test_loader.dataset))

        # Early stopping
        if optimization_technique == 'early_stopping' and patience:
            if test_losses[-1] < best_loss:
                best_loss = test_losses[-1]
                stopping_counter = 0
            else:
                stopping_counter += 1
            if stopping_counter > patience:
                print(f"Early stopping at epoch {epoch+1}/{epochs}")
                break

        # Learning rate scheduler
        if optimization_technique == 'learning_rate_scheduler' and scheduler_patience and scheduler:
            scheduler.step(test_losses[-1])

        print(f"Epoch: {epoch+1}/{epochs}, Training Loss: {train_losses[-1]}, Test Loss: {test_losses[-1]}, Training Accuracy: {train_accuracies[-1]}, Test Accuracy: {test_accuracies[-1]}")

    return train_losses, train_accuracies, test_losses, test_accuracies