{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center> cs231n 2019. [A1, part 3](http://cs231n.github.io/assignments2018/assignment1/). Softmax exercise\n",
    "<img src='../img/cs231n_logo.png' width=70%>\n",
    "    \n",
    "#### <center> **Solution by [Yury Kashnitsky](https://www.kaggle.com/kashnitsky) (@yorko)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "from tqdm import tqdm_notebook\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = '/home/yorko/data/cifar-10-batches-py'\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.364941\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inline Question #1\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ *There are ten classes here, so if the scores are random and mostly equal, we expect the ratio in the softmax formula to be $\\approx$ 0.1.*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: 4.414098 analytic: 4.414098, relative error: 8.407148e-09\n",
      "numerical: 0.115917 analytic: 0.115917, relative error: 2.561369e-07\n",
      "numerical: -1.337843 analytic: -1.337843, relative error: 2.223465e-10\n",
      "numerical: 1.663433 analytic: 1.663433, relative error: 2.801221e-09\n",
      "numerical: 0.345482 analytic: 0.345482, relative error: 2.811123e-08\n",
      "numerical: -2.875655 analytic: -2.875655, relative error: 1.403804e-08\n",
      "numerical: 3.905061 analytic: 3.905061, relative error: 7.269116e-09\n",
      "numerical: -1.111623 analytic: -1.111623, relative error: 1.084694e-08\n",
      "numerical: 1.578582 analytic: 1.578581, relative error: 1.587520e-08\n",
      "numerical: -2.557901 analytic: -2.557901, relative error: 4.136910e-09\n",
      "numerical: -0.080359 analytic: -0.080359, relative error: 3.252329e-07\n",
      "numerical: -1.137684 analytic: -1.137684, relative error: 2.093039e-08\n",
      "numerical: 0.979711 analytic: 0.979711, relative error: 9.203386e-08\n",
      "numerical: 1.420139 analytic: 1.420139, relative error: 1.984016e-08\n",
      "numerical: 3.553916 analytic: 3.553915, relative error: 1.270606e-08\n",
      "numerical: -3.555908 analytic: -3.555908, relative error: 7.909795e-09\n",
      "numerical: 0.037696 analytic: 0.037696, relative error: 2.082735e-07\n",
      "numerical: -2.779842 analytic: -2.779842, relative error: 3.970456e-09\n",
      "numerical: -1.119180 analytic: -1.119180, relative error: 2.000238e-09\n",
      "numerical: -1.375382 analytic: -1.375382, relative error: 5.295108e-10\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.364941e+00 computed in 0.132490s\n",
      "vectorized loss: 2.364941e+00 computed in 0.002477s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, \n",
    "                                            y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "114d12a38f7d46c9a7ed168edb8bb2c6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "66651a622483449fbb8a526c65619f4c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 3.000000e-07 reg 5.000000e+03 train accuracy: 0.372755 val accuracy: 0.384000\n",
      "lr 3.000000e-07 reg 2.750000e+04 train accuracy: 0.321755 val accuracy: 0.331000\n",
      "lr 3.000000e-07 reg 5.000000e+04 train accuracy: 0.300612 val accuracy: 0.320000\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bfe70fa2c14443e2ab100bf8f900439e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 4.000000e-07 reg 5.000000e+03 train accuracy: 0.375265 val accuracy: 0.382000\n",
      "lr 4.000000e-07 reg 2.750000e+04 train accuracy: 0.327633 val accuracy: 0.335000\n",
      "lr 4.000000e-07 reg 5.000000e+04 train accuracy: 0.298449 val accuracy: 0.313000\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0b7289454cb141d88b481d414c2097eb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=3), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 5.000000e-07 reg 5.000000e+03 train accuracy: 0.375714 val accuracy: 0.386000\n",
      "lr 5.000000e-07 reg 2.750000e+04 train accuracy: 0.318204 val accuracy: 0.335000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.293245 val accuracy: 0.305000\n",
      "\n",
      "best validation accuracy achieved during cross-validation: 0.386000\n",
      "CPU times: user 19min 26s, sys: 21.3 s, total: 19min 48s\n",
      "Wall time: 4min 16s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax_clf = None\n",
    "learning_rates = np.linspace(3e-7, 5e-7, 3)\n",
    "regularization_strengths = np.linspace(5e3, 5e4, 3)\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "for lr in tqdm_notebook(learning_rates):\n",
    "    for reg in tqdm_notebook(regularization_strengths):\n",
    "        softmax_clf = Softmax()\n",
    "        _ = softmax_clf.train(X_train, y_train, learning_rate=lr, \n",
    "                      reg=reg,\n",
    "                      num_iters=1500, verbose=False)\n",
    "        y_train_pred = softmax_clf.predict(X_train)\n",
    "        train_acc = np.mean(y_train == y_train_pred)\n",
    "        y_val_pred = softmax_clf.predict(X_val)\n",
    "        val_acc = np.mean(y_val == y_val_pred)\n",
    "        results[(lr, reg)] = (train_acc, val_acc)\n",
    "        print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_acc, val_acc))\n",
    "        if val_acc > best_val:\n",
    "            best_val = val_acc\n",
    "            best_softmax_clf = softmax_clf\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Softmax on raw pixels final test set accuracy: 0.377000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax_clf.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('Softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ *True*\n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$ Hinge (or SVM) loss can be strictly equal to zero for data points with big enough margin. But logarithmic loss (Softmax classifier loss) is always positive.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax_clf.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}