Hi all,
I’m trying to get started with Pytorch by creating my own CNN model to classify dogs and cats. I have 300 photos of each class and a 70/30 split for training/validation. I used OpenCV to resize the RGB images to 50x50 and then used one hot vector to label them. I then saved them into a tensor for easy access. The issue I’m having is that my loss for each training epoch is decreasing but my validation accuracy is not improving. The classification problem is simple and the model is pretty standard. There doesn’t seem to be anything wrong with my set up so I don’t quite understand why my accuracy is not improving. Does anyone have any idea as to why this behavior is happening?
Thanks
from torchvision import models
from tqdm import tqdm
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt 
import math 
import time
import cv2
class Model(nn.Module):
	def __init__(self, channel=1, imageSize=128):
		super().__init__()
		# Create a 4 layer convolutional network with batch normalisation
		self.imageSize = imageSize
		self.channel = channel 
		self.conv1 = nn.Conv2d(self.channel, 24, 5, stride=1, padding=2) 
		self.conv2 = nn.Conv2d(24, 28, 5, stride=1, padding=2)
		self.conv3 = nn.Conv2d(28, 32, 5, stride=1, padding=2) 
		self.conv4 = nn.Conv2d(32, 36, 5, stride=1, padding=2)
		self.bn1 = nn.BatchNorm2d(24)
		self.bn2 = nn.BatchNorm2d(28)
		self.bn3 = nn.BatchNorm2d(32)
		self.bn4 = nn.BatchNorm2d(36)

		# Use dummy data to find the output shape of the final conv layer
		x = torch.randn(self.channel,self.imageSize,self.imageSize).view(-1,self.channel,self.imageSize,self.imageSize)
		self._to_linear = None
		self.convs(x)

		# 3 Dense layers (input, output and a hidden layer)
		self.fc1 = nn.Linear(self._to_linear, 512)
		self.fc2 = nn.Linear(512, 256)
		self.fc3 = nn.Linear(256, 2)

	def convs(self, x):
		# Convolution --> Batch norm --> Activation func --> Pooling
		x = F.max_pool2d(F.relu(self.bn1(self.conv1(x))), (2,2))
		x = F.max_pool2d(F.relu(self.bn2(self.conv2(x))), (2,2))
		x = F.max_pool2d(F.relu(self.bn3(self.conv3(x))), (2,2))
		x = F.max_pool2d(F.relu(self.bn4(self.conv4(x))), (2,2))

		if self._to_linear is None: # Determine the number of output neurons of the last convolutional layer. 
			self._to_linear = x[0].shape[0]*x[0].shape[1]*x[0].shape[2] # This will be the input to the first fully connected layer
			print("Final conv layer output is: ", x.shape)
		return x

	def forward(self,x):
		x = self.convs(x)
		x = x.view(-1, self._to_linear) # Flatten the convolutional layer output before feeding it in the dense layer
		# Apply the activation function and feed the data in the dense layers
		x = F.relu(self.fc1(x))
		x = F.relu(self.fc2(x))
		x = F.softmax(self.fc3(x), dim=1)
		return x


def Training():
	device = torch.device("cuda:0")
	CNNModel = Model(channel=3, imageSize=50).to(device)
	print(CNNModel)
	optimizer = optim.Adam(CNNModel.parameters(), lr=0.001)
	lossFunction = nn.MSELoss()

	# Load the training and validation images/labels
	trainDataX = torch.load('C:\\Users\\louis\\OneDrive\\Desktop\\NN\\TrainingImages.pt')
	trainDataY = torch.load('C:\\Users\\louis\\OneDrive\\Desktop\\NN\\TrainingLabels.pt')
	testDataX = torch.load('C:\\Users\\louis\\OneDrive\\Desktop\\NN\\TestingImages.pt')
	testDataY = torch.load('C:\\Users\\louis\\OneDrive\\Desktop\\NN\\TestingLabels.pt')

	batchSize = 128
	epochs = 50
	epoch_loss = np.zeros((epochs+1,1)) # Used to track total loss for each epoch
	epoch_acc = np.zeros((epochs+1,1)) # Used to track accuracy for each epoch

	for epoch in tqdm(range(epochs)):
		batch_loss = np.zeros((int(len(trainDataX))+1,1)) # Used to store the loss for each batch 
		for i in range(0, len(trainDataX), batchSize):
			batchX = trainDataX[i:i+batchSize]
			batchY = trainDataY[i:i+batchSize]
			CNNModel.zero_grad()
			output = CNNModel(batchX.to(device))
			loss = lossFunction(output, batchY.to(device))
			loss.backward()
			optimizer.step()
			batch_loss[i,:] = float(loss) # Store the loss for this batch
		epoch_loss[epoch+1,:] = np.sum(batch_loss) # Store the total loss for this epoch
		epoch_acc[epoch+1,:] = Testing(testDataX, testDataY, device, CNNModel) # Store the accuracy for this epoch

	# Plot the training loss and accuracy
	ceFig, ceAxes = plt.subplots()  
	ceAxes.set_title("Error")  
	ceAxes.grid(True, which='both') 
	ceAxes.plot(np.arange(1,epochs+1),epoch_loss[1:epochs+1,0]) 
	ceAxes.set_xlabel('Epochs')  
	ceAxes.set_ylabel('Error')
	accFig, accAxes = plt.subplots()  
	accAxes.set_title("Accuracy")  
	accAxes.grid(True, which='both') 
	accAxes.plot(np.arange(1,epochs+1),epoch_acc[1:epochs+1,0]) 
	accAxes.set_xlabel('Epochs')  
	accAxes.set_ylabel('Accuracy')
	plt.show()

def Testing(testDataX, testDataY, device, CNNModel):
	correct = 0
	total = 0
	with torch.no_grad():
		for i in range(len(testDataX)):
			realClass = torch.argmax(testDataY[i]).to(device)
			netOut = CNNModel(testDataX[i].view(-1,3,50,50).to(device))
			predictedClass = torch.argmax(netOut)
			if predictedClass == realClass:
				correct +=1
			total += 1
		return correct/total

image1277×556 50.3 KB