The Applications and Benefits of a PreTrained Model –– Kaggle’s DogsVSCats

Kevin Ku on Unsplash

For image recognition tasks, using pre-trained models are great. For one, they are easier to use as they give you the architecture for “free.” Additionally, they typically have better results and typically require need less training.

To see a real application of this theory, I will be using Kaggle’s CatVSDogs dataset in an attempt to discuss the results of using the different methods.

The steps will be as follows:

1) Imports
2) Download and Unzip Files
3) Organize the Files
4) Set-up and Train Classic CNN Model 
5) Test the CNN Model
6) Set-up and Train Pre-Trained Model
7) Test the Pre-Trained Model

1. Imports

In any machine learning project, imports are necessary. For this project, there are a variety of imports that are required.

import warnings
warnings.filterwarnings("ignore", category=UserWarning, module="torch.nn.functional") 
from google.colab import drive
drive.mount('/content/gdrive')  # connects to data stored on google drive
import os
os.chdir('/content/gdrive/My Drive/')
import shutil
import re
import torch
import torchvision
from torchvision import transforms
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from google.colab import files
import zipfile

While most of these imports won’t be used until later, it is best to import them all now. These imports tend to be of two groups: those for PyTorch and others needed for google collab.

Google Colab offers a free GPU to everyone, so it is great to use, especially for beginners. Use the code below to check that you are using the GPU. If it does not print cuda, turn on your GPU!

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") 
print(device)

PyTorch, similarly, tends to be skewed for beginners as it has an easier interface. However, it still gets the job done for any machine learning task!

2. Download and Unzip Files

The data will be pulled directly from Kaggle, which is an open-source machine learning website. The files can be reached here. Press on Download All. Then, drag the zip file into your Drive and place it in any location desired.

Do not unzip directly from Google Drie or through your computer. This will take an extensive amount of time. Thus, it is in your best interest to program a way to unzip the files and organize them in Google Drive.

Before unzipping, create a DogsVS Cats folder.

os.mkdir('/content/gdrive/My Drive/DogsVSCats')

Here, I will be storing the unzipped data.

To unzip, run the following.

with zipfile.ZipFile('/content/gdrive/My Drive/dogs-vs-cats.zip') as zf:
zf.extractall('/content/gdrive/My Drive/DogsVSCats')

This will extract the dogs-vs-cats zip and place it in the new folder. After this, we need to unzip the test1.zip and train.zip files. You can delete the sample submission.csv file; we will not need it for this tutorial.

To unzip the train.zip file, run the following:

with zipfile.ZipFile('/content/gdrive/My Drive/DogsVSCats/train.zip') as zf:
zf.extractall('/content/gdrive/My Drive/DogsVSCats/')

To unzip the test1.zip file, run the following:

with zipfile.ZipFile('/content/gdrive/My Drive/DogsVSCats/test1.zip') as zf:
zf.extractall('/content/gdrive/My Drive/DogsVSCats/')

It might take some time, but all the files should be in their appropriate folders after that.

3. Organize the Files

Once all the files are unzipped, it is crucial to organize them based on their true classification. For this dataset, we will organize the files into “dog” and “cat” folders.

Make the needed folders.

os.mkdir('/content/gdrive/My Drive/DogsVSCats/train/cat')
os.mkdir('/content/gdrive/My Drive/DogsVSCats/train/dog')

Set-up the classifications.

train_dr= '/content/gdrive/My Drive/DogsVSCats/train/'
train_dog_dir = '/content/gdrive/My Drive/DogsVSCats/train/dog'
train_cat_dir = '/content/gdrive/My Drive/DogsVSCats/train/cat'

files = os.listdir('/content/gdrive/My Drive/DogsVSCats/train')

Then, organize.

train = os.listdir("/content/gdrive/My Drive/DogsVSCats/train")
for f in files:
   catSearchObj = re.search("cat", f)
   dogSearchObj = re.search("dog", f)
   if catSearchObj:
      shutil.move(f'{train_dr}/{f}', train_cat_dir)
      print("moved!-cat")
   elif dogSearchObj:
      shutil.move(f'{train_dr}/{f}', train_dog_dir)
      print("moved!-dog")

You don’t really have to add the print statements, but it is cool to see the movement!

Next, we need to move some of the training data into a validation dataset.

os.mkdir('/content/gdrive/My Drive/DogsVSCats/val/cat')
os.mkdir('/content/gdrive/My Drive/DogsVSCats/val/dog')

val_dog_dir = '/content/gdrive/My Drive/DogsVSCats/val/dog'
val_cat_dir = '/content/gdrive/My Drive/DogsVSCats/val/cat'

Relocate 1,000 files from the train dog folder and send them to the validation folder.

files = os.listdir(train_dog_dir)
for f in files:
   valDogSearch = re.search("5\d\d\d", f)
   if valDogSearch:
        shutil.move(f'{train_dog_dir}/{f}', val_dog_dir)
!ls {val_dog_dir} | head -n 5

Now, do the same for the cat trained folder.

files = os.listdir(train_cat_dir)
for f in files:
   valCatSearch = re.search("5\d\d\d", f)
   if valCatSearch:
       shutil.move(f'{train_cat_dir}/{f}', val_cat_dir)
!ls {val_cat_dir} | head -n 5

The last step for this part would be to transform the data so that it would be easier to train and scan.

transforms = torchvision.transforms.Compose([torchvision.transforms.Resize((224,224)),
torchvision.transforms.ToTensor()])train_image_folder = torchvision.datasets.ImageFolder('/content/gdrive/My Drive/DogsVSCats/train/', transform=transforms)
train_loader = torch.utils.data.DataLoader(train_image_folder, batch_size=64, shuffle=True, num_workers=4)
val_image_folder = torchvision.datasets.ImageFolder('/content/gdrive/My Drive/DogsVSCats/val/', transform=transforms)
val_loader = torch.utils.data.DataLoader(val_image_folder, batch_size=64, shuffle=True, num_workers=4)

4. Set up and Train Classic CNN Model

Now, we reached the actual training part! In this variation, we will be using a classic CNN model.

The model is as follows:

class DogDetector(nn.Module):
   def __init__(self):
      super().__init__()
      self.cnn_layers = nn.Sequential(
         nn.Conv2d(3, 6, kernel_size=3, stride=1, padding=1),
         nn.ReLU(inplace=True),
         nn.MaxPool2d(kernel_size=2, stride=2),
         nn.Conv2d(6, 12, kernel_size=3, stride=1, padding=1),
         nn.ReLU(inplace=True),
         nn.MaxPool2d(kernel_size=2, stride=2), 
      
      )
      
      self.linear_layers = nn.Sequential(
         nn.Linear(256*7*7*3, 196),
         nn.Linear(196, 1),
         nn.Sigmoid(),
      )
   
  def forward(self, x):
     x = self.cnn_layers(x)
     x = x.view(x.size(0), -1)
     x = self.linear_layers(x)
     return x
dog_detector = DogDetector()
dog_detector.cuda()

Now, set the dog_detector to the class and put it on the GPU.

Training the model is a simple procedure. Because we are using the Kaggle files just for testing and not for the direct competition, we do not need the test files. Instead, we can train based on the validation set without the hassle of submitting to Kaggle.

optimizer = optim.Adam(dog_detector.parameters(), lr = 0.0001)
loss_func = nn.BCELoss().cuda()
EPOCHS = 5
for epoch in range(EPOCHS):
   print(f"epoch: {epoch}")
   for i, data in enumerate(train_loader):
      if i % 50 == 0:
         print(f"  batch: {i}")
         X, y = data
         y = y.type(torch.FloatTensor).view(len(y), -1).cuda()
         dog_detector.zero_grad()
         output = dog_detector(X.view(-1, 3, 224, 224).cuda())
         loss_val = loss_func(output, y)
         loss_val.backward()
         optimizer.step()
    print(f"loss: {loss_val}")

The loss values tend to hover around approximately 0.4 — 0.6.

5. Test the CNN Model

Because we are testing based without Kaggle, we need to check the accuracy ourselves, which gives us more direct results. This can be done with the following:

correct = 0
total = 0
with torch.no_grad():
   for data in val_loader:
   X, y = data 
   output = dog_detector(X.view(-1, 3, 224, 224).cuda())
   correct_sum = output.round().transpose(0, 1).cpu() == y
   correct += correct_sum.sum().item()
   total += len(y)
print(f"Accuracy: {round(correct/total, 3)}")

When testing, the accuracy tends to hover over approximately 73.6%. This isn’t bad, but it is far from great.

6. Set up and Train Pre-Trained Model

The pre-trained model is much simpler to set up.

First, download the pre-trained model.

model_resnet18 =  torchvision.models.resnet18(pretrained=True)

new_lin = nn.Sequential(
   nn.Linear(512, 1),
   nn.Sigmoid()  
)
model_resnet18.fc = new_lin

Freeze the layers that are not needed for training.

for name, param in model_resnet18.named_parameters():
   if("bn" not in name):
      param.requires_grad = False

Then, send the model to the GPU.

model_resnet18.cuda()

That’s it! Now it is time to train again.

optimizer = optim.Adam(model_resnet18.parameters(), lr = 0.0001)
loss_func = nn.BCELoss().cuda()
EPOCHS = 5
for epoch in range(EPOCHS):
   print(f"epoch: {epoch}")
   for i, data in enumerate(train_loader):
      if i % 50 == 0:
      print(f"  batch: {i}")
      X, y = data
      y = y.type(torch.FloatTensor).view(len(y), -1).cuda()
      model_resnet18.zero_grad()
      output = model_resnet18(X.view(-1, 3, 224, 224).cuda())
      loss_val = loss_func(output, y)
      loss_val.backward() 
optimizer.step()
print(f"loss: {loss_val}")

The loss ranges between 0.2–0.4, which is significantly better than the CNN model.

7. Test the Pre-Trained Model

correct = 0
total = 0
with torch.no_grad():
   for data in val_loader:
      X, y = data
      output = model_resnet18(X.view(-1, 3, 224, 224).cuda())
      correct_sum = output.round().transpose(0, 1).cpu() == y
      correct += correct_sum.sum().item()
      total += len(y)
print(f"Accuracy: {round(correct/total, 3)}")

Testing the model gives an approximate accuracy of 97.3%, which is significantly better than the CNN model.

To conclude, the results of this test are apparent; using a pre-trained model for many image recognition tasks is beneficial for several reasons. The first reason is the fact that using a pre-trained model requires less training and requires less effort in building the model’s architecture. Instead, the definition of the model is given for “free.” Another positive is the accuracy. Using a pre-trained model is significantly more accurate than using a custom-built convolutionary neural network (CNN). Thus, it would make sense to start with a pre-trained model when doing image recognition tasks, as it is almost always the best course of action.