Tutorial_2_JAX_HeroPro+_Colab.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Tutorial 2: JAX HeroPro+.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyO3Qfb7ojdYCyq/xbaG12/L",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "TPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/gordicaleksa/get-started-with-JAX/blob/main/Tutorial_2_JAX_HeroPro%2B_Colab.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s8H3vBZPC5Ji"
      },
      "source": [
        "# ML with JAX: from Hero to Hero Pro+\n",
        "\n",
        "aka: on the way to building fully fledged Neural Networks! ❤️\n",
        "\n",
        "The notebook also has [an accompanying video](https://www.youtube.com/watch?v=CQQaifxuFcs) which may help you better understand all of the details!\n",
        "\n",
        "<a href=\"https://www.youtube.com/watch?v=CQQaifxuFcs\" target=\"_blank\"><img src=\"https://img.youtube.com/vi/CQQaifxuFcs/0.jpg\" \n",
        "alt=\"JAX - from Hero to HeroPro+!\" width=\"480\" align=\"left\" height=\"360\" border=\"10\" /></a>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FsCNLnKZLKsK"
      },
      "source": [
        "Check out this [notebook](https://github.com/gordicaleksa/get-started-with-JAX/blob/main/Tutorial_1_JAX_basics_Colab.ipynb) and [YouTube video](https://www.youtube.com/watch?v=SstuvS-tVc0) for tutorial #1: *Machine Learning with JAX: From Zero to Hero*\n",
        "\n",
        "Note: this notebook heavily relies on https://jax.readthedocs.io/en/latest/ + some additional code/modifications, comments/notes, etc."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3ABn5x8VESIo"
      },
      "source": [
        "# Let's import the necessary packages\n",
        "import jax\n",
        "import jax.numpy as jnp\n",
        "import numpy as np\n",
        "\n",
        "from jax import grad, jit, vmap, pmap\n",
        "\n",
        "from jax import random\n",
        "import matplotlib.pyplot as plt\n",
        "from copy import deepcopy\n",
        "from typing import Tuple, NamedTuple\n",
        "import functools"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TkfeK5jbYdqZ"
      },
      "source": [
        "The goal of this notebook will be to gain the knowledge necessary to build complex ML models (such as NNs) and train them in parallel on multiple devices! 💻💻💻⚡⚡⚡"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WRaFE9INWMGu"
      },
      "source": [
        "## The Problem of State\n",
        "\n",
        "JAX ❤️ Pure Functions => JAX \"!❤️\" State."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wH8CX7C3WTz2"
      },
      "source": [
        "# 1) We've seen in the last notebook/video that impure functions are problematic.\n",
        "\n",
        "g = 0.  # state\n",
        "\n",
        "# We're accessing some external state in this function which causes problems\n",
        "def impure_uses_globals(x):\n",
        "    return x + g\n",
        "\n",
        "# JAX captures the value of the global/state during the first run\n",
        "print (\"First call: \", jit(impure_uses_globals)(4.))\n",
        "\n",
        "# Let's update the global/state!\n",
        "g = 10.\n",
        "\n",
        "# Subsequent runs may silently use the cached value of the globals/state\n",
        "print (\"Second call: \", jit(impure_uses_globals)(5.))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vkPKuJHRZU-b"
      },
      "source": [
        "# 2) We've also seen this pattern how JAX's PRNG \n",
        "# (which is not stateful in contrast to NumPy's PRNG) is handling state.\n",
        "\n",
        "seed = 0\n",
        "state = jax.random.PRNGKey(seed)\n",
        "\n",
        "# We input the state, we somehow manipulate it and we return it back.\n",
        "# The state is not saved internally.\n",
        "state1, state2 = jax.random.split(state)  # recall: key/subkey was the terminology we used"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q5rUlTHNWO2E"
      },
      "source": [
        "# Let's now explictly address and understand the problem of state!\n",
        "# Why? \n",
        "# Well, NNs love statefulness: model params, optimizer params, BatchNorm, etc.\n",
        "# and we've seen that JAX seems to have a problem with it.\n",
        "\n",
        "class Counter:\n",
        "    \"\"\"A simple counter.\"\"\"\n",
        "\n",
        "    def __init__(self):\n",
        "        self.n = 0\n",
        "\n",
        "    def count(self) -> int:\n",
        "        \"\"\"Increments the counter and returns the new value.\"\"\"\n",
        "        self.n += 1\n",
        "        return self.n\n",
        "\n",
        "    def reset(self):\n",
        "        \"\"\"Resets the counter to zero.\"\"\"\n",
        "        self.n = 0\n",
        "\n",
        "\n",
        "counter = Counter()\n",
        "\n",
        "for _ in range(3):  # works like a charm\n",
        "    print(counter.count())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dtwGMqtBXeF-"
      },
      "source": [
        "counter.reset()\n",
        "fast_count = jax.jit(counter.count)\n",
        "\n",
        "for _ in range(3):  # oops, it's not working as it's supposed to be\n",
        "    print(fast_count())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0kvJ85xUdX44"
      },
      "source": [
        "from jax import make_jaxpr  # let's use jaxpr to understand why this is happening\n",
        "\n",
        "counter.reset()\n",
        "print(make_jaxpr(counter.count)())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pL1Mo84OXna3"
      },
      "source": [
        "# Solution:\n",
        "\n",
        "CounterState = int  # our counter state is implemented as a simple integer\n",
        "\n",
        "class CounterV2:\n",
        "\n",
        "    def count(self, n: CounterState) -> Tuple[int, CounterState]:\n",
        "        # You could just return n+1, but here we separate its role as \n",
        "        # the output and as the counter state for didactic purposes.\n",
        "        # (as the output may be some arbitrary function of state in general case)\n",
        "        return n+1, n+1\n",
        "\n",
        "    def reset(self) -> CounterState:\n",
        "        return 0\n",
        "\n",
        "counter = CounterV2()\n",
        "state = counter.reset()  # notice how reset() now returns state (external vs internal imp)\n",
        "\n",
        "for _ in range(3):  # works like a charm pre-jit, let's see whether the jit version works\n",
        "    value, state = counter.count(state)  # looks familiar?\n",
        "    print(value)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xwxy0k_vXqSG"
      },
      "source": [
        "state = counter.reset()\n",
        "fast_count = jax.jit(counter.count)\n",
        "\n",
        "for _ in range(3):  # nice, working as expected!\n",
        "    value, state = fast_count(state)\n",
        "    print(value)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ueWSgnlfXx5N"
      },
      "source": [
        "In summary we used the following rule to convert a stateful class:\n",
        "\n",
        "```python\n",
        "class StatefulClass\n",
        "\n",
        "    state: State\n",
        "\n",
        "    def stateful_method(*args, **kwargs) -> Output:\n",
        "```\n",
        "\n",
        "into a class of the form:\n",
        "\n",
        "```python\n",
        "class StatelessClass\n",
        "\n",
        "    def stateless_method(state: State, *args, **kwargs) -> (Output, State):\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mBrCCZaS_F6c"
      },
      "source": [
        "Nice - we figured an equivalent way to handle states without introducing the side-effects.\n",
        "\n",
        "This brings us 1 step closer to building neural networks! 🥳\n",
        "\n",
        "We still need to find a way to handle gradients when dealing with big NNs."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xzxoOVo1ERVP"
      },
      "source": [
        "## Enter PyTree 🌳\n",
        "\n",
        "Before we start - why are gradients a problem in the first place?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Lh7AV-GGT4G"
      },
      "source": [
        "### PyTree basics"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Jy0Uf7mC4XA"
      },
      "source": [
        "f = lambda x, y, z, w: x**2 + y**2 + z**2 + w**2  # + 175B params more (minus 4)\n",
        "\n",
        "# JAX: .backward() is not that great\n",
        "# also JAX:\n",
        "x, y, z, w = [1.]*4\n",
        "dfdx, dfdy, dfdz, dfdw = grad(f, argnums=(0, 1, 2, 3))(x, y, z, w)\n",
        "print(dfdx, dfdy, dfdz, dfdw)\n",
        "\n",
        "# Great now we just need to update our params!\n",
        "# lr = 0.001\n",
        "# x -= lr*dfdx\n",
        "# y -= lr*dfdy\n",
        "# ... (175B lines later)\n",
        "# w -= lr*dfdw\n",
        "\n",
        "# No, no, no. \n",
        "# We do have a better way."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U3ehMR0LA3Fl"
      },
      "source": [
        "No, no, no. \n",
        "We do have a better way!\n",
        "\n",
        "We want to, more naturally, wrap our params in some more complex data structures like dictionaries, etc.  \n",
        "\n",
        "JAX knows how to deal with these! The answer is called a **PyTree**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DlfzandhD7M3"
      },
      "source": [
        "# A contrived example for pedagogical purposes\n",
        "# (if your mind needs to attach some semantics to parse this - treat it as model params)\n",
        "pytree_example = [\n",
        "    [1, 'a', object()],\n",
        "    (1, (2, 3), ()),\n",
        "    [1, {'k1': 2, 'k2': (3, 4)}, 5],\n",
        "    {'a': 2, 'b': (2, 3)},\n",
        "    jnp.array([1, 2, 3]),\n",
        "]\n",
        "\n",
        "# Let's see how many leaves they have:\n",
        "for pytree in pytree_example:\n",
        "    leaves = jax.tree_leaves(pytree)  # handy little function\n",
        "    print(f\"{repr(pytree):<45} has {len(leaves)} leaves: {leaves}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8OWOHjGxGcvy"
      },
      "source": [
        "# How do we manipulate PyTrees?\n",
        "\n",
        "list_of_lists = [\n",
        "    {'a': 3},\n",
        "    [1, 2, 3],\n",
        "    [1, 2],\n",
        "    [1, 2, 3, 4]\n",
        "]\n",
        "\n",
        "# For single arg functions use tree_map\n",
        "# tree_map iterates through leaves and applies the lambda function\n",
        "print(jax.tree_map(lambda x: x*2, list_of_lists)) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jsSAxZ4JHwiS"
      },
      "source": [
        "another_list_of_lists = list_of_lists\n",
        "print(jax.tree_multimap(lambda x, y: x+y, list_of_lists, another_list_of_lists))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "09Pdhyh2ISb4"
      },
      "source": [
        "# PyTrees need to have the same structure if we are to apply tree_multimap!\n",
        "another_list_of_lists = deepcopy(list_of_lists)\n",
        "another_list_of_lists.append([23])\n",
        "print(jax.tree_multimap(lambda x, y: x+y, list_of_lists, another_list_of_lists))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RWWsaJOZKQwI"
      },
      "source": [
        "### Less contrived example: training a toy MLP (multi-layer perceptron) model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qQYnvV3xIhrw"
      },
      "source": [
        "def init_mlp_params(layer_widths):\n",
        "    params = []\n",
        "\n",
        "    # Allocate weights and biases (model parameters)\n",
        "    # Notice: we're not using JAX's PRNG here - doesn't matter for this simple example\n",
        "    for n_in, n_out in zip(layer_widths[:-1], layer_widths[1:]):\n",
        "        params.append(\n",
        "            dict(weights=np.random.normal(size=(n_in, n_out)) * np.sqrt(2/n_in),\n",
        "                biases=np.ones(shape=(n_out,))\n",
        "        )\n",
        "    )\n",
        "\n",
        "    return params\n",
        "\n",
        "# Instantiate a single input - single output, 3 layer (2 hidden layers) deep MLP\n",
        "params = init_mlp_params([1, 128, 128, 1])\n",
        "\n",
        "# Another example of how we might use tree_map - verify that shapes make sense:\n",
        "jax.tree_map(lambda x: x.shape, params)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hwQKdHJ0J37n"
      },
      "source": [
        "def forward(params, x):\n",
        "    *hidden, last = params\n",
        "\n",
        "    for layer in hidden:\n",
        "        x = jax.nn.relu(jnp.dot(x, layer['weights']) + layer['biases'])\n",
        "\n",
        "    return jnp.dot(x, last['weights']) + last['biases']\n",
        "\n",
        "def loss_fn(params, x, y):\n",
        "    return jnp.mean((forward(params, x) - y) ** 2)  # MSE loss\n",
        "\n",
        "lr = 0.0001\n",
        "\n",
        "@jit  # notice how we do jit only at the highest level - XLA will have plenty of space to optimize\n",
        "def update(params, x, y):\n",
        "\n",
        "    # Note that grads is a pytree with the same structure as params.\n",
        "    # grad is one of the many JAX functions that has built-in support for pytrees!\n",
        "    grads = jax.grad(loss_fn)(params, x, y)\n",
        "\n",
        "    # Task: analyze grads and make sure it has the same structure as params\n",
        "\n",
        "    # SGD update\n",
        "    return jax.tree_multimap(\n",
        "        lambda p, g: p - lr * g, params, grads  # for every leaf i.e. for every param of MLP\n",
        "    )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "b97nTnyrKb40",
        "outputId": "6b8b418e-9a91-4db5-e28f-4de3d7d21c29"
      },
      "source": [
        "xs = np.random.normal(size=(128, 1))\n",
        "ys = xs ** 2  # let's learn how to regress a parabola\n",
        "\n",
        "# Task experiment a bit with other functions (polynomials, sin, etc.)\n",
        "\n",
        "num_epochs = 5000\n",
        "for _ in range(num_epochs):\n",
        "    params = update(params, xs, ys)  # again our lovely pattern\n",
        "\n",
        "plt.scatter(xs, ys)\n",
        "plt.scatter(xs, forward(params, xs), label='Model prediction')\n",
        "plt.legend();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AFIi6Y-jEEcE"
      },
      "source": [
        "Wohoo! We've trained our first neural network! 🥳🥳🥳\n",
        "\n",
        "In order to be able to build NN libs and layers such as nn.Linear (PyTorch syntax), etc. we need a couple more tricks up our sleeves! 🔥"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P7d5Ff_MQhq-"
      },
      "source": [
        "### Custom PyTrees ⚙️"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oGHnTdw5NvMQ"
      },
      "source": [
        "class MyContainer:  # this could be a linear layer a conv layer or whatever\n",
        "    \"\"\"A named container.\"\"\"\n",
        "    def __init__(self, name: str, a: int, b: int, c: int):\n",
        "        self.name = name\n",
        "        self.a = a\n",
        "        self.b = b\n",
        "        self.c = c"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LkODtq-TQzzd"
      },
      "source": [
        "example_pytree = [MyContainer('Alice', 1, 2, 3), MyContainer('Bob', 4, 5, 6)]  # 8 leaves? Right? Noup.\n",
        "\n",
        "leaves = jax.tree_leaves(example_pytree)\n",
        "print(f\"{repr(example_pytree):<45}\\n has {len(leaves)} leaves:\\n {leaves}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kOWUT1xJQ6ct"
      },
      "source": [
        "print(jax.tree_map(lambda x: x + 1, example_pytree))  # this will not work :/ it'd be nice if it did"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PkWAbkWgR8_K"
      },
      "source": [
        "# Let's get it to work! We'll need to define 2 functions (flatten/unflatten)\n",
        "\n",
        "def flatten_MyContainer(container):\n",
        "    \"\"\"Returns an iterable over container contents, and aux data.\"\"\"\n",
        "    flat_contents = [container.a, container.b, container.c]\n",
        "\n",
        "    # we don't want the name to appear as a child, so it is auxiliary data.\n",
        "    # auxiliary data is usually a description of the structure of a node,\n",
        "    # e.g., the keys of a dict -- anything that isn't a node's children.\n",
        "    aux_data = container.name\n",
        "\n",
        "    return flat_contents, aux_data\n",
        "\n",
        "def unflatten_MyContainer(aux_data, flat_contents):\n",
        "    \"\"\"Converts aux data and the flat contents into a MyContainer.\"\"\"\n",
        "    return MyContainer(aux_data, *flat_contents)\n",
        "\n",
        "# Register a custom PyTree node\n",
        "jax.tree_util.register_pytree_node(MyContainer, flatten_MyContainer, unflatten_MyContainer)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QmdGdkO0FVx7"
      },
      "source": [
        "# Let's try again!\n",
        "leaves = jax.tree_leaves(example_pytree)\n",
        "print(f\"{repr(example_pytree):<45}\\n has {len(leaves)} leaves:\\n {leaves}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UXv9VXCBUI-F"
      },
      "source": [
        "# Let's try applying tree map again\n",
        "result = jax.tree_map(lambda x: x + 1, example_pytree)\n",
        "print(jax.tree_leaves(result))  # it works now as expected!"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XLKzvGM0V_8M"
      },
      "source": [
        "# Finally a common gotcha working with PyTrees: mistaking nodes for leaves/children\n",
        "\n",
        "zeros_tree = [jnp.zeros((2, 3)), jnp.zeros((3, 4))]\n",
        "print(zeros_tree)\n",
        "\n",
        "# Try to make another tree with ones instead of zeros\n",
        "shapes = jax.tree_map(lambda x: x.shape, zeros_tree)  # sol: simply add a jnp.array\n",
        "print(shapes)\n",
        "\n",
        "ones_tree = jax.tree_map(jnp.ones, shapes)\n",
        "print(ones_tree)\n",
        "\n",
        "# Task: debug this"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qFm42oF_GeJz"
      },
      "source": [
        "Great! We can now create custom layers and we can train even bigger neural networks!\n",
        "\n",
        "But what if our neural network is really big? How do we handle training it across multiple devices? \n",
        "\n",
        "I'm glad you asked."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j2IStXTEZlul"
      },
      "source": [
        "## Parallelism in JAX 💻💻\n",
        "\n",
        "Parallelism in JAX is handled by another fundamental transform function: `pmap`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DNw_It2UJY-I"
      },
      "source": [
        "### `pmap` basics"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lTpSJCfhZnyS"
      },
      "source": [
        "# Let's try to get ourselves some TPU goodness\n",
        "import jax.tools.colab_tpu\n",
        "jax.tools.colab_tpu.setup_tpu()\n",
        "\n",
        "jax.devices()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "brnMl8fKbXBQ"
      },
      "source": [
        "# Let's use a simple running example here\n",
        "x = np.arange(5)  # signal\n",
        "w = np.array([2., 3., 4.])  # window/kernel\n",
        "\n",
        "def convolve(w, x):  # implementation of 1D convolution/correlation\n",
        "    output = []\n",
        "\n",
        "    for i in range(1, len(x)-1):\n",
        "        output.append(jnp.dot(x[i-1:i+2], w))\n",
        "\n",
        "    return jnp.array(output)\n",
        "\n",
        "result = convolve(w, x)\n",
        "print(repr(result))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sXd_KxABb8hS"
      },
      "source": [
        "n_devices = jax.local_device_count() \n",
        "print(f'Number of available devices: {n_devices}')\n",
        "\n",
        "# Let's now imagine we have a much heavier load (a batch of examples)\n",
        "xs = np.arange(5 * n_devices).reshape(-1, 5)\n",
        "ws = np.stack([w] * n_devices)\n",
        "\n",
        "print(xs.shape, ws.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B6REXnIccSZp"
      },
      "source": [
        "# First way to optimize this is to simply use vmap\n",
        "vmap_result = jax.vmap(convolve)(ws, xs)\n",
        "print(repr(vmap_result))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zh0KaB1VcbnE"
      },
      "source": [
        "# The amazing thing is if you just swap vmap for pmap you are now running on multiple\n",
        "# devices. How cool is that?\n",
        "pmap_result = jax.pmap(convolve)(ws, xs)\n",
        "print(repr(pmap_result))  # ShardedDeviceArray!"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9AQkWD20ceq4"
      },
      "source": [
        "# No cross-device communication costs. Computations are done independently on each dev.\n",
        "double_pmap_result = jax.pmap(convolve)(jax.pmap(convolve)(ws, xs), xs)\n",
        "print(repr(double_pmap_result))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NPUB-3Fvc-K9"
      },
      "source": [
        "# Same results but we don't have to manually broadcast w (recall: same as for vmap!)\n",
        "pmap_smarter_result = jax.pmap(convolve, in_axes=(None, 0))(w, xs)\n",
        "print(repr(pmap_smarter_result))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6M41OD1EJK1d"
      },
      "source": [
        "This is all great, but oftentimes we do need to communicate between devices. 📱\n",
        "\n",
        "Let's see how that is handled."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9UUiPzdHeJfC"
      },
      "source": [
        "### Communication between devices 📱📱📱📱"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cXjC_T4Jdmuc"
      },
      "source": [
        "# Same example as above but this time we communicate across devices \n",
        "# in order to normalize the outputs\n",
        "def normalized_convolution(w, x):\n",
        "    output = []\n",
        "\n",
        "    for i in range(1, len(x)-1):\n",
        "        output.append(jnp.dot(x[i-1:i+2], w))\n",
        "\n",
        "    output = jnp.array(output)  # same result as before\n",
        "\n",
        "    return output / jax.lax.psum(output, axis_name='batch_dim')  # this is where communication happens\n",
        "\n",
        "res_pmap = jax.pmap(normalized_convolution, axis_name='batch_dim', in_axes=(None, 0))(w, xs)\n",
        "res_vmap = jax.vmap(normalized_convolution, axis_name='batch_dim', in_axes=(None, 0))(w, xs)\n",
        "\n",
        "print(repr(res_pmap))\n",
        "print(repr(res_vmap))\n",
        "\n",
        "print(f'Verify the output is normalized: {sum(res_pmap[:, 0])}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lS36ZnfnLAWB"
      },
      "source": [
        "Great - before we train yet another ML model (this time on multiple devices) let me show you a couple more useful functions!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LXNlDtH1KbCU"
      },
      "source": [
        "# Sometimes aside from grads we also need to return the loss value (for logging, etc.)\n",
        "\n",
        "def sum_squared_error(x, y):\n",
        "    return sum((x-y)**2)\n",
        "\n",
        "x = jnp.arange(4, dtype=jnp.float32)\n",
        "y = x + 0.1\n",
        "\n",
        "# An efficient way to return both grads and loss value\n",
        "jax.value_and_grad(sum_squared_error)(x, y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "__jRUIX7LlKE"
      },
      "source": [
        "# And sometimes the loss function needs to return intermediate results\n",
        " \n",
        "def sum_squared_error_with_aux(x, y):\n",
        "    return sum((x-y)**2), x-y\n",
        "\n",
        "jax.grad(sum_squared_error_with_aux)(x, y)  # has_aux=True"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "57uy7eIxL5BA"
      },
      "source": [
        "We're now ready to see the most complex model pipeline so far in JAX."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NydqBK3-sL9s"
      },
      "source": [
        "### Training a very simple model in parallel!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q5bXckJojUct"
      },
      "source": [
        "class Params(NamedTuple):\n",
        "    weight: jnp.ndarray\n",
        "    bias: jnp.ndarray\n",
        "\n",
        "\n",
        "lr = 0.005\n",
        "\n",
        "\n",
        "def init_model(rng):\n",
        "    weights_key, bias_key = jax.random.split(rng)\n",
        "    weight = jax.random.normal(weights_key, ())\n",
        "    bias = jax.random.normal(bias_key, ())\n",
        "    return Params(weight, bias)\n",
        "\n",
        "\n",
        "def forward(params, xs):\n",
        "    return params.weight * xs + params.bias\n",
        "\n",
        "\n",
        "def loss_fn(params, xs, ys):\n",
        "    pred = forward(params, xs)\n",
        "    return jnp.mean((pred - ys) ** 2)  # MSE\n",
        "\n",
        "\n",
        "@functools.partial(jax.pmap, axis_name='batch')\n",
        "def update(params, xs, ys):\n",
        "\n",
        "    # Compute the gradients on the given minibatch (individually on each device).\n",
        "    loss, grads = jax.value_and_grad(loss_fn)(params, xs, ys)\n",
        "\n",
        "    # Combine the gradient across all devices (by taking their mean).\n",
        "    grads = jax.lax.pmean(grads, axis_name='batch')\n",
        "\n",
        "    # Also combine the loss. Unnecessary for the update, but useful for logging.\n",
        "    loss = jax.lax.pmean(loss, axis_name='batch')\n",
        "\n",
        "    # Each device performs its own SGD update, but since we start with the same params\n",
        "    # and synchronise gradients, the params stay in sync on each device.\n",
        "    new_params = jax.tree_multimap(\n",
        "        lambda param, g: param - g * lr, params, grads)\n",
        "    \n",
        "    # If we were using Adam or another stateful optimizer,\n",
        "    # we would also do something like:\n",
        "    # updates, new_optimizer_state = optimizer(grads, optimizer_state)\n",
        "    # and then use updates instead of grads to actually update the params.\n",
        "    # (And we'd include the new_optimizer_state in the output, naturally.)\n",
        "\n",
        "    return new_params, loss"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "unXtXH5Cn_D9",
        "outputId": "23a7faff-4240-4088-e7bf-543ccd68d373"
      },
      "source": [
        "# Generate true data from y = w*x + b + noise\n",
        "true_w, true_b = 2, -1\n",
        "xs = np.random.normal(size=(128, 1))\n",
        "noise = 0.5 * np.random.normal(size=(128, 1))\n",
        "ys = xs * true_w + true_b + noise\n",
        "\n",
        "plt.scatter(xs, ys)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I-h0bNc7opqw"
      },
      "source": [
        "# Initialise parameters and replicate across devices.\n",
        "params = init_model(jax.random.PRNGKey(0))\n",
        "n_devices = jax.local_device_count()\n",
        "replicated_params = jax.tree_map(lambda x: jnp.array([x] * n_devices), params)\n",
        "print(replicated_params)\n",
        "\n",
        "# Prepare the data\n",
        "def reshape_for_pmap(data, n_devices):\n",
        "    return data.reshape(n_devices, data.shape[0] // n_devices, *data.shape[1:])\n",
        "\n",
        "x_parallel = reshape_for_pmap(xs, n_devices)\n",
        "y_parallel = reshape_for_pmap(ys, n_devices)\n",
        "\n",
        "print(x_parallel.shape, y_parallel.shape)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N0Qm-vgkoxHb"
      },
      "source": [
        "def type_after_update(name, obj):\n",
        "    print(f\"after first `update()`, `{name}` is a {type(obj)}\")\n",
        "\n",
        "# Actual training loop\n",
        "num_epochs = 1000\n",
        "for epoch in range(num_epochs):\n",
        "\n",
        "    # This is where the params and data gets communicated to devices\n",
        "    replicated_params, loss = update(replicated_params, x_parallel, y_parallel)\n",
        "\n",
        "    # replicated_params and loss are now both ShardedDeviceArrays,\n",
        "    # indicating that they're on the devices.\n",
        "    # x/y_parallel remains a NumPy array on the host (simulating data streaming).\n",
        "    if epoch == 0:\n",
        "        type_after_update('replicated_params.weight', replicated_params.weight)\n",
        "        type_after_update('loss', loss)\n",
        "        type_after_update('x_parallel', x_parallel)\n",
        "\n",
        "    if epoch % 100 == 0:\n",
        "        print(loss.shape)\n",
        "        print(f\"Step {epoch:3d}, loss: {loss[0]:.3f}\")\n",
        "\n",
        "# Like the loss, the leaves of params have an extra leading dimension,\n",
        "# so we take the params from the first device.\n",
        "params = jax.device_get(jax.tree_map(lambda x: x[0], replicated_params))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "c0tCilpSpKWw",
        "outputId": "9175f43a-fc1a-4c4a-cb83-9ff3462ec4ab"
      },
      "source": [
        "plt.scatter(xs, ys)\n",
        "plt.plot(xs, forward(params, xs), c='red', label='Model Prediction')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JND-OYezMFgg"
      },
      "source": [
        "Wohoo! We trained a model in parallel on multiple devices! 🥳🥳🥳\n",
        "\n",
        "There are more super important tools we're missing though.\n",
        "\n",
        "1. How would we go about transfer learning in JAX? \n",
        "2. How do we freeze certain layers and fine tune others?\n",
        "3. How do we get per sample gradients (and not the usual per batch gradients)?\n",
        "\n",
        "And so on. That brings us to the last section!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0F8N22xO8Y1b"
      },
      "source": [
        "## \"Advanced\" Autodiff 🚀"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vXQUwTScDy9b"
      },
      "source": [
        "### Stop gradients\n",
        "\n",
        "`jax.lax.stop_gradient` is the primitive used for this purpose.\n",
        "\n",
        "\n",
        "**Example 1: TD(0) update (RL algorithm).**\n",
        "\n",
        "The TD(0) update to the network parameters is:\n",
        "\n",
        "$$\n",
        "\\Delta \\theta = (r_t + v_{\\theta}(s_t) - v_{\\theta}(s_{t-1})) \\nabla v_{\\theta}(s_{t-1})\n",
        "$$\n",
        "\n",
        "This update is not the gradient of any loss function.\n",
        "\n",
        "However, it can be **written** as the gradient of the pseudo loss function\n",
        "\n",
        "$$\n",
        "L(\\theta) = [r_t + v_{\\theta}(s_t) - v_{\\theta}(s_{t-1})]^2\n",
        "$$\n",
        "\n",
        "if the dependency of the target $r_t + v_{\\theta}(s_t)$ on the parameter $\\theta$ is ignored."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u1q_6ako8deU"
      },
      "source": [
        "# Value function (simple linear fn) and initial parameters\n",
        "value_fn = lambda theta, state: jnp.dot(theta, state)\n",
        "theta = jnp.array([0.1, -0.1, 0.])\n",
        "\n",
        "# An example transition\n",
        "s_tm1 = jnp.array([1., 2., -1.])\n",
        "r_t = jnp.array(1.)\n",
        "s_t = jnp.array([2., 1., 0.])\n",
        "\n",
        "def td_loss(theta, s_tm1, r_t, s_t):\n",
        "    v_tm1 = value_fn(theta, s_tm1)\n",
        "    target = r_t + value_fn(theta, s_t)\n",
        "    return (jax.lax.stop_gradient(target) - v_tm1) ** 2\n",
        "\n",
        "td_update = jax.grad(td_loss)\n",
        "delta_theta = td_update(theta, s_tm1, r_t, s_t)\n",
        "\n",
        "delta_theta"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3ZQoNA2NVd3U"
      },
      "source": [
        "**Example 2: straight-through estimator**\n",
        "\n",
        "\n",
        "(used in e.g. VQ-VAE, check out my video: https://www.youtube.com/watch?v=VZFVUrYcig0)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oGlfaNGyBJGj"
      },
      "source": [
        "def f(x):\n",
        "    return jnp.round(x)  # non-differentiable\n",
        "\n",
        "def straight_through_f(x):\n",
        "    return x + jax.lax.stop_gradient(f(x) - x) # f(x) = x => dfdx = 1\n",
        "\n",
        "x = 5.6\n",
        "print(\"f(x): \", f(x))\n",
        "print(\"straight_through_f(x):\", straight_through_f(x))  # same values in the forward pass\n",
        "\n",
        "print(\"grad(f)(x):\", jax.grad(f)(x))  # non-diff so it just returns 0\n",
        "print(\"grad(straight_through_f)(x):\", jax.grad(straight_through_f)(x))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6jWHgOEZEaKW"
      },
      "source": [
        "### Per sample gradients\n",
        "\n",
        "\"In many frameworks (PyTorch, TF, Theano) it is often not trivial to compute\n",
        "per-example gradients, because the library directly accumulates the gradient\n",
        "over the batch. Naive workarounds, such as computing a separate loss per example\n",
        "and then aggregating the resulting gradients are typically very inefficient.\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nCA6lYhdDQN5"
      },
      "source": [
        "# Here is how to do it in JAX!\n",
        "\n",
        "# Batch the data\n",
        "batched_s_tm1 = jnp.stack([s_tm1, s_tm1])\n",
        "batched_r_t = jnp.stack([r_t, r_t])\n",
        "batched_s_t = jnp.stack([s_t, s_t])\n",
        "\n",
        "perex_grads = jax.jit(jax.vmap(jax.grad(td_loss), in_axes=(None, 0, 0, 0)))\n",
        "perex_grads(theta, batched_s_tm1, batched_r_t, batched_s_t)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TEnkEnhxGIHq"
      },
      "source": [
        "### Advanced stuff 🐉\n",
        "\n",
        "JAX autodiff engine is very powerful.\n",
        "\n",
        "You can do various things like define custom derivative rules, etc. \n",
        "Take a look at advanced tutorials in the docs (e.g. https://jax.readthedocs.io/en/latest/notebooks/autodiff_cookbook.html)\n",
        "\n",
        "Here is an example of how to calculate update for MAML (notice how similar the code is to math!)\n",
        "\n",
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KvLjDP4yGWoP"
      },
      "source": [
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "txim014sEKl2"
      },
      "source": [
        "# Very easy to do in JAX\n",
        "def meta_loss_fn(params, data):\n",
        "    \"\"\"Computes the loss after one step of SGD.\"\"\"\n",
        "    grads = jax.grad(loss_fn)(params, data)\n",
        "    return loss_fn(params - lr * grads, data)\n",
        "\n",
        "meta_grads = jax.grad(meta_loss_fn)(params, data)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}