coarse_grained_classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.optim import lr_scheduler\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",
    "from torch.autograd import Variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im_size = 224"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = 'my_train'\n",
    "def load_split_train_test(datadir, valid_size = .05):\n",
    "    train_transforms = transforms.Compose([transforms.Resize([im_size,im_size]),\n",
    "                                       transforms.ToTensor(),\n",
    "                                       ])\n",
    "    test_transforms = transforms.Compose([transforms.Resize([im_size,im_size]),\n",
    "                                      transforms.ToTensor(),\n",
    "                                      ])\n",
    "    train_data = datasets.ImageFolder(datadir,       \n",
    "                    transform=train_transforms)\n",
    "    test_data = datasets.ImageFolder(datadir,\n",
    "                    transform=test_transforms)\n",
    "    num_train = len(train_data)\n",
    "    print(num_train)\n",
    "    indices = list(range(num_train))\n",
    "    split = int(np.floor(valid_size * num_train))\n",
    "    np.random.shuffle(indices)\n",
    "    from torch.utils.data.sampler import SubsetRandomSampler\n",
    "    train_idx, test_idx = indices[split:], indices[:split]\n",
    "    train_sampler = SubsetRandomSampler(train_idx)\n",
    "    test_sampler = SubsetRandomSampler(test_idx)\n",
    "    trainloader = torch.utils.data.DataLoader(train_data,\n",
    "                   sampler=train_sampler, batch_size=32)\n",
    "    testloader = torch.utils.data.DataLoader(test_data,\n",
    "                   sampler=test_sampler, batch_size=32)\n",
    "    return trainloader, testloader\n",
    "trainloader, testloader = load_split_train_test(data_dir, .05)\n",
    "# print(trainloader.dataset.)\n",
    "print(trainloader.dataset.classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() \n",
    "                                  else \"cpu\")\n",
    "# model = models.inception_v3(pretrained=True)\n",
    "model = models.vgg16(pretrained=True)\n",
    "# model = models.alexnet(pretrained=True)\n",
    "# model = models.resnet18(pretrained=True)\n",
    "# model = models.densenet121(pretrained=True)\n",
    "# model = models.resnet18(pretrained=True)\n",
    "model.eval()\n",
    "# print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # for inceptionv3\n",
    "# for param in model.parameters():\n",
    "#     param.requires_grad = False\n",
    "\n",
    "# # model.AuxLogits = None\n",
    "# # model.fc = nn.Linear(2048, 5)\n",
    "# model.aux_logits = False\n",
    "# model.fc = nn.Sequential(nn.Linear(2048, 5),\n",
    "#                                  nn.LogSoftmax(dim=1))\n",
    "# criterion = nn.NLLLoss()\n",
    "# optimizer = optim.Adam(model.fc.parameters(), lr=0.003)\n",
    "# model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#for VGG16\n",
    "# for param in model.parameters():\n",
    "#     param.requires_grad = False\n",
    "\n",
    "# x = []\n",
    "\n",
    "# count = -1\n",
    "# for i in model.features.children():\n",
    "#     count+=1\n",
    "#     if count in [12, 13, 14, 15]:\n",
    "#         continue\n",
    "#     x.append(i)\n",
    "    \n",
    "    \n",
    "    \n",
    "# x = []\n",
    "\n",
    "# count = -1\n",
    "# for i in model.features.children():\n",
    "#     count+=1\n",
    "#     if count == 24:\n",
    "#         list(model.features.children())[24] = nn.Conv2d(512, 512, kernel_size=(1,1), stride=(1,1), padding=(1,1))\n",
    "#         continue\n",
    "#     x.append(i)\n",
    "# pretrained_weights = model.features[24].weight\n",
    "# new_features = nn.Sequential(*list(model.features.children()))\n",
    "# new_features[24] = nn.Conv2d(512, 512, kernel_size=1, stride=1, padding=0)\n",
    "# new_features[24].weight.data.normal_(0, 0.001)\n",
    "# new_features[28] = nn.Conv2d(512, 512, kernel_size=1, stride=1, padding=0)\n",
    "# new_features[28].weight.data.normal_(0, 0.001)\n",
    "# # new_features[24].weight.data[:, :3, :, :] = pretrained_weights\n",
    "# model.features = new_features\n",
    "\n",
    "# model.features = None\n",
    "# model.features = nn.Sequential(*x)\n",
    "# nn.features.\n",
    "model.classifier = nn.Sequential(nn.Linear(25088, 5),\n",
    "                                 nn.LogSoftmax(dim=1))\n",
    "criterion = nn.NLLLoss()\n",
    "optimizer = optim.Adam(model.classifier.parameters(), lr=0.003)\n",
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pytorch_total_params = sum(p.numel() for p in model.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pytorch_total_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "epochs = 3\n",
    "steps = 0\n",
    "running_loss = 0\n",
    "print_every = 10\n",
    "train_losses, test_losses = [], []\n",
    "for epoch in range(epochs):\n",
    "    for inputs, labels in trainloader:\n",
    "        steps += 1\n",
    "        inputs, labels = inputs.to(device),labels.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        logps = model.forward(inputs)\n",
    "        loss = criterion(logps, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        running_loss += loss.item()\n",
    "        \n",
    "        if steps % print_every == 0:\n",
    "            test_loss = 0\n",
    "            accuracy = 0\n",
    "            model.eval()\n",
    "            with torch.no_grad():\n",
    "                for inputs, labels in testloader:\n",
    "                    inputs, labels = inputs.to(device), labels.to(device)\n",
    "                    logps = model.forward(inputs)\n",
    "                    batch_loss = criterion(logps, labels)\n",
    "                    test_loss += batch_loss.item()\n",
    "                    ps = torch.exp(logps)\n",
    "                    top_p, top_class = ps.topk(1, dim=1)\n",
    "                    equals = top_class == labels.view(*top_class.shape)\n",
    "                    accuracy += torch.mean(equals.type(torch.FloatTensor)).item()\n",
    "            train_losses.append(running_loss/len(trainloader))\n",
    "            test_losses.append(test_loss/len(testloader))                    \n",
    "            print(f\"Epoch {epoch+1}/{epochs}.. \"\n",
    "                  f\"Train loss : {running_loss/print_every:.3f}.. \"\n",
    "                  f\"Test loss: {test_loss/len(testloader):.3f}.. \"\n",
    "                  f\"Test accuracy: {accuracy/len(testloader):.3f}\")\n",
    "            acc = accuracy/len(testloader)\n",
    "            if acc >= 0.99:\n",
    "                torch.save(model, 'bilinear-cnn/model/coarse_grained_vgg_with_fine_tune.pth')\n",
    "            running_loss = 0\n",
    "            model.train()\n",
    "torch.save(model, 'bilinear-cnn/model/coarse_grained_vgg_final.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model=torch.load('models/all_coarse_grained_vgg16_saved.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model=torch.load('bilinear-cnn/model/coarse_grained_vgg_with_fine_tune.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_transforms = transforms.Compose([transforms.Resize([im_size,im_size]),\n",
    "                                      transforms.ToTensor()])\n",
    "\n",
    "def predict_image(image):\n",
    "    image_tensor = test_transforms(image).float()\n",
    "    image_tensor = image_tensor.unsqueeze_(0)\n",
    "    inputa = Variable(image_tensor)\n",
    "    inputa = inputa.to(device)\n",
    "    output = model(inputa)\n",
    "    index = output.data.cpu().numpy().argmax()\n",
    "#     print(index)\n",
    "    return index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "from PIL import Image\n",
    "\n",
    "lab = ['aircrafts', 'birds', 'cars', 'dogs', 'flowers']\n",
    "\n",
    "count = 0\n",
    "total = 0\n",
    "for category in os.listdir(\"coarse_test\"):\n",
    "    for i in os.listdir(\"coarse_test/\" + category):\n",
    "        image = Image.open(\"coarse_test/\" + category + \"/\" + i)\n",
    "        index = predict_image(image)\n",
    "        res = category == lab[index]\n",
    "#         print(index)\n",
    "        if res:\n",
    "            count+=1\n",
    "        total+=1\n",
    "print(\"Test accuracy : \", count/total)\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(model, 'models/coarse_grained_vgg16.pth')"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}