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": [
    "from __future__ import print_function\n",
    "\n",
    "\n",
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\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.336643\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",
    "# 최초 W는 uniform distribution 형태로 값을 초기화해주었기 때문에 각각의 class가 uniform한 형태를 띈다.\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:** *Fill this in*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: 0.888916 analytic: 0.888916, relative error: 3.401218e-09\n",
      "numerical: 1.308463 analytic: 1.308463, relative error: 1.615824e-09\n",
      "numerical: 3.274005 analytic: 3.274005, relative error: 2.091380e-08\n",
      "numerical: 0.866501 analytic: 0.866501, relative error: 1.798549e-08\n",
      "numerical: 3.269544 analytic: 3.269544, relative error: 1.070273e-08\n",
      "numerical: 0.765095 analytic: 0.765095, relative error: 2.501645e-08\n",
      "numerical: 0.637601 analytic: 0.637601, relative error: 1.060830e-08\n",
      "numerical: -0.559772 analytic: -0.559772, relative error: 1.215968e-07\n",
      "numerical: -2.144577 analytic: -2.144577, relative error: 5.343260e-10\n",
      "numerical: -1.151067 analytic: -1.151067, relative error: 3.061701e-08\n",
      "numerical: -0.485088 analytic: -0.485088, relative error: 6.020959e-08\n",
      "numerical: -1.847271 analytic: -1.847271, relative error: 1.263958e-09\n",
      "numerical: -2.122723 analytic: -2.122723, relative error: 3.122308e-08\n",
      "numerical: 0.492103 analytic: 0.492103, relative error: 1.002470e-07\n",
      "numerical: 1.635968 analytic: 1.635967, relative error: 3.796918e-08\n",
      "numerical: -0.549857 analytic: -0.549857, relative error: 4.378783e-08\n",
      "numerical: 0.005565 analytic: 0.005565, relative error: 3.355644e-06\n",
      "numerical: 1.909513 analytic: 1.909513, relative error: 1.923511e-08\n",
      "numerical: 0.374663 analytic: 0.374663, relative error: 3.689836e-08\n",
      "numerical: 0.836093 analytic: 0.836093, relative error: 3.083437e-08\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.336643e+00 computed in 0.053396s\n",
      "vectorized loss: 2.336643e+00 computed in 0.003914s\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": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning_rate: 1e-07\n",
      "iteration 0 / 5000: loss 6.007414\n",
      "iteration 100 / 5000: loss 3.796989\n",
      "iteration 200 / 5000: loss 3.399084\n",
      "iteration 300 / 5000: loss 3.368123\n",
      "iteration 400 / 5000: loss 3.229301\n",
      "iteration 500 / 5000: loss 3.109791\n",
      "iteration 600 / 5000: loss 2.790406\n",
      "iteration 700 / 5000: loss 2.718862\n",
      "iteration 800 / 5000: loss 2.802477\n",
      "iteration 900 / 5000: loss 2.798928\n",
      "iteration 1000 / 5000: loss 2.748844\n",
      "iteration 1100 / 5000: loss 2.845263\n",
      "iteration 1200 / 5000: loss 2.631957\n",
      "iteration 1300 / 5000: loss 2.631149\n",
      "iteration 1400 / 5000: loss 2.733225\n",
      "iteration 1500 / 5000: loss 2.538150\n",
      "iteration 1600 / 5000: loss 2.731532\n",
      "iteration 1700 / 5000: loss 2.621759\n",
      "iteration 1800 / 5000: loss 2.396096\n",
      "iteration 1900 / 5000: loss 2.316272\n",
      "iteration 2000 / 5000: loss 2.676291\n",
      "iteration 2100 / 5000: loss 2.473975\n",
      "iteration 2200 / 5000: loss 2.486844\n",
      "iteration 2300 / 5000: loss 2.405810\n",
      "iteration 2400 / 5000: loss 2.510109\n",
      "iteration 2500 / 5000: loss 2.452974\n",
      "iteration 2600 / 5000: loss 2.142711\n",
      "iteration 2700 / 5000: loss 2.423208\n",
      "iteration 2800 / 5000: loss 2.283322\n",
      "iteration 2900 / 5000: loss 2.484605\n",
      "iteration 3000 / 5000: loss 2.311577\n",
      "iteration 3100 / 5000: loss 2.105128\n",
      "iteration 3200 / 5000: loss 2.308263\n",
      "iteration 3300 / 5000: loss 2.254410\n",
      "iteration 3400 / 5000: loss 2.268587\n",
      "iteration 3500 / 5000: loss 2.199374\n",
      "iteration 3600 / 5000: loss 2.175384\n",
      "iteration 3700 / 5000: loss 2.285832\n",
      "iteration 3800 / 5000: loss 2.373543\n",
      "iteration 3900 / 5000: loss 2.289997\n",
      "iteration 4000 / 5000: loss 2.128992\n",
      "iteration 4100 / 5000: loss 2.261295\n",
      "iteration 4200 / 5000: loss 2.342884\n",
      "iteration 4300 / 5000: loss 2.307936\n",
      "iteration 4400 / 5000: loss 2.071578\n",
      "iteration 4500 / 5000: loss 2.328902\n",
      "iteration 4600 / 5000: loss 2.160069\n",
      "iteration 4700 / 5000: loss 2.049166\n",
      "iteration 4800 / 5000: loss 2.313026\n",
      "iteration 4900 / 5000: loss 2.110719\n",
      "Learning_rate: 5e-07\n",
      "iteration 0 / 5000: loss 5.462009\n",
      "iteration 100 / 5000: loss 3.449149\n",
      "iteration 200 / 5000: loss 2.740322\n",
      "iteration 300 / 5000: loss 2.258514\n",
      "iteration 400 / 5000: loss 2.714832\n",
      "iteration 500 / 5000: loss 2.401395\n",
      "iteration 600 / 5000: loss 2.355603\n",
      "iteration 700 / 5000: loss 2.173991\n",
      "iteration 800 / 5000: loss 2.239378\n",
      "iteration 900 / 5000: loss 2.123806\n",
      "iteration 1000 / 5000: loss 2.100623\n",
      "iteration 1100 / 5000: loss 2.035166\n",
      "iteration 1200 / 5000: loss 2.245484\n",
      "iteration 1300 / 5000: loss 2.137722\n",
      "iteration 1400 / 5000: loss 2.220291\n",
      "iteration 1500 / 5000: loss 1.889363\n",
      "iteration 1600 / 5000: loss 2.066140\n",
      "iteration 1700 / 5000: loss 1.988158\n",
      "iteration 1800 / 5000: loss 1.954781\n",
      "iteration 1900 / 5000: loss 1.913344\n",
      "iteration 2000 / 5000: loss 1.941756\n",
      "iteration 2100 / 5000: loss 1.978405\n",
      "iteration 2200 / 5000: loss 2.044888\n",
      "iteration 2300 / 5000: loss 1.886922\n",
      "iteration 2400 / 5000: loss 2.071914\n",
      "iteration 2500 / 5000: loss 1.863915\n",
      "iteration 2600 / 5000: loss 1.882939\n",
      "iteration 2700 / 5000: loss 2.130364\n",
      "iteration 2800 / 5000: loss 1.841941\n",
      "iteration 2900 / 5000: loss 2.049744\n",
      "iteration 3000 / 5000: loss 2.173506\n",
      "iteration 3100 / 5000: loss 1.917682\n",
      "iteration 3200 / 5000: loss 1.905964\n",
      "iteration 3300 / 5000: loss 1.854401\n",
      "iteration 3400 / 5000: loss 1.871771\n",
      "iteration 3500 / 5000: loss 1.991071\n",
      "iteration 3600 / 5000: loss 1.786346\n",
      "iteration 3700 / 5000: loss 1.787810\n",
      "iteration 3800 / 5000: loss 1.919482\n",
      "iteration 3900 / 5000: loss 1.949383\n",
      "iteration 4000 / 5000: loss 1.909695\n",
      "iteration 4100 / 5000: loss 1.743190\n",
      "iteration 4200 / 5000: loss 2.069927\n",
      "iteration 4300 / 5000: loss 1.891670\n",
      "iteration 4400 / 5000: loss 1.966801\n",
      "iteration 4500 / 5000: loss 1.829648\n",
      "iteration 4600 / 5000: loss 1.768487\n",
      "iteration 4700 / 5000: loss 1.928138\n",
      "iteration 4800 / 5000: loss 1.996294\n",
      "iteration 4900 / 5000: loss 1.724933\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",
    "for lr in learning_rates:\n",
    "    print('Learning_rate:',lr)\n",
    "    clf = Softmax()\n",
    "    clf.train(X = X_train, y = y_train, \n",
    "              learning_rate = lr, num_iters = 5000, verbose = True)\n",
    "    \n",
    "best_softmax = clf\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": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(49000, 3073)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1000,)\n",
      "softmax on raw pixels final test set accuracy: 0.346000\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*:\n",
    "\n",
    "*Your explanation*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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.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])"
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}