logistic_regression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4.1\n"
     ]
    }
   ],
   "source": [
    "# %matplotlib inline\n",
    "# %config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "# import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "print(torch.__version__)\n",
    "import torchvision\n",
    "from torchvision import datasets, transforms\n",
    "import torch.nn as nn\n",
    "\n",
    "from IPython.display import clear_output\n",
    "\n",
    "import helper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch Gradient Descent and Binary Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = '/Users/akshaykulkarni/flowers/train/'\n",
    "batch_size = 1024\n",
    "tf = transforms.Compose([transforms.Resize((255, 255)),\n",
    "                         transforms.ToTensor(),\n",
    "                        ])\n",
    "\n",
    "train_dataset = datasets.ImageFolder(data_dir, transform = tf)\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size = batch_size, shuffle = True, drop_last = True)\n",
    "\n",
    "data_dir = '/Users/akshaykulkarni/flowers/test/'\n",
    "\n",
    "test_dataset = datasets.ImageFolder(data_dir, transform = tf)\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size = 32, shuffle = True, drop_last = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "images, labels = next(iter(train_loader))\n",
    "print(images.shape)\n",
    "images = images.view(-1, images.shape[0]).float()\n",
    "print(images.shape)\n",
    "images /= 255\n",
    "labels = labels.float()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dimensions of different variables\n",
    "# W and dw - (n, 1)\n",
    "# b and db - (1)\n",
    "# images - (n, batch_size)\n",
    "# labels - (batch_size)\n",
    "# out and pred - (1, batch_size)\n",
    "# loss - (1)\n",
    "m = len(train_loader) * batch_size\n",
    "n = 255 * 255 * 3\n",
    "learning_rate = 2\n",
    "W = torch.randn(n, 1).float()\n",
    "b = torch.randn(1).float()\n",
    "num_epochs = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def binary_cross_entropy(A, Y):\n",
    "    loss = (-1 / batch_size) * (torch.matmul(torch.log(A), Y) + torch.matmul(torch.log(1 - A), (1 - Y)))\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    return (1 / (1 + torch.exp(-x)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward(x, y):\n",
    "    out = sigmoid(torch.add(torch.matmul(W.t(), x), b))\n",
    "    # size - (1, batch_size)\n",
    "    loss = binary_cross_entropy(out, y)\n",
    "    return loss, out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def backward(A, Y, X):\n",
    "    Y2 = Y.view(1, Y.shape[0])\n",
    "    dz = A - Y2\n",
    "    dw = torch.matmul(X, dz.t()) / batch_size\n",
    "    db = torch.sum(dz) / batch_size\n",
    "    db = db.reshape([1])\n",
    "    assert(W.shape == dw.shape)\n",
    "    assert(b.shape == db.shape)\n",
    "    return dw, db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Batch Gradient Descent\n",
    "loss_list = list()\n",
    "for i in range(4000):\n",
    "    # convert to GPU tensors\n",
    "    if torch.cuda.is_available():\n",
    "        images, labels = images.cuda(), labels.cuda()\n",
    "        W, b = W.cuda(), b.cuda()\n",
    "\n",
    "    loss, pred = forward(images, labels)\n",
    "    epoch_loss = loss.item()\n",
    "    loss_list.append(loss.item())\n",
    "    dw, db = backward(pred, labels, images)\n",
    "    # updating weights\n",
    "    W = W - (learning_rate * dw)\n",
    "    b = b - (learning_rate * db)\n",
    "    \n",
    "#     print(W)\n",
    "#     print(b)\n",
    "    if i % 20 == 0:\n",
    "        print('Loss at epoch ', i, ' = ', epoch_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.cuda.is_available():\n",
    "    images = images.cuda()\n",
    "    labels = labels.cuda()\n",
    "    W = W.cuda()\n",
    "    b = b.cuda()\n",
    "    \n",
    "loss, pred = forward(images, labels)\n",
    "pred = (pred >= 0.5)\n",
    "\n",
    "pred = pred.view(pred.shape[1])\n",
    "mismatch = (torch.eq(pred, labels.byte()))\n",
    "acc = torch.sum(mismatch.float())\n",
    "acc = acc * 100 / 1024\n",
    "print('Training accuracy = ', acc)\n",
    "\n",
    "# acc = 0\n",
    "# for batch_idx, (images, labels) in enumerate(test_loader):\n",
    "#     if torch.cuda.is_available():\n",
    "#         images = images.cuda()\n",
    "#         labels = labels.cuda()\n",
    "#         W = W.cuda()\n",
    "#         b = b.cuda()\n",
    "#     labels = labels.float()\n",
    "#     images = images.view(-1, images.shape[0]).float()\n",
    "#     images /= 255\n",
    "\n",
    "#     loss, pred = forward(images, labels)\n",
    "#     pred = (pred >= 0.5)\n",
    "\n",
    "#     pred = pred.view(pred.shape[1])\n",
    "#     mismatch = torch.sum(torch.eq(pred, labels.byte()))\n",
    "#     acc += mismatch.item()\n",
    "\n",
    "# acc /= (len(test_loader) * 32)\n",
    "# print('Validation accuracy = ', acc * 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mini-Batch Gradient Descent and Binary Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = '/home/ivlabs/users/akshay/flowers/train/'\n",
    "batch_size = 32\n",
    "tf = transforms.Compose([transforms.Resize((255, 255)),\n",
    "                         transforms.RandomHorizontalFlip(p = 0.5),\n",
    "                         transforms.ToTensor(),\n",
    "                        ])\n",
    "\n",
    "train_dataset = datasets.ImageFolder(data_dir, transform = tf)\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size = batch_size, shuffle = True, drop_last = True)\n",
    "\n",
    "data_dir = '/home/ivlabs/users/akshay/flowers/test/'\n",
    "\n",
    "test_dataset = datasets.ImageFolder(data_dir, transform = tf)\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size = batch_size, shuffle = True, drop_last = True)\n",
    "\n",
    "print('No. of training images - ', len(train_loader) * batch_size)\n",
    "print('No. of testing images - ', len(test_loader) * batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dimensions of different variables\n",
    "# W and dw - (n, 1)\n",
    "# b and db - (1)\n",
    "# images - (n, batch_size)\n",
    "# labels - (batch_size)\n",
    "# out and pred - (1, batch_size)\n",
    "# loss - (1)\n",
    "m = len(train_loader) * batch_size\n",
    "n = 255 * 255 * 3\n",
    "learning_rate = 1\n",
    "# W = torch.randn(n, 1).float()\n",
    "b = torch.randn(1).float()\n",
    "# Xavier initialization of weights\n",
    "W = torch.empty(n, 1)\n",
    "nn.init.xavier_uniform_(W, gain=nn.init.calculate_gain('sigmoid'))\n",
    "num_epochs = 500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def binary_cross_entropy(A, Y):\n",
    "    loss = (-1 / batch_size) * (torch.matmul(torch.log(A), Y) + torch.matmul(torch.log(1 - A), (1 - Y)))\n",
    "    return loss\n",
    "\n",
    "def sigmoid(x):\n",
    "    return (1 / (1 + torch.exp(-x)))\n",
    "\n",
    "def forward(x, y):\n",
    "    out = torch.add(torch.matmul(W.t(), x), b)\n",
    "    out = sigmoid(out)\n",
    "    # size - (1, batch_size)\n",
    "    loss = binary_cross_entropy(out, y)\n",
    "    return loss, out\n",
    "\n",
    "def backward(A, Y, X):\n",
    "    Y2 = Y.view(1, Y.shape[0])\n",
    "    dz = A - Y2\n",
    "    dw = torch.matmul(X, dz.t()) / batch_size\n",
    "    db = torch.sum(dz) / batch_size\n",
    "    db = db.reshape([1])\n",
    "    assert(W.shape == dw.shape)\n",
    "    assert(b.shape == db.shape)\n",
    "    return dw, db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_acc_list = list()\n",
    "train_loss_list = list()\n",
    "val_loss_list = list()\n",
    "val_acc_list = list()\n",
    "for i in range(num_epochs):\n",
    "    train_loss = 0\n",
    "    train_acc = 0\n",
    "    # DW = torch.zeros(n, 1).float()\n",
    "    # DB = torch.zeros(1).float()\n",
    "    for batch_idx, (images, labels) in enumerate(train_loader):\n",
    "        # convert to GPU tensors\n",
    "        if torch.cuda.is_available():\n",
    "            images, labels = images.cuda(), labels.cuda()\n",
    "            W, b = W.cuda(), b.cuda()\n",
    "            # DW, DB = DW.cuda(), DB.cuda()\n",
    "\n",
    "        # convert to float and resize images to (n, batch_size) size\n",
    "        labels = labels.float()\n",
    "        images = images.view(-1, images.shape[0]).float()\n",
    "        images /= 255\n",
    "\n",
    "        loss, pred = forward(images, labels)\n",
    "        train_loss += loss.item()\n",
    "\n",
    "        dw, db = backward(pred, labels, images)\n",
    "        # assert(DW.shape == dw.shape)\n",
    "        # assert(DB.shape == db.shape)\n",
    "        # DW += dw\n",
    "        # DB += db\n",
    "\n",
    "        pred = (pred >= 0.5)\n",
    "        pred = pred.view(pred.shape[1])\n",
    "        mismatch = torch.sum(torch.eq(pred, labels.byte()))\n",
    "        train_acc += mismatch.item()\n",
    "\n",
    "        W = W - (learning_rate * dw)\n",
    "        b = b - (learning_rate * db)\n",
    "\n",
    "    # DB /= len(train_loader)\n",
    "    # DW /= len(train_loader)\n",
    "    # # updating weights\n",
    "    # W = W - (learning_rate * DW)\n",
    "    # b = b - (learning_rate * DB)\n",
    "\n",
    "    if i % 25 == 0:\n",
    "        weights_name = 'weights_' + str(i) + '.pt'\n",
    "        bias_name = 'bias_' + str(i) + '.pt'\n",
    "        torch.save(W, weights_name)\n",
    "        torch.save(b, bias_name)\n",
    "#     print(W)\n",
    "#     print(b)\n",
    "\n",
    "    train_loss /= len(train_loader)\n",
    "    train_loss_list.append(train_loss)\n",
    "    # print(f'Training Loss at {i} is equal to {epoch_loss}')\n",
    "\n",
    "    train_acc /= (len(train_loader) * batch_size)\n",
    "    train_acc_list.append(train_acc * 100)\n",
    "    # print('Training accuracy at epoch ', i, ' = ', acc * 100)\n",
    "\n",
    "    val_loss = 0\n",
    "    val_acc = 0\n",
    "    for batch_idx, (images, labels) in enumerate(test_loader):\n",
    "        if torch.cuda.is_available():\n",
    "            images = images.cuda()\n",
    "            labels = labels.cuda()\n",
    "            W = W.cuda()\n",
    "            b = b.cuda()\n",
    "        labels = labels.float()\n",
    "        images = images.view(-1, images.shape[0]).float()\n",
    "        images /= 255\n",
    "\n",
    "        loss, pred = forward(images, labels)\n",
    "        val_loss += loss.item()\n",
    "        pred = (pred >= 0.5)\n",
    "\n",
    "        pred = pred.view(pred.shape[1])\n",
    "        mismatch = torch.sum(torch.eq(pred, labels.byte()))\n",
    "        val_acc += mismatch.item()\n",
    "\n",
    "    val_loss /= len(test_loader)\n",
    "    val_loss_list.append(val_loss)\n",
    "    # print('Validation Loss at epoch ', i, ' = ', val_loss)\n",
    "\n",
    "    val_acc /= (len(test_loader) * batch_size)\n",
    "    val_acc_list.append(val_acc * 100)\n",
    "    # print('Validation accuracy at epoch ', i, ' = ', val_acc * 100)\n",
    "    print(f'Epoch : [{i} / {num_epochs}] | TL : {train_loss} | TA : {train_acc * 100} | VL : {val_loss} | VA : {val_acc * 100}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "csvfile = \"train_loss_list_500epochs.csv\"\n",
    "with open(csvfile, \"w\") as output:\n",
    "    writer = csv.writer(output, lineterminator='\\n')\n",
    "    for value in train_loss_list:\n",
    "        writer.writerow([value])\n",
    "\n",
    "csvfile = \"val_loss_list_500epochs.csv\"\n",
    "with open(csvfile, \"w\") as output:\n",
    "    writer = csv.writer(output, lineterminator='\\n')\n",
    "    for value in val_loss_list:\n",
    "        writer.writerow([value])\n",
    "\n",
    "csvfile = \"train_acc_list_500epochs.csv\"\n",
    "with open(csvfile, \"w\") as output:\n",
    "    writer = csv.writer(output, lineterminator='\\n')\n",
    "    for value in train_acc_list:\n",
    "        writer.writerow([value])\n",
    "\n",
    "csvfile = \"val_acc_list_500epochs.csv\"\n",
    "with open(csvfile, \"w\") as output:\n",
    "    writer = csv.writer(output, lineterminator='\\n')\n",
    "    for value in val_acc_list:\n",
    "        writer.writerow([value])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import csv\n",
    "import numpy as np\n",
    "\n",
    "with open('/home/ivlabs/Downloads/train_loss_list_500epochs.csv', 'r') as f:\n",
    "    reader = csv.reader(f)\n",
    "    train_loss_list2 = list(reader)\n",
    "\n",
    "train_loss_list = list()\n",
    "for i in train_loss_list2:\n",
    "    for j in i:\n",
    "        train_loss_list.append(float(j))\n",
    "        \n",
    "with open('/home/ivlabs/Downloads/train_acc_list_500epochs.csv', 'r') as f:\n",
    "    reader = csv.reader(f)\n",
    "    train_acc_list2 = list(reader)\n",
    "\n",
    "train_acc_list = list()\n",
    "for i in train_acc_list2:\n",
    "    for j in i:\n",
    "        train_acc_list.append(float(j))\n",
    "        \n",
    "with open('/home/ivlabs/Downloads/val_loss_list_500epochs.csv', 'r') as f:\n",
    "    reader = csv.reader(f)\n",
    "    val_loss_list2 = list(reader)\n",
    "\n",
    "val_loss_list = list()\n",
    "for i in val_loss_list2:\n",
    "    for j in i:\n",
    "        val_loss_list.append(float(j))\n",
    "        \n",
    "with open('/home/ivlabs/Downloads/val_acc_list_500epochs.csv', 'r') as f:\n",
    "    reader = csv.reader(f)\n",
    "    val_acc_list2 = list(reader)\n",
    "\n",
    "val_acc_list = list()\n",
    "for i in val_acc_list2:\n",
    "    for j in i:\n",
    "        val_acc_list.append(float(j))\n",
    "\n",
    "iterations = np.arange(0, 101, 1)\n",
    "plt.plot(iterations, train_loss_list, 'r')\n",
    "plt.plot(iterations, train_acc_list, 'g')\n",
    "plt.plot(iterations, val_loss_list, 'b')\n",
    "plt.plot(iterations, val_acc_list, 'y')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multi-class classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1875\n",
      "313\n"
     ]
    }
   ],
   "source": [
    "import torchvision.datasets as datasets\n",
    "mnist_trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transforms.ToTensor())\n",
    "mnist_testset = datasets.MNIST(root='./data', train=False, download=True, transform=transforms.ToTensor())\n",
    "\n",
    "batch_size = 32\n",
    "trainloader = torch.utils.data.DataLoader(mnist_trainset, batch_size = batch_size, shuffle = True, num_workers = 2)\n",
    "testloader = torch.utils.data.DataLoader(mnist_testset, batch_size = batch_size, shuffle = True, num_workers = 2)\n",
    "print(len(trainloader))\n",
    "print(len(testloader))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import matplotlib.pyplot as plt\n",
    "# import numpy as np\n",
    "\n",
    "# # functions to show an image\n",
    "\n",
    "\n",
    "# def imshow(img):\n",
    "#     img = img / 2 + 0.5     # unnormalize\n",
    "#     npimg = img.numpy()\n",
    "#     plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
    "#     plt.show()\n",
    "\n",
    "\n",
    "# # get some random training images\n",
    "# dataiter = iter(trainloader)\n",
    "# images, labels = dataiter.next()\n",
    "\n",
    "# # show images\n",
    "# imshow(torchvision.utils.make_grid(images))\n",
    "# # print labels\n",
    "# print(' '.join('%5s' % classes[labels[j]] for j in range(4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32])\n",
      "torch.Size([32, 1])\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Exception ignored in: <function _DataLoaderIter.__del__ at 0x120018ae8>\n",
      "Traceback (most recent call last):\n",
      "  File \"/Users/akshaykulkarni/anaconda3/lib/python3.7/site-packages/torch/utils/data/dataloader.py\", line 399, in __del__\n",
      "    self._shutdown_workers()\n",
      "  File \"/Users/akshaykulkarni/anaconda3/lib/python3.7/site-packages/torch/utils/data/dataloader.py\", line 378, in _shutdown_workers\n",
      "    self.worker_result_queue.get()\n",
      "  File \"/Users/akshaykulkarni/anaconda3/lib/python3.7/multiprocessing/queues.py\", line 354, in get\n",
      "    return _ForkingPickler.loads(res)\n",
      "  File \"/Users/akshaykulkarni/anaconda3/lib/python3.7/site-packages/torch/multiprocessing/reductions.py\", line 167, in rebuild_storage_filename\n",
      "    storage = cls._new_shared_filename(manager, handle, size)\n",
      "RuntimeError: Interrupted system call at /Users/soumith/miniconda2/conda-bld/pytorch_1532624435833/work/torch/lib/libshm/core.cpp:99\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "index 783 is out of bounds for dimension 1 with size 1",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-e84e1482065c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mview\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mlabels_2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimages\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels_2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# correct_scores_exp = scores_exp[y, xrange(num_train)] # [N, ]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mRuntimeError\u001b[0m: index 783 is out of bounds for dimension 1 with size 1"
     ]
    }
   ],
   "source": [
    "dataiter = iter(trainloader)\n",
    "images, labels = dataiter.next()\n",
    "images = images.view(-1, images.shape[0])\n",
    "print(labels.shape)\n",
    "labels = labels.view(labels.shape[0], 1)\n",
    "print(labels.shape)\n",
    "labels_2 = labels[labels, range(images.shape[0])]\n",
    "print(labels_2)\n",
    "# correct_scores_exp = scores_exp[y, xrange(num_train)] # [N, ]"
   ]
  },
  {
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}