transfer.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function, division\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.optim import lr_scheduler\n",
    "from torch.autograd import Variable\n",
    "import numpy as np\n",
    "import torchvision\n",
    "from torchvision import datasets, models, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import os\n",
    "import copy\n",
    "import numpy as np\n",
    "from torch.utils.data.sampler import SubsetRandomSampler\n",
    "\n",
    "plt.ion()   # interactive mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_train_valid_loader(data_dir,\n",
    "                           batch_size,\n",
    "                           augment,\n",
    "                           random_seed,\n",
    "                           valid_size=0.1,\n",
    "                           shuffle=True,\n",
    "                           show_sample=False,\n",
    "                           num_workers=4,\n",
    "                           pin_memory=False):\n",
    "    \"\"\"\n",
    "    Utility function for loading and returning train and valid\n",
    "    multi-process iterators over the CIFAR-10 dataset. A sample\n",
    "    9x9 grid of the images can be optionally displayed.\n",
    "\n",
    "    If using CUDA, num_workers should be set to 1 and pin_memory to True.\n",
    "\n",
    "    Params\n",
    "    ------\n",
    "    - data_dir: path directory to the dataset.\n",
    "    - batch_size: how many samples per batch to load.\n",
    "    - augment: whether to apply the data augmentation scheme\n",
    "      mentioned in the paper. Only applied on the train split.\n",
    "    - random_seed: fix seed for reproducibility.\n",
    "    - valid_size: percentage split of the training set used for\n",
    "      the validation set. Should be a float in the range [0, 1].\n",
    "    - shuffle: whether to shuffle the train/validation indices.\n",
    "    - show_sample: plot 9x9 sample grid of the dataset.\n",
    "    - num_workers: number of subprocesses to use when loading the dataset.\n",
    "    - pin_memory: whether to copy tensors into CUDA pinned memory. Set it to\n",
    "      True if using GPU.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    - train_loader: training set iterator.\n",
    "    - valid_loader: validation set iterator.\n",
    "    \"\"\"\n",
    "    error_msg = \"[!] valid_size should be in the range [0, 1].\"\n",
    "    assert ((valid_size >= 0) and (valid_size <= 1)), error_msg\n",
    "\n",
    "    normalize = transforms.Normalize(\n",
    "        mean=[0.485, 0.456, 0.406],\n",
    "        std=[0.229, 0.224, 0.225],\n",
    "    )\n",
    "\n",
    "    # define transforms\n",
    "    valid_transform = transforms.Compose([\n",
    "        transforms.Resize((256,256)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ])\n",
    "    if augment:\n",
    "        train_transform = transforms.Compose([\n",
    "        transforms.RandomSizedCrop(224),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "        ])\n",
    "    else:\n",
    "        train_transform = transforms.Compose([\n",
    "        transforms.Resize((256,256)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "        ])\n",
    "\n",
    "    # load the dataset\n",
    "    train_dataset = datasets.ImageFolder(root=data_dir, transform=train_transform)\n",
    "#     train_dataset = datasets.CIFAR10(\n",
    "#         root=data_dir, train=True,\n",
    "#         download=True, transform=train_transform,\n",
    "#     )\n",
    "    classes = train_dataset.classes\n",
    "    valid_dataset = datasets.ImageFolder(root=data_dir, transform=valid_transform)\n",
    "#     valid_dataset = datasets.CIFAR10(\n",
    "#         root=data_dir, train=True,\n",
    "#         download=True, transform=valid_transform,\n",
    "#     )\n",
    "\n",
    "    num_train = len(train_dataset)\n",
    "    indices = list(range(num_train))\n",
    "    split = int(np.floor(valid_size * num_train))\n",
    "\n",
    "    if shuffle:\n",
    "        np.random.seed(random_seed)\n",
    "        np.random.shuffle(indices)\n",
    "\n",
    "    train_idx, valid_idx = indices[split:], indices[:split]\n",
    "    train_sampler = SubsetRandomSampler(train_idx)\n",
    "    valid_sampler = SubsetRandomSampler(valid_idx)\n",
    "    train_data_size = len(train_sampler)\n",
    "    valid_data_size = len(valid_sampler)\n",
    "    \n",
    "    train_loader = torch.utils.data.DataLoader(\n",
    "        train_dataset, batch_size=batch_size, sampler=train_sampler,\n",
    "        num_workers=num_workers, pin_memory=pin_memory,\n",
    "    )\n",
    "    valid_loader = torch.utils.data.DataLoader(\n",
    "        valid_dataset, batch_size=batch_size, sampler=valid_sampler,\n",
    "        num_workers=num_workers, pin_memory=pin_memory,\n",
    "    )\n",
    "    return train_loader, valid_loader, train_data_size, valid_data_size, classes\n",
    "\n",
    "def imshow(inp, title=None):\n",
    "    \"\"\"Imshow for Tensor.\"\"\"\n",
    "    inp = inp.numpy().transpose((1, 2, 0))\n",
    "    mean = np.array([0.485, 0.456, 0.406])\n",
    "    std = np.array([0.229, 0.224, 0.225])\n",
    "    inp = std * inp + mean\n",
    "    inp = np.clip(inp, 0, 1)\n",
    "    plt.imshow(inp)\n",
    "    if title is not None:\n",
    "        plt.title(title)\n",
    "    plt.pause(0.001)  # pause a bit so that plots are updated\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jayanth/.virtualenvs/torch/lib/python3.5/site-packages/torchvision/transforms/transforms.py:397: UserWarning: The use of the transforms.RandomSizedCrop transform is deprecated, please use transforms.RandomResizedCrop instead.\n",
      "  \"please use transforms.RandomResizedCrop instead.\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 13\n",
      "  3\n",
      "  9\n",
      " 25\n",
      " 33\n",
      "  8\n",
      "  3\n",
      " 35\n",
      "[torch.LongTensor of size 8]\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f29752285f8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get a batch of training data\n",
    "data_dir = 'GTSRB/Final_Training/Images/'\n",
    "\n",
    "train_loader, valid_loader, train_size, valid_size, classes = get_train_valid_loader(data_dir, \n",
    "                                                    batch_size=8,\n",
    "                                                    augment=True,\n",
    "                                                    random_seed=1,\n",
    "                                                    valid_size=0.1,\n",
    "                                                    shuffle=True,\n",
    "                                                    show_sample=False,\n",
    "                                                    num_workers=1,\n",
    "                                                    pin_memory=True)\n",
    "\n",
    "data_iter = iter(train_loader)\n",
    "images, labels = data_iter.next()\n",
    "print(labels)\n",
    "# Make a grid from batch\n",
    "out = torchvision.utils.make_grid(images)\n",
    "\n",
    "imshow(out, title=[classes[x] for x in labels])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, train_loader, valid_loader, train_size, valid_size,\n",
    "                criterion, optimizer, scheduler, num_epochs=25):\n",
    "    since = time.time()\n",
    "\n",
    "    best_model_wts = copy.deepcopy(model.state_dict())\n",
    "    best_acc = 0.0\n",
    "\n",
    "    for epoch in range(num_epochs):\n",
    "        print('Epoch {}/{}'.format(epoch, num_epochs - 1))\n",
    "        print('-' * 10)\n",
    "\n",
    "        # Each epoch has a training and validation phase\n",
    "        for phase in ['train', 'val']:\n",
    "            if phase == 'train':\n",
    "                scheduler.step()\n",
    "                model.train(True)  # Set model to training mode\n",
    "            else:\n",
    "                model.train(False)  # Set model to evaluate mode\n",
    "\n",
    "            running_loss = 0.0\n",
    "            running_corrects = 0\n",
    "\n",
    "            # Iterate over data.\n",
    "            if phase=='train':\n",
    "                dataloader = train_loader\n",
    "            else:\n",
    "                dataloader = valid_loader\n",
    "                \n",
    "            for data in dataloader:\n",
    "                # get the inputs\n",
    "                inputs, labels = data\n",
    "\n",
    "                # wrap them in Variable\n",
    "                if use_gpu:\n",
    "                    inputs = Variable(inputs.cuda())\n",
    "                    labels = Variable(labels.cuda())\n",
    "                else:\n",
    "                    inputs, labels = Variable(inputs), Variable(labels)\n",
    "\n",
    "                # zero the parameter gradients\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "                # forward\n",
    "                outputs = model(inputs)\n",
    "                _, preds = torch.max(outputs.data, 1)\n",
    "                loss = criterion(outputs, labels)\n",
    "\n",
    "                # backward + optimize only if in training phase\n",
    "                if phase == 'train':\n",
    "                    loss.backward()\n",
    "                    optimizer.step()\n",
    "\n",
    "                # statistics\n",
    "                running_loss += loss.data[0] * inputs.size(0)\n",
    "                running_corrects += torch.sum(preds == labels.data)\n",
    "\n",
    "            if phase=='train':    \n",
    "                epoch_loss = running_loss / train_size\n",
    "                epoch_acc = running_corrects / train_size\n",
    "            else:\n",
    "                epoch_loss = running_loss / valid_size\n",
    "                epoch_acc = running_corrects / valid_size\n",
    "\n",
    "                \n",
    "            print('{} Loss: {:.4f} Acc: {:.4f}'.format(\n",
    "                phase, epoch_loss, epoch_acc))\n",
    "\n",
    "            # deep copy the model\n",
    "            if phase == 'val' and epoch_acc > best_acc:\n",
    "                best_acc = epoch_acc\n",
    "                best_model_wts = copy.deepcopy(model.state_dict())\n",
    "\n",
    "        print()\n",
    "\n",
    "    time_elapsed = time.time() - since\n",
    "    print('Training complete in {:.0f}m {:.0f}s'.format(\n",
    "        time_elapsed // 60, time_elapsed % 60))\n",
    "    print('Best val Acc: {:4f}'.format(best_acc))\n",
    "\n",
    "    # load best model weights\n",
    "    model.load_state_dict(best_model_wts)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "use_gpu = torch.cuda.is_available()\n",
    "\n",
    "model_ft = models.resnet18(pretrained=True)\n",
    "num_ftrs = model_ft.fc.in_features\n",
    "model_ft.fc = nn.Linear(num_ftrs, len(classes))\n",
    "if use_gpu:\n",
    "    model_ft = model_ft.cuda()\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "# Observe that all parameters are being optimized\n",
    "optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# Decay LR by a factor of 0.1 every 7 epochs\n",
    "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_ft = train_model(model_ft, criterion, optimizer_ft, exp_lr_scheduler,\n",
    "                       num_epochs=25)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}