softmax.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*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": 36,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\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": 37,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "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 = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\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": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.363967\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": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ Initially, all classes would be equally probable due to our weight initialization. Since there are 10 classes, each class will have a probability of 0.1.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: 1.061303 analytic: 1.061303, relative error: 2.824876e-08\n",
      "numerical: 0.024116 analytic: 0.024116, relative error: 1.725638e-06\n",
      "numerical: 1.471800 analytic: 1.471800, relative error: 7.008426e-09\n",
      "numerical: -4.702537 analytic: -4.702537, relative error: 1.107301e-08\n",
      "numerical: 0.056118 analytic: 0.056118, relative error: 1.401171e-07\n",
      "numerical: 3.796247 analytic: 3.796247, relative error: 2.402967e-08\n",
      "numerical: -0.434871 analytic: -0.434871, relative error: 1.588643e-08\n",
      "numerical: -1.562803 analytic: -1.562803, relative error: 6.379280e-09\n",
      "numerical: -1.079343 analytic: -1.079343, relative error: 5.514487e-09\n",
      "numerical: -3.050263 analytic: -3.050262, relative error: 1.517748e-08\n",
      "numerical: 1.964741 analytic: 1.964741, relative error: 9.270505e-09\n",
      "numerical: 2.758717 analytic: 2.758717, relative error: 5.417117e-09\n",
      "numerical: -4.190522 analytic: -4.190522, relative error: 7.769921e-09\n",
      "numerical: -2.389206 analytic: -2.389206, relative error: 1.364591e-08\n",
      "numerical: 2.163199 analytic: 2.163199, relative error: 1.452871e-08\n",
      "numerical: 2.079569 analytic: 2.079569, relative error: 1.778206e-08\n",
      "numerical: 0.863934 analytic: 0.863934, relative error: 6.962344e-08\n",
      "numerical: -3.165123 analytic: -3.165123, relative error: 1.090666e-08\n",
      "numerical: 1.507121 analytic: 1.507121, relative error: 2.721717e-08\n",
      "numerical: 0.037639 analytic: 0.037639, relative error: 6.212641e-07\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": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.363967e+00 computed in 0.073440s\n",
      "vectorized loss: 2.363967e+00 computed in 0.011912s\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, 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": 41,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.327571 val accuracy: 0.335000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.307878 val accuracy: 0.318000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.323041 val accuracy: 0.341000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.282918 val accuracy: 0.298000\n",
      "best validation accuracy achieved during cross-validation: 0.341000\n"
     ]
    }
   ],
   "source": [
    "# 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 = None\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\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",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "\n",
    "num_iters = 1500\n",
    "for lr in learning_rates:\n",
    "    for reg in regularization_strengths:\n",
    "        softmax = Softmax()\n",
    "        loss_hist = softmax.train(X_train, y_train, learning_rate=lr, reg=reg,\n",
    "                      num_iters=num_iters, verbose=False)\n",
    "        y_train_pred = softmax.predict(X_train)\n",
    "        y_val_pred = softmax.predict(X_val)\n",
    "        train_acc = np.mean(y_train == y_train_pred)\n",
    "        val_acc = np.mean(y_val == y_val_pred)\n",
    "        results[(lr, reg)] = (train_acc, val_acc)\n",
    "        \n",
    "        if best_val == -1 or best_val < val_acc:\n",
    "            best_val = val_acc\n",
    "            best_softmax = softmax\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.334000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.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": {
    "tags": [
     "pdf-inline"
    ]
   },
   "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:}$ It is possible that the SVM loss will be zero as all the differences between class scores are within the margin, but softmax classifier loss may be non-zero as the predicted correct class probability may be highest but not 1.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}