[Python] PyTorch High Train Loss and Test Loss

So I'm using a CNN with 3 Conv layers with FGVCAircraft Dataset but my loss is so much higher than I expected and I don't know why.Here is the code of my CNN:

from torch import nn
class MNIST_model(nn.Module):
def __init__(self,input_features,output_features,hidden_units):
super().__init__()
self.conv_block1 = nn.Sequential(
nn.Conv2d(in_channels = input_features,
out_channels = hidden_units,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(),
nn.Conv2d(in_channels = hidden_units,
out_channels = hidden_units,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2
))
self.conv_block2 = nn.Sequential(
nn.Conv2d(in_channels = hidden_units,
out_channels = hidden_units,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(),
nn.Conv2d(in_channels = hidden_units,
out_channels = hidden_units,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2
))

self.conv_block3 = nn.Sequential(
nn.Conv2d(in_channels = hidden_units,
out_channels = hidden_units,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(),
nn.Conv2d(in_channels = hidden_units,
out_channels = hidden_units,
kernel_size=3,
stride=1,
padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2
))


self.adaptive_pool = nn.AdaptiveAvgPool2d((6,6))
self.classifier = nn.Sequential(
nn.Flatten(),
nn.Linear(in_features=input_features*1536
, out_features=output_features),
)


def forward(self,x):
x = self.conv_block1(x)
x = self.conv_block2(x)
x = self.adaptive_pool(x)
x = self.classifier(x)
return x


torch.manual_seed(42)

# Measure time
from tqdm.auto import tqdm
from timeit import default_timer as timer
train_time_start_on_gpu = timer()
torch.cuda.empty_cache()


epochs = 10
for epoch in tqdm(range(epochs)):
print(f"Epoch: {epoch}\n---------")
train_step(data_loader=train_data,
model=model,
loss_fn=loss_fn,
optimizer=optimizer,
accuracy_fn=accuracy_fn
)
test_step(data_loader=test_data,
model=model,
loss_fn=loss_fn,
accuracy_fn=accuracy_fn
)

train_time_end_on_gpu = timer()
total_train_time_model_1 = print_train_time(start=train_time_start_on_gpu,
end=train_time_end_on_gpu,
device=device)

def train_step(model: torch.nn.Module,
data_loader: torch.utils.data.DataLoader,
loss_fn: torch.nn.Module,
optimizer: torch.optim.Optimizer,
accuracy_fn,
device: torch.device = device):
train_loss, train_acc = 0, 0
model.to(device)
for batch, (X, y) in enumerate(data_loader):
# Send data to GPU
X, y = X.to(device), y.to(device)

# 1. Forward pass
y_pred = model(X.to(device))

# 2. Calculate loss
loss = loss_fn(y_pred, y.to(device))
train_loss += loss
train_acc += accuracy_fn(y_true=y,
y_pred=y_pred.argmax(dim=1)) # Go from logits -> pred labels

# 3. Optimizer zero grad
optimizer.zero_grad()

# 4. Loss backward
loss.backward()

# 5. Optimizer step
optimizer.step()

if batch % 400 == 0:
print(f"Looked at {batch * len(X)}/{len(train_data.dataset)} samples")


# Calculate loss and accuracy per epoch and print out what's happening
train_loss /= len(data_loader)
train_acc /= len(data_loader)
print(f"Train loss: {train_loss:.5f} | Train accuracy: {train_acc:.2f}%")

def test_step(data_loader: torch.utils.data.DataLoader,
model: torch.nn.Module,
loss_fn: torch.nn.Module,
accuracy_fn,
device: torch.device = device):
test_loss, test_acc = 0, 0
model.to(device)
model.eval() # put model in eval mode
# Turn on inference context manager
with torch.inference_mode():
for X, y in data_loader:
# Send data to GPU
X, y = X.to(device), y.to(device)

# 1. Forward pass
test_pred = model(X)

# 2. Calculate loss and accuracy
test_loss += loss_fn(test_pred, y)
test_acc += accuracy_fn(y_true=y,
y_pred=test_pred.argmax(dim=1) # Go from logits -> pred labels
)

# Adjust metrics and print out
test_loss /= len(data_loader)
test_acc /= len(data_loader)
print(f"Test loss: {test_loss:.5f} | Test accuracy: {test_acc:.2f}%\n")

loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(params=model.parameters(),lr=0.001,momentum=0.9)
def accuracy_fn(y_true, y_pred):
correct = torch.eq(y_true, y_pred).sum().item()
acc = (correct / len(y_pred)) * 100
return acc



I played with hyperparameters of optimizer but it didn't work out.My accuracy is like below: Looked at 0/5333 samples Train loss: 4.60587 | Train accuracy: 1.10% Test loss: 4.60679 | Test accuracy: 0.52%

Continue reading...