assignment1/softmax.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from __future__ import print_function\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 = 'cs231n/datasets/cifar-10-batches-py'\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",
    "# 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",
    "# 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.307921\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",
    "**Your answer:** Here we use randomized weight, and there are 10 classes in total; we expect the probability for each class to be roughly 0.1; as a result, our loss should be roughly -log(0.1).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: 3.935013 analytic: 3.935013, relative error: 1.819341e-08\n",
      "numerical: -0.636789 analytic: -0.636789, relative error: 8.941177e-09\n",
      "numerical: -0.294643 analytic: -0.294643, relative error: 8.805406e-08\n",
      "numerical: 1.893063 analytic: 1.893063, relative error: 2.094499e-08\n",
      "numerical: 0.003739 analytic: 0.003739, relative error: 6.246347e-06\n",
      "numerical: 2.597944 analytic: 2.597944, relative error: 4.087584e-09\n",
      "numerical: 1.645502 analytic: 1.645501, relative error: 3.837923e-08\n",
      "numerical: 1.148792 analytic: 1.148792, relative error: 6.457316e-08\n",
      "numerical: -1.885135 analytic: -1.885135, relative error: 4.465834e-09\n",
      "numerical: 0.562830 analytic: 0.562830, relative error: 5.845654e-08\n",
      "numerical: -0.093025 analytic: -0.093025, relative error: 1.115006e-06\n",
      "numerical: -1.808901 analytic: -1.808901, relative error: 1.199267e-08\n",
      "numerical: -1.027364 analytic: -1.027364, relative error: 4.513780e-08\n",
      "numerical: 0.663262 analytic: 0.663262, relative error: 6.650123e-08\n",
      "numerical: -0.811511 analytic: -0.811511, relative error: 2.710793e-08\n",
      "numerical: -0.452803 analytic: -0.452803, relative error: 1.834379e-08\n",
      "numerical: 1.013467 analytic: 1.013467, relative error: 1.083238e-08\n",
      "numerical: -0.474259 analytic: -0.474259, relative error: 2.586262e-08\n",
      "numerical: -1.123693 analytic: -1.123693, relative error: 2.913647e-08\n",
      "numerical: 0.441083 analytic: 0.441082, relative error: 1.402724e-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": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.307921e+00 computed in 0.045215s\n",
      "vectorized loss: 2.307921e+00 computed in 0.005315s\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": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 5.000000e-08 reg 5.000000e+03 train accuracy: 0.311245 val accuracy: 0.317000\n",
      "lr 5.000000e-08 reg 2.500000e+04 train accuracy: 0.330714 val accuracy: 0.343000\n",
      "lr 5.000000e-08 reg 5.000000e+04 train accuracy: 0.304837 val accuracy: 0.326000\n",
      "lr 1.000000e-07 reg 5.000000e+03 train accuracy: 0.369286 val accuracy: 0.380000\n",
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.330245 val accuracy: 0.341000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.301122 val accuracy: 0.321000\n",
      "lr 2.000000e-07 reg 5.000000e+03 train accuracy: 0.374857 val accuracy: 0.391000\n",
      "lr 2.000000e-07 reg 2.500000e+04 train accuracy: 0.323000 val accuracy: 0.337000\n",
      "lr 2.000000e-07 reg 5.000000e+04 train accuracy: 0.314041 val accuracy: 0.330000\n",
      "best validation accuracy achieved during cross-validation: 0.391000\n",
      "CPU times: user 45.5 s, sys: 130 ms, total: 45.7 s\n",
      "Wall time: 45.5 s\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 = None\n",
    "learning_rates = [5e-8, 1e-7, 2e-7]\n",
    "regularization_strengths = [5e3, 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",
    "# Your code\n",
    "def softmax_cv(X_train, y_train, X_val, y_val, lr, reg, num_iters=2500):\n",
    "    softmax = Softmax()\n",
    "    softmax.train(X_train, y_train, learning_rate=lr, reg=reg, num_iters=num_iters, verbose=False)\n",
    "    y_train_pred = softmax.predict(X_train)\n",
    "    y_val_pred = softmax.predict(X_val)\n",
    "    return np.mean(y_train == y_train_pred), np.mean(y_val == y_val_pred), softmax\n",
    "\n",
    "for lr in learning_rates:\n",
    "    for reg in regularization_strengths:\n",
    "        train_accuracy, val_accuracy, curr_softmax = softmax_cv(X_train, y_train, X_val, y_val, lr, reg)\n",
    "        results[(lr, reg)] = (train_accuracy, val_accuracy)\n",
    "        print('lr %e reg %e train accuracy: %f val accuracy: %f' % (lr, reg, train_accuracy, val_accuracy))\n",
    "        if val_accuracy > best_val:\n",
    "            best_val, best_softmax = val_accuracy, curr_softmax\n",
    "\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################\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": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.375000\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": {},
   "source": [
    "**Inline Question** - *True or False*\n",
    "\n",
    "It's 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",
    "*Your answer*: True\n",
    "\n",
    "*Your explanation*: For SVM, the score wouldn't change as long as the score for the correct label is higher than scores for all other labels by at least the value of pre-defined threshold (margin); for softmax, the probability for each class is typically larger than 0, and a new datapoint would thus bring non-zero loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f50f93f2b38>"
      ]
     },
     "metadata": {},
     "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 (py36)",
   "language": "python",
   "name": "py36"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}