lr_test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "import logging\n",
    "import os\n",
    "import random\n",
    "import math\n",
    "\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data.sampler import SubsetRandomSampler\n",
    "\n",
    "import torchvision\n",
    "from torchvision import transforms\n",
    "\n",
    "from mylogger import create_logger\n",
    "from net.mobilenetv3 import MobileNetV3Large, MobileNetV3Small\n",
    "from trainer import ClassifierTrainer as Trainer\n",
    "import utils\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 1760\n",
    "NUM_WORKERS = 96\n",
    "EPOCHS = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device('cuda') if torch.cuda.is_available() else 'cpu'\n",
    "normalizer = transforms.Normalize(\n",
    "    mean=[0.485, 0.456, 0.406],\n",
    "    std=[0.229, 0.224, 0.225]\n",
    ")\n",
    "\n",
    "transform_train = transforms.Compose([\n",
    "    transforms.RandomResizedCrop(224, scale=(0.8, 1.0)),\n",
    "    transforms.RandomRotation(3),\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.ColorJitter(brightness=0.3,\n",
    "                           contrast=0.3,\n",
    "                           saturation=0.3,\n",
    "                           hue=0.1),\n",
    "    transforms.ToTensor(),\n",
    "    utils.Cutout(20),\n",
    "    normalizer\n",
    "])\n",
    "\n",
    "transform_valid = transforms.Compose([\n",
    "    transforms.Resize(256),\n",
    "    transforms.CenterCrop(224),\n",
    "    transforms.ToTensor(),\n",
    "    normalizer\n",
    "])\n",
    "\n",
    "train_val_dataset = torchvision.datasets.ImageFolder(\n",
    "    './data/imagenet/train', transform=transform_train\n",
    ")\n",
    "\n",
    "# Create validation dataset\n",
    "dataset_size = len(train_val_dataset)\n",
    "indices = list(range(dataset_size))\n",
    "random.shuffle(indices)\n",
    "\n",
    "train_indices = indices[50000:]\n",
    "valid_indices = indices[:50000]\n",
    "\n",
    "train_sampler = SubsetRandomSampler(train_indices)\n",
    "valid_sampler = SubsetRandomSampler(valid_indices)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_loader = DataLoader(\n",
    "    train_val_dataset, batch_size=BATCH_SIZE, sampler=valid_sampler, num_workers=NUM_WORKERS\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Credit: https://medium.com/coinmonks/training-neural-networks-upto-10x-faster-3246d84caacd\n",
    "def findLR(model, optimizer, criterion, trainloader, final_value=10, init_value=1e-8):\n",
    "    '''\n",
    "      findLR plots the graph for the optimum learning rates for the model with the \n",
    "      corresponding dataset.\n",
    "      The technique is quite simple. For one epoch,\n",
    "      1. Start with a very small learning rate (around 1e-8) and increase the learning rate linearly.\n",
    "      2. Plot the loss at each step of LR.\n",
    "      3. Stop the learning rate finder when loss stops going down and starts increasing.\n",
    "      \n",
    "      A graph is created with the x axis having learning rates and the y axis\n",
    "      having the losses.\n",
    "      \n",
    "      Arguments:\n",
    "      1. model -  (torch.nn.Module) The deep learning pytorch network.\n",
    "      2. optimizer: (torch.optim) The optimiser for the model eg: SGD,CrossEntropy etc\n",
    "      3. criterion: (torch.nn) The loss function that is used for the model.\n",
    "      4. trainloader: (torch.utils.data.DataLoader) The data loader that loads data in batches for input into model \n",
    "      5. final_value: (float) Final value of learning rate\n",
    "      6. init_value: (float) Starting learning rate.\n",
    "      \n",
    "      Returns:\n",
    "       Nothing\n",
    "       \n",
    "      Plots a matplotlib graph\n",
    "      \n",
    "    '''\n",
    "    model.train() # setup model for training configuration\n",
    "    \n",
    "    num = len(trainloader) - 1 # total number of batches\n",
    "    mult = (final_value / init_value) ** (1/num)\n",
    "    \n",
    "    losses = []\n",
    "    lrs = []\n",
    "    best_loss = 0.\n",
    "    avg_loss = 0.\n",
    "    beta = 0.98 # the value for smooth losses\n",
    "    lr = init_value\n",
    "    \n",
    "    for batch_num, (inputs, targets) in enumerate(trainloader):\n",
    "        \n",
    "        \n",
    "        optimizer.param_groups[0]['lr'] = lr\n",
    "        \n",
    "        batch_num += 1 # for non zero value\n",
    "        inputs, targets = inputs.to(device), targets.to(device) # convert to cuda for GPU usage\n",
    "        optimizer.zero_grad() # clear gradients\n",
    "        outputs = model(inputs) # forward pass\n",
    "        loss = criterion(outputs, targets) # compute loss\n",
    "       \n",
    "        #Compute the smoothed loss to create a clean graph\n",
    "        avg_loss = beta * avg_loss + (1-beta) *loss.item()\n",
    "        smoothed_loss = avg_loss / (1 - beta**batch_num)\n",
    "        \n",
    "        #Record the best loss\n",
    "        if smoothed_loss < best_loss or batch_num==1:\n",
    "            best_loss = smoothed_loss\n",
    "        \n",
    "        # append loss and learning rates for plotting\n",
    "        lrs.append(math.log10(lr))\n",
    "        losses.append(smoothed_loss)\n",
    "        \n",
    "        # Stop if the loss is exploding\n",
    "        if batch_num > 1 and smoothed_loss > 4 * best_loss:\n",
    "            break\n",
    "        \n",
    "        # backprop for next step\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        # update learning rate\n",
    "        lr = mult*lr\n",
    "        \n",
    "    plt.xlabel('Learning Rates')\n",
    "    plt.ylabel('Losses')\n",
    "    plt.plot(lrs,losses)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = MobileNetV3Large(n_classes=1000).to(device)\n",
    "if torch.cuda.device_count() > 1:\n",
    "    model = nn.DataParallel(model)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=1e-5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "findLR(model, optimizer, criterion, valid_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}