Hi, im using a resnet34 on the stanford car dataset(https://www.kaggle.com/jutrera/stanford-car-dataset-by-classes-folder 1).
The things that are happening

Training loss is decreasing, training acc is increasing
Test accuracy stays the same throughout the training, doesnt matter how many epochs

With about 5 epochs the models peaks to 90% acc and then doesn’t increase that much.
But the validation accuracy is still around 4%, doesn’t matter when i measure it (1, 2, …, 6 epochs)
Can somebody help me find a problem with my code or what i might improve upon?
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.models as models
import torchvision.transforms as transforms
import time
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)

tfms = transforms.Compose([transforms.Resize((300, 300)),
                           transforms.ToTensor()])

dataset = torchvision.datasets.ImageFolder(root="../../Data/car_data2/train", transform = tfms)
trainloader = torch.utils.data.DataLoader(dataset, batch_size = 16, shuffle=True)

dataset2 = torchvision.datasets.ImageFolder(root="../../Data/car_data2/test", transform = tfms)
testloader = torch.utils.data.DataLoader(dataset2, batch_size = 16, shuffle=False)

def train_model(model, criterion, optimizer, n_epochs = 5):
    
    for epoch in range(n_epochs):
        running_loss = 0.0
        running_correct = 0.0
        for i, data in enumerate(trainloader, 0):

            # get the inputs
            inputs, labels = data
            inputs = inputs.to(device)
            labels = labels.to(device)
            optimizer.zero_grad()
            
            # forward + backward + optimize
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            
            running_loss += loss.item()
            running_correct += (labels==predicted).sum().item()
            
            if i % 10 == 9:    # print every 10 mini-batches (change according to data)
                print('[Epoch %d, %5d / %5d] loss: %.3f acc: %.3f' %
                      (epoch + 1, i + 1, len(trainloader), running_loss / 10, (100/16)*running_correct/10))
                running_loss = 0.0
                running_correct = 0.0

    print('Finished Training')
    return model

model_ft = models.resnet34(pretrained=True)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, 196)

model_ft = model_ft.to(device)

criterion = nn.CrossEntropyLoss()

optimizer = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9)

model_ft = train_model(model_ft, criterion, optimizer, n_epochs=5)

# Test the model
correct = 0
total = 0
with torch.no_grad():
    for i, data in enumerate(testloader):
        images, labels = data
        images = images.to(device)
        labels = labels.to(device)
        outputs = model_ft(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
print('Accuracy of the network on the test images: %d %%' % (
    100 * correct / total))