I hit a wall a few months ago in my development and was wondering if anyone could figure out why. Essentially any model I train ends up predicting the same class almost every time. Dataset seems to not matter, as I’ve tried it now on a few different datasets of various class sizes including the Mnist dataset. Predictions will vary from each test run, so for example, testing a batch of four images might return “2” four times, and then running it again on another four images may return “8” four times.
I’ve tried a lot of things, I think it’s a bug in my code somewhere but haven’t been able to figure out what. Possibly one lead could be that the issues started happening when I migrated to a Windows environment from Ubuntu. But upon going back the issue still persists on Linux. Another idea could be the dimensions of my network or the hyper-parameters but I have not had much luck with changing things around.
Here’s some code, largely from my Uni’s AI club as I’ve tried starting back from square one but still haven’t been able to overcome this issue.
from pathlib import Path
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.image as img
from PIL import Image
from PIL import ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True
# PyTorch imports
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.utils
from torch.utils.data import DataLoader, Dataset
from torch import optim
from torchvision.datasets import ImageFolder
from torchvision.models import resnet18
from torchvision import transforms
from torchsummary import summary
import time
import glob
import os
DATA_DIR = Path('data')
input_size = (28, 28)
batch_size = 8
num_workers = 4
if __name__ == '__main__':
data_transforms = {
'Train': transforms.Compose([transforms.Resize(input_size),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5])
]),
'Validation': transforms.Compose([transforms.Resize(input_size),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5])
]),
'Test': transforms.Compose([transforms.Resize(input_size),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5])
])
}
image_datasets = {x: ImageFolder(os.path.join(DATA_DIR, x),data_transforms[x])
for x in ['Train', 'Validation']}
# dataset class to load images with no labels, for our testing set to submit to the competition
class ImageLoader(Dataset):
def __init__(self, root, transform=None):
# get image file paths
self.images = sorted(glob.glob(os.path.join(root, "*")), key=self.glob_format)
self.transform = transform
def __len__(self):
return len(self.images)
def __getitem__(self, idx):
img = Image.open(self.images[idx]).convert('RGB')
if self.transform is not None:
img = self.transform(img)
return img
else:
return transforms.ToTensor(img)
@staticmethod
def glob_format(key):
#key = os.path.basename(key)
key = ''.join(c for c in key if c.isdigit())
#key = key.split("\\")[-1].split(".")[0]
return "{:04d}".format(int(key))
image_datasets['Test'] = ImageLoader(str(DATA_DIR / "Test"), transform=data_transforms["Test"])
dataloaders = {x: DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True, num_workers = num_workers)
for x in ['Train', 'Validation']}
test_loader = DataLoader(dataset = image_datasets['Test'], batch_size = 1, shuffle=True)
classes = image_datasets['Train'].classes
print(classes)
dataset_sizes = {x: len(image_datasets[x]) for x in ['Train', 'Validation', 'Test']}
print('Train Length: {} | Valid Length: {} | Test Length: {} '.format(dataset_sizes['Train'], dataset_sizes['Validation'], dataset_sizes['Test']))
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
device
def get_padding(input_dim, output_dim, kernel_size, stride):
#Calculates padding necessary to create a certain output size,
#given a input size, kernel size and stride
padding = (((output_dim - 1) * stride) - input_dim + kernel_size) // 2
if padding < 0:
return 0
else:
return padding
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
#nn.Sequential() is simply a container that groups layers into one object
#Pass layers into it separated by commas
self.block1 = nn.Sequential(
# The first convolutional layer. Think about how many channels the input starts off with
# Let's have this first layer extract 32 features
nn.Conv2d(3, 32, 3, 1, 1),
# Don't forget to apply a non-linearity
nn.ReLU())
self.block2 = nn.Sequential(
# The second convolutional layer. How many channels does it receive, given the number of features extracted by the first layer?
# Have this layer extract 64 features
nn.Conv2d(32, 64, 3, 1, 1),
# Non linearity
nn.ReLU(),
# Lets introduce a Batch Normalization layer
nn.BatchNorm2d(64),
# Downsample the input with Max Pooling
nn.MaxPool2d(2, 2, 0)
)
#Mimic the second block here, except have this block extract 128 features
self.block3 = nn.Sequential(
nn.Conv2d(64, 128, 3, 1, 1),
nn.ReLU(),
nn.BatchNorm2d(128),
nn.MaxPool2d(2, 2, 0)
)
# Applying a global pooling layer
# Turns the 128 channel rank 4 tensor into a rank 2 tensor of size 32 x 128 (32 128-length arrays, one for each of the inputs in a batch)
self.global_pool = nn.AdaptiveAvgPool2d(1)
self.fc1 = nn.Linear(128, 512)
self.drop_out = nn.Dropout(0.5)
self.fc2 = nn.Linear(512, len(classes))
#Feed the input through each of the layers we defined
def forward(self, x):
# Input size changes from (32 x 3 x 224 x 224) to (32 x 32 x 224 x 224)
x = self.block1(x)
# Size changes from (32 x 32 x 224 x 224) to (32 x 64 x 112 x 112) after max pooling
x = self.block2(x)
# Size changes from (32 x 64 x 112 x 112) to (32 x 128 x 56 x 56) after max pooling
x = self.block3(x)
# Reshapes the input from (32 x 128 x 56 x 56) to (32 x 128)
x = self.global_pool(x)
x = x.view(x.size(0), -1)
# Fully connected layer, size changes from (32 x 128) to (32 x 512)
x = self.fc1(x)
x = self.drop_out(x)
# Size change from (32 x 512) to (32 x 133) to create prediction arrays for each of the images in the batch
x = self.fc2(x)
return x
model = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr = 0.0001)
#optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
epochs = 10
model.to(device)
summary(model, (3,28, 28))
def run_epoch(epoch, model, criterion, optimizer, dataloaders, device, phase):
running_loss = 0.0
running_corrects = 0
if phase == 'Train':
model.train()
else:
model.eval()
#Looping through batches
for i, (inputs, labels) in enumerate(dataloaders[phase]):
# ensures we're doing this calculation on our GPU if possible
inputs = inputs.to(device)
labels = labels.to(device)
# Zero parameter gradients
optimizer.zero_grad()
# Calculate gradients only if we're in the training phase
with torch.set_grad_enabled(phase == 'Train'):
# This calls the forward() function on a batch of inputs
outputs = model(inputs)
# Calculate the loss of the batch
loss = criterion(outputs, labels)
# Gets the predictions of the inputs (highest value in the array)
_, preds = torch.max(outputs, 1)
# Adjust weights through backpropagation if we're in training phase
if phase == 'Train':
loss.backward()
optimizer.step()
# Document statistics for the batch
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
# Calculate epoch statistics
epoch_loss = running_loss / image_datasets[phase].__len__()
epoch_acc = running_corrects.double() / image_datasets[phase].__len__()
return epoch_loss, epoch_acc
def train(model, criterion, optimizer, num_epochs, dataloaders, device):
start = time.time()
best_model_wts = model.state_dict()
best_acc = 0.0
print('| Epoch\t | Train Loss\t| Train Acc\t| Valid Loss\t| Valid Acc\t| Epoch Time |')
print('-' * 86)
# Iterate through epochs
for epoch in range(num_epochs):
epoch_start = time.time()
# Training phase
train_loss, train_acc = run_epoch(epoch, model, criterion, optimizer, dataloaders, device, 'Train')
# Validation phase
val_loss, val_acc = run_epoch(epoch, model, criterion, optimizer, dataloaders, device, 'Validation')
epoch_time = time.time() - epoch_start
# Print statistics after the validation phase
print("| {}\t | {:.4f}\t| {:.4f}\t| {:.4f}\t| {:.4f}\t| {:.0f}m {:.0f}s |"
.format(epoch + 1, train_loss, train_acc, val_loss, val_acc, epoch_time // 60, epoch_time % 60))
# Copy and save the model's weights if it has the best accuracy thus far
if val_acc > best_acc:
best_acc = val_acc
best_model_wts = model.state_dict()
total_time = time.time() - start
print('-' * 74)
print('Training complete in {:.0f}m {:.0f}s'.format(total_time // 60, total_time % 60))
print('Best validation accuracy: {:.4f}'.format(best_acc))
# load best model weights and return them
model.load_state_dict(best_model_wts)
return model
def test_model(model, num_images):
was_training = model.training
model.eval()
images_so_far = 0
fig = plt.figure(num_images, (10, 10))
with torch.no_grad():
for i, (images, labels) in enumerate(dataloaders['Validation']):
#for i, (images in enumerate(dataloaders['Validation']):
images = images.to(device)
labels = labels.to(device)
outputs = model(images)
# pylint: disable=E1101
_, preds = torch.max(outputs, 1)
# pylint: enable=E1101
for j in range(images.size()[0]):
images_so_far += 1
ax = plt.subplot(num_images//2, 2, images_so_far)
ax.axis('off')
ax.set_title('Actual: ??? \n Prediction: {}'.format(classes[preds[j]]))
#ax.set_title('Actual: {} \n Prediction: {}'.format(gauge_ranges[labels[j]], gauge_ranges[preds[j]]))
#print('Actual: {} , Prediction: {} '.format(gauge_ranges[labels[j]], gauge_ranges[preds[j]]))
#plt.title('Actual: ??? \n Prediction: {}'.format(classes[preds[j]]))
print('Actual: ??? , Prediction: {} '.format(classes[preds[j]]))
image = images.cpu().data[j].numpy().transpose((1, 2, 0))
mean = np.array([0.5, 0.5, 0.5])
std = np.array([0.5, 0.5, 0.5])
image = std * image + mean
image = np.clip(image, 0, 1)
#plt.imshow(image, aspect='equal')
plt.imshow(image)
#plt.axis('on')
#plt.show()
if images_so_far == num_images:
model.train(mode=was_training)
return
model.train(mode=was_training)
test_model(model, 4)
#model = train(model, criterion, optimizer, epochs, dataloaders, device)