Search⌘ K
Home/
Courses/
Hands-On Generative Adversarial Networks with PyTorch

Generative Adversarial Examples: Working with Classifier

Practice generating adversarial examples and breaking some models using cats vs. dogs dataset.

We'll cover the following...

Let's try generating adversarial examples with GANs and break some models.

Preparing an ensemble classifier for Kaggle’s cats vs. dogs

⚠️ The dataset is intended only for non-commercial research and educational use.

To make our demonstration more similar to practical scenarios, we will train a decent model on Kaggle’s cats vs. dogs datasethttps://www.kaggle.com/c/dogs-vs-cats, then break the model with adversarial examples generated by GAN. This dataset contains 25,000 training images and 12,500 testing images of either dogs or cats. Here, we will only use the 25,000 training images in our experiment.

For convenience, after downloading the dataset, put images of cats and dogs in separate folders so that the file structure looks like this: 

/cats-dogs-kaggle
       /cat
           /cat.0.jpg
           /cat.1.jpg
           ...
       /dog
           /dog.0.jpg
           /dog.1.jpg
           ...
Dataset file structure

The model we are training on this dataset is formed of several pre-trained models provided by PyTorch Hubhttps://github.com/pytorch/hub. We will also need to perform transfer training on the pre-trained models to fit our dataset:

Ensemble model for Kaggle's cats vs. dogs
Ensemble model for Kaggle's cats vs. dogs

Now, we need to load and preprocess the data, create an ensemble classifier, and train this model. Here are the detailed steps:

  1. Create a Python file named cats_dogs.py and import the Python modules:

Python 3.10.4
import argparse
import os
import random
import sys
import matplotlib.pyplot as plt
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
import torch.utils.data
import torchvision
import torchvision.datasets as dset
import torchvision.utils as vutils
import utils
from advGAN import AdvGAN_Attack
from data_utils import data_prefetcher, _transforms_catsdogs
from model_ensemble import transfer_init, ModelEnsemble

Here, the custom module files, advGAN, data_utils, and model_ensemble, are discussed below.

  1. Define the main entry point in cats_dogs.py, in which argument values are parsed and the image decoding backend is defined:

Python 3.10.4
if __name__ == '__main__':
    from utils import boolean_string
    legal_models = ['resnet18', 'resnet34', 'mobilenet_v2', 'shufflenet_v2_x1_0', 'squeezenet1_1', 'densenet121', 'googlenet', 'resnext50_32x4d', 'vgg11']
    parser = argparse.ArgumentParser(description='Hands-On GANs - Chapter 8')
    parser.add_argument('--model', type=str, default='resnet18', help='one of {}'.format(legal_models))
    parser.add_argument('--cuda', type=boolean_string, default=True, help='enable CUDA.')
    parser.add_argument('--train_single', type=boolean_string, default=True, help='train single model.')
    parser.add_argument('--train_ensemble', type=boolean_string, default=True, help='train final model.')
    parser.add_argument('--model_dir', type=str, default='models', help='directory for trained models')
    parser.add_argument('--data_dir', type=str, default='/media/john/FastData/cats-dogs-kaggle/train', help='Directory for dataset.')
    parser.add_argument('--data_split', type=float, default=0.8, help='split ratio for train and val data')
    parser.add_argument('--cutout', type=boolean_string, default=False, help='use cutout')
    parser.add_argument('--cutout_length', type=int, default=64, help='number of epochs')
    parser.add_argument('--out_dir', type=str, default='output', help='Directory for output.')
    parser.add_argument('--epochs', type=int, default=60, help='number of epochs')
    parser.add_argument('--batch_size', type=int, default=128, help='size of batches')
    parser.add_argument('--lr', type=float, default=0.01, help='learning rate')
    parser.add_argument('--classes', type=int, default=2, help='number of classes')
    parser.add_argument('--img_size', type=int, default=224, help='size of images')
    parser.add_argument('--channels', type=int, default=3, help='number of image channels')
    parser.add_argument('--log_interval', type=int, default=50, help='interval between logging and image sampling')
    parser.add_argument('--pretrained_epoch', type=int, default=60, help='epoch number of pretrained generator')
    parser.add_argument('--seed', type=int, default=1, help='random seed')
    FLAGS = parser.parse_args()
    FLAGS.cuda = FLAGS.cuda and torch.cuda.is_available()
    assert FLAGS.model in legal_models
    if FLAGS.seed is not None:
        torch.manual_seed(FLAGS.seed)
        if FLAGS.cuda:
            torch.cuda.manual_seed(FLAGS.seed)
        np.random.seed(FLAGS.seed)
    cudnn.benchmark = True
    try:
        import accimage
        torchvision.set_image_backend('accimage')
        print('Image loader backend: accimage')
    except:
        print('Image loader backend: PIL')
    if FLAGS.train_single:
        utils.clear_folder(FLAGS.out_dir)
    log_file = os.path.join(FLAGS.out_dir, 'log.txt')
    print("Logging to {}\n".format(log_file))
    sys.stdout = utils.StdOut(log_file)
    print("PyTorch version: {}".format(torch.__version__))
    print("CUDA version: {}\n".format(torch.version.cuda))
    print(" " * 9 + "Args" + " " * 9 + "|    " + "Type" + \
          "    |    " + "Value")
    print("-" * 50)
    for arg in vars(FLAGS):
        arg_str = str(arg)
        var_str = str(getattr(FLAGS, arg))
        type_str = str(type(getattr(FLAGS, arg)).__name__)
        print("  " + arg_str + " " * (20-len(arg_str)) + "|" + \
              "  " + type_str + " " * (10-len(type_str)) + "|" + \
              "  " + var_str)
    main()
...