assignment1/softmax.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8aaae81",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This mounts your Google Drive to the Colab VM.\n",
    "from google.colab import drive\n",
    "drive.mount('/content/drive')\n",
    "\n",
    "# TODO: Enter the foldername in your Drive where you have saved the unzipped\n",
    "# assignment folder, e.g. 'cs231n/assignments/assignment1/'\n",
    "FOLDERNAME = None\n",
    "assert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n",
    "\n",
    "# Now that we've mounted your Drive, this ensures that\n",
    "# the Python interpreter of the Colab VM can load\n",
    "# python files from within it.\n",
    "import sys\n",
    "sys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n",
    "\n",
    "# This downloads the CIFAR-10 dataset to your Drive\n",
    "# if it doesn't already exist.\n",
    "%cd /content/drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n",
    "!bash get_datasets.sh\n",
    "%cd /content/drive/My\\ Drive/$FOLDERNAME"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2c3cfa1",
   "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": 1,
   "id": "c55a72bf",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "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",
    "%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,
   "id": "b99594ec",
   "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",
   "id": "2713b7f4",
   "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": 18,
   "id": "6168f67e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.396957\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",
   "id": "b35bc604",
   "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:}$ \n",
    "\n",
    "有 10 个类别，所以平均而言，通过随机猜测正确分类真实标签的概率为 0.1。\n",
    "\n",
    "我们希望概率接近 0.1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b7bef674",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: 0.994886 analytic: 0.994886, relative error: 4.040906e-08\n",
      "numerical: -0.110419 analytic: -0.110419, relative error: 5.890618e-08\n",
      "numerical: 2.673210 analytic: 2.673210, relative error: 3.454302e-08\n",
      "numerical: -0.554525 analytic: -0.554525, relative error: 9.031858e-08\n",
      "numerical: -0.064739 analytic: -0.064739, relative error: 4.892423e-07\n",
      "numerical: 0.437539 analytic: 0.437539, relative error: 1.084708e-08\n",
      "numerical: 2.071003 analytic: 2.071003, relative error: 1.726489e-08\n",
      "numerical: -0.661887 analytic: -0.661887, relative error: 8.552310e-08\n",
      "numerical: 2.238773 analytic: 2.238772, relative error: 4.553863e-08\n",
      "numerical: -1.071853 analytic: -1.071853, relative error: 1.000644e-09\n",
      "numerical: -0.529727 analytic: -0.529727, relative error: 1.408935e-07\n",
      "numerical: -1.015710 analytic: -1.015710, relative error: 3.644312e-08\n",
      "numerical: 3.409544 analytic: 3.409544, relative error: 1.114026e-08\n",
      "numerical: 1.811444 analytic: 1.811444, relative error: 1.141884e-10\n",
      "numerical: -0.211312 analytic: -0.211312, relative error: 1.126727e-07\n",
      "numerical: -0.107410 analytic: -0.107410, relative error: 6.769405e-07\n",
      "numerical: -0.524265 analytic: -0.524265, relative error: 6.052658e-08\n",
      "numerical: -0.466537 analytic: -0.466538, relative error: 1.119220e-07\n",
      "numerical: 3.848656 analytic: 3.848656, relative error: 9.182922e-09\n",
      "numerical: -1.667093 analytic: -1.667093, relative error: 3.443010e-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": 28,
   "id": "3994f8a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.396957e+00 computed in 0.058194s\n",
      "vectorized loss: 2.396957e+00 computed in 0.003887s\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": 38,
   "id": "bd171311",
   "metadata": {
    "tags": [
     "code"
    ],
    "test": "tuning"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 7.500000e-08 reg 3.000000e+04 train accuracy: 0.329673 val accuracy: 0.342000\n",
      "lr 7.500000e-08 reg 3.250000e+04 train accuracy: 0.321510 val accuracy: 0.337000\n",
      "lr 7.500000e-08 reg 3.500000e+04 train accuracy: 0.317959 val accuracy: 0.332000\n",
      "lr 7.500000e-08 reg 3.750000e+04 train accuracy: 0.318286 val accuracy: 0.336000\n",
      "lr 7.500000e-08 reg 4.000000e+04 train accuracy: 0.307612 val accuracy: 0.322000\n",
      "lr 7.500000e-08 reg 4.250000e+04 train accuracy: 0.314265 val accuracy: 0.331000\n",
      "lr 7.500000e-08 reg 4.500000e+04 train accuracy: 0.309429 val accuracy: 0.329000\n",
      "lr 7.500000e-08 reg 4.750000e+04 train accuracy: 0.303592 val accuracy: 0.322000\n",
      "lr 7.500000e-08 reg 5.000000e+04 train accuracy: 0.308327 val accuracy: 0.324000\n",
      "lr 1.250000e-07 reg 3.000000e+04 train accuracy: 0.315878 val accuracy: 0.332000\n",
      "lr 1.250000e-07 reg 3.250000e+04 train accuracy: 0.329592 val accuracy: 0.346000\n",
      "lr 1.250000e-07 reg 3.500000e+04 train accuracy: 0.316469 val accuracy: 0.331000\n",
      "lr 1.250000e-07 reg 3.750000e+04 train accuracy: 0.313388 val accuracy: 0.324000\n",
      "lr 1.250000e-07 reg 4.000000e+04 train accuracy: 0.320082 val accuracy: 0.335000\n",
      "lr 1.250000e-07 reg 4.250000e+04 train accuracy: 0.312694 val accuracy: 0.329000\n",
      "lr 1.250000e-07 reg 4.500000e+04 train accuracy: 0.309224 val accuracy: 0.323000\n",
      "lr 1.250000e-07 reg 4.750000e+04 train accuracy: 0.306224 val accuracy: 0.323000\n",
      "lr 1.250000e-07 reg 5.000000e+04 train accuracy: 0.305714 val accuracy: 0.325000\n",
      "lr 1.500000e-07 reg 3.000000e+04 train accuracy: 0.324347 val accuracy: 0.339000\n",
      "lr 1.500000e-07 reg 3.250000e+04 train accuracy: 0.315755 val accuracy: 0.335000\n",
      "lr 1.500000e-07 reg 3.500000e+04 train accuracy: 0.314959 val accuracy: 0.330000\n",
      "lr 1.500000e-07 reg 3.750000e+04 train accuracy: 0.316796 val accuracy: 0.328000\n",
      "lr 1.500000e-07 reg 4.000000e+04 train accuracy: 0.316408 val accuracy: 0.328000\n",
      "lr 1.500000e-07 reg 4.250000e+04 train accuracy: 0.313347 val accuracy: 0.338000\n",
      "lr 1.500000e-07 reg 4.500000e+04 train accuracy: 0.301306 val accuracy: 0.317000\n",
      "lr 1.500000e-07 reg 4.750000e+04 train accuracy: 0.310082 val accuracy: 0.331000\n",
      "lr 1.500000e-07 reg 5.000000e+04 train accuracy: 0.312041 val accuracy: 0.322000\n",
      "lr 2.000000e-07 reg 3.000000e+04 train accuracy: 0.325612 val accuracy: 0.341000\n",
      "lr 2.000000e-07 reg 3.250000e+04 train accuracy: 0.313347 val accuracy: 0.328000\n",
      "lr 2.000000e-07 reg 3.500000e+04 train accuracy: 0.311633 val accuracy: 0.326000\n",
      "lr 2.000000e-07 reg 3.750000e+04 train accuracy: 0.313388 val accuracy: 0.325000\n",
      "lr 2.000000e-07 reg 4.000000e+04 train accuracy: 0.307449 val accuracy: 0.331000\n",
      "lr 2.000000e-07 reg 4.250000e+04 train accuracy: 0.312286 val accuracy: 0.335000\n",
      "lr 2.000000e-07 reg 4.500000e+04 train accuracy: 0.318714 val accuracy: 0.328000\n",
      "lr 2.000000e-07 reg 4.750000e+04 train accuracy: 0.306367 val accuracy: 0.321000\n",
      "lr 2.000000e-07 reg 5.000000e+04 train accuracy: 0.314122 val accuracy: 0.327000\n",
      "best validation accuracy achieved during cross-validation: 0.346000\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",
    "\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\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",
    "\n",
    "# Provided as a reference. You may or may not want to change these hyperparameters\n",
    "learning_rates = [2e-7, 0.75e-7, 1.5e-7, 1.25e-7, 0.75e-7]\n",
    "regularization_strengths = [3e4, 3.25e4, 3.5e4,\n",
    "                            3.75e4, 4e4, 4.25e4, 4.5e4, 4.75e4, 5e4]\n",
    "\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "for lr in learning_rates:\n",
    "    for reg in regularization_strengths:\n",
    "        softmax = Softmax()\n",
    "        softmax.train(X_train, y_train, lr, reg, num_iters=1000)\n",
    "        y_train_pred, y_val_pred = softmax.predict(\n",
    "            X_train), softmax.predict(X_val)\n",
    "        results[(lr, reg)] = np.mean(\n",
    "            y_train == y_train_pred), np.mean(y_val == y_val_pred)\n",
    "\n",
    "        if results[(lr, reg)][1] > best_val:\n",
    "            best_val = results[(lr, reg)][1]\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": 41,
   "id": "f94a8f12",
   "metadata": {
    "test": "test"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.339000\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",
   "id": "7e2112ee",
   "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:}$\n",
    "\n",
    "_True_\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n",
    "感性理解一下，SVM 是给每个分配分数，比较独立\n",
    "\n",
    "回想一下 SVM 的计算过程，概率是互相关联的，显然新增项无论如何都会造成影响\n",
    "\n",
    "Detailed Explanation from [Mantasu](https://github.com/mantasu/cs231n/blob/master/assignment1/softmax.ipynb)\n",
    "\n",
    "First, let's revise how individual loss functions look ($\\hat y$ - score, $i$ - any class label, $c$ - true class label):\n",
    "\n",
    "$$\\text{SVM loss: }\\ L_n = \\sum_{i\\ne c}^I\\max(0, \\hat y_i-\\hat y_c+\\Delta)$$\n",
    "\n",
    "$$\\text{Softmax loss: }\\ L_n=-\\log\\left(\\frac{e^{\\hat y_c}}{\\sum_{i=1}^Ie^{\\hat y_i}}\\right)$$\n",
    "\n",
    "Explanation:\n",
    "* The nature of **SVM loss** is to teach the model to assign a high enough score for the correct label. The total loss is unaffected if the scores for the incorrect labels are already lower by some margin than the score for a correct label because nothing is added to the overall loss.\n",
    "* The nature of **Softmax loss** is to make the model raise the probability for the correct label to `1` while the probabilities for other labels decrease to `0`. The loss is always affected because no matter what score is produced for an incorrect label, it still induces some probability which does not allow the true label to reach the probability of `1`.\n",
    "  * Aside: theoretically, if all the scores for incorrect classes were $-\\infty$, the probability of the correct class would be `1` so the individual loss would be $-\\log 1=0$ and that would not affect the overall loss\n",
    "* Assuming the overall loss is just the sum of every individual loss, the data point which produces safe score differences between the incorrect labels and a correct one is a data point that does not affect the **SVM loss**, however, it is guaranteed that it will affect the **Softmax loss** by some (however tiny) amount.\n",
    "\n",
    "Example:\n",
    "* Suppose we get a score vector $\\mathbf{\\hat y}=\\begin{bmatrix}1 \\\\ 0\\end{bmatrix}$ and that the first entry represents the score for a correct class, i.e., $\\hat y_1=1$.\n",
    "* Assuming our margin for **SVM loss** is `1`: $\\Delta=1$, the individual loss for $\\mathbf{\\hat y}$ is `0` because it satisfies the margin. However, the individual **Softmax loss** will produce a value of $\\log(1+e)-1$ which will affect the overall loss.\n",
    "\n",
    "<br>\n",
    "\n",
    "Hence it is possible to add a datapoint which would not affect the (described) overall **SVM loss** but would affect the overall **Softmax loss**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "86d86120",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 10 Axes>"
      ]
     },
     "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])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24688f99",
   "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}