Untitled1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "usage: ipykernel_launcher.py [-h] [--resume RESUME]\n",
      "ipykernel_launcher.py: error: unrecognized arguments: -f /run/user/1000/jupyter/kernel-a5b43cae-5e64-472d-a4f6-ec9f85dd0af5.json\n"
     ]
    },
    {
     "ename": "SystemExit",
     "evalue": "2",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\u001b[0;31m:\u001b[0m 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/cai/miniconda3/envs/py36/lib/python3.6/site-packages/IPython/core/interactiveshell.py:2870: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import numpy as np\n",
    "from torch.autograd import Variable\n",
    "\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from PIL import Image\n",
    "\n",
    "import sys, os, shutil, random\n",
    "import argparse \n",
    "parser = argparse.ArgumentParser(description='PyTorch Shallow CNN')\n",
    "parser.add_argument(\"--resume\", type=str, default=\"\", help=\"path of saved model\")\n",
    "args = parser.parse_args()\n",
    "\n",
    "class shallowCNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        #self.config = config\n",
    "        super(shallowCNN, self).__init__()\n",
    "        # [in, out, kernel_size, stride, padding]\n",
    "        self.bn0 = nn.BatchNorm2d(3)\n",
    "        self.max_pool0 = nn.MaxPool2d(2, 2)\n",
    "\n",
    "        self.conv1 = nn.Conv2d(3, 16, 3, 1, 1)\n",
    "        self.bn1 = nn.BatchNorm2d(16)\n",
    "        self.max_pool1 = nn.MaxPool2d(2, 2)\n",
    "\n",
    "        self.conv2 = nn.Conv2d(16, 32, 3, 1, 1)\n",
    "        self.bn2 = nn.BatchNorm2d(32)\n",
    "        self.max_pool2 = nn.MaxPool2d(2, 2)\n",
    "\n",
    "        self.conv3 = nn.Conv2d(32, 64, 3, 1, 1)\n",
    "        self.bn3 = nn.BatchNorm2d(64)\n",
    "        self.max_pool3 = nn.MaxPool2d(2, 2)\n",
    "        \n",
    "        self.conv4 = nn.Conv2d(64, 128, 3, 1, 1)\n",
    "        self.bn4 = nn.BatchNorm2d(128)\n",
    "        self.max_pool4 = nn.MaxPool2d(2, 2)\n",
    "\n",
    "        self.conv5 = nn.Conv2d(128, 256, 3, 1, 1)\n",
    "        self.bn5 = nn.BatchNorm2d(256)\n",
    "        self.max_pool5 = nn.MaxPool2d(2, 2)\n",
    "        self.linear1 = nn.Linear(256 * 4 * 4 * 2, 2048)\n",
    "\n",
    "        self.linear2 = nn.Linear(2048, 346)\n",
    "        #self.linear1 = None\n",
    "        #self.linear2 = None\n",
    "    def forward(self, x, xx):\n",
    "        x = self.max_pool0(self.bn0(x))\n",
    "        x = self.max_pool1(F.leaky_relu(self.bn1(self.conv1(x))))\n",
    "        x = self.max_pool2(F.leaky_relu(self.bn2(self.conv2(x))))\n",
    "        x = self.max_pool3(F.leaky_relu(self.bn3(self.conv3(x))))\n",
    "        x = self.max_pool4(F.leaky_relu(self.bn4(self.conv4(x))))\n",
    "        x = self.max_pool5(F.leaky_relu(self.bn5(self.conv5(x))))\n",
    "        #print(x.size(), x.size(1) * x.size(2) * x.size(3))\n",
    "        #exit()\n",
    "        x = x.view(-1, x.size(1) * x.size(2) * x.size(3))\n",
    "       \n",
    "        xx = self.max_pool0(self.bn0(xx))\n",
    "        xx = self.max_pool1(F.leaky_relu(self.bn1(self.conv1(xx))))\n",
    "        xx = self.max_pool2(F.leaky_relu(self.bn2(self.conv2(xx))))\n",
    "        xx = self.max_pool3(F.leaky_relu(self.bn3(self.conv3(xx))))\n",
    "        xx = self.max_pool4(F.leaky_relu(self.bn4(self.conv4(xx))))\n",
    "        xx = self.max_pool5(F.leaky_relu(self.bn5(self.conv5(xx))))\n",
    "        xx = xx.view(-1, xx.size(1) * xx.size(2) * xx.size(3)) #[M, 4096]\n",
    "\n",
    "        xxx = torch.cat([x, xx], dim=1) #[M, 4096 * 2]\n",
    "        xxx = F.leaky_relu(self.linear1(xxx))\n",
    "        xxx = F.dropout(xxx, p=0.5)\n",
    "        xxx = F.sigmoid(xxx)\n",
    "        return x\n",
    "\n",
    "\n",
    "train_info = pd.read_csv(\"processed_train_info.csv\")\n",
    "\n",
    "processed_train_info = train_info.drop(['title', 'style', 'genre', 'date', 'Unnamed: 6', 'Unnamed: 0'], axis=1)\n",
    "\n",
    "filenames = processed_train_info['filename'].tolist()\n",
    "artists = processed_train_info['artist'].tolist()\n",
    "\n",
    "artist_dict = {}\n",
    "for i in range(len(artists)):\n",
    "    if artists[i] not in artist_dict:\n",
    "        artist_dict[artists[i]] = [filenames[i]]\n",
    "    else:\n",
    "        artist_dict[artists[i]].append(filenames[i])\n",
    "\n",
    "def pick_positive_pair(artists, artist_dict):\n",
    "\tartist = np.random.choice(artists)\n",
    "\treturn np.random.choice(artist_dict[artists], 2)\n",
    "\n",
    "def pick_negative_pair(artists, artist_dict):\n",
    "    artist_pair = np.random.choice(artists, 2)\n",
    "    return [np.random.choice(artist_dict[artist_pair[0]]), np.random.choice(artist_dict[artist_pair[1]])]\n",
    "\n",
    "def load_pretrained_model(model, optimizer):\n",
    "\tprint(\"=> loading checkpoint '{}'\".format(args.resume))\n",
    "\tcheckpoint = torch.load(args.resume)\n",
    "\tSTART_EPOCH = checkpoint[\"epoch\"] + 1\n",
    "\tmodel.load_state_dict(checkpoint['state_dict'])\n",
    "\t#optimizer.load_state_dict(checkpoint['optimizer'])\n",
    "\tprint(\"=> loaded checkpoint '{}' (epoch {})\"\n",
    "\t\t.format(args.resume, checkpoint['epoch']))\n",
    "\treturn model, optimizer\n",
    "\n",
    "LR = 1e-4\n",
    "STEPS = 1e6\n",
    "\n",
    "model = shallowCNN()\n",
    "\n",
    "for p in model.named_parameters():\n",
    "\tif p[0].find(\"linear\") != -1:\n",
    "\t\tp[1].requires_grad = True\n",
    "\telse:\n",
    "\t\tp[1].requires_grad = False\n",
    "\n",
    "loss_fn = nn.BCELoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=LR)\n",
    "\n",
    "for i in range(STEPS):\n",
    "\tpos_pair_examples = []\n",
    "\tfor _ in range(32):\n",
    "\t\tpos_pair_examples.append(pick_negative_pair(artists, artist_dict))\n",
    "\tneg_pair_examples = []\n",
    "\tfor _ in range(32):\n",
    "\t\tneg_pair_examples.append(pick_negative_pair(artists, artist_dict))\n",
    "\n",
    "if args.resume:\n",
    "\tmodel, optimizer = load_pretrained_model(model, optimizer)\n",
    "\t\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}