hw1-checkpointing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kmYWeWHqIAKX"
   },
   "source": [
    "# Checkpointing\n",
    "\n",
    "Your task is to implement checkpointing for a MLP using NumPy.\n",
    "\n",
    "You are free to use the implementation of a MLP and the backpropagation algorithm that you have developed during lab sessions.\n",
    "\n",
    "The key takeaway from this task is that with checkpointing we can trade off the computational resources needed to compute the forward pass of the network for the memory requirement needed to perform a backward pass in the network, which is often a major bottleneck when training large networks. In plain english, we can slightly increase the time required for training our network to save some of our GPU's precious memory.\n",
    "\n",
    "## What is checkpointing?\n",
    "\n",
    "The aim of checkpointing is to save every $n$-th layer's (e.g. every 2-nd layer's) forward result (instead of saving every layer's forward result as in plain backpropagation) and use these checkpoints for recomputing the forward pass of the network upon doing a backward pass. Checkpoint layers are kept in memory after the forward pass, while the remaining activations are recomputed at most once. After being recomputed, the non-checkpoint layers are kept in memory until they are no longer required."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zwft3A6_IAKb"
   },
   "source": [
    "# What should be done\n",
    "\n",
    "1. Take the implementation a MLP trained with backpropagation. Analyze the algorithm with respect to the memory that is used by the algorithm with respect to the number of hidden layers.\n",
    "\n",
    "2. Implement a class NetworkWithCheckpointing that inherits from the Network class defined during lab sessions by:\n",
    "    a) implementing a method `forward_between_checkpoints` that will recompute the forward pass of the network using one of the checkpointed layers\n",
    "    b) override the method `backprop` to use only checkpointed layers and otherwise compute the activations using `forward_between_checkpoints` method and keep it in memory until no longer needed.\n",
    "\n",
    "3. Train your network with checkpoinintg on MNIST. Compare running times and memory usage with respect to the network without checkpointing.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ik27BADyIAKb"
   },
   "source": [
    "# Implement Checkpointing for a MLP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "jLVz7a-OIAKc"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from torchvision import datasets, transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "UuWbhT_wIAKd",
    "outputId": "fb3c271e-5f6f-42ad-89c4-5614153decd6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File ‘mnist.npz’ already there; not retrieving.\r\n"
     ]
    }
   ],
   "source": [
    "!wget -nc -O mnist.npz https://s3.amazonaws.com/img-datasets/mnist.npz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "G3xxfvC9IAKe"
   },
   "outputs": [],
   "source": [
    "# Let's read the mnist dataset\n",
    "\n",
    "def load_mnist(path='mnist.npz'):\n",
    "    with np.load(path) as f:\n",
    "        x_train, _y_train = f['x_train'], f['y_train']\n",
    "        x_test, _y_test = f['x_test'], f['y_test']\n",
    "\n",
    "    x_train = x_train.reshape(-1, 28 * 28) / 255.\n",
    "    x_test = x_test.reshape(-1, 28 * 28) / 255.\n",
    "\n",
    "    y_train = np.zeros((_y_train.shape[0], 10))\n",
    "    y_train[np.arange(_y_train.shape[0]), _y_train] = 1\n",
    "\n",
    "    y_test = np.zeros((_y_test.shape[0], 10))\n",
    "    y_test[np.arange(_y_test.shape[0]), _y_test] = 1\n",
    "\n",
    "    return (x_train, y_train), (x_test, y_test)\n",
    "\n",
    "(x_train, y_train), (x_test, y_test) = load_mnist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    return 1.0 / (1.0 + np.exp(-z))\n",
    "\n",
    "def logsumexp(z):\n",
    "    c = z.max()\n",
    "    return c + np.log(np.sum(np.exp(z - c)))\n",
    "\n",
    "def softmax(z):\n",
    "    exp = np.exp(z - z.max())\n",
    "    return exp / np.sum(exp, axis=0)\n",
    "\n",
    "def softmax_jacobian(inputs):\n",
    "    return np.array([np.diag(inp) - np.outer(inp, inp) for inp in inputs])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "SwLDbN6mIAKf"
   },
   "outputs": [],
   "source": [
    "class Network(object):\n",
    "    def __init__(self, sizes):\n",
    "        # initialize biases and weights with random normal distr.\n",
    "        # weights are indexed by target node first\n",
    "        self.num_layers = len(sizes)\n",
    "        self.sizes = sizes\n",
    "        self.biases = [np.random.randn(y, 1) for y in sizes[1: ]]\n",
    "        self.weights = [np.random.randn(y, x) \n",
    "                        for x, y in zip(sizes[: -1], sizes[1: ])]\n",
    "        self.momentum_w = [np.zeros_like(w) for w in self.weights]\n",
    "        self.momentum_b = [np.zeros_like(b) for b in self.biases]\n",
    "        \n",
    "        self.mem_usage = {}\n",
    "        \n",
    "    def feedforward(self, a):\n",
    "        # Run the network on a mini batch\n",
    "        a = a.T\n",
    "        for b, w in zip(self.biases[: -1], self.weights[: -1]):\n",
    "            a = sigmoid(w @ a + b)\n",
    "        a = softmax(self.weights[-1] @ a + self.biases[-1])\n",
    "        return a\n",
    "    \n",
    "    def update_mini_batch(self, x_mini_batch, y_mini_batch, eta, gamma, lambd):\n",
    "        # Update networks weights and biases by applying a single step\n",
    "        # of gradient descent using backpropagation to compute the gradient.\n",
    "        # The gradient is computed for a mini_batch.\n",
    "        # eta: learning rate\n",
    "        # gamma: momentum parameter\n",
    "        # lambd: L2 regularization parameter\n",
    "        nabla_b, nabla_w = self.backprop(x_mini_batch.T, y_mini_batch.T)\n",
    "        \n",
    "        # Learning rate should scale with the mini batch size\n",
    "        # https://stackoverflow.com/questions/53033556\n",
    "        eta /= len(x_mini_batch)\n",
    "        \n",
    "        # L2 regularization here! ('- lambda * w')\n",
    "        self.momentum_w = [\n",
    "            gamma * mw - eta * nw - lambd * w\n",
    "            for w, nw, mw in zip(self.weights, nabla_w, self.momentum_w)\n",
    "        ]\n",
    "        # Never regularize the biases\n",
    "        self.momentum_b = [\n",
    "            gamma * mb - eta * nb\n",
    "            for b, nb, mb in zip(self.biases, nabla_b, self.momentum_b)\n",
    "        ]\n",
    "        \n",
    "        self.weights = [w + mw for w, mw in zip(self.weights, self.momentum_w)]\n",
    "        self.biases = [b + mb for b, mb in zip(self.biases, self.momentum_b)]\n",
    "        \n",
    "    def backprop(self, x, y):\n",
    "        # For an input mini-batch (x,y) return a pair of\n",
    "        # gradients over biases and gradients over weights\n",
    "        \n",
    "        # no transposition here - x and y have already been\n",
    "        # transposed in the caller function\n",
    "        afters = [x]\n",
    "        # skip the last layer to apply softmax instead of sigmoid\n",
    "        for biases, weights in zip(self.biases[: -1], self.weights[: -1]):\n",
    "            # add biases before applying sigmoid, because it would normally\n",
    "            # correspond to a weight with a fixed input of 1\n",
    "            before = weights @ afters[-1] + biases\n",
    "            afters += [sigmoid(before)]\n",
    "        before = self.weights[-1] @ afters[-1] + self.biases[-1]\n",
    "        afters += [softmax(before)]\n",
    "        \n",
    "        if 'afters' not in self.mem_usage:\n",
    "            self.mem_usage['afters'] = sum(res.nbytes for res in afters)\n",
    "        \n",
    "        # First initialize the list of gradient arrays\n",
    "        nabla_b = []\n",
    "        nabla_w = []\n",
    "        \n",
    "        # Now go backward from the final cost applying backpropagation\n",
    "        deriv = self.cost_derivative(afters[-1], y)   \n",
    "        first_iteration = True\n",
    "        for activation, prev_activation, weights in zip(\n",
    "            reversed(afters), reversed(afters[: -1]), reversed(self.weights)\n",
    "        ):\n",
    "            # don't calculate dL/dg^N and dg^N/df^N separately for the softmax layer\n",
    "            # no need to calculate the Jacobian matrix - calculate dL/df^N directly\n",
    "            # in softmax regression with log-loss, this is dL/df^N, *not* dL/dg^N!\n",
    "            if not first_iteration:\n",
    "                # now deriv = d(L) / d(g^k)\n",
    "                # calculate deriv = d(L) / d(f^k)\n",
    "                # the below is the Hadamard product of the matrices\n",
    "                assert deriv.shape == activation.shape\n",
    "                deriv = deriv * (activation * (1 - activation))\n",
    "            first_iteration = False\n",
    "            \n",
    "            # d(L)/d(W^k) = d(L)/d(f^k) @ d(f^k) / d(W^k) = d(L) / d(f^k) @ (g^{k-1})^T\n",
    "            nabla_w += [deriv @ prev_activation.T]\n",
    "            # d(L)/d(b^k) = d(L)/d(f^k) @ d(f^k) / d(b^k) = d(L) / d(f^k) @ [1, 1 .., 1]\n",
    "            nabla_b += [deriv @ np.ones([deriv.shape[1], 1])]\n",
    "            \n",
    "            # calculate deriv = d(L) / d(g^{k - 1})\n",
    "            deriv = weights.T @ deriv\n",
    "        nabla_b, nabla_w = list(reversed(nabla_b)), list(reversed(nabla_w))\n",
    "        \n",
    "        if 'nabla_b' not in self.mem_usage:\n",
    "            self.mem_usage['nabla_b'] = sum(res.nbytes for res in nabla_b)\n",
    "        if 'nabla_w' not in self.mem_usage:\n",
    "            self.mem_usage['nabla_w'] = sum(res.nbytes for res in nabla_w)\n",
    "        return nabla_b, nabla_w\n",
    "\n",
    "    def evaluate(self, x_test, y_test):\n",
    "        # Count the number of correct answers for test_data\n",
    "        y_pred = np.argmax(self.feedforward(x_test), axis=0)\n",
    "        y = np.argmax(y_test, axis=1).T\n",
    "        return np.mean(y_pred == y)\n",
    "    \n",
    "    def cost_derivative(self, output_activations, y):\n",
    "        return output_activations - y\n",
    "    \n",
    "    def SGD(self, training_data, epochs, mini_batch_size, eta, gamma, lambd, test_data=None):\n",
    "        x_train, y_train = training_data\n",
    "        if test_data:\n",
    "            x_test, y_test = test_data\n",
    "        \n",
    "        for i in range(epochs):\n",
    "            for x_batch, y_batch in zip(\n",
    "                np.array_split(x_train, x_train.shape[0] // mini_batch_size),\n",
    "                np.array_split(y_train, y_train.shape[0] // mini_batch_size)\n",
    "            ):\n",
    "                self.update_mini_batch(x_batch, y_batch, eta, gamma, lambd)\n",
    "            \n",
    "            if test_data is not None:\n",
    "                print(\"Epoch: {0}, Accuracy: {1}\".format(i, self.evaluate(x_test, y_test)))\n",
    "            else:\n",
    "                print(\"Epoch: {0}\".format(j))\n",
    "        \n",
    "        mem = self.mem_usage['afters']\n",
    "        print(f'Total size of forward results: {mem}B = {sum(self.sizes)} * {mini_batch_size} * 8B')\n",
    "        mem = self.mem_usage['nabla_b']\n",
    "        print(f\"Total size of biases' gradients: {mem}B = {sum(self.sizes[1: ])} * 8B\")\n",
    "        mem = self.mem_usage['nabla_w']\n",
    "        prod = sum(a * b for a, b in zip(self.sizes, self.sizes[1: ]))\n",
    "        print(f\"Total size of weights' gradients` {mem}B = {prod} * 8B\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Memory usage analysis for plain backpropagation\n",
    "Let's analyze the memory usage of our backpropagation implementation.  \n",
    "We can quickly see that the only significant memory usage increment is due to these three arrays:  \n",
    "-`afters`: forward results; size = (sum of layer sizes) * (mini-batch size) * (dtype size)  \n",
    "-`nabla_b`: biases' gradients; size = (sum of layer sizes) * (dtype size)  \n",
    "-`nabla_w`: weights' gradients; size = (number of weights) * (dtype size)  \n",
    "Let's verify that our hypothesis about the sizes is sound:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Accuracy: 0.8638\n",
      "Epoch: 1, Accuracy: 0.8432\n",
      "Total size of forward results: 635200B = 794 * 100 * 8B\n",
      "Total size of biases' gradients: 80B = 10 * 8B\n",
      "Total size of weights' gradients` 62720B = 7840 * 8B\n"
     ]
    }
   ],
   "source": [
    "network = Network([784, 10])\n",
    "network.SGD((x_train, y_train),epochs=2,mini_batch_size=100,eta=3e-1,gamma=0.9,lambd=3e-5,test_data=(x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 635200 == 794 * 100 * 8 and 80 == 10 * 8 and 62720 == 7840 * 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Accuracy: 0.8828\n",
      "Epoch: 1, Accuracy: 0.9252\n",
      "Total size of forward results: 795200B = 994 * 100 * 8B\n",
      "Total size of biases' gradients: 1680B = 210 * 8B\n",
      "Total size of weights' gradients` 715200B = 89400 * 8B\n"
     ]
    }
   ],
   "source": [
    "network = Network([784, 100, 100, 10])\n",
    "network.SGD((x_train, y_train),epochs=2,mini_batch_size=100,eta=3e-1,gamma=0.9,lambd=3e-5,test_data=(x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 795200 == 994 * 100 * 8 and 1680 == 210 * 8 and 715200 == 89400 * 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's focus on networks with layer_sizes array of the form `[784, n, n, 10]`.  \n",
    "Let's see how the memory usage looks like with varying `n` for the `mini-batch size = 100`."
   ]
  },
  {
   "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": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def usage(n: int):\n",
    "    sizes = [784, n, n, 10]\n",
    "    mini_batch_size = 100\n",
    "    prod = sum(a * b for a, b in zip(sizes, sizes[1: ]))\n",
    "    return sum(sizes) * mini_batch_size, sum(sizes[1: ]), prod\n",
    "\n",
    "xs = [10, 100, 1000, 10000, 100000]\n",
    "ys = np.array(list(map(usage, xs)))\n",
    "\n",
    "plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.plot(xs, ys[:, 0], 'ro--', label='forwards')\n",
    "plt.plot(xs, ys[:, 1], 'go--', label='nabla_b')\n",
    "plt.plot(xs, ys[:, 2], 'bo--', label='nabla_w')\n",
    "plt.title('Memory usage of a [784, n, n, 10] MLP with varying n (in bytes)')\n",
    "plt.plot(xs, ys.sum(axis=1), 'yo--', label='total')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clearly, the memory usage is dominated by the weights' gradients.  \n",
    "We have good measures of reducing this size, but we're not allowed to  \n",
    "modify other parts of the class in this task. Let's ignore this and focus  \n",
    "just on the `forwards` array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def usage(n: int):\n",
    "    sizes = [784] + [10 for _ in range(n)] + [10]\n",
    "    mini_batch_size = 100\n",
    "    prod = sum(a * b for a, b in zip(sizes, sizes[1: ]))\n",
    "    return sum(sizes) * mini_batch_size, sum(sizes[1: ]), prod\n",
    "\n",
    "xs = [10, 100, 1_000, 10_000, 100_000]\n",
    "ys = np.array(list(map(usage, xs)))\n",
    "\n",
    "plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.plot(xs, ys[:, 0], 'ro--', label='forwards')\n",
    "plt.title('Memory usage of a [784, 10, 10, ..., 10, 10] MLP with varying # of the hidden layers (in bytes)')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The behavior is, as expected, linear. We will try to reduce that to  \n",
    "O(sqrt(n)) by implementing checkpointing and choosing the appropriate step size  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "id": "_uTvzzlmIAKf"
   },
   "outputs": [],
   "source": [
    "class NetworkWithCheckpointing(Network):\n",
    "    def __init__(self, sizes, checkpoint_every_nth_layer: int, *args, **kwargs):\n",
    "        super().__init__(sizes, *args, **kwargs)\n",
    "        self.k = checkpoint_every_nth_layer\n",
    "        # checkpoints[i] = vector of activations of the ith layer\n",
    "        # i.e. checkpoints[0] = x\n",
    "        self.checkpoints = []\n",
    "        self.cache = {}\n",
    "    \n",
    "    def checkpoint_idx_for_layer(self, layer_idx):\n",
    "        return layer_idx // self.k\n",
    "    \n",
    "    def layer_idx_after_checkpoint(self, checkpoint_idx):\n",
    "        # for x=checkpoint[0] we calculate weights[0] @ x @ biases[0] etc.\n",
    "        return checkpoint_idx * self.k\n",
    "        \n",
    "    def forward_between_checkpoints(self, x, layer_idx_end, backwards=False):\n",
    "        if not backwards:\n",
    "            assert not self.checkpoints\n",
    "            layer_idx_start = 0\n",
    "        else:\n",
    "            checkpoint = self.checkpoint_idx_for_layer(layer_idx_end)\n",
    "            assert checkpoint == len(self.checkpoints) - 1 >= 0\n",
    "            layer_idx_start = self.layer_idx_after_checkpoint(checkpoint)\n",
    "            x = self.checkpoints[checkpoint]\n",
    "        \n",
    "        # Run the network on a mini batch\n",
    "        for i, weights, biases in zip(\n",
    "            range(layer_idx_start, layer_idx_end),\n",
    "            self.weights[layer_idx_start: layer_idx_end],\n",
    "            self.biases[layer_idx_start: layer_idx_end]\n",
    "        ):\n",
    "            if not backwards and i % self.k == 0:\n",
    "                self.checkpoints += [x]\n",
    "            \n",
    "            if i not in self.cache:\n",
    "                x = weights @ x + biases\n",
    "                if backwards:\n",
    "                    self.cache[i] = x\n",
    "            else:\n",
    "                x = self.cache[i]\n",
    "                \n",
    "            if i != self.num_layers - 1:\n",
    "                x = sigmoid(x)\n",
    "            else:\n",
    "                x = softmax(x)\n",
    "        # here we would have i == layer_idx_end - 2\n",
    "        # simulate making the next iteration of the loop (i.e. i == layer_idx_end - 1)\n",
    "        # and make a checkpoint if necessary\n",
    "        if not backwards and (layer_idx_end - 1) % self.k == 0:\n",
    "            self.checkpoints += [x]\n",
    "            \n",
    "        return x\n",
    "\n",
    "    def backprop(self, x, y):\n",
    "        # For an input mini-batch (x,y) return a pair of\n",
    "        # gradients over biases and gradients over weights\n",
    "        gN = self.forward_between_checkpoints(x, self.num_layers)\n",
    "        \n",
    "        if 'afters' not in self.mem_usage:\n",
    "            self.mem_usage['afters'] = sum(res.nbytes for res in self.checkpoints)\n",
    "        \n",
    "        # First initialize the list of gradient arrays\n",
    "        nabla_b = []\n",
    "        nabla_w = []\n",
    "        \n",
    "        # Now go backward from the final cost applying backpropagation\n",
    "        deriv = self.cost_derivative(gN, y)\n",
    "        first_iteration = True\n",
    "        for i in range(self.num_layers - 1, 0, -1):\n",
    "            activation = self.forward_between_checkpoints(x, i, backwards=True)\n",
    "            if i % self.k == 0:\n",
    "                layer_redundant = self.layer_idx_after_checkpoint(len(self.checkpoints) - 1)\n",
    "                to_del = {layer for layer in self.cache if layer > layer_redundant}\n",
    "                self.checkpoints.pop()\n",
    "                for layer in to_del:\n",
    "                    del self.cache[layer]\n",
    "                \n",
    "            prev_activation = self.forward_between_checkpoints(x, i - 1, backwards=True)\n",
    "                \n",
    "            weights = self.weights[i - 1]\n",
    "            \n",
    "            # don't calculate dL/dg^N and dg^N/df^N separately for the softmax layer\n",
    "            # no need to calculate the Jacobian matrix - calculate dL/df^N directly\n",
    "            # in softmax regression with log-loss, this is dL/df^N, *not* dL/dg^N!\n",
    "            if not first_iteration:\n",
    "                # now deriv = d(L) / d(g^k)\n",
    "                # calculate deriv = d(L) / d(f^k)\n",
    "                # the below is the Hadamard product of the matrices\n",
    "                assert deriv.shape == activation.shape\n",
    "                deriv = deriv * (activation * (1 - activation))\n",
    "            first_iteration = False\n",
    "            \n",
    "            # d(L)/d(W^k) = d(L)/d(f^k) @ d(f^k) / d(W^k) = d(L) / d(f^k) @ (g^{k-1})^T\n",
    "            nabla_w += [deriv @ prev_activation.T]\n",
    "            # d(L)/d(b^k) = d(L)/d(f^k) @ d(f^k) / d(b^k) = d(L) / d(f^k) @ [1, 1 .., 1]\n",
    "            nabla_b += [deriv @ np.ones([deriv.shape[1], 1])]\n",
    "            \n",
    "            # calculate deriv = d(L) / d(g^{k - 1})\n",
    "            deriv = weights.T @ deriv\n",
    "        self.checkpoints.pop()\n",
    "        assert not self.checkpoints\n",
    "        assert len(self.cache) <= self.k\n",
    "        self.cache.clear()\n",
    "        \n",
    "        nabla_b, nabla_w = list(reversed(nabla_b)), list(reversed(nabla_w))\n",
    "        if 'nabla_b' not in self.mem_usage:\n",
    "            self.mem_usage['nabla_b'] = sum(res.nbytes for res in nabla_b)\n",
    "        if 'nabla_w' not in self.mem_usage:\n",
    "            self.mem_usage['nabla_w'] = sum(res.nbytes for res in nabla_w)\n",
    "        return nabla_b, nabla_w\n",
    "    \n",
    "    # Not modifying this function - only the print statements\n",
    "    def SGD(self, training_data, epochs, mini_batch_size, eta, gamma, lambd, test_data=None):\n",
    "        x_train, y_train = training_data\n",
    "        if test_data:\n",
    "            x_test, y_test = test_data\n",
    "        \n",
    "        for i in range(epochs):\n",
    "            for x_batch, y_batch in zip(\n",
    "                np.array_split(x_train, x_train.shape[0] // mini_batch_size),\n",
    "                np.array_split(y_train, y_train.shape[0] // mini_batch_size)\n",
    "            ):\n",
    "                self.update_mini_batch(x_batch, y_batch, eta, gamma, lambd)\n",
    "            \n",
    "            if test_data is not None:\n",
    "                print(\"Epoch: {0}, Accuracy: {1}\".format(i, self.evaluate(x_test, y_test)))\n",
    "            else:\n",
    "                print(\"Epoch: {0}\".format(j))\n",
    "        \n",
    "        mem = self.mem_usage['afters']\n",
    "        print(f'Total size of forward results: {mem}B = {sum(self.sizes[::self.k])} * {mini_batch_size} * 8B')\n",
    "        mem = self.mem_usage['nabla_b']\n",
    "        print(f\"Total size of biases' gradients: {mem}B = {sum(self.sizes[1: ])} * 8B\")\n",
    "        mem = self.mem_usage['nabla_w']\n",
    "        prod = sum(a * b for a, b in zip(self.sizes, self.sizes[1: ]))\n",
    "        print(f\"Total size of weights' gradients` {mem}B = {prod} * 8B\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Accuracy: 0.8843\n",
      "Epoch: 1, Accuracy: 0.9292\n",
      "Total size of forward results: 707200B = 884 * 100 * 8B\n",
      "Total size of biases' gradients: 2480B = 310 * 8B\n",
      "Total size of weights' gradients` 795200B = 99400 * 8B\n"
     ]
    }
   ],
   "source": [
    "sizes = [784, 100, 100, 100, 10]\n",
    "network = NetworkWithCheckpointing(sizes, checkpoint_every_nth_layer=3)\n",
    "network.SGD((x_train, y_train),epochs=2, mini_batch_size=100,eta=3e-1,gamma=0.9,lambd=3e-5,test_data=(x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 707200 == 884 * 100 * 8 and 2480 == 310 * 8 and 795200 == 99400 * 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's once again state our hypothesis and verify it. \n",
    "The memory consumption of this implementation is the highest at the beginning,  \n",
    "when we have to store all the checkpoints and two last activations for  \n",
    "gradient calculation. Putting aside the two activations, the model should store  \n",
    "as much as `sum(layer_sizes[:: step]) * (mini-batch size) * (dtype size)` bytes.\n",
    "Is it really true?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Accuracy: 0.1009\n",
      "Total size of forward results: 947200B = 1184 * 100 * 8B\n",
      "Total size of biases' gradients: 12880B = 1610 * 8B\n",
      "Total size of weights' gradients` 1835200B = 229400 * 8B\n"
     ]
    }
   ],
   "source": [
    "n = 16\n",
    "sizes = [784] + [100 for _ in range(n)] + [10]\n",
    "step = int(np.sqrt(n))\n",
    "network = NetworkWithCheckpointing(sizes, checkpoint_every_nth_layer=step)\n",
    "network.SGD((x_train, y_train),epochs=1,mini_batch_size=100,eta=3e-1,gamma=0.9,lambd=3e-5,test_data=(x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 947200 == 1184 * 100 * 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It seems like it indeed. I tested this relation for multiple architectures,  \n",
    "but decided not to keep all the intermediate results in this final notebook.  \n",
    "So, the relation of memory usage of the plain backpropagation algorithm to the  \n",
    "checkpointing one is given by `sum(layer_sizes) / sum(layer_sizes[:: step])`.  \n",
    "We can clearly see that if the layers are similiar in size, by choosing `step = sqrt(n)`,  \n",
    "we can reduce the memory usage to sub-linear:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def usage(n, step):\n",
    "    # yes, we could just multiply\n",
    "    layer_sizes = [100 for _ in range(n)]\n",
    "    return sum(layer_sizes), sum(layer_sizes[:: step])\n",
    "\n",
    "xs = [10, 100, 1_000, 10_000, 100_000, 1_000_000]\n",
    "ys = np.array(list(map(lambda x: usage(x, int(np.sqrt(x))), xs)))\n",
    "\n",
    "plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.plot(xs, ys[:, 0], 'ro--', label='naive')\n",
    "plt.plot(xs, np.sqrt(ys[:, 0]), 'ro--', label='sqrt(naive)')\n",
    "plt.plot(xs, ys[:, 1], 'go--', label='checkpointing')\n",
    "plt.plot(xs, ys[:, 1] ** 2, 'go--', label='checkpointing^2')\n",
    "plt.title('Memory usage of a [100, 100, ..., 100, 100] MLP with varying # of the hidden layers (in bytes)')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mind the log scales! We can see clearly that `checkpointing ~ sqrt(naive)` and `checkpointing^2 ~ naive`  \n",
    "in terms of memory usage, asymptotically (for storing the list of forward results).  \n",
    "Thus, we achieved a sub-linear-memory backpropagation implementation.  \n",
    "The results in standard scale and for inputs of the same order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "xs = np.arange(1, 100, 10)\n",
    "ys = np.array(list(map(lambda x: usage(x, int(np.sqrt(x))), xs)))\n",
    "\n",
    "# plt.yscale('log')\n",
    "plt.plot(xs, ys[:, 0], 'ro--', label='naive')\n",
    "plt.plot(xs, np.sqrt(ys[:, 0]), 'ro--', label='sqrt(naive)')\n",
    "plt.plot(xs, ys[:, 1], 'go--', label='checkpointing')\n",
    "plt.title('Memory usage of a [100, 100, ..., 100, 100] MLP with varying # of the hidden layers (in bytes)')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running time analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Accuracy: 0.9087\n",
      "Epoch: 1, Accuracy: 0.9326\n",
      "Epoch: 2, Accuracy: 0.9432\n",
      "Epoch: 3, Accuracy: 0.9496\n",
      "Epoch: 4, Accuracy: 0.9494\n",
      "Total size of forward results: 875200B = 1094 * 100 * 8B\n",
      "Total size of biases' gradients: 2480B = 310 * 8B\n",
      "Total size of weights' gradients` 795200B = 99400 * 8B\n",
      "CPU times: user 1min 32s, sys: 1min 18s, total: 2min 51s\n",
      "Wall time: 26.8 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "network = Network([784, 100, 100, 100, 10])\n",
    "network.SGD((x_train, y_train),epochs=5,mini_batch_size=100,eta=3e-1,gamma=0.9,lambd=3e-5,test_data=(x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Accuracy: 0.9024\n",
      "Epoch: 1, Accuracy: 0.9173\n",
      "Epoch: 2, Accuracy: 0.936\n",
      "Epoch: 3, Accuracy: 0.9523\n",
      "Epoch: 4, Accuracy: 0.9493\n",
      "Total size of forward results: 715200B = 894 * 100 * 8B\n",
      "Total size of biases' gradients: 2480B = 310 * 8B\n",
      "Total size of weights' gradients` 795200B = 99400 * 8B\n",
      "CPU times: user 1min 34s, sys: 1min 1s, total: 2min 36s\n",
      "Wall time: 19.8 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "network = NetworkWithCheckpointing([784, 100, 100, 100, 10], checkpoint_every_nth_layer=2)\n",
    "network.SGD((x_train, y_train),epochs=5,mini_batch_size=100,eta=3e-1,gamma=0.9,lambd=3e-5,test_data=(x_test, y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above converge nicely. Running time of the checkpointing version is `94s`, whereas  \n",
    "the plain backpropagation version finshed in `92s` (CPU time).  \n",
    "The running times are basically the same, but we saved some memory - `715kB` compared to `875kB`.\n",
    "But this is a very small network. To see the power of checkpointing, let's use a 'longer' architecture:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "arch = [784, 100, 100, 100, 100, 100, 100, 100, 100, 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Accuracy: 0.101\n",
      "Epoch: 1, Accuracy: 0.101\n",
      "Epoch: 2, Accuracy: 0.4378\n",
      "Epoch: 3, Accuracy: 0.9088\n",
      "Epoch: 4, Accuracy: 0.9159\n",
      "Total size of forward results: 1275200B = 1594 * 100 * 8B\n",
      "Total size of biases' gradients: 6480B = 810 * 8B\n",
      "Total size of weights' gradients` 1195200B = 149400 * 8B\n",
      "CPU times: user 3min 22s, sys: 3min 11s, total: 6min 34s\n",
      "Wall time: 1min 5s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "network = Network(arch)\n",
    "network.SGD((x_train, y_train),epochs=5,mini_batch_size=100,eta=3e-1,gamma=0.9,lambd=3e-5,test_data=(x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 1275200 == 1594 * 100 * 8 and 6480 == 810 * 8 and 1195200 == 149400 * 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0, Accuracy: 0.4021\n",
      "Epoch: 1, Accuracy: 0.6271\n",
      "Epoch: 2, Accuracy: 0.7844\n",
      "Epoch: 3, Accuracy: 0.8862\n",
      "Epoch: 4, Accuracy: 0.9064\n",
      "Total size of forward results: 795200B = 994 * 100 * 8B\n",
      "Total size of biases' gradients: 6480B = 810 * 8B\n",
      "Total size of weights' gradients` 1195200B = 149400 * 8B\n",
      "CPU times: user 3min 49s, sys: 2min 52s, total: 6min 41s\n",
      "Wall time: 50.9 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "network = NetworkWithCheckpointing(arch, checkpoint_every_nth_layer=3)\n",
    "network.SGD((x_train, y_train),epochs=5,mini_batch_size=100,eta=3e-1,gamma=0.9,lambd=3e-5,test_data=(x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 787200 == 984 * 100 * 8 and 6480 == 810 * 8 and 1195200 == 149400 * 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the ratio is `229s/202s = 1.13` - we could argue about statistical significance of that,  \n",
    "but in general small (linear) penalties are expected, because of the caching between two consecutive  \n",
    "checkpoints that we have implemented.\n",
    "\n",
    "Thus, by implementing checkpointing, we can reduce the memory consumption of  \n",
    "the backpropagation algorithm, but at the cost of increased computation time."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "provenance": []
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}