demo/flash-attention-ipu-demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright (c) 2023 Graphcore Ltd. All rights reserved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------------+---------------------------------------------------------------------------------+\n",
      "|  gc-monitor   |          Partition: 631709-reconfig [active] has 4 reconfigurable IPUs          |\n",
      "+-------------+--------------------+--------+--------------+----------+-------+----+------+-------+\n",
      "|    IPU-M    |       Serial       |IPU-M SW|Server version|  ICU FW  | Type  | ID | IPU# |Routing|\n",
      "+-------------+--------------------+--------+--------------+----------+-------+----+------+-------+\n",
      "| 10.5.13.15  | 0032.0002.8204821  |...0-028|    1.11.0    |  2.5.9   | M2000 | 0  |  3   |  DNC  |\n",
      "| 10.5.13.15  | 0032.0002.8204821  |...0-028|    1.11.0    |  2.5.9   | M2000 | 1  |  2   |  DNC  |\n",
      "| 10.5.13.15  | 0032.0001.8204821  |...0-028|    1.11.0    |  2.5.9   | M2000 | 2  |  1   |  DNC  |\n",
      "| 10.5.13.15  | 0032.0001.8204821  |...0-028|    1.11.0    |  2.5.9   | M2000 | 3  |  0   |  DNC  |\n",
      "+-------------+--------------------+--------+--------------+----------+-------+----+------+-------+\n",
      "+--------------------------------------------------------------------------------------------------+\n",
      "|                        No attached processes in partition 631709-reconfig                        |\n",
      "+--------------------------------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "# Check we can see our IPUs!\n",
    "# Top line should say Partition: {partition_name} has {n} reconfigurable IPUs if successful\n",
    "!gc-monitor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!git submodule update --init\n",
    "!pip install -r requirements.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimizing Memory Usage with Custom Ops: A Case Study with FlashAttention\n",
    "\n",
    "If you have ever tried porting an arbitrary PyTorch model to the IPU, your first attempt to run the model will likely have resulted in an out-of-memory (OOM) error. Most PyTorch models have been written to fit all weights, cached activations, and optimizer states on a single GPU with ≥16 GB VRAM, whereas a single IPU has around 900 MB SRAM. How does [[1](https://www.theregister.com/2022/06/16/graphcore_nvidia_gpus/)] an IPU [[2](https://www.hpcwire.com/2022/06/29/the-mainstreaming-of-mlperf-nvidia-dominates-training-v2-0-but-challengers-are-rising/)] with >16x less memory [[3](https://www.eetimes.com/graphcore-supercharges-ipu-with-wafer-on-wafer/)] compete with a GPU [[4](https://www.graphcore.ai/performance-results)]? \n",
    "\n",
    "The simple answer is that the performance of a majority of deep learning applications are limited by the rate at which they can read and write to the highest level of memory (memory-bandwidth bound) and the VRAM used in GPUs has a much lower memory-bandwidth (1-4 TB/s depending on the GPU device) than the SRAM used in IPUs (65 TB/s). **This means that if you can squeeze your model into IPU memory, it should run much faster than on GPUs** (subject to any other overheads such as collective bandwidth and host-offloading.). Thankfully, Graphcore's software engineers have written some IPU-specific extensions to PyTorch along with a [handy guide](https://docs.graphcore.ai/projects/memory-performance-optimisation/en/latest/common-memory-optimisations.html) on how to apply common memory optimisations to leverage these performance benefits.\n",
    "\n",
    "One of the suggestions described briefly in the [Memory and Performance Optimisation guide](https://docs.graphcore.ai/projects/memory-performance-optimisation/en/latest/common-memory-optimisations.html) is to use custom operations. The [PyTorch for IPU user guide](https://docs.graphcore.ai/projects/popart-user-guide/en/latest) describes [how to write custom ops](https://docs.graphcore.ai/projects/popart-user-guide/en/latest/custom_ops.html), using the example of implementing a custom Leaky ReLU op.\n",
    "\n",
    "But what about a more meaty custom operation that actually does some memory optimisation? Enter FlashAttention [[5](https://arxiv.org/abs/2205.14135)][[6](https://arxiv.org/abs/2307.08691)], an optimised attention operator for GPUs that has recently been adopted by PyTorch and others as the default attention implementation for large language models due to its ability to scale to large sequence lengths. The problem it solves is that a naive attention operation computes an intermediate \"attention matrix\" that you must read and write to memory. However, the size of this attention matrix scales with the square of sequence length and makes reading and writing it very costly. For sequences longer than about 2 048 tokens, communicating the attention matrix can become the main bottleneck in the runtime of a transformer model.\n",
    "\n",
    "The solution is to break up the attention computation into chunks such that the attention matrix never needs to be present in memory all at once. When these chunks are small enough, each chunk can fit into a GPU L2 Cache (40-50 MB), eliminating the need to read from and write to VRAM. As a result FlashAttention adeptly overcomes a key bottleneck in training and high throughput inference of transformers.\n",
    " \n",
    "The same algorithm can also be used to minimise the memory usage of the attention operation to allow us to run models with larger sequence lengths on the IPU.\n",
    "\n",
    "In this notebook we will show a toy demonstration of what this looks like for the IPU. We will:\n",
    "1. Load a PyTorch model workload we did not write ourselves (specifically [nanoGPT training](https://github.com/karpathy/nanoGPT/)) and show what happens when it is run out of the box.\n",
    "2. Profile the model to demonstrate that the attention matrix is consuming a lot of IPU memory.\n",
    "3. Show how our implementation of [FlashAttention](https://github.com/graphcore-research/flash-attention-ipu) eliminates the contribution of the attention matrix to IPU memory usage.\n",
    "4. Successfully train nanoGPT!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Load nanoGPT and try to run\n",
    "\n",
    "nanoGPT is the de-facto mini-workload for testing and debugging new features of a deep learning toolkit. We take a small character-level variant of the model (about 10M parameters) and train it on the works of Shakespeare. Crucially, because backpropagation requires every operation to cache its output activations, these activations become the key memory bottleneck. The typical solution to this is to cache only a subset of these activation (activation checkpointing), and recompute the rest while the gradient graph is being traversed during backpropagation. \n",
    "\n",
    "We will not do that here so that we can provide a simple illustration of how you would go about optimising memory usage through a custom operation.\n",
    "\n",
    "We'll now see what happens when we take nanoGPT and try to train it without doing any memory optimisation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nanoGPT import model\n",
    "from train import config, train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of parameters: 10.67M\n"
     ]
    }
   ],
   "source": [
    "gpt = model.GPT(config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training standard-attn-train ...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nethome/lukep/Projects/flash-attention-ipu/demo/train.py:177: UserWarning: The given buffer is not writable, and PyTorch does not support non-writable tensors. This means you can write to the underlying (supposedly non-writable) buffer using the tensor. You may want to copy the buffer to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:1462.)\n",
      "  split: torch.frombuffer(\n",
      "/nethome/lukep/envs/venv_poptorch_3.3.0/lib/python3.8/site-packages/torch/nn/modules/module.py:1802: UserWarning: Positional args are being deprecated, use kwargs instead. Refer to https://pytorch.org/docs/master/generated/torch.nn.Module.html#torch.nn.Module.state_dict for details.\n",
      "  warnings.warn(\n",
      "[10:48:22.016] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 78\n",
      "[10:48:22.016] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 79\n",
      "[10:48:22.016] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 80\n",
      "[10:48:22.023] [poptorch:cpp] [warning] [DISPATCHER] Tensor (ptr 0xace15d0) type coerced from Double to Float\n",
      "[10:48:22.025] [poptorch:cpp] [warning] [DISPATCHER] Tensor (ptr 0xacf7b20) type coerced from Double to Float\n",
      "[10:48:22.039] [poptorch:cpp] [warning] [DISPATCHER] Tensor (ptr 0xda9aca0) type coerced from Double to Float\n",
      "[10:48:22.041] [poptorch:cpp] [warning] [DISPATCHER] Tensor (ptr 0xdaafbe0) type coerced from Double to Float\n",
      "[10:48:22.055] [poptorch:cpp] [warning] ...repeated messages suppressed...\n",
      "Graph compilation: 100%|██████████| 100/100 [00:54<00:00]\n",
      "[10:49:28.722] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 634\n",
      "[10:49:28.723] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 635\n",
      "[10:49:28.723] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 636\n",
      "Graph compilation: 100%|██████████| 100/100 [02:05<00:00]\n",
      "2023-09-25T10:51:36.208051Z popart:devicex 16364.16364 E: Memory allocation error : /opt/jenkins/workspace/poplar/poplar_ci_ubuntu_20_04_unprivileged/popart/willow/src/popx/irlowering.cpp:3536 Out of memory on tile 0: 876060 bytes used but tiles only have 638976 bytes of memory\n",
      "2023-09-25T10:51:36.209161Z popart:popart 16364.16364 E: /opt/jenkins/workspace/poplar/poplar_ci_ubuntu_20_04_unprivileged/popart/willow/src/popx/irlowering.cpp:3536 Out of memory on tile 0: 876060 bytes used but tiles only have 638976 bytes of memory\n",
      "\n",
      "[0] popart::popx::Devicex::prepare()\n",
      "[1] popart::Session::prepareDevice(bool)\n",
      "[2] poptorch::popart_compiler::Compiler::compileAndPrepareDevice()\n",
      "[3] poptorch::detail::LowerToPopartImpl::compile()\n",
      "[4] poptorch::LowerToPopart::compile()\n",
      "\n",
      "\n",
      "\n",
      "[10:51:36.209] [poptorch:cpp] [error] Out of memory, the graph profile is available here: \n"
     ]
    }
   ],
   "source": [
    "# Simple (non-optimised) trainer for IPU\n",
    "train(gpt, experiment_name=\"standard-attn-train\")\n",
    "### OOM EXPECTED ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOM error! 😭 \n",
    "\n",
    "Oh dear. As expected, we've exceeded 900 MB of IPU memory.\n",
    "\n",
    "What now?\n",
    "\n",
    "## 2. Profile the model to find out what is consuming our memory\n",
    "\n",
    "Thankfully, the benevolent and hard-working army of Graphcore software engineers have built profiling tools to inspect in detail how your program has compiled, and how it is executed on the IPU if successfully compiled. The [Poplar SDK](https://docs.graphcore.ai/projects/sdk-overview/) contains the [`libpva`](https://docs.graphcore.ai/projects/libpva/en/latest/intro.html) library that can help you to profile your code. We use `libpva` in this notebook to build a couple of utilities for displaying this information in a notebook. For an introduction to profiling on the IPU refer to the [Profiling Quick Start guide](https://docs.graphcore.ai/projects/profiling-quick-start/). For more advanced tooling to inspect profiles with a graphical user interface, you can also use the [PopVision Graph Analyser](https://www.graphcore.ai/developer/popvision-tools).\n",
    "\n",
    "This time we'll run the same experiment again, but with profiling turned on. It will still go out of memory, but at least the IPU will give us something back to find out why.\n",
    "\n",
    "Look in the stack trace for where it says our model is profiled: `Out of memory, the graph profile is available here: profiles/standard-attn-profile/training/profile.pop`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of parameters: 10.67M\n"
     ]
    }
   ],
   "source": [
    "gpt.destroy()\n",
    "gpt = model.GPT(config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training standard-attn-profile ...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[10:55:11.437] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 1190\n",
      "[10:55:11.438] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 1191\n",
      "[10:55:11.438] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 1192\n",
      "Graph compilation: 100%|██████████| 100/100 [01:02<00:00]\n",
      "[10:56:32.620] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 1746\n",
      "[10:56:32.621] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 1747\n",
      "[10:56:32.622] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 1748\n",
      "Graph compilation: 100%|██████████| 100/100 [02:49<00:00]\n",
      "Graph compilation:   0%|          | 0/100 [00:00<?]\n",
      "2023-09-25T10:59:25.284929Z popart:devicex 16364.16364 E: Memory allocation error : /opt/jenkins/workspace/poplar/poplar_ci_ubuntu_20_04_unprivileged/popart/willow/src/popx/irlowering.cpp:3536 Out of memory: Cannot fit all variable data onto one or more tiles. Profile saved to: profiles/standard-attn-profile/training/profile.pop\n",
      "2023-09-25T10:59:25.286035Z popart:popart 16364.16364 E: /opt/jenkins/workspace/poplar/poplar_ci_ubuntu_20_04_unprivileged/popart/willow/src/popx/irlowering.cpp:3536 Out of memory: Cannot fit all variable data onto one or more tiles. Profile saved to: profiles/standard-attn-profile/training/profile.pop\n",
      "\n",
      "[0] popart::popx::Devicex::prepare()\n",
      "[1] popart::Session::prepareDevice(bool)\n",
      "[2] poptorch::popart_compiler::Compiler::compileAndPrepareDevice()\n",
      "[3] poptorch::detail::LowerToPopartImpl::compile()\n",
      "[4] poptorch::LowerToPopart::compile()\n",
      "\n",
      "\n",
      "\n",
      "[10:59:25.286] [poptorch:cpp] [error] Out of memory, the graph profile is available here: profiles/standard-attn-profile/training/profile.pop\n"
     ]
    }
   ],
   "source": [
    "train(gpt, experiment_name=\"standard-attn-profile\", profile=True)\n",
    "### OOM EXPECTED ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inspecting a liveness trace\n",
    "\n",
    "We're going to plot a \"liveness trace\". When we compile a model, the compiler figures out a sequence of \"program steps\" to execute one after the other. The liveness trace shows us how much memory is being used during each program step. For a training step, you will typically see a ramp up during the forward pass while tensors are generated and cached for the backward pass, a peak when the loss is computed, and a ramp down during the backward pass while activations are consumed and deleted once they are no longer needed.\n",
    "\n",
    "You can split up the variables stored in memory by those that are needed throughout the program (always live or constant memory variables, for example, weights, accumulation buffers, code) and those that are created and destroyed somewhere in the middle of the program (not always live or temporary memory variables, for example, gradients, activations)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from profile_utils import plot_liveness_trace, get_step_variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "standard_attn_report = \"./profiles/standard-attn-profile/training/profile.pop\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_liveness_trace(standard_attn_report)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The liveness trace shows use that our memory usage exceeds the maximum available memory at around step 1,500, with peak memory usage at around step 1,800.\n",
    "\n",
    "Let's inspect the size of the variables at step 1,800 to see which variables are eating up most of the available memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = get_step_variables(standard_attn_report, step_num=1800)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>MB</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3749/4/attn/Softmax:0</th>\n",
       "      <td>50.331648</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5/attn/Softmax/3674/SoftmaxGrad/SoftMaxGradient/Op/Multiply/Out</th>\n",
       "      <td>50.331648</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/attn/Softmax/4190/0/attn/Softmax:0</th>\n",
       "      <td>50.331648</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/attn/Softmax/4190/call_subgraph(17)/1/attn/Softmax:0</th>\n",
       "      <td>50.331648</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3726/1/attn/Softmax:0</th>\n",
       "      <td>50.331648</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3749/2/attn/Softmax:0</th>\n",
       "      <td>50.331648</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/c_fc/Reshape/4371/0/mlp/c_fc/Reshape:0/1</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2/mlp/gelu/Gelu/295</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/gelu/Gelu/161</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1/mlp/gelu/Gelu/3729</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3727/1/mlp/c_fc/Reshape:0/1</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1/mlp/gelu/Gelu/3729/1/mlp/gelu/Gelu:0</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           MB\n",
       "3749/4/attn/Softmax:0                               50.331648\n",
       "5/attn/Softmax/3674/SoftmaxGrad/SoftMaxGradient...  50.331648\n",
       "0/attn/Softmax/4190/0/attn/Softmax:0                50.331648\n",
       "0/attn/Softmax/4190/call_subgraph(17)/1/attn/So...  50.331648\n",
       "3726/1/attn/Softmax:0                               50.331648\n",
       "3749/2/attn/Softmax:0                               50.331648\n",
       "0/mlp/c_fc/Reshape/4371/0/mlp/c_fc/Reshape:0/1      12.582912\n",
       "2/mlp/gelu/Gelu/295                                 12.582912\n",
       "0/mlp/gelu/Gelu/161                                 12.582912\n",
       "1/mlp/gelu/Gelu/3729                                12.582912\n",
       "3727/1/mlp/c_fc/Reshape:0/1                         12.582912\n",
       "1/mlp/gelu/Gelu/3729/1/mlp/gelu/Gelu:0              12.582912"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***A bit of background*** *: Our PyTorch compiler assigns names to each activation tensor based on the operation that generated it.*\n",
    "\n",
    "Here we can see the top contributors to memory usage. The top 6 are all called something like `foo/Softmax:0`, meaning they are the output of a softmax operation. Which tensor is the output of a softmax operation? The attention matrix!\n",
    "\n",
    "We can therefore see that the cached attention matrices over all layers eats up about a third of the IPU memory!\n",
    "\n",
    "So let's get rid of them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of parameters: 10.67M\n"
     ]
    }
   ],
   "source": [
    "gpt.destroy()\n",
    "gpt = model.GPT(config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Solving OOM with `import flash_attention_ipu.auto`\n",
    "\n",
    "Here we'll import a small library of custom ops implementing FlashAttention on the IPU. There are currently a number of ways that public PyTorch models use FlashAttention, including via the [FlashAttention library](https://github.com/Dao-AILab/flash-attention), [custom Triton implementations](https://github.com/mosaicml/llm-foundry/blob/main/llmfoundry/models/layers/flash_attn_triton.py), or using `torch.nn.functional.scaled_dot_product_attention` directly in PyTorch (as of the PyTorch 2.0 release).\n",
    "\n",
    "nanoGPT uses the latter implementation (see https://github.com/karpathy/nanoGPT/blob/master/model.py#L64). This function makes a choice for the user amongst various fused-attention schemes based on tensor shapes, hardware (CPU or GPU), and other arguments (for example, masks). Since the PyTorch compiler first traces the model on the CPU, this results in a non-optimal function being traced for the IPU. \n",
    "\n",
    "As such we present `flash_attention_ipu`, which provides a more efficient lowering of `torch.nn.functional.scaled_dot_product_attention` for the IPU. Importing `flash_attention_ipu.auto` automatically patches `torch.nn.functional.scaled_dot_product_attention` and the job is done!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import flash_attention_ipu.auto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's profile the model again to confirm that we have successfully overcome our OOM issue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training flash-attn-profile ...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nethome/lukep/envs/venv_poptorch_3.3.0/lib/python3.8/site-packages/torch/nn/modules/module.py:1802: UserWarning: Positional args are being deprecated, use kwargs instead. Refer to https://pytorch.org/docs/master/generated/torch.nn.Module.html#torch.nn.Module.state_dict for details.\n",
      "  warnings.warn(\n",
      "[10:59:48.283] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 2302\n",
      "[10:59:48.283] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 2303\n",
      "[10:59:48.283] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 2304\n",
      "Graph compilation: 100%|██████████| 100/100 [00:40<00:00]\n",
      "[11:00:58.309] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 2738\n",
      "[11:00:58.310] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 2739\n",
      "[11:00:58.310] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 2740\n",
      "Graph compilation: 100%|██████████| 100/100 [02:14<00:00]\n",
      "100%|██████████| 1/1 [00:00<00:00, 21290.88it/s]\n"
     ]
    }
   ],
   "source": [
    "train(gpt, experiment_name=\"flash-attn-profile\", profile=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Success! 🎉\n",
    "\n",
    "How does the liveness trace look now?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "flash_attn_report = \"./profiles/flash-attn-profile/training/profile.pop\"\n",
    "plot_liveness_trace(flash_attn_report)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have a healthy clearance with our memory limit.\n",
    "\n",
    "If we wanted to take this further, what should we target next? What are the next biggest contributors to our memory consumption that might become a problem with larger models?\n",
    "\n",
    "The peak memory usage is around program step 2,500 now, so let's look there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>MB</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0/mlp/gelu/Gelu/3132/3/mlp/gelu/Gelu:0</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/gelu/Gelu/3132/2/mlp/gelu/Gelu:0</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/c_fc/Reshape/3530/3/mlp/c_fc/Reshape:0/1</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/c_fc/Reshape/3530/2/mlp/c_fc/Reshape:0/1</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/c_fc/Reshape/3530/1/mlp/c_fc/Reshape:0/1</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/c_fc/Reshape/3530/0/mlp/c_fc/Reshape:0/1</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/c_fc/Gemm/3127/matmulGrouped/Conv_1/serialOut[0]</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/gelu/Gelu/3132</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/gelu/Gelu/3132/0/mlp/gelu/Gelu:0</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/gelu/Gelu/3132/1/mlp/gelu/Gelu:0</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/c_fc/Reshape/3530/4/mlp/c_fc/Reshape:0/1</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/gelu/Gelu/3132/4/mlp/gelu/Gelu:0</th>\n",
       "      <td>12.582912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0/mlp/c_proj/Reshape/3517/4/mlp/c_proj/Reshape:0/1</th>\n",
       "      <td>3.145728</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2/ln_2/Flatten/264</th>\n",
       "      <td>3.145728</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3/ln_1/Flatten/286</th>\n",
       "      <td>3.145728</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3/ln_2/Flatten/324</th>\n",
       "      <td>3.145728</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                           MB\n",
       "0/mlp/gelu/Gelu/3132/3/mlp/gelu/Gelu:0              12.582912\n",
       "0/mlp/gelu/Gelu/3132/2/mlp/gelu/Gelu:0              12.582912\n",
       "0/mlp/c_fc/Reshape/3530/3/mlp/c_fc/Reshape:0/1      12.582912\n",
       "0/mlp/c_fc/Reshape/3530/2/mlp/c_fc/Reshape:0/1      12.582912\n",
       "0/mlp/c_fc/Reshape/3530/1/mlp/c_fc/Reshape:0/1      12.582912\n",
       "0/mlp/c_fc/Reshape/3530/0/mlp/c_fc/Reshape:0/1      12.582912\n",
       "0/mlp/c_fc/Gemm/3127/matmulGrouped/Conv_1/seria...  12.582912\n",
       "0/mlp/gelu/Gelu/3132                                12.582912\n",
       "0/mlp/gelu/Gelu/3132/0/mlp/gelu/Gelu:0              12.582912\n",
       "0/mlp/gelu/Gelu/3132/1/mlp/gelu/Gelu:0              12.582912\n",
       "0/mlp/c_fc/Reshape/3530/4/mlp/c_fc/Reshape:0/1      12.582912\n",
       "0/mlp/gelu/Gelu/3132/4/mlp/gelu/Gelu:0              12.582912\n",
       "0/mlp/c_proj/Reshape/3517/4/mlp/c_proj/Reshape:0/1   3.145728\n",
       "2/ln_2/Flatten/264                                   3.145728\n",
       "3/ln_1/Flatten/286                                   3.145728\n",
       "3/ln_2/Flatten/324                                   3.145728"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = get_step_variables(flash_attn_report, step_num=2500)\n",
    "df.head(16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Remember: Tensors are named based on the operator that created them.*\n",
    "\n",
    "Here we can see 6 tensors with names of the form `foo/Reshape` and 6 tensors with names of the form `bar/Gelu`. What could these be?\n",
    "\n",
    "Since we aren't doing any activation checkpointing, we know all intermediate tensors are being cached for the backwards pass. We know that there is a `gelu` in the middle of the transformer layer MLP, so the `bar/Gelu` tensors must be the hidden state of the MLP. The fact that these come out to 12.5 MB makes sense because we know the attention matrix came out to 50 MB, which should be 4x larger for a transformer with embedding dimension = 384, attention heads = 6, and sequence length = 1,024.\n",
    "\n",
    "The `foo/Reshape` tensors are the same size as the `bar/Gelu` tensors, so we can guess that these are either the result of some reshaping after the MLP input matmul, or before the MLP output matmul. The name of the tensor is not descriptive enough to tell us exactly which one it is, but we have a rough idea where it might be beneficial to write some custom memory optimisations next! For now, we'll leave this to future work (see [Next Steps](#next-steps))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's complete a successful training run now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of parameters: 10.67M\n",
      "Training flash-attn-train ...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nethome/lukep/envs/venv_poptorch_3.3.0/lib/python3.8/site-packages/torch/nn/modules/module.py:1802: UserWarning: Positional args are being deprecated, use kwargs instead. Refer to https://pytorch.org/docs/master/generated/torch.nn.Module.html#torch.nn.Module.state_dict for details.\n",
      "  warnings.warn(\n",
      "[12:18:57.502] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 3174\n",
      "[12:18:57.502] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 3175\n",
      "[12:18:57.503] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 3176\n",
      "Graph compilation: 100%|██████████| 100/100 [00:39<00:00]\n",
      "[12:20:07.498] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 3610\n",
      "[12:20:07.499] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 3611\n",
      "[12:20:07.499] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 3612\n",
      "Graph compilation: 100%|██████████| 100/100 [02:11<00:00]\n",
      "100%|██████████| 2000/2000 [10:17<00:00,  3.24it/s]  \n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "gpt = model.GPT(config)\n",
    "train(gpt, experiment_name=\"flash-attn-train\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 🥳 📉 Huzzah! 📉 🥳\n",
    "\n",
    "We can see the classic training and validation curves for a model overfitting the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wrapping up\n",
    "\n",
    "In this notebook, we used a custom op from `flash_attention_ipu` to solve an OOM error with a public model we have tried to get running on IPU. We saw:\n",
    "\n",
    "1. How an IPU responds when a model requires too much memory\n",
    "2. How we can profile and inspect the state of a compiled model on IPU to diagnose how best to optimise memory usage\n",
    "3. How the use of `flash_attention_ipu` eliminated major contributors to memory consumption\n",
    "4. A successful training run of a model after fitting it in memory.\n",
    "\n",
    "## Next steps\n",
    "\n",
    "This notebook demonstrated a toy example of how to use custom ops to solve OOM errors when porting public models to the IPU. We would first recommend trying to perform simpler memory optimisations outlined in our [Memory and Performance Optimisation guide](https://docs.graphcore.ai/projects/memory-performance-optimisation/en/latest/common-memory-optimisations.html) before writing a custom op. Can you figure out how to edit `train.py` to optimise nanoGPT for IPU and improve training time? Try looking at our [PyTorch tutorials](https://github.com/graphcore/examples/tree/master/tutorials/tutorials/pytorch) and [BERT example](https://github.com/graphcore/examples/tree/master/nlp/bert/pytorch) to get a sense of how you can more rigorously optimise an application for the IPU.\n",
    "\n",
    "Perhaps instead you want to get more experience writing custom ops? Or even to help improve our FlashAttention implementation (see [bottom of notebook](#next-next-steps) for ideas)? Take a look at our [Poplar tutorials](https://github.com/graphcore/examples/tree/master/tutorials/tutorials/poplar) to see how to write lower-level code for the IPU, and perhaps take a look at some of the other more meaty custom ops that have been implemented, such as for [ray tracing](https://github.com/graphcore-research/ipu-ray-lib), [distance matrices](https://github.com/graphcore-research/poptorch-experimental-addons/blob/main/poptorch_experimental_addons/cpp/distance_matrix.cpp), and [Non-Maximum Suppression](https://github.com/graphcore/NMS) for image segmentation. You can also try our experimental Python library [`tesselate`](https://github.com/graphcore-research/tessellate-ipu) for writing low-level IPU code, where you can explore the MIMD capabilities of the IPU for accelerating linear algebra!\n",
    "\n",
    "If you want to stick with this notebook a little longer, we also have a few appendix items that might be of interest to you."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix A: Proof of numerical parity with and without `flash_attention_ipu`\n",
    "\n",
    "If you are sceptical, you might be thinking \"Hang on! How do I even know you're computing attention correctly at all here? You haven't shown me any comparisons with a trusted baseline!\".\n",
    "\n",
    "1. This is a fantastic attitude to have and will serve you well in life!\n",
    "\n",
    "2. Fear not! We'll show you a comparison with a training run using a shorter sequence length that doesn't need FlashAttention to fit on the IPU."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of parameters: 10.67M\n",
      "Training standard-attn-train-blocksize256 ...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nethome/lukep/envs/venv_poptorch_3.3.0/lib/python3.8/site-packages/torch/nn/modules/module.py:1802: UserWarning: Positional args are being deprecated, use kwargs instead. Refer to https://pytorch.org/docs/master/generated/torch.nn.Module.html#torch.nn.Module.state_dict for details.\n",
      "  warnings.warn(\n",
      "[12:33:28.917] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 4046\n",
      "[12:33:28.918] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 4047\n",
      "[12:33:28.918] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 4048\n",
      "Graph compilation: 100%|██████████| 100/100 [00:24<00:00]\n",
      "[12:34:04.782] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 4602\n",
      "[12:34:04.783] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 4603\n",
      "[12:34:04.784] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 4604\n",
      "Graph compilation: 100%|██████████| 100/100 [01:23<00:00]\n",
      "100%|██████████| 2000/2000 [04:39<00:00,  7.16it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of parameters: 10.67M\n",
      "Training flash-attn-train-blocksize_256 ...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nethome/lukep/envs/venv_poptorch_3.3.0/lib/python3.8/site-packages/torch/nn/modules/module.py:1802: UserWarning: Positional args are being deprecated, use kwargs instead. Refer to https://pytorch.org/docs/master/generated/torch.nn.Module.html#torch.nn.Module.state_dict for details.\n",
      "  warnings.warn(\n",
      "[12:40:19.234] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 5158\n",
      "[12:40:19.234] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 5159\n",
      "[12:40:19.235] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 5160\n",
      "Graph compilation: 100%|██████████| 100/100 [00:28<00:00]\n",
      "[12:41:01.837] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 5594\n",
      "[12:41:01.838] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 5595\n",
      "[12:41:01.838] [poptorch:cpp] [warning] [DISPATCHER] Type coerced from Long to Int for tensor id 5596\n",
      "Graph compilation: 100%|██████████| 100/100 [01:31<00:00]\n",
      "100%|██████████| 2000/2000 [05:06<00:00,  6.52it/s]  \n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Temporarily undo function patching\n",
    "import torch.nn.functional as F\n",
    "patched_fn = F.scaled_dot_product_attention\n",
    "F.scaled_dot_product_attention = F.scaled_dot_product_attention.__wrapped__\n",
    "\n",
    "gpt = model.GPT(config)\n",
    "train(gpt, experiment_name=\"standard-attn-train-blocksize256\", block_size=256)\n",
    "\n",
    "# Reset patched function\n",
    "F.scaled_dot_product_attention = patched_fn\n",
    "\n",
    "gpt = model.GPT(config)\n",
    "train(gpt, experiment_name=\"flash-attn-train-blocksize_256\", block_size=256)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These training and validation curves are pretty much the same, subject to a bit of randomness and non-associativity of floating point arithmetic.\n",
    "\n",
    "If you need more convincing, take a look at the [tests](https://github.com/graphcore-research/flash-attention-ipu/blob/main/tests/python/test_flash_attention_qkv_packed.py). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix B: A context of 1,024 is still quite small. Surely with 900 MB of SRAM you can go bigger?\n",
    "\n",
    "**This appendix section is not as performant as I was expecting it to be (should be able to get 2x larger tensors in)**\n",
    "\n",
    "It is possible to fit much larger context lengths, but it is application dependent. Even with plenty of memory optimisation, training workloads have quite a large memory footprint that scales with micro-batch size and number of model layers as you need to save some activation checkpoints. Inference workloads usually have much smaller memory footprints as activations generally don't need to be cached (U-net is an exception), but sometimes they are to reduce latency (for example in autoregressive token generation). \n",
    "\n",
    "A good application of `flash_attention_ipu` with long context length is the prefill phase of large language model inference with lots of additional context retrieved from a database, or generating embeddings for very long documents.\n",
    "\n",
    "For now, we'll just show a simple mini-benchmark for a representative workload that would be part of a larger production system.\n",
    "\n",
    "A typical setup for a large language model would split weights across multiple IPUs, potentially storing weights in external memory buffers if the available SRAM in the system is less than is required for the whole model. For attention, this would mean splitting heads across multiple chips as these are easily parallelised and require no communication between chips. \n",
    "\n",
    "- For the sake of argument, let's say we have 8 attention heads per chip. \n",
    "\n",
    "- Since IPUs can still attain high throughput at low batch sizes, we might set our batch size to 1.\n",
    "\n",
    "- Attention heads usually have a head dimension of 128, so let's use that for our representative benchmark.\n",
    "\n",
    "- We'll assume a float16 data type for activation tensors since we can halve our memory usage and double our FLOPs.\n",
    "\n",
    "We have 900 MB of SRAM, but we often need to reserve about 200 MB for code, leaving 700 MB for the operation.\n",
    "\n",
    "The attention operation itself takes in 3 tensors and outputs 1 tensor, each of size `[batch_size, num_heads, ctx_len, head_dim]`. For float16 (2 bytes per element) with `batch_size=1`, `num_heads=8`, `head_dim=128`, the function will need at least `2 * 4 * 8 * ctx_len * 128` bytes = `8192 * ctx_len` bytes. If we broke up the attention operation into super small chunks so that it had next to no overhead, we should be able to fit a context length of `700 * 10**6 / 8192 = 85449`. \n",
    "\n",
    "Realistically, we want the attention operation to have large enough chunks that we get decent FLOP utilisation, so we need to account for both an attention chunk. To make the maths easy, lets say these chunks are the same size as the individual input and output tensors. That means the function would need at least `(8192 + 2048) * ctx_len` bytes = `10240 * ctx_len` bytes. Realistically then, we should be able to fit a context length of `700 * 10**6 / 10240 = 68359`.\n",
    "\n",
    "Finally, we'll also round down to the nearest power of 2 (`ctx_len = 2**16 = 65536`) to allow ourselves a little more room for memory overheads."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Graph compilation: 100%|██████████| 100/100 [00:30<00:00]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attention operation with size [1, 8, 65536, 64] ran successfully\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import poptorch\n",
    "\n",
    "# We'll use the flash_attention op directly so we can control chunk size\n",
    "from flash_attention_ipu import flash_attention_qkv_packed\n",
    "\n",
    "batch_size = 1\n",
    "num_heads = 8\n",
    "ctx_len = 65536\n",
    "head_dim = 64\n",
    "\n",
    "qkv = torch.randn(3, batch_size, num_heads, ctx_len, head_dim, dtype=torch.float16)\n",
    "\n",
    "class AttentionBenchmarker(torch.nn.Module):\n",
    "    def __init__(self, qkv):\n",
    "        super().__init__()\n",
    "        self.register_buffer(\"qkv\", qkv)\n",
    "    \n",
    "    def forward(self):\n",
    "        return flash_attention_qkv_packed(self.qkv.reshape(3, -1, *self.qkv.shape[-2:]), num_chunks_q=64, num_chunks_kv=64)\n",
    "\n",
    "benchmarker = poptorch.inferenceModel(AttentionBenchmarker(qkv))\n",
    "\n",
    "out = benchmarker()\n",
    "\n",
    "print(f\"Attention operation with size [{batch_size}, {num_heads}, {ctx_len}, {head_dim}] ran successfully\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix C: Dive into the Poplar implementation of FlashAttention\n",
    "\n",
    "If you've made it this far and still feel like you haven't seen enough code, you're in luck! Here we'll take you through the [Poplar implementation of FlashAttention](https://github.com/graphcore-research/flash-attention-ipu/blob/main/flash_attention_ipu/cpp/flash_attention_qkv_packed.cpp). Some details are omitted here for brevity, but many comments are added for explanation.\n",
    "\n",
    "For context, Poplar is a C++ framework for writing tensor programs to run on the IPU. The user constructs a graph (a `poplar::Graph` object) that calls a number of subprograms (for example, a `poplar::program::Sequence` object), each of which consists of a set of ops (for example, `popnn::gelu`, `poplin::matMul`, `popops::expInPlace`) that do some manipulation of data referred to by a `poplar::Tensor` object, where each `poplar::Tensor` has a bit of metadata called a `TileMapping` that dictates how a tensor's data should be laid out across the 1,472 tiles in an IPU. \n",
    "\n",
    "For now, this should be all the context you need to get a reasonable idea of what is going on, but for more detail on the Poplar framework, take a look through the [Poplar User Guide](https://docs.graphcore.ai/projects/poplar-user-guide/en/latest/poplar_programs.html) and [Poplar and PopLibs API reference](https://docs.graphcore.ai/projects/poplar-api/en/latest/poplibs_api.html). \n",
    "\n",
    "```c++\n",
    "\n",
    "/* \n",
    "Data structure to hold the output of FlashAttention operation, \n",
    "which returns the attention output and the log of the softmax\n",
    "denominator to be used in the gradient operation.\n",
    "*/ \n",
    "\n",
    "struct AttentionOutputWithStash {\n",
    "    poplar::Tensor output;\n",
    "    poplar::Tensor logSumExp;\n",
    "};\n",
    "\n",
    "AttentionOutputWithStash flashAttentionQKVPackedWithStash(\n",
    "    poplar::Graph& graph, // full program graph\n",
    "    const poplar::Tensor& qkv,  // packed query, key, value input tensor with shape 3 x (batch_size * num_heads) x seq_len x emb_dim\n",
    "    uint32_t num_chunks_q, // number of query blocks to iterate over\n",
    "    uint32_t num_chunks_kv, // number of key/value blocks to iterate over\n",
    "    poplar::program::Sequence& prog, // subprogram being added to\n",
    "    const poplar::DebugContext& dc) /* object that stores names of operations used when profiling and debugging */ { \n",
    "\n",
    "    /*\n",
    "    Poplar implementation of FlashAttention, using the scheme described in https://arxiv.org/abs/2307.08691 with fewer non-matmul FLOPs\n",
    "    */\n",
    "\n",
    "    // get shape data\n",
    "    auto groups = qkv.dim(1); // groups = batch_size * num_heads\n",
    "    auto seqLen = qkv.dim(2);\n",
    "    auto headDim = qkv.dim(3);\n",
    "    \n",
    "    // Check you have valid inputs\n",
    "    assert(qkv.dim(0) == 3);\n",
    "    assert(seqLen % num_chunks_q == 0);\n",
    "    assert(seqLen % num_chunks_kv == 0);\n",
    "\n",
    "    // compute sizes of chunked sequence length\n",
    "    auto chunkedQueryLen = seqLen / num_chunks_q; \n",
    "    auto chunkedKVLen = seqLen / num_chunks_kv; \n",
    "\n",
    "    /* \n",
    "    Unpack q,k,v and copy data to sliceable tensors with nice tile mappings\n",
    "\n",
    "    A key step to optimising tensor programs to run on IPUs is making sure that tensors have\n",
    "    tile mappings that evenly distribute work across tiles and minimise the amount of data that needs\n",
    "    to be exchanged across tiles to complete an operation.\n",
    "\n",
    "    An example of this would be with an element-wise addition between two tensors A + B.\n",
    "\n",
    "    If tensor A is split across tiles 1 and 2, and tensor B is split across tiles 3 and 4, to complete\n",
    "    the add operation you would need all elements being added together to reside on the same set of tiles.\n",
    "    You could do this by moving tensor B to tiles 1 and 2 for example.\n",
    "\n",
    "    PopLibs contains a number of utilities for creating tensors with good tile mappings for the workload\n",
    "    you want to complete.\n",
    "\n",
    "    The relevant utility here is `popops::createSliceableTensor` that creates a tensor with a tile mapping\n",
    "    that will can be efficiently sliced in the dimensions we choose.\n",
    "    */\n",
    "\n",
    "    auto query = popops::createSliceableTensor(\n",
    "        graph, // poplar::Graph object we are constructing \n",
    "        qkv.elementType() // datatype,\n",
    "        {num_chunks_q, groups, chunkedQueryLen, headDim} // shape, \n",
    "        {0} /*slice dimension */, {1} /* slice size */, 4 /* minimum elements per tile*/, \n",
    "        {dc, \"create_query\"} // name this operation (useful when debugging)\n",
    "    );\n",
    "    auto key = popops::createSliceableTensor(graph, qkv.elementType(), {num_chunks_kv, groups, chunkedKVLen, headDim}, {0}, {1}, 4, {dc, \"create_key\"});\n",
    "    auto value = popops::createSliceableTensor(graph, qkv.elementType(), {num_chunks_kv, groups, chunkedKVLen, headDim}, {0}, {1}, 4, {dc, \"create_value\"});\n",
    "\n",
    "    // We need to copy the data from our packed qkv tensor into the sliceable tensor \n",
    "    prog.add(Copy(qkv[0].reshape({groups, num_chunks_q, chunkedQueryLen, headDim}).dimShuffle({1, 0, 2, 3}), query));\n",
    "    prog.add(Copy(qkv[1].reshape({groups, num_chunks_kv, chunkedKVLen, headDim}).dimShuffle({1, 0, 2, 3}), key));\n",
    "    prog.add(Copy(qkv[2].reshape({groups, num_chunks_kv, chunkedKVLen, headDim}).dimShuffle({1, 0, 2, 3}), value));\n",
    "\n",
    "    /* \n",
    "    Create output tensor\n",
    "\n",
    "    Here we use graph.clone() to generate a tensor with the same tile mapping as another. \n",
    "    Since we know that transformers go through many layers, we might suspect that the output\n",
    "    tensor should have a similar tile mapping to the input tensor.\n",
    "\n",
    "    Once we've cloned the tensor, we'll need to zero out the data\n",
    "    */\n",
    "\n",
    "    auto out = graph.clone(query, {dc, \"create_output\"});\n",
    "    popops::zero(graph, out, prog, {dc, \"zero_output\"});\n",
    "\n",
    "    // create tensors to store running logsumexp\n",
    "    auto logSumExp = popops::createSliceableTensor(graph, query.elementType(), {num_chunks_q, groups, chunkedQueryLen}, {0}, {1}, 4, \"create_logsumexp_store\");\n",
    "    popops::zero(graph, logSumExp, prog, {dc, \"zero_logsumexp\"});\n",
    "\n",
    "\n",
    "    /*\n",
    "    We'll need a couple of counter variables for our two loops, so we'll create them here.\n",
    "    */\n",
    "\n",
    "    // outer loop counter on q read\n",
    "    auto qCounter = graph.addVariable(poplar::UNSIGNED_INT, {1}, {dc, \"init_qCounter(i=0)\"});\n",
    "    // inner loop counter on kv read\n",
    "    auto kvCounter = graph.addVariable(poplar::UNSIGNED_INT, {1}, {dc, \"init_kvCounter(j=0)\"});\n",
    "    \n",
    "    // gimme tiles\n",
    "    poputil::mapTensorLinearly(graph, qCounter);\n",
    "    poputil::mapTensorLinearly(graph, kvCounter);\n",
    "\n",
    "    popops::zero(graph, qCounter, prog, {dc, \"zero_qCounter\"});\n",
    "    popops::zero(graph, kvCounter, prog, {dc, \"zero_kvCounter\"});\n",
    "\n",
    "    /*\n",
    "    We've now finished initialising all of the data needed for the bulk of the\n",
    "    work in FlashAttention.\n",
    "\n",
    "    We're now going to setup the two loops of FlashAttention in which we doubly iterate over\n",
    "    chunks of the query tensor and key/value tensors to compute the output\n",
    "\n",
    "    To do this we're going to create two subprograms that will correspond to the body of each\n",
    "    loop.\n",
    "\n",
    "    The reason for this is that it will create a very small code footprint on the IPU. If we\n",
    "    were to write a native c++ for loop here, this would require a huge amount of code to be\n",
    "    compiled to run on the IPU, especially for very long sequences chunked up into small pieces.\n",
    "    This would quickly use up all of the precious memory on the IPU.\n",
    "\n",
    "    Instead, we're going to create a body program that will be compiled once and reused over and\n",
    "    over again by a special Repeat operation (seen way down below).\n",
    "\n",
    "    This is one example of how to write programs with control flow on the IPU. We'll see another\n",
    "    example further down.\n",
    "\n",
    "    Note: from here on we'll try to write some numpy-ish equivalent code in the debug string\n",
    "    (e.g., {dc, \"x+=y\"}) to help you understand what the intended effect is\n",
    "    */\n",
    "\n",
    "    // Q loop body program\n",
    "    Sequence qLoopProg; {\n",
    "        /*\n",
    "        Slice q and output tensor\n",
    "        \n",
    "        Slices are dynamic because within the context of this body program we don't know what\n",
    "        the state of qCounter will be. \n",
    "        \n",
    "        As a result, the access pattern will be different for \n",
    "        each call to this loop body program.\n",
    "        */\n",
    "        auto qi = popops::dynamicSlice(graph, query, qCounter, {0}, {1}, qLoopProg, {dc, \"q_i = q.at[i].get()\"}).squeeze({0}); \n",
    "        auto oi = popops::dynamicSlice(graph, out, qCounter, {0}, {1}, qLoopProg, {dc, \"o_i = o.at[i].get()\"}).squeeze({0});\n",
    "\n",
    "        // slice running logSumExp\n",
    "        auto li = popops::dynamicSlice(graph, logSumExp, qCounter, {0}, {1}, qLoopProg, {dc, \"l_i = l.at[i].get()\"}).squeeze({0});\n",
    "        // clone li for colocating running max on same tiles\n",
    "        auto mi = graph.clone(li, {dc, \"m_i = array_like(l_i)\"});\n",
    "        popops::fill(graph, mi, qLoopProg, -10000, {dc, \"fill(m_i, -10000)\"});\n",
    "\n",
    "        // KV loop body program\n",
    "        Sequence kvLoopProg; {\n",
    "            /*\n",
    "            We're now in the inner loop! The first thing we're actually going to do is decide\n",
    "            whether we're going to do any work in this block at all.\n",
    "\n",
    "            A nice property of causally masked attention is that you can skip up to half of\n",
    "            the blocks as we know the attention matrix will be zero for these elements no matter\n",
    "            the inputs.\n",
    "\n",
    "            Here we compute a condition tensor for determining whether we'll execute this block or not\n",
    "            then create the body of the program to execute if when it evaluates to true at runtime.\n",
    "\n",
    "            This is the another example of how to write control flow code in IPU programs, this time\n",
    "            using conditional statements.\n",
    "\n",
    "            We're going to create a number of subprograms in this block so we need to be careful which\n",
    "            we're adding ops to at any particular moment.\n",
    "            */\n",
    "\n",
    "            // Condition for executing (true) or skipping (false) block\n",
    "            auto doBlock = popops::map(graph, ((pe::_1 + 1) * uint(chunkedQueryLen)) > (pe::_2 * uint(chunkedKVLen)), {qCounter, kvCounter}, kvLoopProg, {dc, \"(i+1) * q_chunk_size > j * kv_chunk_size\"})[0];\n",
    "            \n",
    "            // Conditional execute block program body\n",
    "            Sequence doBlockProg;\n",
    "\n",
    "            // slice k and v\n",
    "            auto kj = popops::dynamicSlice(graph, key, kvCounter, {0}, {1}, doBlockProg, {dc, \"k_j = k.at[j].get()\"}).squeeze({0});\n",
    "            auto vj = popops::dynamicSlice(graph, value, kvCounter, {0}, {1}, doBlockProg, {dc, \"v_j = v.at[j].get()\"}).squeeze({0});\n",
    "\n",
    "            // compute QK^t \n",
    "            auto t = poplin::matMulGrouped(graph, qi, kj.dimShuffle({0, 2, 1}), doBlockProg, kj.elementType(), {dc, \"attn_ij = q_i @ k_j.T\"});\n",
    "            \n",
    "            /*\n",
    "            Condition for making masks\n",
    "\n",
    "            We make mask blocks during the first iteration of the loop rather than ahead of the loops because\n",
    "            we want mask blocks to have the same tile mapping as the attention block. For this we need to have\n",
    "            already created an attention block.\n",
    "\n",
    "            We use a popops::map operation here as these are useful for automatically generating efficient tile code\n",
    "            for a composition of small element-wise expressions.\n",
    "            */\n",
    "\n",
    "            auto doMakeMasks = popops::map(\n",
    "                graph, // poplar::Graph object\n",
    "                (pe::_1 == 0) && (pe::_2 == 0), // expression\n",
    "                {qCounter, kvCounter}, // expression inputs\n",
    "                doBlockProg, // program\n",
    "                {dc, \"i==0 and j==0\"} // string description\n",
    "            )[0]; // [0] to make this a scalar\n",
    "            \n",
    "            // generate causal masks\n",
    "            // clone attention matrix block to colocate mask block elements with attn matrix block elements\n",
    "            Sequence doMakeMasksProg;\n",
    "            auto masks = makeDynamicCausalMaskBlocks(graph, t, doMakeMasksProg, {dc, \"make_masks\"});\n",
    "\n",
    "            Sequence skipMakeMasksProg;\n",
    "            /* \n",
    "            Here we add our first block of control flow to a bit of control flow to our program, using the \n",
    "            `poplar::program::If` function\n",
    "            */\n",
    "            doBlockProg.add(If(doMakeMasks, doMakeMasksProg, skipMakeMasksProg, {dc, \"initialise_masks\"}));\n",
    "\n",
    "            /*\n",
    "            Condition for adding mask to q@k.T\n",
    "\n",
    "            We need to determine whether we are on the block diagonal (in which case we need to create\n",
    "            and add the causal mask to the block), or if we are in the block lower triangle (in which case\n",
    "            we don't).\n",
    "            */\n",
    "            auto doMask = popops::map(graph, (pe::_1 * uint(chunkedQueryLen) < ((pe::_2 + 1) * uint(chunkedKVLen) - 1)), {qCounter, kvCounter}, doBlockProg, {dc, \"i * q_chunk_size < (j+1) * kv_chunk_size - 1\"})[0];\n",
    "            \n",
    "            // Conditional add mask program body\n",
    "            Sequence doMaskProg;\n",
    "            dynamicAddMask(graph, t, masks.tensor, masks.counter, doMaskProg, {dc, \"add_mask\"}); \n",
    "\n",
    "            // Empty skip mask program\n",
    "            Sequence skipMaskProg;\n",
    "\n",
    "            // Add conditional mask program to execute block program \n",
    "            doBlockProg.add(If(doMask, doMaskProg, skipMaskProg, {dc, \"q@k.T + mask if i==j else q@k.T\"}));\n",
    "\n",
    "\n",
    "            /*\n",
    "            We've made it through all of the IPU specific control flow of this block! \n",
    "            The rest of this block is should hopefully be quite readable and understandable\n",
    "            if you are familiar with the maths of attention.\n",
    "            \n",
    "            We'll compute the online softmax algorithm that requires a max and sum across\n",
    "            the block, followed by a matrix multiplication that updates the output block.\n",
    "            */\n",
    "\n",
    "            // compute qk^T max for stable softmax\n",
    "            auto newMaxs = popops::reduce(\n",
    "                graph, // poplar::Graph\n",
    "                t /* tensor being reduced*/, t.elementType() /* data type */, {2} /* reduction dimension*/, \n",
    "                {popops::Operation::MAX}, // reduction operation (max)\n",
    "                doBlockProg, // program\n",
    "                {dc, \"m_tmp = sum(attn_ij, dim=2)\"} // debug string\n",
    "            );\n",
    "            newMaxs = popops::max(graph, mi, newMaxs, doBlockProg, {dc, \"m_new = max(m_i, m_tmp)\"});\n",
    "            auto c = popops::map(graph, pe::Exp(pe::_1 - pe::_2), {mi, newMaxs}, doBlockProg, {dc, \"c = exp(m_i - m_new)\"});\n",
    "            doBlockProg.add(Copy(newMaxs, mi));\n",
    "            \n",
    "            // subtract max from qk^T\n",
    "            popops::subInPlace(graph, t, newMaxs.expand({2}), doBlockProg, {dc, \"attn_ij -= m_tmp\"});\n",
    "            // compute softmax numerator: exp(qk^T - max)\n",
    "            popops::expInPlace(graph, t, doBlockProg, {dc, \"attn_ij = exp(attn_ij)\"});\n",
    "            \n",
    "            // compute sum exps\n",
    "            auto s = popops::reduce(graph, t, t.elementType(), {2}, {popops::Operation::ADD}, doBlockProg, {dc, \"s = sum(attn_ij, dim=2)\"});\n",
    "\n",
    "            // compute running max update\n",
    "            auto newSums = popops::map(graph, pe::_1 * pe::_2 + pe::_3, {li, c, s}, doBlockProg, {dc, \"l_new = l_i * c + s\"});\n",
    "            doBlockProg.add(Copy(newSums, li));\n",
    "            \n",
    "            // compute output(o_i = (c*o_i + attn_ij @ v_j))\n",
    "            popops::mulInPlace(graph, oi, c.expand({2}), doBlockProg, {dc, \"o_i *= c\"});\n",
    "            poplin::matMulGroupedAcc(graph, oi, 1.0, t, vj, doBlockProg, {dc, \"o_i += attn_ij @ v_j\"});\n",
    "            \n",
    "            // Empty skip block program\n",
    "            Sequence skipBlockProg;\n",
    "            // Add block program to inner loop program\n",
    "            kvLoopProg.add(If(doBlock, doBlockProg, skipBlockProg));\n",
    "\n",
    "            // update kv loop counter\n",
    "            popops::mapInPlace(graph, pe::_1 + 1, {kvCounter}, kvLoopProg, {dc, \"j+=1\"});\n",
    "        }\n",
    "        /* \n",
    "        Repeat kv loop body within q loop body\n",
    "\n",
    "        Uses a poplar::program::Repeat op to a loop body that gets reused by the calling program\n",
    "        */\n",
    "        qLoopProg.add(Repeat(key.dim(0), kvLoopProg, {dc, \"serialised_attention_inner_loop_repeat\"}));\n",
    "        \n",
    "        // apply denominator of softmax\n",
    "        popops::divInPlace(graph, oi, li.expand({2}), qLoopProg, {dc, \"o_i /= l_i\"});\n",
    "        // update running logsumexp\n",
    "        li = popops::map(graph, pe::_1 + pe::Log(pe::_2), {mi, li}, qLoopProg, {dc, \"l_i = m_i + log(l_i)\"});\n",
    "        \n",
    "        // update output and running logsumexp slices\n",
    "        popops::dynamicUpdate(graph, out, oi.expand({0}), qCounter, {0}, {1}, qLoopProg, {dc, \"o = o.at[i].set(o_i)\"});\n",
    "        popops::dynamicUpdate(graph, logSumExp, li.expand({0}), qCounter, {0}, {1}, qLoopProg, {dc, \"update logSumExp\"});\n",
    "\n",
    "        // update q loop counter\n",
    "        popops::mapInPlace(graph, pe::_1 + 1, {qCounter}, qLoopProg, {dc, \"i+=1\"});\n",
    "        // reset kv loop counter\n",
    "        popops::zero(graph, kvCounter, qLoopProg, {dc, \"j=0\"});\n",
    "    }\n",
    "    // Repeat q loop body in main body\n",
    "    prog.add(Repeat(query.dim(0), qLoopProg, {dc, \"serialised_attention_outer_loop_repeat\"}));\n",
    "    \n",
    "    // Rearrange dims to remove chunking\n",
    "    out = out.dimShuffle({1, 0, 2, 3}).reshape({groups, seqLen, headDim});\n",
    "\n",
    "    return {out, logSumExp};\n",
    "}\n",
    "```\n",
    "\n",
    "And that's it! A fair bit more verbose than PyTorch or jax, but worthwhile to get the IPU performance benefits (at least until the ML community has figured out how to write a good cross-platform python jit compiler!).\n",
    "\n",
    "### Next Next steps\n",
    "\n",
    "There's quite a bit more you could do to optimise this for IPU, especially for shorter sequence lengths.\n",
    "\n",
    "1. Write a custom tile mapping to optimise the layout of Q, K, V tensors for attention and minimise exchange.\n",
    "2. Write a custom vertex to fuse the non-matmul operations.\n",
    "3. Write a compiler utility to help choose `num_chunks_q` and `num_chunks_kv` based on the available memory.\\\n",
    "4. Fuse the whole transformer layer! See [Blockwise Parallel Transformer](https://arxiv.org/abs/2305.19370)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv_poptorch_3.3.0",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}