explanations/optimizers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimizers\n",
    "\n",
    "In the last few lessons, we learned how to build several neural network architectures.  We used gradient descent, a technique we originally learned in the [dense neural network](https://github.com/VikParuchuri/zero_to_gpt/blob/master/explanations/dense.ipynb) lesson, to adjust model parameters.\n",
    "\n",
    "Gradient descent is a type of optimizer.  Optimizers adjust neural network parameters to try to get loss to (hopefully) a global minimum value.  In this lesson, we'll learn more about optimizers.  We'll first go into more depth on gradient descent, and discuss batch size, learning rate schedules, weight decay, and momentum.  We'll then discuss the Adam optimizer, which is a popular optimizer that extends the idea of momentum.  Adam variants are the most popular optimizers for large language models."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stochastic Gradient Descent\n",
    "\n",
    "The type of optimizer we've used so far is called stochastic gradient descent, or SGD.  In SGD, we take a minibatch of training examples, then compute the average gradient across the minibatch.  We then adjust the parameters using this average gradient.\n",
    "\n",
    "Let's define a three-layer dense neural network, then explore the effect of batch size on our loss over time.  We'll first load in a dataset of house prices.\n",
    "\n",
    "Each row in this dataset represents a single house.  The predictor columns are:\n",
    "\n",
    "- `interest`: The interest rate\n",
    "- `vacancy`: The vacancy rate\n",
    "- `cpi`: The consumer price index\n",
    "- `price`: The price of a house\n",
    "- `value`: The value of a house\n",
    "- `adj_price`: The price of a house, adjusted for inflation\n",
    "- `adj_value`: The value of a house, adjusted for inflation\n",
    "\n",
    "The predictor columns have all been scaled using the scikit-learn `StandardScaler`.  This gives each column a mean of 0 and a standard deviation of 1.  This makes it easier to activate our nonlinearities.\n",
    "\n",
    "The target column is `next_quarter`, which is the price of the house in three months.  `next_quarter` has been scaled so the minimum value is `0`, and it has been divided by `1000` and rounded to the nearest integer.  This makes the prediction task simpler for our network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys, os\n",
    "sys.path.append(os.path.abspath('../data'))\n",
    "from csv_data import HousePricesDatasetWrapper\n",
    "\n",
    "wrapper = HousePricesDatasetWrapper()\n",
    "train_data, valid_data, test_data = wrapper.get_flat_datasets()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.94509048,  1.39642758, -1.52275521, -0.64519476, -0.11676266,\n",
       "        -0.13891486,  0.8225858 ],\n",
       "       [ 1.93249288,  1.39642758, -1.49354416, -0.64519476, -0.11676266,\n",
       "        -0.15597175,  0.80219322]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Show the train predictors\n",
    "train_data[0][:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[22.],\n",
       "       [22.]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Show the train target\n",
    "train_data[1][:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we'll define a single layer of our neural network.  We'll make a few modifications from earlier lessons:\n",
    "\n",
    "- Instead of directly updating the parameters, we'll return the weight and bias gradients\n",
    "- We'll add an update method that updates the weights later\n",
    "\n",
    "This will enable us to swap different optimizers in and out of our network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import numpy as np\n",
    "\n",
    "class Dense():\n",
    "    def __init__(self, input_size, output_size, activation=True, seed=0):\n",
    "        self.add_activation = activation\n",
    "        self.hidden = None\n",
    "        self.prev_hidden = None\n",
    "\n",
    "        # Initialize the weights.  They'll be in the range -sqrt(k) to sqrt(k), where k = 1 / input_size\n",
    "        np.random.seed(seed)\n",
    "        k = math.sqrt(1 / input_size)\n",
    "        self.weights = np.random.rand(input_size, output_size) * (2 * k) - k\n",
    "\n",
    "        # Our bias will be initialized to 1\n",
    "        self.bias = np.ones((1,output_size))\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Copy the layer input for backprop\n",
    "        self.prev_hidden = x.copy()\n",
    "        # Multiply the input by the weights, then add the bias\n",
    "        x = np.matmul(x, self.weights) + self.bias\n",
    "        # Apply the activation function\n",
    "        if self.add_activation:\n",
    "            x = np.maximum(x, 0)\n",
    "        # Copy the layer output for backprop\n",
    "        self.hidden = x.copy()\n",
    "        return x\n",
    "\n",
    "    def backward(self, grad):\n",
    "        # \"Undo\" the activation function if it was added\n",
    "        if self.add_activation:\n",
    "            grad = np.multiply(grad, np.heaviside(self.hidden, 0))\n",
    "\n",
    "        # Calculate the parameter gradients\n",
    "        w_grad = self.prev_hidden.T @ grad # This is not averaged across the batch, due to the way matrix multiplication sums\n",
    "        b_grad = np.mean(grad, axis=0) # This is averaged across the batch\n",
    "        param_grads = [w_grad, b_grad]\n",
    "\n",
    "        # Calculate the next layer gradient\n",
    "        grad = grad @ self.weights.T\n",
    "        return param_grads, grad\n",
    "\n",
    "    def update(self, w_grad, b_grad):\n",
    "        # Update the weights given an update matrix\n",
    "        self.weights += w_grad\n",
    "        self.bias += b_grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then use the `Dense` class to create a 3-layer neural network.  The first layer will take in our predictors and generate `25` hidden features, the second layer combine those features into `10` new features, and the final layer will make a prediction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "layers = [\n",
    "    Dense(7, 25),\n",
    "    Dense(25, 10),\n",
    "    Dense(10, 1, activation=False)\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll define functions that run forward and backward passes across all the layers together.  `forward` will do a full forward pass across all 3 layers, and `backward` will do a full backward pass across all 3 layers.\n",
    "\n",
    "The backward pass will return the gradients instead of updating the parameters.  We'll use these gradients to update the parameters in our optimizer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward(x, layers):\n",
    "    # Loop through each layer\n",
    "    for layer in layers:\n",
    "        # Run the forward pass\n",
    "        x = layer.forward(x)\n",
    "    return x\n",
    "\n",
    "def backward(grad, layers):\n",
    "    # Save the gradients for each layer\n",
    "    layer_grads = []\n",
    "    # Loop through each layer in reverse order (starting from the output layer)\n",
    "    for layer in reversed(layers):\n",
    "        # Get the parameter gradients and the next layer gradient\n",
    "        param_grads, grad = layer.backward(grad)\n",
    "        layer_grads.append(param_grads)\n",
    "    return layer_grads"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll then define our SGD optimizer, which will take in a set of gradients, and use it to update the network parameters.\n",
    "\n",
    "The process for SGD is:\n",
    "\n",
    "- Normalize the gradient by batch size, so that the gradient is the average gradient across the batch (in our case, our bias gradient is already normalized, but the weight gradient is not)\n",
    "- Multiply the gradient by learning rate\n",
    "- Multiply the gradient by `-1` so it is subtracted from the parameters in the `update` function\n",
    "\n",
    "We'll define the optimizer as a class, so we can keep track of hyperparameters like learning rate.  Overriding the `__call__` method will enable us to call the optimizer like a function for ease of use.  We'll inherit from an `Optimizer` class that I've created that will make it easy for us to graph how the optimizer changes the weights over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys, os\n",
    "sys.path.append(os.path.abspath(\"../nnets\"))\n",
    "\n",
    "# Import the optimizer class\n",
    "from optimizer import Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SGD(Optimizer):\n",
    "    def __init__(self, lr):\n",
    "        # Store hyperparameters\n",
    "        self.lr = lr\n",
    "        super().__init__()\n",
    "\n",
    "    def __call__(self, layer_grads, layers, batch_size, step):\n",
    "        # Loop through the layer grads.  Reverse the layers to match the grads (from output backward to input).\n",
    "        for layer_grad, layer in zip(layer_grads, reversed(layers)):\n",
    "            w_grad, b_grad = layer_grad\n",
    "\n",
    "            # Normalize the weight gradient by batch size\n",
    "            w_grad /= batch_size\n",
    "\n",
    "            # Calculate the update sizes\n",
    "            w_update = -self.lr * w_grad\n",
    "            b_update = -self.lr * b_grad\n",
    "\n",
    "            # Actually do the update\n",
    "            layer.update(w_update, b_update)\n",
    "\n",
    "        # Save the first layer weights to generate a graph later.  This is not part of the SGD algorithm - we're doing it to graph the weight changes.\n",
    "        self.save_vector(layers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Monitoring\n",
    "\n",
    "We can now write a function to train the network using the SGD optimizer and our data.  Since we'll be testing different batch sizes and optimizers, we want a way to monitor our network and compare different runs to wach other.  So far, we've been using print statements to monitor per-epoch accuracy in our network, which is hard to compare to other runs.\n",
    "\n",
    "We'll use a tool called [Weights & Biases](https://wandb.ai) to monitor our network.  We can use it to track the loss and accuracy of our network, and compare different runs to each other.  W&B is a free tool, and you can sign up for an account [here](https://wandb.ai).  If you don't want to use W&B, you can also use TensorBoard, but it's harder to setup and use.\n",
    "\n",
    "We'll start by importing `wandb` and logging in.  We'll also set the `WANDB_SILENT` environment variable to `True`, so that W&B doesn't print out a lot of system messages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: WANDB_SILENT=True\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%env WANDB_SILENT=True\n",
    "\n",
    "import wandb\n",
    "wandb.login()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With W&B, we track each training run separately.  W&B will track the loss in each epoch, or anything else we want to keep track of.  It will also render graphs for us, so we can compare different runs against each other.\n",
    "\n",
    "The key W&B functions are:\n",
    "\n",
    "- `wandb.init` - This will initialize a new run.  We can use the `config` parameter to pass in run-specific information we want to view.\n",
    "- `wandb.log` - This will log a dictionary of metrics to the current run.\n",
    "- `wandb.define_metric` - This will define a metric that we want to track.  You normally don't need to define wandb metrics upfront, but we'll use a custom `step_metric` to ensure that results from runs with different batch sizes line up.\n",
    "\n",
    "We'll use W&B to log a running training loss, the final training set loss each epoch, and the validation set loss.  We'll also track how long each epoch takes to run."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Training Loop\n",
    "\n",
    "We can now write a function that will train our network using SGD, and log the loss to W&B.  This function will be very similar to training loops that we've written in previous lessons.\n",
    "\n",
    "We won't do this here, but you usually want to shuffle your training data each epoch to ensure that batch composition changes.  Random shuffling is important when our batch size is greater than `1`.  As we saw earlier, the gradient is averaged across all the examples in a batch.  Random shuffling will put different training examples together each time, allowing the model to see more combinations of gradients.  This reduces overfitting, and improves the generalization of our network.  It can also make SGD converge faster (get to the global minimum error).\n",
    "\n",
    "In our case, we won't do random shuffling, since the data is time series.  Shuffling can actually cause validation error to increase significantly with time series data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def training_run(epochs, batch_size, optimizer, train_data, valid_data, name=None):\n",
    "    # Initialize a new W&B run, with the right parameters\n",
    "    wandb.init(project=\"optimizers\",\n",
    "               name=name,\n",
    "               config={\"batch_size\": batch_size,\n",
    "                       \"lr\": optimizer.lr,\n",
    "                       \"epochs\": epochs,\n",
    "                       \"optimizer\": type(optimizer).__name__})\n",
    "\n",
    "    # Setup the metrics we want to track with wandb.  You usually don't need to do this, but we want a custom axis for each metric.\n",
    "    wandb.define_metric(\"batch_step\") # This will ensure that results from runs with different batch sizes line up\n",
    "    wandb.define_metric(\"epoch\") # This will ensure that results from runs with different batch sizes line up\n",
    "    wandb.define_metric(\"valid_loss\", step_metric=\"epoch\") # The step metric is the x-axis scale\n",
    "    wandb.define_metric(\"train_loss\", step_metric=\"epoch\")\n",
    "    wandb.define_metric(\"runtime\", step_metric=\"epoch\")\n",
    "    wandb.define_metric(\"running_loss\", step_metric=\"batch_step\")\n",
    "\n",
    "    # Setup the layers for the training run\n",
    "    layers = [\n",
    "        Dense(7, 25),\n",
    "        Dense(25,10),\n",
    "        Dense(10, 1, activation=False)\n",
    "    ]\n",
    "\n",
    "    # Split the training and valid data into x and y\n",
    "    train_x, train_y = train_data\n",
    "    valid_x, valid_y = valid_data\n",
    "\n",
    "    for epoch in range(epochs):\n",
    "        running_loss = 0\n",
    "        start = time.time() # The start time of our run\n",
    "\n",
    "        for i in range(0, len(train_x), batch_size):\n",
    "            # Get the x and y batches\n",
    "            x_batch = train_x[i:(i+batch_size)]\n",
    "            y_batch = train_y[i:(i+batch_size)]\n",
    "            # Make a prediction\n",
    "            pred = forward(x_batch, layers)\n",
    "\n",
    "            # Run the backward pass\n",
    "            loss = pred - y_batch\n",
    "            layer_grads = backward(loss, layers)\n",
    "\n",
    "            # Run the optimizer\n",
    "            step_count = (i + batch_size) // batch_size + epoch * len(train_x) // batch_size\n",
    "            optimizer(layer_grads, layers, batch_size, step_count)\n",
    "\n",
    "            # Update running loss\n",
    "            running_loss += np.mean(loss ** 2)\n",
    "\n",
    "            batch_idx = i + batch_size # Get the last index of the current batch\n",
    "            batch_step = batch_idx + epoch * len(train_x)\n",
    "            # Log running loss.  We multiply by batch size to offset the mean from earlier.\n",
    "            wandb.log({\"running_loss\": running_loss / batch_idx * batch_size, \"batch_step\": batch_step})\n",
    "\n",
    "        # Calculate and log validation loss\n",
    "        valid_preds = forward(valid_x, layers)\n",
    "        valid_loss = np.mean((valid_preds - valid_y) ** 2)\n",
    "        train_loss = running_loss / len(train_x) * batch_size\n",
    "        wandb.log({\n",
    "            \"valid_loss\": valid_loss,\n",
    "            \"epoch\": epoch,\n",
    "            \"train_loss\": train_loss,\n",
    "            \"runtime\": time.time() - start\n",
    "        })\n",
    "\n",
    "    # Mark the run as complete\n",
    "    wandb.finish()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then initialize our hyperparameters and start the run.  We define the optimizer, then pass it into the training loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Setup our parameters\n",
    "epochs = 10\n",
    "batch_size = 4\n",
    "lr = 1e-4\n",
    "\n",
    "# Run our training loop\n",
    "sgd = SGD(lr=lr)\n",
    "training_run(epochs, batch_size, sgd, train_data, valid_data, name=\"sgd_small\")\n",
    "\n",
    "# Plot the path of the weights over time.\n",
    "sgd.plot_path()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should now be able to see your run in W&B.  You will need to click on the `optimizers` project in your [dashboard](https://wandb.ai/home).\n",
    "\n",
    "You should also see a plot above showing how the singular value of the weight matrix in the last layer changes over time.  The x-axis is time, and the y-axis is the singular value.  The red dot is the starting point, and the green dot is the ending point.\n",
    "\n",
    "The final weight matrix is `10x1`, so it only has one singular value.  If you're familiar with linear algebra, the singular value is the result of SVD.  If you're not familiar with linear algebra, you can think of the singular value as how much the weights change the inputs to the last layer.  Graphing the singular value tells us how much the weights in the final layer are stretching the inputs in a single direction.\n",
    "\n",
    "As you can see above, the singular value oscillates a lot over time.  This is because our batch size is small, and the gradients can vary quite a bit from batch to batch.  This is inefficient, since it takes the network more iterations to get to the optimal value.\n",
    "\n",
    "We'll later be able to compare this graph to the graphs from other optimizers to see how they improve on SGD.\n",
    "\n",
    "## Batch Size\n",
    "\n",
    "We can now compare our first run to a run with a higher batch size.  We'll use a batch size of `16`.  We'll increase the number of epochs, to keep the total number of steps the same between runs.  The number of steps is the number of times we run the forward and backward pass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Setup our parameters\n",
    "epochs = 40 # higher number of epochs so total steps are equal for comparison purposes\n",
    "batch_size = 16\n",
    "lr = 1e-4\n",
    "\n",
    "# Run our training loop\n",
    "sgd = SGD(lr=lr)\n",
    "training_run(epochs, batch_size, sgd, train_data, valid_data, name=\"sgd_large\")\n",
    "sgd.plot_path()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should end up with a dashboard that looks like this:\n",
    "\n",
    "![W&B Dashboard](images/optimizers/wandb_comp2.png)\n",
    "\n",
    "We can draw a few conclusions from this graph and the graph of our average weights:\n",
    "\n",
    "1. The higher batch size descends more slowly than a lower batch size\n",
    "2. The higher batch size converges to a higher training and validation loss\n",
    "3. The higher batch size runs each epoch much faster\n",
    "4. A higher batch size has more stable weight updates - the singular value of the weight matrix doesn't get pulled back and forth as much (in the graph)\n",
    "\n",
    "Batch size can make a big impact on the final accuracy of your model.  In general, a higher batch size is a form of regularization (which we'll talk about in depth in a later lesson).  Regularization increases training loss, but decreases validation loss.  This happens because you're averaging over multiple training examples in the batch, and making it harder to overfit to specific examples.  It may seem counterintuitive, but our goal in training neural networks isn't to get the lowest training loss possible.  It's instead to get the lowest validation loss possible.  This is because we want the model to work well on new data that we feed into it after it's been trained.  Regularization helps the model generalize well to new data.\n",
    "\n",
    "Higher batch sizes can run much faster than lower batch sizes.  This is because we're just adding rows to existing matrices.  In practice, if the batch size is too high, then validation loss starts to suffer.  So you need to find the batch size that runs quickly and minimizes validation loss.  This is different for each dataset, so it can take some experimentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Momentum\n",
    "\n",
    "One downside to the basic SGD optimizer is that it has no knowledge of past gradients.  It has to make the decision on how to adjust the parameters based only on the current gradient.  It's like asking you to predict if a stock price will go up or down tomorrow.  If you only know how the stock did today, your guess will be worse than if you know how the stock did over the past year.\n",
    "\n",
    "We can solve this by keeping track of the stock price over time.  More recent stock prices are more informative than older ones, so we might weight the mean exponentially.  The formula would look like:\n",
    "\n",
    "$$\\text{ema}=\\beta \\text{ema} + (1-\\beta) * \\text{price}$$\n",
    "\n",
    "$\\beta$ is the decay coefficient that governs how quickly older values shrink.  $\\text{ema}$ is the exponential moving average."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([8, 9, 9, 8, 2, 3, 7, 3, 7, 2])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Initialize a list of random stock prices between 2 and 10\n",
    "prices = np.random.randint(2,10,10)\n",
    "prices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8.        , 9.        , 9.        , 8.        , 2.        ,\n",
       "        3.        , 7.        , 3.        , 7.        , 2.        ],\n",
       "       [8.        , 8.5       , 8.75      , 8.375     , 5.1875    ,\n",
       "        4.09375   , 5.546875  , 4.2734375 , 5.63671875, 3.81835938]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp_avg = []\n",
    "ema = prices[0] # Store the moving average.  Initialize it to the first value.\n",
    "decay = .5 # How fast the values decay.  The higher this is, the more we care about past values\n",
    "\n",
    "# Calculate the exponential average\n",
    "for i in range(prices.shape[0]):\n",
    "    ema = ema * decay + (1-decay) * prices[i]\n",
    "    exp_avg.append(ema)\n",
    "np.vstack((prices, exp_avg))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see above, the exponential moving average moves around less than the prices.  This is useful when we want to minimize the effect of outliers.\n",
    "\n",
    "When we apply this to SGD, it is called momentum.  With momentum, we give the optimizer knowledge of the direction the gradient is moving in.  We do this by using an exponential moving average of the history of the gradient.  When we make a parameter update, we combine this exponential moving average with the current gradient value.\n",
    "\n",
    "The equation for SGD with momentum looks like:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "v_t &= \\beta v_{t-1} - \\alpha \\nabla L(w_t) \\\\\n",
    "w_{t+1} &= w_t + v_t\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "$v_{t-1}$ is the previous momentum value, $\\beta$ is a parameter that controls how quickly the momentum decays, $\\alpha$ is the learning rate, and $\\nabla L(w_t)$ is the gradient of the loss with respect to the parameter.  We use a slightly different formula from the `ema` formula we used earlier so that the velocity doesn't start out very close to `0` for several iterations (this happens if you multiply the gradient by $(1-\\beta)$.\n",
    "\n",
    "Each iteration, we update the momentum, then combine it with the current gradient.  We then update the parameter based on the combined value.  We say that the momentum exponentially decays since each value added to the velocity will be multiplied by $\\beta$ once per update.\n",
    "\n",
    "Intuitively, this stops the weight value from changing as drastically between iterations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SGDMomentum(Optimizer):\n",
    "    def __init__(self, lr, beta):\n",
    "        # Store hyperparameters\n",
    "        self.lr = lr\n",
    "        self.beta = beta\n",
    "        # Used to store history of momentum\n",
    "        self.momentums = None\n",
    "\n",
    "        super().__init__()\n",
    "\n",
    "    def initialize_momentums(self, layer_grads):\n",
    "        self.momentums = []\n",
    "\n",
    "        # Initialize momentums to have the same shape as the parameters\n",
    "        for layer_grad in layer_grads:\n",
    "            w_grad, b_grad = layer_grad\n",
    "            initial_momentums = [np.zeros_like(w_grad), np.zeros_like(b_grad)]\n",
    "            self.momentums.append(initial_momentums)\n",
    "\n",
    "    def __call__(self, layer_grads, layers, batch_size, step):\n",
    "        if self.momentums is None:\n",
    "            self.initialize_momentums(layer_grads)\n",
    "\n",
    "        # Used to store momentums for the next parameter update\n",
    "        new_momentums = []\n",
    "        for layer_grad, momentum, layer in zip(layer_grads, self.momentums, reversed(layers)):\n",
    "            w_grad, b_grad = layer_grad\n",
    "            w_vel, b_vel = momentum\n",
    "\n",
    "            # Normalize the weight gradient by batch size\n",
    "            w_grad /= batch_size\n",
    "\n",
    "            # Calculate the update sizes\n",
    "            w_vel = w_vel * self.beta - self.lr * w_grad\n",
    "            b_vel = b_vel * self.beta - self.lr * b_grad\n",
    "\n",
    "            layer.update(w_vel, b_vel)\n",
    "            new_momentums.append([w_vel, b_vel])\n",
    "        self.momentums = new_momentums\n",
    "        self.save_vector(layers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Setup our parameters\n",
    "epochs = 40\n",
    "batch_size = 16\n",
    "lr = 1e-4\n",
    "beta = .9\n",
    "\n",
    "# Run our training loop\n",
    "sgd = SGDMomentum(lr, beta)\n",
    "training_run(epochs, batch_size, sgd, train_data, valid_data, name=\"sgd_momentum\")\n",
    "sgd.plot_path()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we look at the graph above and the W&B dashboard, we notice a few things about SGD with momentum:\n",
    "\n",
    "- It descends faster than vanilla SGD\n",
    "- The train and validation losses end up lower\n",
    "- The weight updates seem to be more consistent\n",
    "\n",
    "Momentum can help neural networks avoid local minima, and can improve training efficiency.\n",
    "\n",
    "## Adam\n",
    "\n",
    "SGD uses what is called the first moment of the gradient, which is the mean.  It keeps track of a moving average (mean) of the gradient over time.  It doesn't have any information about how different one gradient is from the next.  To know this, we'd have to track the variance, or the second moment of the gradient.  The variance tells us how much the gradient varies across batches.\n",
    "\n",
    "Adam is an optimizer that extends SGD to use the second moment.  It also corrects the moving average of the first and second moment so that they don't stay close to 0 during the first few iterations.\n",
    "\n",
    "With Adam, we first calculate the moving average of the first moment $m$ and the second moment $v$.  We now have 2 exponential decay coefficients, $\\beta_1$ and $\\beta_{2}$:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "m_t &= \\beta_1 m_{t-1} + (1 - \\beta_1) \\nabla L(w_t) \\\\\n",
    "v_t &= \\beta_2 v_{t-1} + (1 - \\beta_2) \\nabla L(w_t)^2\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "Normally, the variance is centered by subtracting the mean before squaring.  In this case, we calculate the uncentered variance, since we don't know the population mean.  We then correct the values, so that they aren't too small in the first few iterations:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\hat{m}_t &= \\frac{m_t}{1 - \\beta_1^t} \\\\\n",
    "\\hat{v}t &= \\frac{v_t}{1 - \\beta_2^t}\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "Note that the correct factor is raised to the power $t$, which is the index of the iteration we're on.  This start $1-\\beta_1^t$ out at a very low number, then increase it towards `1` as we progress.  This will increase the value of $m_t$ early on, and not change it in later iterations.  This corrects for the fact that the exponential moving averages are initialized with value `0`, which is below the true moving average of the gradient values.\n",
    "\n",
    "We then update the parameters:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "w_{t+1} &= w_t - \\alpha\\frac{\\hat{m}_t}{\\sqrt{\\hat{v}_t} + \\epsilon}\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "$\\alpha$ is our learning rate, and $\\epsilon$ is a small tolerance value to avoid dividing by a number that is too small and will cause numerical instability.  It works lik the tolerance we used in an earlier lesson on softmax.\n",
    "\n",
    "We can look at an example of how this works by going back to our stock prices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8.00000000e+00, 9.00000000e+00, 9.00000000e+00, 8.00000000e+00,\n",
       "        2.00000000e+00, 3.00000000e+00, 7.00000000e+00, 3.00000000e+00,\n",
       "        7.00000000e+00, 2.00000000e+00],\n",
       "       [8.00000000e+00, 1.13333333e+01, 1.16190476e+01, 1.04634921e+01,\n",
       "        6.43277010e+00, 4.79124830e+00, 5.94204639e+00, 4.48855662e+00,\n",
       "        5.75551956e+00, 3.88155036e+00],\n",
       "       [6.40000000e+01, 3.45789474e+02, 1.17826762e+03, 3.10218337e+03,\n",
       "        6.81879572e+03, 1.30993453e+04, 2.26073236e+04, 3.57266370e+04,\n",
       "        5.24974680e+04, 7.25419272e+04]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Initialize a list of random stock prices between 2 and 10\n",
    "prices = np.random.randint(2,10,10)\n",
    "\n",
    "exp_avg = []\n",
    "exp_var = []\n",
    "\n",
    "ema = 0 # Store the moving average.  Initialize it to 0.\n",
    "emv = 0 # Moving variance.\n",
    "\n",
    "beta1 = .5 # How fast the ema decays.  The higher this is, the more we care about past values\n",
    "beta2 = .9\n",
    "\n",
    "# Calculate the first and second moments\n",
    "for i in range(prices.shape[0]):\n",
    "    # First moment\n",
    "    ema = ema * beta1 + (1-beta1) * prices[i]\n",
    "    ema /= (1 - beta1 ** (i+1)) # this will increase the ema when we're starting out.  Over time, `beta1 ** i` will decrease to close to 0.\n",
    "    exp_avg.append(ema)\n",
    "\n",
    "    # Second moment\n",
    "    emv = emv * beta2 + (1-beta2) * prices[i] ** 2\n",
    "    emv /= (1 - beta2 ** (i+1))\n",
    "    exp_var.append(emv)\n",
    "np.vstack((prices, exp_avg, exp_var))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see above, we keep track of both the mean and the variance.  We can now implement the Adam optimizer in code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "\n",
    "class Adam(Optimizer):\n",
    "    def __init__(self, lr, beta1, beta2, eps, decay):\n",
    "        # Track hyperparameters\n",
    "        self.lr = lr\n",
    "        self.beta1 = beta1\n",
    "        self.beta2 = beta2\n",
    "        self.eps = eps\n",
    "        self.decay = decay\n",
    "\n",
    "        # Track first and secone moment\n",
    "        self.moments = None\n",
    "\n",
    "        super().__init__()\n",
    "\n",
    "    def initialize_moments(self, layer_grads):\n",
    "        self.moments = []\n",
    "        for layer_grad in layer_grads:\n",
    "            w_grad, b_grad = layer_grad\n",
    "            # Initialize arrays to hold first moment values\n",
    "            moment1 = [np.zeros_like(w_grad), np.zeros_like(b_grad)]\n",
    "            moment2 = deepcopy(moment1)\n",
    "            self.moments.append([moment1, moment2])\n",
    "\n",
    "    def __call__(self, layer_grads, layers, batch_size, step):\n",
    "        if self.moments is None:\n",
    "            self.initialize_moments(layer_grads)\n",
    "\n",
    "        new_moments = []\n",
    "        for layer_grad, moment, layer in zip(layer_grads, self.moments, reversed(layers)):\n",
    "            w_grad, b_grad = layer_grad\n",
    "            moment1, moment2 = moment\n",
    "\n",
    "            # Normalize the weight gradient by batch size\n",
    "            w_grad /= batch_size\n",
    "\n",
    "            corrected_moments = []\n",
    "            for i, grad in enumerate([w_grad, b_grad]):\n",
    "                # Calculate the first and second moments\n",
    "                moment1[i] = moment1[i] * self.beta1 + (1 - self.beta1) * grad\n",
    "                moment2[i] = moment2[i] * self.beta2 + (1 - self.beta2) * np.square(grad)\n",
    "\n",
    "                # Correct the moments\n",
    "                corrected_moments.append([\n",
    "                    moment1[i] / (1 - self.beta1 ** step),\n",
    "                    moment2[i] / (1 - self.beta2 ** step)\n",
    "                ])\n",
    "\n",
    "            # Calculate the updates\n",
    "            w_update = -self.lr * corrected_moments[0][0] / (corrected_moments[0][1] ** .5 + self.eps)\n",
    "            b_update = -self.lr * corrected_moments[1][0] / (corrected_moments[1][1] ** .5 + self.eps)\n",
    "            layer.update(w_update, b_update)\n",
    "\n",
    "            # Save moments for next iteration\n",
    "            new_moments.append([moment1, moment2])\n",
    "        self.moments = new_moments\n",
    "        self.save_vector(layers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Setup our parameters\n",
    "epochs = 40\n",
    "batch_size = 16\n",
    "lr = 1e-3\n",
    "\n",
    "# Run our training loop\n",
    "adam = Adam(lr, .9, .999, 1e-8, .1)\n",
    "training_run(epochs, batch_size, adam, train_data, valid_data, name=\"adam\")\n",
    "adam.plot_path()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the chart and the W&B dashboard tells us a few things:\n",
    "\n",
    "- Adam updates weights smoothly, without big oscillations\n",
    "- Adam descends to a lower training loss than sgd with momentum, but a higher validation loss\n",
    "- Adam descends smoothly\n",
    "\n",
    "In this case, Adam seems to have overfit our data relative to SGD with momentum.  A variant of Adam, called AdamW, corrects for this by regularizing the parameter values.  We'll learn about AdamW in a later lesson.\n",
    "\n",
    "One downside of Adam is that it has large memory requirements.  As you saw in the `initialize_moments` method, we had to make 2 arrays of equal size for each parameter array.  The gradient is also an array of equal size to the original parameter.  So Adam requires 4x as much memory as you would need to just store your parameters.  SGD only requires 2x (1x for the parameters, and 1x for the gradient).  We'll learn more about how to mitigate this in later lessons."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning Rate Schedule\n",
    "\n",
    "The most important hyperparameter for any optimizer is the learning rate.  The learning rate directly impacts how well gradient descent works.  So far, we've used a fixed learning rate that doesn't change during training.\n",
    "\n",
    "In practice, it's common to use a learning rate scheduler.  A learning rate scheduler changes the learning rate during training.  This helps the model converge, and avoid taking gradient descent steps that are too large.\n",
    "\n",
    "It's common to alter the learning rate in two ways:\n",
    "\n",
    "- Set the learning rate low initially as a warmup phase.  This helps to stabilize training, and avoid large gradient steps initially.\n",
    "- Gradually lower the learning rate in subsequent epochs.  This makes the model take smaller steps as time goes on.\n",
    "\n",
    "We can see how these 2 concepts work by implementing them.  First, we can modify an optimizer to take in a scheduler:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SGD(Optimizer):\n",
    "    def __init__(self, scheduler):\n",
    "        # Store scheduler\n",
    "        self.scheduler = scheduler\n",
    "        self.lr = self.scheduler.lr\n",
    "        super().__init__()\n",
    "\n",
    "    def __call__(self, layer_grads, layers, batch_size, step):\n",
    "        # Loop through the layer grads.  Reverse the layers to match the grads (from output backward to input).\n",
    "        for layer_grad, layer in zip(layer_grads, reversed(layers)):\n",
    "            w_grad, b_grad = layer_grad\n",
    "\n",
    "            # Normalize the weight gradient by batch size\n",
    "            w_grad /= batch_size\n",
    "\n",
    "            # Call scheduler to get learning rate\n",
    "            lr = self.scheduler(step)\n",
    "            # Calculate the update sizes\n",
    "            w_update = -lr * w_grad\n",
    "            b_update = -lr * b_grad\n",
    "\n",
    "            # Actually do the update\n",
    "            layer.update(w_update, b_update)\n",
    "\n",
    "        # Save the first layer weights to generate a graph later.  This is not part of the SGD algorithm - we're doing it to graph the weight changes.\n",
    "        self.save_vector(layers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we can define a scheduler.  This scheduler will linearly increase the learning rate for a specified number of warmup steps, then decrease it linearly throughout training:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from optimizer import Scheduler\n",
    "\n",
    "class LinearScheduler(Scheduler):\n",
    "    def __init__(self, lr, total_steps, warmup_steps=1000):\n",
    "        # Setup parameters of scheduler\n",
    "        self.total_steps = total_steps\n",
    "        self.warmup_steps = warmup_steps\n",
    "        self.lr = lr\n",
    "\n",
    "    def __call__(self, step):\n",
    "        # If we're warming up, return the scaled learning rate\n",
    "        if step <= self.warmup_steps:\n",
    "            return self.lr * step / self.warmup_steps\n",
    "\n",
    "        # Scale the learning rate linearly down after warmup\n",
    "        decay_steps = self.total_steps - self.warmup_steps\n",
    "        return self.lr - self.lr * (step - self.warmup_steps) / decay_steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualize how the learning rate will change during training:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "schedule = LinearScheduler(1e-3, 1000, 100)\n",
    "schedule.plot_lr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we can test our scheduler:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Setup our parameters\n",
    "epochs = 40 # higher number of epochs so total steps are equal for comparison purposes\n",
    "batch_size = 16\n",
    "lr = 1e-4\n",
    "\n",
    "# Run our training loop\n",
    "schedule = LinearScheduler(lr, epochs * len(train_data) // batch_size, 10000)\n",
    "sgd = SGD(schedule)\n",
    "training_run(epochs, batch_size, sgd, train_data, valid_data, name=\"sgd_scheduled\")\n",
    "sgd.plot_path()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, descent looks much worse with a scheduler.  We typically use a scheduler when we're training models for a much longer duration than we are here.  In those cases, schedulers can significantly improve descent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wrap-up\n",
    "\n",
    "We've learned a ton in this lesson!  We've covered SGD, momentum, Adam, and learning rate scheduling.  These are very important concepts when you're training LLMs, and I hope you'll spend some time experimenting and trying to implement these optimizers on your own.  Building an intuition around how different hyperparameters affect gradient descent is also important.\n",
    "\n",
    "In the next lesson, we'll cover PyTorch, a framework that automatically handles the backward pass of neural networks!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}