Tutorial_2_JAX_HeroPro+_Colab.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "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": [
    "# JAX: from Hero to Hero Pro+\n",
    "\n",
    "aka: on the way to building fully fledged Neural Networks! ❤️\n",
    "\n",
    "Note1: this notebook heavily relies on https://jax.readthedocs.io/en/latest/ + some additional code/modifications, comments/notes, etc.\n",
    "\n",
    "Note2: YouTube video incoming (check out [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)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "3ABn5x8VESIo"
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "id": "wH8CX7C3WTz2"
   },
   "outputs": [],
   "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.))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vkPKuJHRZU-b"
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Q5rUlTHNWO2E"
   },
   "outputs": [],
   "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())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dtwGMqtBXeF-"
   },
   "outputs": [],
   "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())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0kvJ85xUdX44"
   },
   "outputs": [],
   "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)())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pL1Mo84OXna3"
   },
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Xwxy0k_vXqSG"
   },
   "outputs": [],
   "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)"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "id": "5Jy0Uf7mC4XA"
   },
   "outputs": [],
   "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."
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "id": "DlfzandhD7M3"
   },
   "outputs": [],
   "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}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8OWOHjGxGcvy"
   },
   "outputs": [],
   "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)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jsSAxZ4JHwiS"
   },
   "outputs": [],
   "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))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "09Pdhyh2ISb4"
   },
   "outputs": [],
   "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))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RWWsaJOZKQwI"
   },
   "source": [
    "### Less contrived example: training a toy MLP (multi-layer perceptron) model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qQYnvV3xIhrw"
   },
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "hwQKdHJ0J37n"
   },
   "outputs": [],
   "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",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "id": "b97nTnyrKb40",
    "outputId": "e373c2d0-d0b1-4306-ebdb-29ee769fea52"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "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\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();"
   ]
  },
  {
   "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",
   "execution_count": 12,
   "metadata": {
    "id": "oGHnTdw5NvMQ"
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LkODtq-TQzzd"
   },
   "outputs": [],
   "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}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kOWUT1xJQ6ct"
   },
   "outputs": [],
   "source": [
    "print(jax.tree_map(lambda x: x + 1, example_pytree))  # this will not work :/ it'd be nice if it did"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "PkWAbkWgR8_K"
   },
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QmdGdkO0FVx7"
   },
   "outputs": [],
   "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}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UXv9VXCBUI-F"
   },
   "outputs": [],
   "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!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XLKzvGM0V_8M"
   },
   "outputs": [],
   "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",
    "\n",
    "# Try to make another tree with ones instead of zeros\n",
    "shapes = jax.tree_map(lambda x: x.shape, zeros_tree)\n",
    "print(shapes)\n",
    "\n",
    "ones_tree = jax.tree_map(jnp.ones, shapes)\n",
    "print(ones_tree)\n",
    "\n",
    "# Task: debug this"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "id": "lTpSJCfhZnyS"
   },
   "outputs": [],
   "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()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "brnMl8fKbXBQ"
   },
   "outputs": [],
   "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))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sXd_KxABb8hS"
   },
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "B6REXnIccSZp"
   },
   "outputs": [],
   "source": [
    "# First way to optimize this is to simply use vmap\n",
    "vmap_result = jax.vmap(convolve)(ws, xs)\n",
    "print(repr(vmap_result))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zh0KaB1VcbnE"
   },
   "outputs": [],
   "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!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9AQkWD20ceq4"
   },
   "outputs": [],
   "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))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NPUB-3Fvc-K9"
   },
   "outputs": [],
   "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))"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "id": "cXjC_T4Jdmuc"
   },
   "outputs": [],
   "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])}')"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "id": "LXNlDtH1KbCU"
   },
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "__jRUIX7LlKE"
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "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",
   "execution_count": 38,
   "metadata": {
    "id": "q5bXckJojUct"
   },
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "id": "unXtXH5Cn_D9",
    "outputId": "9597b1a2-2416-42ed-be16-e4b903a5f632"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "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()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "I-h0bNc7opqw"
   },
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "N0Qm-vgkoxHb"
   },
   "outputs": [],
   "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))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "id": "c0tCilpSpKWw",
    "outputId": "4e166acf-b6c2-47bf-9978-5d8ac2c0d003"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(xs, ys)\n",
    "plt.plot(xs, forward(params, xs), c='red', label='Model Prediction')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "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",
   "execution_count": 41,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "u1q_6ako8deU",
    "outputId": "2e63ce93-9345-434e-84d9-cc835a569e97"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DeviceArray([-2.4, -4.8,  2.4], dtype=float32)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "id": "oGlfaNGyBJGj"
   },
   "outputs": [],
   "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)\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))"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "id": "nCA6lYhdDQN5"
   },
   "outputs": [],
   "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)"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "id": "txim014sEKl2"
   },
   "outputs": [],
   "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)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "TPU",
  "colab": {
   "authorship_tag": "ABX9TyNoQovNyxRLR+MbW+ePMHA2",
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "Tutorial 2: Hero Pro +.ipynb",
   "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.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}