From 301f4eccde4ddf51b58d6514a9422155a701f864 Mon Sep 17 00:00:00 2001 From: JJ Date: Thu, 9 Feb 2023 05:54:51 +0900 Subject: [PATCH] overfit training examples with 3-layer net and 5-layer net & done inline question 1 #1 - the sensitivity of the network --- .../assignment2/FullyConnectedNets.ipynb | 748 ++++++++++++++++++ 1 file changed, 748 insertions(+) create mode 100644 cs231n_2022/assignment2/FullyConnectedNets.ipynb diff --git a/cs231n_2022/assignment2/FullyConnectedNets.ipynb b/cs231n_2022/assignment2/FullyConnectedNets.ipynb new file mode 100644 index 0000000..8ac753b --- /dev/null +++ b/cs231n_2022/assignment2/FullyConnectedNets.ipynb @@ -0,0 +1,748 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "d:\\Assignments\\ML_DL\\AI_git\\cs231n_2022\\assignment2\\cs231n\\datasets\n", + "d:\\Assignments\\ML_DL\\AI_git\\cs231n_2022\\assignment2\n" + ] + } + ], + "source": [ + "# This downloads the CIFAR-10 dataset to your Drive\n", + "# if it doesn't already exist.\n", + "%cd cs231n/datasets/\n", + "#!bash get_datasets.sh\n", + "!bash get_datasets_windows.sh\n", + "%cd ../../" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multi-Layer Fully Connected Network\n", + "In this exercise, you will implement a fully connected network with an arbitrary number of hidden layers." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n", + "\n", + "Implement the network initialization, forward pass, and backward pass. Throughout this assignment, you will be implementing layers in `cs231n/layers.py`. You can re-use your implementations for `affine_forward`, `affine_backward`, `relu_forward`, `relu_backward`, and `softmax_loss` from Assignment 1. For right now, don't worry about implementing dropout or batch/layer normalization yet, as you will add those features later.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "tags": [ + "pdf-ignore" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=========== You can safely ignore the message below if you are NOT working on ConvolutionalNetworks.ipynb ===========\n", + "\tYou will need to compile a Cython extension for a portion of this assignment.\n", + "\tThe instructions to do this will be given in a section of the notebook below.\n" + ] + } + ], + "source": [ + "# Setup cell.\n", + "import time\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from cs231n.classifiers.fc_net import *\n", + "from cs231n.data_utils import get_CIFAR10_data\n", + "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n", + "from cs231n.solver import Solver\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", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "def rel_error(x, y):\n", + " \"\"\"Returns relative error.\"\"\"\n", + " return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X_train: (49000, 3, 32, 32)\n", + "y_train: (49000,)\n", + "X_val: (1000, 3, 32, 32)\n", + "y_val: (1000,)\n", + "X_test: (1000, 3, 32, 32)\n", + "y_test: (1000,)\n" + ] + } + ], + "source": [ + "# Load the (preprocessed) CIFAR-10 data.\n", + "data = get_CIFAR10_data()\n", + "for k, v in list(data.items()):\n", + " print(f\"{k}: {v.shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initial Loss and Gradient Check\n", + "\n", + "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. This is a good way to see if the initial losses seem reasonable.\n", + "\n", + "For gradient checking, you should expect to see errors around 1e-7 or less." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running check with reg = 0\n", + "Initial loss: 2.3004790897684924\n", + "W1 relative error: 7.696803870986541e-08\n", + "W2 relative error: 1.7087519140575808e-05\n", + "W3 relative error: 2.9508423118300657e-07\n", + "b1 relative error: 4.660094650186831e-09\n", + "b2 relative error: 2.085654124402131e-09\n", + "b3 relative error: 6.598642296022133e-11\n", + "Running check with reg = 3.14\n", + "Initial loss: 7.052114776533016\n", + "W1 relative error: 3.904542008453064e-09\n", + "W2 relative error: 6.86942277940646e-08\n", + "W3 relative error: 2.1311298702113723e-08\n", + "b1 relative error: 1.1683196894962977e-08\n", + "b2 relative error: 1.7223751746766738e-09\n", + "b3 relative error: 1.3200479211447775e-10\n" + ] + } + ], + "source": [ + "np.random.seed(231)\n", + "N, D, H1, H2, C = 2, 15, 20, 30, 10\n", + "X = np.random.randn(N, D)\n", + "y = np.random.randint(C, size=(N,))\n", + "\n", + "for reg in [0, 3.14]:\n", + " print(\"Running check with reg = \", reg)\n", + " model = FullyConnectedNet(\n", + " [H1, H2],\n", + " input_dim=D,\n", + " num_classes=C,\n", + " reg=reg,\n", + " weight_scale=5e-2,\n", + " dtype=np.float64\n", + " )\n", + "\n", + " loss, grads = model.loss(X, y)\n", + " print(\"Initial loss: \", loss)\n", + "\n", + " # Most of the errors should be on the order of e-7 or smaller. \n", + " # NOTE: It is fine however to see an error for W2 on the order of e-5\n", + " # for the check when reg = 0.0\n", + " for name in sorted(grads):\n", + " f = lambda _: model.loss(X, y)[0]\n", + " grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n", + " print(f\"{name} relative error: {rel_error(grad_num, grads[name])}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As another sanity check, make sure your network can overfit on a small dataset of 50 images. First, we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(Iteration 1 / 40) loss: 2.385904\n", + "(Epoch 0 / 20) train acc: 0.260000; val_acc: 0.112000\n", + "(Epoch 1 / 20) train acc: 0.380000; val_acc: 0.113000\n", + "(Epoch 2 / 20) train acc: 0.480000; val_acc: 0.109000\n", + "(Epoch 3 / 20) train acc: 0.680000; val_acc: 0.157000\n", + "(Epoch 4 / 20) train acc: 0.600000; val_acc: 0.123000\n", + "(Epoch 5 / 20) train acc: 0.700000; val_acc: 0.144000\n", + "(Iteration 11 / 40) loss: 0.986071\n", + "(Epoch 6 / 20) train acc: 0.740000; val_acc: 0.153000\n", + "(Epoch 7 / 20) train acc: 0.820000; val_acc: 0.168000\n", + "(Epoch 8 / 20) train acc: 0.900000; val_acc: 0.172000\n", + "(Epoch 9 / 20) train acc: 0.920000; val_acc: 0.187000\n", + "(Epoch 10 / 20) train acc: 0.900000; val_acc: 0.160000\n", + "(Iteration 21 / 40) loss: 0.258918\n", + "(Epoch 11 / 20) train acc: 0.980000; val_acc: 0.171000\n", + "(Epoch 12 / 20) train acc: 0.920000; val_acc: 0.182000\n", + "(Epoch 13 / 20) train acc: 0.980000; val_acc: 0.189000\n", + "(Epoch 14 / 20) train acc: 0.960000; val_acc: 0.194000\n", + "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.177000\n", + "(Iteration 31 / 40) loss: 0.117595\n", + "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.174000\n", + "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.188000\n", + "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.189000\n", + "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.181000\n", + "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.182000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# TODO: Use a three-layer Net to overfit 50 training examples by \n", + "# tweaking just the learning rate and initialization scale.\n", + "\n", + "num_train = 50\n", + "small_data = {\n", + " \"X_train\": data[\"X_train\"][:num_train],\n", + " \"y_train\": data[\"y_train\"][:num_train],\n", + " \"X_val\": data[\"X_val\"],\n", + " \"y_val\": data[\"y_val\"],\n", + "}\n", + "\n", + "weight_scale = 1e-2 # Experiment with this!\n", + "learning_rate = 1e-2 # Experiment with this!\n", + "model = FullyConnectedNet(\n", + " [100, 100],\n", + " weight_scale=weight_scale,\n", + " dtype=np.float64\n", + ")\n", + "solver = Solver(\n", + " model,\n", + " small_data,\n", + " print_every=10,\n", + " num_epochs=20,\n", + " batch_size=25,\n", + " update_rule=\"sgd\",\n", + " optim_config={\"learning_rate\": learning_rate},\n", + ")\n", + "solver.train()\n", + "\n", + "plt.plot(solver.loss_history)\n", + "plt.title(\"Training loss history\")\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"Training loss\")\n", + "plt.grid(linestyle='--', linewidth=0.5)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, try to use a five-layer network with 100 units on each layer to overfit on 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(Iteration 1 / 40) loss: 4.783901\n", + "(Epoch 0 / 20) train acc: 0.220000; val_acc: 0.114000\n", + "(Epoch 1 / 20) train acc: 0.400000; val_acc: 0.114000\n", + "(Epoch 2 / 20) train acc: 0.460000; val_acc: 0.131000\n", + "(Epoch 3 / 20) train acc: 0.700000; val_acc: 0.115000\n", + "(Epoch 4 / 20) train acc: 0.740000; val_acc: 0.149000\n", + "(Epoch 5 / 20) train acc: 0.880000; val_acc: 0.125000\n", + "(Iteration 11 / 40) loss: 0.549426\n", + "(Epoch 6 / 20) train acc: 0.920000; val_acc: 0.126000\n", + "(Epoch 7 / 20) train acc: 0.940000; val_acc: 0.136000\n", + "(Epoch 8 / 20) train acc: 0.940000; val_acc: 0.146000\n", + "(Epoch 9 / 20) train acc: 0.960000; val_acc: 0.142000\n", + "(Epoch 10 / 20) train acc: 0.980000; val_acc: 0.134000\n", + "(Iteration 21 / 40) loss: 0.289741\n", + "(Epoch 11 / 20) train acc: 0.980000; val_acc: 0.144000\n", + "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.139000\n", + "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.135000\n", + "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.139000\n", + "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.140000\n", + "(Iteration 31 / 40) loss: 0.113694\n", + "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.140000\n", + "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.138000\n", + "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.136000\n", + "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.145000\n", + "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.142000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# TODO: Use a five-layer Net to overfit 50 training examples by \n", + "# tweaking just the learning rate and initialization scale.\n", + "\n", + "num_train = 50\n", + "small_data = {\n", + " 'X_train': data['X_train'][:num_train],\n", + " 'y_train': data['y_train'][:num_train],\n", + " 'X_val': data['X_val'],\n", + " 'y_val': data['y_val'],\n", + "}\n", + "\n", + "learning_rate = 5e-3 # Experiment with this!\n", + "weight_scale = 5e-2 # Experiment with this!\n", + "model = FullyConnectedNet(\n", + " [100, 100, 100, 100],\n", + " weight_scale=weight_scale,\n", + " dtype=np.float64\n", + ")\n", + "solver = Solver(\n", + " model,\n", + " small_data,\n", + " print_every=10,\n", + " num_epochs=20,\n", + " batch_size=25,\n", + " update_rule='sgd',\n", + " optim_config={'learning_rate': learning_rate},\n", + ")\n", + "solver.train()\n", + "\n", + "plt.plot(solver.loss_history)\n", + "plt.title('Training loss history')\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Training loss')\n", + "plt.grid(linestyle='--', linewidth=0.5)\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "tags": [ + "pdf-inline" + ] + }, + "source": [ + "## Inline Question 1: \n", + "Did you notice anything about the comparative difficulty of training the three-layer network vs. training the five-layer network? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n", + "\n", + "## Answer:\n", + "[5 layer net이 3 layer net보다 weight initaliation scale에 더 sensitive한 것으로 보인다. 네트워크가 깊어질수록, 작은 weight scale은 vanishing gradients/큰 weight scale은 exploding gradients 문제가 더욱 많이 발생할 것으로 예상된다.]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Update rules\n", + "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## SGD+Momentum\n", + "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n", + "\n", + "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from cs231n.optim import sgd_momentum\n", + "\n", + "N, D = 4, 5\n", + "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n", + "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n", + "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n", + "\n", + "config = {\"learning_rate\": 1e-3, \"velocity\": v}\n", + "next_w, _ = sgd_momentum(w, dw, config=config)\n", + "\n", + "expected_next_w = np.asarray([\n", + " [ 0.1406, 0.20738947, 0.27417895, 0.34096842, 0.40775789],\n", + " [ 0.47454737, 0.54133684, 0.60812632, 0.67491579, 0.74170526],\n", + " [ 0.80849474, 0.87528421, 0.94207368, 1.00886316, 1.07565263],\n", + " [ 1.14244211, 1.20923158, 1.27602105, 1.34281053, 1.4096 ]])\n", + "expected_velocity = np.asarray([\n", + " [ 0.5406, 0.55475789, 0.56891579, 0.58307368, 0.59723158],\n", + " [ 0.61138947, 0.62554737, 0.63970526, 0.65386316, 0.66802105],\n", + " [ 0.68217895, 0.69633684, 0.71049474, 0.72465263, 0.73881053],\n", + " [ 0.75296842, 0.76712632, 0.78128421, 0.79544211, 0.8096 ]])\n", + "\n", + "# Should see relative errors around e-8 or less\n", + "print(\"next_w error: \", rel_error(next_w, expected_next_w))\n", + "print(\"velocity error: \", rel_error(expected_velocity, config[\"velocity\"]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "num_train = 4000\n", + "small_data = {\n", + " 'X_train': data['X_train'][:num_train],\n", + " 'y_train': data['y_train'][:num_train],\n", + " 'X_val': data['X_val'],\n", + " 'y_val': data['y_val'],\n", + "}\n", + "\n", + "solvers = {}\n", + "\n", + "for update_rule in ['sgd', 'sgd_momentum']:\n", + " print('Running with ', update_rule)\n", + " model = FullyConnectedNet(\n", + " [100, 100, 100, 100, 100],\n", + " weight_scale=5e-2\n", + " )\n", + "\n", + " solver = Solver(\n", + " model,\n", + " small_data,\n", + " num_epochs=5,\n", + " batch_size=100,\n", + " update_rule=update_rule,\n", + " optim_config={'learning_rate': 5e-3},\n", + " verbose=True,\n", + " )\n", + " solvers[update_rule] = solver\n", + " solver.train()\n", + "\n", + "fig, axes = plt.subplots(3, 1, figsize=(15, 15))\n", + "\n", + "axes[0].set_title('Training loss')\n", + "axes[0].set_xlabel('Iteration')\n", + "axes[1].set_title('Training accuracy')\n", + "axes[1].set_xlabel('Epoch')\n", + "axes[2].set_title('Validation accuracy')\n", + "axes[2].set_xlabel('Epoch')\n", + "\n", + "for update_rule, solver in solvers.items():\n", + " axes[0].plot(solver.loss_history, label=f\"loss_{update_rule}\")\n", + " axes[1].plot(solver.train_acc_history, label=f\"train_acc_{update_rule}\")\n", + " axes[2].plot(solver.val_acc_history, label=f\"val_acc_{update_rule}\")\n", + " \n", + "for ax in axes:\n", + " ax.legend(loc=\"best\", ncol=4)\n", + " ax.grid(linestyle='--', linewidth=0.5)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## RMSProp and Adam\n", + "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n", + "\n", + "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n", + "\n", + "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n", + "\n", + "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n", + "\n", + "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Test RMSProp implementation\n", + "from cs231n.optim import rmsprop\n", + "\n", + "N, D = 4, 5\n", + "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n", + "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n", + "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n", + "\n", + "config = {'learning_rate': 1e-2, 'cache': cache}\n", + "next_w, _ = rmsprop(w, dw, config=config)\n", + "\n", + "expected_next_w = np.asarray([\n", + " [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n", + " [-0.132737, -0.08078555, -0.02881884, 0.02316247, 0.07515774],\n", + " [ 0.12716641, 0.17918792, 0.23122175, 0.28326742, 0.33532447],\n", + " [ 0.38739248, 0.43947102, 0.49155973, 0.54365823, 0.59576619]])\n", + "expected_cache = np.asarray([\n", + " [ 0.5976, 0.6126277, 0.6277108, 0.64284931, 0.65804321],\n", + " [ 0.67329252, 0.68859723, 0.70395734, 0.71937285, 0.73484377],\n", + " [ 0.75037008, 0.7659518, 0.78158892, 0.79728144, 0.81302936],\n", + " [ 0.82883269, 0.84469141, 0.86060554, 0.87657507, 0.8926 ]])\n", + "\n", + "# You should see relative errors around e-7 or less\n", + "print('next_w error: ', rel_error(expected_next_w, next_w))\n", + "print('cache error: ', rel_error(expected_cache, config['cache']))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Test Adam implementation\n", + "from cs231n.optim import adam\n", + "\n", + "N, D = 4, 5\n", + "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n", + "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n", + "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n", + "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n", + "\n", + "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n", + "next_w, _ = adam(w, dw, config=config)\n", + "\n", + "expected_next_w = np.asarray([\n", + " [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n", + " [-0.1380274, -0.08544591, -0.03286534, 0.01971428, 0.0722929],\n", + " [ 0.1248705, 0.17744702, 0.23002243, 0.28259667, 0.33516969],\n", + " [ 0.38774145, 0.44031188, 0.49288093, 0.54544852, 0.59801459]])\n", + "expected_v = np.asarray([\n", + " [ 0.69966, 0.68908382, 0.67851319, 0.66794809, 0.65738853,],\n", + " [ 0.64683452, 0.63628604, 0.6257431, 0.61520571, 0.60467385,],\n", + " [ 0.59414753, 0.58362676, 0.57311152, 0.56260183, 0.55209767,],\n", + " [ 0.54159906, 0.53110598, 0.52061845, 0.51013645, 0.49966, ]])\n", + "expected_m = np.asarray([\n", + " [ 0.48, 0.49947368, 0.51894737, 0.53842105, 0.55789474],\n", + " [ 0.57736842, 0.59684211, 0.61631579, 0.63578947, 0.65526316],\n", + " [ 0.67473684, 0.69421053, 0.71368421, 0.73315789, 0.75263158],\n", + " [ 0.77210526, 0.79157895, 0.81105263, 0.83052632, 0.85 ]])\n", + "\n", + "# You should see relative errors around e-7 or less\n", + "print('next_w error: ', rel_error(expected_next_w, next_w))\n", + "print('v error: ', rel_error(expected_v, config['v']))\n", + "print('m error: ', rel_error(expected_m, config['m']))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n", + "for update_rule in ['adam', 'rmsprop']:\n", + " print('Running with ', update_rule)\n", + " model = FullyConnectedNet(\n", + " [100, 100, 100, 100, 100],\n", + " weight_scale=5e-2\n", + " )\n", + " solver = Solver(\n", + " model,\n", + " small_data,\n", + " num_epochs=5,\n", + " batch_size=100,\n", + " update_rule=update_rule,\n", + " optim_config={'learning_rate': learning_rates[update_rule]},\n", + " verbose=True\n", + " )\n", + " solvers[update_rule] = solver\n", + " solver.train()\n", + " print()\n", + " \n", + "fig, axes = plt.subplots(3, 1, figsize=(15, 15))\n", + "\n", + "axes[0].set_title('Training loss')\n", + "axes[0].set_xlabel('Iteration')\n", + "axes[1].set_title('Training accuracy')\n", + "axes[1].set_xlabel('Epoch')\n", + "axes[2].set_title('Validation accuracy')\n", + "axes[2].set_xlabel('Epoch')\n", + "\n", + "for update_rule, solver in solvers.items():\n", + " axes[0].plot(solver.loss_history, label=f\"{update_rule}\")\n", + " axes[1].plot(solver.train_acc_history, label=f\"{update_rule}\")\n", + " axes[2].plot(solver.val_acc_history, label=f\"{update_rule}\")\n", + " \n", + "for ax in axes:\n", + " ax.legend(loc='best', ncol=4)\n", + " ax.grid(linestyle='--', linewidth=0.5)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [ + "pdf-inline" + ] + }, + "source": [ + "## Inline Question 2:\n", + "\n", + "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n", + "\n", + "```\n", + "cache += dw**2\n", + "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n", + "```\n", + "\n", + "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n", + "\n", + "\n", + "## Answer: \n", + "[FILL THIS IN]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train a Good Model!\n", + "Train the best fully connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully connected network.\n", + "\n", + "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional networks rather than fully connected networks.\n", + "\n", + "**Note:** You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "best_model = None\n", + "\n", + "################################################################################\n", + "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might #\n", + "# find batch/layer normalization and dropout useful. Store your best model in #\n", + "# the best_model variable. #\n", + "################################################################################\n", + "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n", + "\n", + "pass\n", + "\n", + "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n", + "################################################################################\n", + "# END OF YOUR CODE #\n", + "################################################################################" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test Your Model!\n", + "Run your best model on the validation and test sets. You should achieve at least 50% accuracy on the validation set." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n", + "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n", + "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n", + "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cs231n", + "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.8.16" + }, + "vscode": { + "interpreter": { + "hash": "5e00141dcb59c9550fed165717cca77960dd1735615929409445b81de918a119" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}