WHY MY LOSS AND ACCURACY SCORE ARE CRAZY?

[DeepNeuralDog]

Hi guys, I made this model and ran it for 20 epochs.
The code goes below:

class CNN(nn.Module):

    def __init__(self, in_channel, hidden, out_shape):
        super().__init__()
        torch.manual_seed(42)
        self.conv_1 = nn.Sequential(
            nn.Conv2d(
                in_channels = in_channel,
                out_channels = hidden,
                kernel_size = 3,
                stride = 1,
                padding = 1
            ),
            nn.Conv2d(
                in_channels = hidden,
                out_channels = hidden,
                kernel_size = 3,
                stride = 1,
                padding = 1
            ),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2)

        )
        self.conv_2 = nn.Sequential(
            nn.Conv2d(
                in_channels = hidden,
                out_channels = hidden,
                kernel_size = 3,
                stride = 1,
                padding = 1
            ),
            nn.Conv2d(
                in_channels = hidden,
                out_channels = hidden,
                kernel_size = 3,
                stride = 2,
             ))
        self.conv_3 = nn.Sequential(
            nn.Conv2d(
                in_channels = hidden,
                out_channels = hidden,
                kernel_size = 3,
                stride = 1,
                padding = 1
            ),
            nn.Conv2d(
                in_channels = hidden,
                out_channels = hidden,
                kernel_size = 3,
                stride = 2,
                padding = 1
            ),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2)

        )
        self.nnn =nn.Sequential(
            nn.Flatten(),
            nn.Linear(in_features=hidden*4*4, out_features=hidden),  # (for testing) nn.Linear(in_features=in_channel*0, out_features=hidden),
            nn.ReLU(),
            nn.Linear(in_features=hidden, out_features=hidden),
            nn.ReLU(),
            nn.Linear(in_features=hidden, out_features=out_shape)

        )
    def forward(self,x):
        x = self.conv_1(x)
        x = self.conv_2(x)
        x = self.conv_3(x)
        x = self.nnn(x)
        return x

in_channel=3
hidden= 32
output= len(class_names)

# MODEL INSTANCE
model_2= CNN(
    in_channel = in_channel,
    hidden = hidden,
    out_shape = output
).to(device)

# SET LOSS FN & OPTIMIZER

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

epoch= 20
for i in tqdm(range(epoch)):
    # TRAINING
    train_loss=0
    train_acc=0
    for batch, (X, y) in enumerate(train_dataloader):
        X,y= X.to(device),y.to(device)
        model_2.train()

        y_pred= model_2(X)

        loss = loss_fn(y_pred,y.to(device))
        train_loss+=loss
        train_acc += accuracy_fn(y, y_pred.argmax(dim=1))

        optimizer.zero_grad()

        loss.backward()

        optimizer.step()


    if i==0:
        print('Length of train dataloader',len(train_dataloader))
    train_loss /= len(train_dataloader)
    train_acc /= len(train_dataloader)

    #TESTING
    test_loss,test_acc = 0,0

    model_2.eval()
    with torch.inference_mode():


        for X_test, y_test in test_dataloader:
            X_test,y_test= X_test.to(device),y_test.to(device)

            test_pred = model_2(X_test)

            test_loss += loss_fn(test_pred,y_test)

            test_acc += accuracy_fn(y_test, test_pred.argmax(dim=1))

        test_loss /= len(test_dataloader)

        test_acc /= len(test_dataloader)

        print(f"Epoch: {i}| TrainLoss= {train_loss}|TestLoss= {test_loss}|TrainAccuracy= {train_acc}|TestAccuracy = {test_acc}")

Here are the result:
Length of train dataloader 2368
Epoch: 0| TrainLoss= 4.620189666748047|TestLoss= 4.620077610015869|TrainAccuracy= 0.9897592905405406|TestAccuracy = 0.9889240506329114
Epoch: 1| TrainLoss= 4.619851589202881|TestLoss= 4.619748115539551|TrainAccuracy= 1.025390625|TestAccuracy = 1.0917721518987342
Epoch: 2| TrainLoss= 4.6195573806762695|TestLoss= 4.61945915222168|TrainAccuracy= 1.0451858108108107|TestAccuracy = 1.071993670886076
Epoch: 3| TrainLoss= 4.619240760803223|TestLoss= 4.619195461273193|TrainAccuracy= 1.0882953265765767|TestAccuracy = 1.0126582278481013

[alkali333]

Have you tried it on the CPU? Just do one epoch because it takes a while. With the free version of Google Collab I sometimes got very random behaviour on the GPU and had to keep resettin the kernal.

The only thing I can see is that with your model, after all the convolutions and pooling, the output passed to the flatten layer only has 4*4. That's a small feature map.

[DeepNeuralDog]

Thank you so much bro. Totally got it. One last thing to ask..
Is there any way to move my dataset/dataloader to gpu before the training loop because it is taking a huge amount of time in the training loop .