I have updated my code based on another example i found online:
class CustomDatasetFromImages(Dataset):
    def __init__(self, csv_path):
        """
        Args:
            csv_path (string): path to csv file
            img_path (string): path to the folder where images are
            transform: pytorch transforms for transforms and tensor conversion
        """
        # Transforms
        self.to_tensor = transforms.ToTensor()
        # Read the csv file
        self.data_info = pd.read_csv(csv_path)
        # First column contains the image paths
        self.image_arr = np.asarray(self.data_info.iloc[:, 0])
        # Column is the labels
        self.label_arr = np.asarray(self.data_info.iloc[:, 18])
        # Calculate len
        self.data_len = len(self.data_info.index)

    def __getitem__(self, index):
        # Get image name from the pandas df
        single_image_name = self.image_arr[index]
        # Open image
        img_as_img = Image.open(single_image_name)
        # Transform image to tensor
        img_as_tensor = self.to_tensor(img_as_img)
        # Get label(class) of the image based on the cropped pandas column
        single_image_label = self.label_arr[index]

        return (img_as_tensor, single_image_label)

    def __len__(self):
        return self.data_len

if __name__ == "__main__":
    # Call dataset
    custom_mnist_from_images =  \
        CustomDatasetFromImages('annotations.csv')

    # Define data loader
    mn_dataset_loader = torch.utils.data.DataLoader(dataset=custom_mnist_from_images,
                                                    batch_size=4,
                                                    shuffle=False)


This is providing me the output i was expecting from the dataloader. However, I am not getting the expected results when i run it through my CNN network.
import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 125 * 157, 157) 
        #print(self.fc1) 
        self.fc2 = nn.Linear(157, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        #print(x.size()) 
        x = self.pool(F.relu(self.conv1(x)))
        #print(x.size()) 
        x = self.pool(F.relu(self.conv2(x)))
        #print(x.size())
        x = x.view(x.size(0), -1)
        print(x.size()) # torch.Size([50240, 400])
        x = F.relu(self.fc1(x))
        print(x.size()) # torch.Size([50240, 120])
        x = F.relu(self.fc2(x))
        print(x.size()) # torch.Size([50240, 84])
        x = self.fc3(x) 
        #print(x.size()) # torch.Size([50240, 10])
        return x


net = Net()

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

for epoch in range(2):

    running_loss = 0.0
    for i, data in enumerate(mn_dataset_loader, 0):
        images, labels = data
        #print(images.shape, labels.shape)
        images = Variable(images)
        labels = Variable(labels)
        # Clear gradients
        optimizer.zero_grad()
        #print(images.shape, labels.shape)
        # Forward pass
        outputs = net(images)
        # Calculate loss
        loss = criterion(outputs, labels)
        # Backward pass
        loss.backward()
        #print(loss)
        # Update weights
        optimizer.step()
        
        running_loss += loss.item()
        if i % 1000 == 999:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0
            
print('Finished Training')

The result i am getting is:
Finished Training

But i was expecting something like this (based on the ‘Training a Classifier’ PyTorch tutorial):
[1,  2000] loss: 2.216
[1,  4000] loss: 1.904
[1,  6000] loss: 1.675
[1,  8000] loss: 1.573
[1, 10000] loss: 1.529
[1, 12000] loss: 1.461
[2,  2000] loss: 1.408
[2,  4000] loss: 1.383
[2,  6000] loss: 1.355
[2,  8000] loss: 1.323
[2, 10000] loss: 1.289
[2, 12000] loss: 1.292
Finished Training

Again any advice would be greatly appreciated.