From bf1d8687f450307cccc66fc99cf9db4890518757 Mon Sep 17 00:00:00 2001
From: Daniel Kleine <53251018+d-kleine@users.noreply.github.com>
Date: Wed, 14 Aug 2024 03:57:41 +0200
Subject: [PATCH] added std error bars (#320)

* added std error bars

* fixed changes

* Update on A100

---------

Co-authored-by: Sebastian Raschka <mail@sebastianraschka.com>
---
 .../mha-implementations.ipynb                 | 1642 +++--------------
 1 file changed, 260 insertions(+), 1382 deletions(-)

diff --git a/ch03/02_bonus_efficient-multihead-attention/mha-implementations.ipynb b/ch03/02_bonus_efficient-multihead-attention/mha-implementations.ipynb
index 5cd4e72..c89a89d 100644
--- a/ch03/02_bonus_efficient-multihead-attention/mha-implementations.ipynb
+++ b/ch03/02_bonus_efficient-multihead-attention/mha-implementations.ipynb
@@ -44,21 +44,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "7898551e-f582-48ac-9f66-3632abe2a93f",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "7898551e-f582-48ac-9f66-3632abe2a93f",
-    "outputId": "1d132538-9d44-4393-c2de-6947fee4c793"
+    "outputId": "3aa27e4f-402c-4adc-f2d1-271bc6e0385d"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "PyTorch version: 2.4.0\n"
+      "PyTorch version: 2.5.0.dev20240813\n"
      ]
     }
    ],
@@ -90,14 +90,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "297c93ed-aec0-4896-bb89-42c4b294d3d1",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "297c93ed-aec0-4896-bb89-42c4b294d3d1",
-    "outputId": "b63ea806-ef0d-4673-c36a-c22f0381e7ad"
+    "outputId": "e76a6a62-7a52-4c6b-aa36-e90cea0cd415"
    },
    "outputs": [
     {
@@ -139,14 +139,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "id": "4ee6a61b-d25c-4a0c-8a59-f285544e3710",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "4ee6a61b-d25c-4a0c-8a59-f285544e3710",
-    "outputId": "79618eba-bc6f-4247-8d30-14381323a129"
+    "outputId": "650c8992-a6c6-4f28-938a-ee9297131d38"
    },
    "outputs": [
     {
@@ -193,8 +193,8 @@
     "id": "1fa1a5ea-eaff-4d2d-aaf0-b34cdb6fd4dd"
    },
    "source": [
-    "- The code for the `MultiHeadAttentionAlt` class below is based on code that was kindly shared by [Rayed Bin Wahed](https://github.com/rasbt/LLMs-from-scratch/discussions/51)\n",
-    "- The main difference between the `MultiHeadAttentionAlt` class and the `MultiHeadAttention` class used in chapter 3 is that `MultiHeadAttentionAlt` uses a single weight matrix, `self.qkv = nn.Linear(d_in, 3 * d_out, bias=qkv_bias)` instead of separate weight matrices:\n",
+    "- The code for the `MultiHeadAttentionCombinedQKV` class below is based on code that was kindly shared by [Rayed Bin Wahed](https://github.com/rasbt/LLMs-from-scratch/discussions/51)\n",
+    "- The main difference between the `MultiHeadAttentionCombinedQKV` class and the `MultiHeadAttention` class used in chapter 3 is that `MultiHeadAttentionCombinedQKV` uses a single weight matrix, `self.qkv = nn.Linear(d_in, 3 * d_out, bias=qkv_bias)` instead of separate weight matrices:\n",
     "\n",
     "  - `self.W_query = nn.Linear(d_in, d_out, bias=qkv_bias)`\n",
     "  - `self.W_key = nn.Linear(d_in, d_out, bias=qkv_bias)`\n",
@@ -206,14 +206,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "id": "9a6bd0a2-f27c-4602-afa0-c96cd295c1a6",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "9a6bd0a2-f27c-4602-afa0-c96cd295c1a6",
-    "outputId": "011ba527-4dcb-4909-ffa2-383b92b81c9f"
+    "outputId": "f0bae195-7caf-4aee-efd6-d55a56c1d4d3"
    },
    "outputs": [
     {
@@ -322,7 +322,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "id": "1b8e5a0d-1f65-4a03-bf6e-723f0cc428f5",
    "metadata": {
     "id": "1b8e5a0d-1f65-4a03-bf6e-723f0cc428f5"
@@ -374,14 +374,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "id": "fbc8ba92-3471-41cb-b1b2-4c0ef5be392b",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "fbc8ba92-3471-41cb-b1b2-4c0ef5be392b",
-    "outputId": "fcd0508d-f474-4f81-89e5-7e1dbd6305f4"
+    "outputId": "da8b6836-35c6-43f5-a9e2-99217d517101"
    },
    "outputs": [
     {
@@ -423,7 +423,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "id": "bad53538-e905-4065-ba0c-caacdfec5a0b",
    "metadata": {
     "id": "bad53538-e905-4065-ba0c-caacdfec5a0b"
@@ -483,14 +483,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "id": "f3da7850-e772-47d3-bd51-22d077b01412",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "f3da7850-e772-47d3-bd51-22d077b01412",
-    "outputId": "841ee076-8f71-4223-85e0-9e74fc7ac2f4"
+    "outputId": "3c726fe1-6601-4a30-c2d2-e9fd48547c50"
    },
    "outputs": [
     {
@@ -540,14 +540,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "id": "3799c7ef-3155-42c6-a829-f95656453ae0",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "3799c7ef-3155-42c6-a829-f95656453ae0",
-    "outputId": "2f001121-6357-4ee2-9ba5-8ec1e687ea23"
+    "outputId": "dcb11757-c8c2-4909-c0e5-5ba2cf7b1096"
    },
    "outputs": [
     {
@@ -643,14 +643,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "id": "4a4c2afe-5e1f-4bd7-a118-67031176f147",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "4a4c2afe-5e1f-4bd7-a118-67031176f147",
-    "outputId": "311c1e2b-f437-4c4d-cbdc-1ecb0db3b78c"
+    "outputId": "60a22fd6-fda4-478a-98d9-331623814018"
    },
    "outputs": [
     {
@@ -691,21 +691,20 @@
     "- See [FlexAttention: The Flexibility of PyTorch with the Performance of FlashAttention](https://pytorch.org/blog/flexattention/) to learn more about FlexAttention\n",
     "- This is currently only supported in PyTorch 2.5 (nightly), which you can install on a CPU machine via\n",
     "\n",
-    "```python\n",
-    "pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cpu -U\n",
-    "```\n",
+    "    ```bash\n",
+    "    pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cpu -U\n",
+    "    ```\n",
     "\n",
     "- To install PyTorch nighly on a GPU machine, use the following (for more information, also see the installation menu on [pytorch.org](https://pytorch.org/))\n",
     "\n",
-    "```python\n",
-    "pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu121 -U\n",
-    "```\n",
-    "\n"
+    "    ```bash\n",
+    "    pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu121 -U\n",
+    "    ```"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "id": "834318c8-4748-4902-99f0-70ee02bef63e",
    "metadata": {
     "id": "834318c8-4748-4902-99f0-70ee02bef63e"
@@ -725,7 +724,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 14,
    "id": "WYyFRCXndVH9",
    "metadata": {
     "id": "WYyFRCXndVH9"
@@ -733,8 +732,7 @@
    "outputs": [],
    "source": [
     "if current_version >= required_version:\n",
-    "    from torch.nn.attention.flex_attention import flex_attention\n",
-    "    from torch.nn.attention.flex_attention import create_block_mask\n",
+    "    from torch.nn.attention.flex_attention import flex_attention, create_block_mask\n",
     "\n",
     "\n",
     "def causal(b, h, q_idx, kv_idx):\n",
@@ -757,7 +755,7 @@
     "        self.proj = nn.Linear(d_out, d_out)\n",
     "        self.dropout = dropout\n",
     "        # self.register_buffer(\"block_mask\", create_block_mask(causal, B=None, H=None, Q_LEN=context_length, KV_LEN=context_length))\n",
-    "        # `create_block_mask` function doesn not support buffers, yet\n",
+    "        # `create_block_mask` function does not support buffers, yet\n",
     "        self.block_mask = create_block_mask(causal, B=None, H=None, Q_LEN=context_length, KV_LEN=context_length)\n",
     "\n",
     "\n",
@@ -797,18 +795,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 15,
    "id": "9cdaaf8a-f956-44bc-932f-4d33448e8aaf",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "9cdaaf8a-f956-44bc-932f-4d33448e8aaf",
-    "outputId": "0888271f-d6ae-4905-fabb-805b70f9e712"
+    "outputId": "0d13771e-46df-4200-e20d-422fcb8144b3"
    },
    "outputs": [],
    "source": [
-    "if current_version >= required_version:\n",
+    "if current_version >= required_version and torch.cuda.is_available():\n",
     "\n",
     "    mha_pytorch_flex = MHAPyTorchFlexAttention(\n",
     "        d_in=embed_dim,\n",
@@ -838,21 +836,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 16,
    "id": "219cf93a-078f-434d-888c-2458d0731285",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "219cf93a-078f-434d-888c-2458d0731285",
-    "outputId": "2bb41cd4-a152-4754-f361-94f9e17cf498"
+    "outputId": "a10b52d4-b4e6-43c2-9677-113c41edd3b7"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "PyTorch version: 2.4.0\n",
+      "PyTorch version: 2.5.0.dev20240813\n",
       "Running on cpu\n"
      ]
     }
@@ -866,21 +864,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 17,
    "id": "a97c0b2e-6593-49d8-98bc-2267b3aa610f",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "a97c0b2e-6593-49d8-98bc-2267b3aa610f",
-    "outputId": "67389a57-945b-42c9-e1a1-1e2a8b8cb710"
+    "outputId": "7bcd7da4-d115-4ba6-efba-377a0bd7d3a8"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "196 ms ± 3.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
+      "183 ms ± 6.95 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
      ]
     }
    ],
@@ -891,21 +889,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 18,
    "id": "19db9c2c-8e75-431a-8eef-0b4d8284e6e6",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "19db9c2c-8e75-431a-8eef-0b4d8284e6e6",
-    "outputId": "930a14ee-36df-4a41-c162-374f9e1ea600"
+    "outputId": "b04b4d0d-71aa-4944-f02b-131bf5a50202"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "204 ms ± 14.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
+      "179 ms ± 1.22 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
      ]
     }
    ],
@@ -916,21 +914,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 19,
    "id": "aa526ee0-7a88-4f34-a49a-f8f97da83779",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "aa526ee0-7a88-4f34-a49a-f8f97da83779",
-    "outputId": "801cf4e1-4f2a-44d8-e5d7-89fe0c62cee9"
+    "outputId": "5436928a-7b98-4c40-bf51-97973f13327e"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "214 ms ± 8.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
+      "197 ms ± 1.78 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
      ]
     }
    ],
@@ -941,21 +939,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 20,
    "id": "cc2b4256-16d8-4c34-9fd0-d4b4af0e60fa",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "cc2b4256-16d8-4c34-9fd0-d4b4af0e60fa",
-    "outputId": "b9b43252-8942-46f4-84de-4b2889e3fb7e"
+    "outputId": "9e07ce73-a2de-4e2c-8276-64626df9450e"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "81 ms ± 15.9 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
+      "65.4 ms ± 315 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
      ]
     }
    ],
@@ -966,21 +964,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 21,
    "id": "c44305ce-9f61-451a-b9ef-30caba222357",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "c44305ce-9f61-451a-b9ef-30caba222357",
-    "outputId": "a044e5f2-212e-45d5-ea40-4f4611077794"
+    "outputId": "6bab4a24-5bb4-4ad6-b260-3b442f598950"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "83.7 ms ± 2.32 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
+      "112 ms ± 20.2 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
      ]
     }
    ],
@@ -991,21 +989,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 22,
    "id": "0f209e70-ebb6-4a1a-b608-1ff42e41c01d",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "0f209e70-ebb6-4a1a-b608-1ff42e41c01d",
-    "outputId": "c3f002da-b9b6-42d1-a24b-45789369c9a9"
+    "outputId": "630c49d1-8a06-4148-cd96-a7b2467310a0"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "251 ms ± 23.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
+      "199 ms ± 3.87 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
      ]
     }
    ],
@@ -1016,21 +1014,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 23,
    "id": "3f4968c2-8d40-4ab9-8dba-052b4f77d756",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "3f4968c2-8d40-4ab9-8dba-052b4f77d756",
-    "outputId": "7d85c861-6e77-4d8b-8cb3-b05d8ddd243d"
+    "outputId": "10f6a268-f9cf-446c-aa83-e87b6a0b4f5c"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "131 ms ± 20.1 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
+      "143 ms ± 19.7 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
      ]
     }
    ],
@@ -1042,13 +1040,13 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "5d7ee70d-7bdd-48ad-ad7f-af3bf2439609",
+   "id": "c143200a-6e26-4185-af52-6cf2379d72ae",
    "metadata": {},
    "outputs": [],
    "source": [
     "## 8) Using PyTorch's FlexAttention\n",
     "\n",
-    "# Requires PyTorch 2.5.0 or newer\n",
+    "# Requires PyTorch 2.5.0 or newer and currently only supports CUDA PyTorch\n",
     "%timeit mha_pytorch_flex(embeddings)"
    ]
   },
@@ -1067,7 +1065,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 24,
    "id": "RStnI1pEi6Eo",
    "metadata": {
     "id": "RStnI1pEi6Eo"
@@ -1080,21 +1078,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 25,
    "id": "e8431d75-e1c9-4d9a-b7da-9a1ff391f2bf",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "e8431d75-e1c9-4d9a-b7da-9a1ff391f2bf",
-    "outputId": "5176759d-9599-4c8b-90bd-58cf8890ccde"
+    "outputId": "308f8f74-1757-4534-9050-78676bb948a5"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "PyTorch version: 2.5.0.dev20240810+cu121\n",
+      "PyTorch version: 2.5.0.dev20240813+cu121\n",
       "Running on cuda\n"
      ]
     }
@@ -1108,21 +1106,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "id": "707a2a14-a089-48a8-88aa-d328e1e0a9d0",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "707a2a14-a089-48a8-88aa-d328e1e0a9d0",
-    "outputId": "d0fe060f-058a-43ec-8d23-de23a94ed4cb"
+    "outputId": "38942aa6-8bd7-4dd9-e528-b833231999d0"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "4.35 ms ± 30.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+      "4.28 ms ± 26.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
      ]
     }
    ],
@@ -1133,21 +1131,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 27,
    "id": "8686dd69-3655-40e4-a57b-a2c55532a010",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "8686dd69-3655-40e4-a57b-a2c55532a010",
-    "outputId": "b404c9e6-e0e0-4cb4-921f-fd612beb8668"
+    "outputId": "0f8adeba-2119-4361-a439-e48b1e870857"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "3.09 ms ± 136 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      "3.09 ms ± 108 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
      ]
     }
    ],
@@ -1158,21 +1156,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 28,
    "id": "2209d7df-e54b-4910-ae2b-c78cf684d9bf",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "2209d7df-e54b-4910-ae2b-c78cf684d9bf",
-    "outputId": "ef47787d-65bb-4407-d718-77dadb6f53d2"
+    "outputId": "3ce8ddef-df53-4ead-8654-d46f4f343844"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "3.81 ms ± 189 ns per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+      "3.81 ms ± 4.91 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
      ]
     }
    ],
@@ -1183,21 +1181,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 29,
    "id": "1075abe2-4839-4fd6-af3e-c09bb3651e26",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "1075abe2-4839-4fd6-af3e-c09bb3651e26",
-    "outputId": "58c8f320-79e2-400f-978c-1983fb810cf3"
+    "outputId": "e4c72e71-1275-4ce5-9973-2dfde98fc626"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "1.21 ms ± 875 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
+      "1.24 ms ± 1.14 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
      ]
     }
    ],
@@ -1208,21 +1206,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 30,
    "id": "218adbaf-f17f-47d9-81d5-41c758218df7",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "218adbaf-f17f-47d9-81d5-41c758218df7",
-    "outputId": "4e66760e-516a-43a5-a148-0afef96d23ca"
+    "outputId": "9251f2a9-aaa9-4403-87bd-b24b0a6e8be4"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "1.96 ms ± 117 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+      "2.01 ms ± 120 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
      ]
     }
    ],
@@ -1233,21 +1231,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 31,
    "id": "868e3670-8edc-47bc-9e06-eb505e44dc9d",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "868e3670-8edc-47bc-9e06-eb505e44dc9d",
-    "outputId": "c17ddc03-0aab-4ef5-d3e3-a3695ec30b62"
+    "outputId": "d951ed94-1fef-4d63-935e-19ee8e007f71"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "3.05 ms ± 225 ns per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+      "3.06 ms ± 228 ns per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
      ]
     }
    ],
@@ -1258,21 +1256,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 32,
    "id": "944870e6-de54-4e3b-a455-b8f21f6f92c8",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "944870e6-de54-4e3b-a455-b8f21f6f92c8",
-    "outputId": "e2781053-e7f4-4d87-99a1-08ca20f92951"
+    "outputId": "8c69a388-ec32-49d4-a59e-cac4af1aa37a"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2.29 ms ± 5.66 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+      "2.34 ms ± 6.28 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
      ]
     }
    ],
@@ -1283,21 +1281,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 33,
    "id": "evKtpb5QN_2A",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "evKtpb5QN_2A",
-    "outputId": "a8af4a1c-e1c2-4a41-f454-cd395818a327"
+    "outputId": "38702248-46c0-4dc6-e584-96617f2a9650"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "12.2 ms ± 587 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
+      "8.38 ms ± 476 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
      ]
     }
    ],
@@ -1319,26 +1317,26 @@
     "&nbsp;\n",
     "\n",
     "\n",
-    "## Speed comparison (Nvidia A100 GPU) with warmup (forward pass only)"
+    "# Visualizations"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 34,
    "id": "bbb2f729-d3d8-46d0-b249-9249197ea574",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
     },
     "id": "bbb2f729-d3d8-46d0-b249-9249197ea574",
-    "outputId": "09bf4056-d219-4f90-f8f7-f31b62ffa671"
+    "outputId": "fcf22728-5570-4edf-9c9d-4bbf0e1e1413"
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "PyTorch version: 2.5.0.dev20240810+cu121\n",
+      "PyTorch version: 2.5.0.dev20240813+cu121\n",
       "Running on cuda\n"
      ]
     }
@@ -1352,7 +1350,87 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 35,
+   "id": "b0620bf5",
+   "metadata": {
+    "id": "b0620bf5"
+   },
+   "outputs": [],
+   "source": [
+    "functions = {\n",
+    "    \"1) MHA wrapper class\": mha_ch03_wrapper,\n",
+    "    \"2) MHA Ch03\": mha_ch03,\n",
+    "    \"3) MHA with combined QKV weights\": mha_combined_qkv,\n",
+    "    \"4) MHA with PyTorch scaled_dot_product_attention\": mha_pytorch_scaled,\n",
+    "    \"5) PyTorch's SDPA, no FlashAttention\": mha_pytorch_sdpa_no_flash,\n",
+    "    \"6) PyTorch MHA class defaults\": mha_pytorch_class_default,\n",
+    "    \"7) PyTorch MHA with need_weights=False\": mha_pytorch_class_noweights\n",
+    "    }\n",
+    "\n",
+    "if current_version >= required_version:\n",
+    "    functions[\"8) PyTorch's FlexAttention\"] =  mha_pytorch_flex"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "CDJAPZaszaqx",
+   "metadata": {
+    "id": "CDJAPZaszaqx"
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Customize further for dark mode aesthetics\n",
+    "plt.rcParams[\"figure.facecolor\"] = \"#121212\"\n",
+    "plt.rcParams[\"axes.facecolor\"] = \"#121212\"\n",
+    "plt.rcParams[\"axes.edgecolor\"] = \"white\"\n",
+    "plt.rcParams[\"axes.labelcolor\"] = \"white\"\n",
+    "plt.rcParams[\"text.color\"] = \"white\"\n",
+    "plt.rcParams[\"xtick.color\"] = \"white\"\n",
+    "plt.rcParams[\"ytick.color\"] = \"white\"\n",
+    "plt.rcParams[\"grid.color\"] = \"#444444\"\n",
+    "plt.rcParams[\"lines.linewidth\"] = 2\n",
+    "plt.rcParams[\"lines.markersize\"] = 8\n",
+    "\n",
+    "def plot_execution_times(functions, execution_means, execution_stds, filename):\n",
+    "\n",
+    "    # Create plot\n",
+    "    fig, ax = plt.subplots()\n",
+    "    bars = ax.bar(functions.keys(), execution_means, yerr=execution_stds, capsize=5, error_kw={'ecolor': 'grey'})\n",
+    "\n",
+    "    plt.ylabel(\"Execution time (ms)\")\n",
+    "    plt.xticks(rotation=45, ha=\"right\")\n",
+    "\n",
+    "    # Calculate new ylim with a margin\n",
+    "    max_execution_time = max(execution_means)\n",
+    "    upper_ylim = max_execution_time + 0.4 * max_execution_time  # Adding a 40% margin\n",
+    "    plt.ylim(0, upper_ylim)\n",
+    "\n",
+    "    # Annotate bars with execution times\n",
+    "    for bar in bars:\n",
+    "        yval = bar.get_height()\n",
+    "        plt.text(bar.get_x() + bar.get_width()/2, yval + (0.05 * upper_ylim), round(yval, 2), ha=\"center\", va=\"bottom\")\n",
+    "\n",
+    "    plt.tight_layout()\n",
+    "    plt.savefig(filename)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4df834dc",
+   "metadata": {
+    "id": "4df834dc"
+   },
+   "source": [
+    "## Speed comparison (Nvidia A100 GPU) with warmup (forward pass only)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
    "id": "29b63d3d-6d0b-43bb-9c68-d5514dc81000",
    "metadata": {
     "id": "29b63d3d-6d0b-43bb-9c68-d5514dc81000"
@@ -1363,8 +1441,9 @@
     "# and based on code from\n",
     "# https://github.com/cuda-mode/lectures/blob/main/lecture1/pytorch_square.py\n",
     "\n",
-    "def time_pytorch_function(func, *input, num_repeats = 1_000):\n",
-    "    # CUDA IS ASYNC so can't use python time module\n",
+    "import numpy as np\n",
+    "\n",
+    "def time_pytorch_function(func, *input, num_repeats=1_000):\n",
     "    start = torch.cuda.Event(enable_timing=True)\n",
     "    end = torch.cuda.Event(enable_timing=True)\n",
     "\n",
@@ -1373,31 +1452,33 @@
     "        func(*input)\n",
     "    torch.cuda.synchronize()\n",
     "\n",
-    "    start.record()\n",
+    "    times = []\n",
     "    for _ in range(num_repeats):\n",
+    "        start.record()\n",
     "        func(*input)\n",
+    "        end.record()\n",
     "        torch.cuda.synchronize()\n",
-    "    end.record()\n",
-    "    torch.cuda.synchronize()\n",
-    "    return start.elapsed_time(end) / num_repeats"
+    "        times.append(start.elapsed_time(end))\n",
+    "\n",
+    "    return np.mean(times), np.std(times)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "CDJAPZaszaqx",
+   "execution_count": 38,
+   "id": "9dd07a09",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/",
-     "height": 488
+     "height": 487
     },
-    "id": "CDJAPZaszaqx",
-    "outputId": "86fef2d2-856b-4ae1-beb9-cc04b4ed6aad"
+    "id": "9dd07a09",
+    "outputId": "b8db6c34-b593-45a6-9713-81107860d4c7"
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1407,64 +1488,12 @@
     }
    ],
    "source": [
-    "import matplotlib.pyplot as plt\n",
+    "execution_stats = [time_pytorch_function(fn, embeddings) for fn in functions.values()]\n",
+    "execution_means = [stat[0] for stat in execution_stats]\n",
+    "execution_stds = [stat[1] for stat in execution_stats]\n",
     "\n",
     "\n",
-    "embeddings_cuda = embeddings.to(torch.device(\"cuda\"))\n",
-    "\n",
-    "\n",
-    "functions = {\n",
-    "    \"1) MHA wrapper class\": mha_ch03_wrapper,\n",
-    "    \"2) MHA Ch03\": mha_ch03,\n",
-    "    \"3) MHA with combined QKV weights\": mha_combined_qkv,\n",
-    "    \"4) MHA with PyTorch scaled_dot_product_attention\": mha_pytorch_scaled,\n",
-    "    \"5) PyTorch's SDPA, no FlashAttention\": mha_pytorch_sdpa_no_flash,\n",
-    "    \"6) PyTorch MHA class defaults\": mha_pytorch_class_default,\n",
-    "    \"7) PyTorch MHA with need_weights=False\": mha_pytorch_class_noweights,\n",
-    "\n",
-    "}\n",
-    "\n",
-    "if current_version >= required_version:\n",
-    "    functions[\"8) PyTorch's FlexAttention\"] =  mha_pytorch_flex\n",
-    "\n",
-    "execution_times = [time_pytorch_function(fn, embeddings_cuda) for name,fn in functions.items()]\n",
-    "\n",
-    "\n",
-    "# Plotting\n",
-    "\n",
-    "# Customize further for dark mode aesthetics\n",
-    "plt.rcParams[\"figure.facecolor\"] = \"#121212\"  # Dark figure background\n",
-    "plt.rcParams[\"axes.facecolor\"] = \"#121212\"    # Dark axes background\n",
-    "plt.rcParams[\"axes.edgecolor\"] = \"white\"      # White axes border\n",
-    "plt.rcParams[\"axes.labelcolor\"] = \"white\"     # White labels\n",
-    "plt.rcParams[\"text.color\"] = \"white\"          # White text\n",
-    "plt.rcParams[\"xtick.color\"] = \"white\"         # White x ticks\n",
-    "plt.rcParams[\"ytick.color\"] = \"white\"         # White y ticks\n",
-    "plt.rcParams[\"grid.color\"] = \"#444444\"        # Lighter grid lines for contrast\n",
-    "plt.rcParams[\"lines.linewidth\"] = 2           # Thicker plot lines for visibility\n",
-    "plt.rcParams[\"lines.markersize\"] = 8          # Larger markers for visibility\n",
-    "\n",
-    "fig, ax = plt.subplots()\n",
-    "bars = plt.bar(functions.keys(), execution_times)\n",
-    "\n",
-    "plt.ylabel(\"Execution time (ms)\")\n",
-    "plt.xticks(rotation=45, ha=\"right\")\n",
-    "\n",
-    "# Calculate new ylim with a margin\n",
-    "max_execution_time = max(execution_times)\n",
-    "upper_ylim = max_execution_time + 0.2 * max_execution_time  # Adding a 20% margin\n",
-    "\n",
-    "plt.ylim(0, upper_ylim)  # Setting new ylim\n",
-    "\n",
-    "# Annotate bars with execution times\n",
-    "for bar in bars:\n",
-    "    yval = bar.get_height()\n",
-    "    plt.text(bar.get_x() + bar.get_width()/2, yval + (0.05 * upper_ylim), round(yval, 2), ha=\"center\", va=\"bottom\")\n",
-    "\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.savefig(\"1_forward-only.pdf\")\n",
-    "plt.show()"
+    "plot_execution_times(functions, execution_means, execution_stds, filename=\"1_forward-only.pdf\")"
    ]
   },
   {
@@ -1483,28 +1512,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "ReCmeRhCOpm8",
+   "execution_count": 39,
+   "id": "69e6377b",
    "metadata": {
-    "colab": {
-     "base_uri": "https://localhost:8080/",
-     "height": 488
-    },
-    "id": "ReCmeRhCOpm8",
-    "outputId": "79daea84-6ca3-41d2-91c9-ecabb1a035bb"
+    "id": "69e6377b"
    },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "def forward_backward(func, embeddings):\n",
     "    if embeddings.grad is not None:\n",
@@ -1525,42 +1538,48 @@
     "        forward_backward(func, *input)\n",
     "    torch.cuda.synchronize()\n",
     "\n",
-    "    start.record()\n",
+    "    times = []\n",
     "    for _ in range(num_repeats):\n",
+    "        start.record()\n",
     "        forward_backward(func, *input)\n",
+    "        end.record()\n",
     "        torch.cuda.synchronize()\n",
-    "    end.record()\n",
-    "    torch.cuda.synchronize()\n",
-    "    return start.elapsed_time(end) / num_repeats\n",
+    "        times.append(start.elapsed_time(end))\n",
+    "\n",
+    "    return np.mean(times), np.std(times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "ReCmeRhCOpm8",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 487
+    },
+    "id": "ReCmeRhCOpm8",
+    "outputId": "01159c54-afac-4a0d-a06f-b41cad1b30e6"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "execution_stats = [time_pytorch_function_forward_backward(fn, embeddings) for fn in functions.values()]\n",
+    "execution_means = [stat[0] for stat in execution_stats]\n",
+    "execution_stds = [stat[1] for stat in execution_stats]\n",
     "\n",
     "\n",
-    "execution_times = [time_pytorch_function_forward_backward(fn, embeddings_cuda) for name,fn in functions.items()]\n",
-    "\n",
-    "\n",
-    "# Plotting\n",
-    "\n",
-    "\n",
-    "fig, ax = plt.subplots()\n",
-    "bars = plt.bar(functions.keys(), execution_times)\n",
-    "\n",
-    "plt.ylabel(\"Execution time (ms)\")\n",
-    "plt.xticks(rotation=45, ha=\"right\")\n",
-    "\n",
-    "# Calculate new ylim with a margin\n",
-    "max_execution_time = max(execution_times)\n",
-    "upper_ylim = max_execution_time + 0.2 * max_execution_time  # Adding a 20% margin\n",
-    "\n",
-    "plt.ylim(0, upper_ylim)  # Setting new ylim\n",
-    "\n",
-    "# Annotate bars with execution times\n",
-    "for bar in bars:\n",
-    "    yval = bar.get_height()\n",
-    "    plt.text(bar.get_x() + bar.get_width()/2, yval + (0.05 * upper_ylim), round(yval, 2), ha=\"center\", va=\"bottom\")\n",
-    "\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.savefig(\"2_forward-and-backward.pdf\")\n",
-    "plt.show()"
+    "plot_execution_times(functions, execution_means, execution_stds, filename=\"2_forward-and-backward.pdf\")"
    ]
   },
   {
@@ -1579,1150 +1598,37 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 41,
    "id": "LQDiAPooiYAz",
+   "metadata": {
+    "id": "LQDiAPooiYAz"
+   },
+   "outputs": [],
+   "source": [
+    "import torch._dynamo\n",
+    "torch._dynamo.config.suppress_errors = True\n",
+    "\n",
+    "def prepare_function(fn):\n",
+    "    fn = torch.compile(fn)\n",
+    "    return fn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "aac06ffe",
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/",
-     "height": 1000
+     "height": 488
     },
-    "id": "LQDiAPooiYAz",
-    "outputId": "09d66064-0986-480e-ee39-c9a5faf7dcf5"
+    "id": "aac06ffe",
+    "outputId": "f64e3437-487b-45d2-d080-43c98464c47e"
    },
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] WON'T CONVERT forward <ipython-input-12-a390090d40bb> line 30 \n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] due to: \n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] Traceback (most recent call last):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/output_graph.py\", line 1438, in _call_user_compiler\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_fn = compiler_fn(gm, self.example_inputs())\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/repro/after_dynamo.py\", line 129, in __call__\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_gm = compiler_fn(gm, example_inputs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/__init__.py\", line 2236, in __call__\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return compile_fx(model_, inputs_, config_patches=self.config)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 1507, in compile_fx\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return aot_autograd(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/backends/common.py\", line 72, in __call__\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     cg = aot_module_simplified(gm, example_inputs, **self.kwargs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_functorch/aot_autograd.py\", line 1033, in aot_module_simplified\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_fn = dispatch_and_compile()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_functorch/aot_autograd.py\", line 1022, in dispatch_and_compile\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_fn, _ = create_aot_dispatcher_function(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_functorch/aot_autograd.py\", line 435, in create_aot_dispatcher_function\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return _create_aot_dispatcher_function(flat_fn, flat_args, aot_config)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_functorch/aot_autograd.py\", line 736, in _create_aot_dispatcher_function\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_fn, fw_metadata = compiler_fn(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_functorch/_aot_autograd/jit_compile_runtime_wrappers.py\", line 564, in aot_dispatch_autograd\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_fw_func = aot_config.fw_compiler(fw_module, adjusted_flat_args)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 1336, in fw_compiler_base\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return _fw_compiler_base(model, example_inputs, is_inference)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 1407, in _fw_compiler_base\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return inner_compile(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 468, in compile_fx_inner\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return wrap_compiler_debug(_compile_fx_inner, compiler_name=\"inductor\")(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/repro/after_aot.py\", line 85, in debug_wrapper\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     inner_compiled_fn = compiler_fn(gm, example_inputs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 653, in _compile_fx_inner\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_graph = FxGraphCache.load(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/codecache.py\", line 1319, in load\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_graph = compile_fx_fn(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 563, in codegen_and_compile\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_graph = fx_codegen_and_compile(gm, example_inputs, **fx_kwargs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 845, in fx_codegen_and_compile\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     graph.run(*example_inputs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/graph.py\", line 772, in run\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return super().run(*args)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/fx/interpreter.py\", line 147, in run\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     self.env[node] = self.run_node(node)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/graph.py\", line 1280, in run_node\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     result = super().run_node(n)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/fx/interpreter.py\", line 204, in run_node\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return getattr(self, n.op)(n.target, args, kwargs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/graph.py\", line 1037, in call_function\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     raise LoweringException(e, target, args, kwargs).with_traceback(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/graph.py\", line 1034, in call_function\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     out = lowerings[target](*args, **kwargs)  # type: ignore[index]\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/lowering.py\", line 323, in wrapped\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     out = decomp_fn(*args, **kwargs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/kernel/flex_attention.py\", line 627, in flex_attention\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     query.get_stride(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/ir.py\", line 6151, in __getattr__\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     fn = getattr(self.data, name)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] torch._inductor.exc.LoweringException: AttributeError: 'View' object has no attribute 'get_stride'\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   target: flex_attention\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[0]: TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     View(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           ExternKernelOut(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name='extern_kernels.mm',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             name=buf0,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             layout=FixedLayout('cuda', torch.float32, size=[8192, 2304], stride=[2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             inputs=[ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_1', layout=FixedLayout('cuda', torch.float32, size=[8, 1024, 768], stride=[786432, 768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[8192, 768], stride=[768, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ), ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_2', layout=FixedLayout('cuda', torch.float32, size=[2304, 768], stride=[768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[768, 2304], stride=[1, 768]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             )],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             constant_args=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwargs={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             output_view=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name=extern_kernels.mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             cpp_kernel_name=at::mm_out,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ordered_kwargs_for_cpp_kernel=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             op_overload=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             arg_properties=[{}, {}],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwarg_properties=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             unbacked_bindings={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             mutation_outputs=[],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origin_node=mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         FixedLayout('cuda', torch.float32, size=[1, 8, 12, 1024, 64], stride=[768, 2359296, 64, 2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         origins=OrderedSet([select])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       size=[8, 12, 1024, 64],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       reindex=lambda i0, i1, i2, i3: [0, i0, i1, i2, i3],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([select])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[1]: TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     View(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           ExternKernelOut(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name='extern_kernels.mm',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             name=buf0,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             layout=FixedLayout('cuda', torch.float32, size=[8192, 2304], stride=[2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             inputs=[ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_1', layout=FixedLayout('cuda', torch.float32, size=[8, 1024, 768], stride=[786432, 768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[8192, 768], stride=[768, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ), ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_2', layout=FixedLayout('cuda', torch.float32, size=[2304, 768], stride=[768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[768, 2304], stride=[1, 768]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             )],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             constant_args=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwargs={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             output_view=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name=extern_kernels.mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             cpp_kernel_name=at::mm_out,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ordered_kwargs_for_cpp_kernel=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             op_overload=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             arg_properties=[{}, {}],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwarg_properties=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             unbacked_bindings={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             mutation_outputs=[],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origin_node=mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         FixedLayout('cuda', torch.float32, size=[1, 8, 12, 1024, 64], stride=[768, 2359296, 64, 2304, 1], offset=768),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         origins=OrderedSet([select_1])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       size=[8, 12, 1024, 64],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       reindex=lambda i0, i1, i2, i3: [0, i0, i1, i2, i3],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([select_1])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[2]: TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     View(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           ExternKernelOut(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name='extern_kernels.mm',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             name=buf0,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             layout=FixedLayout('cuda', torch.float32, size=[8192, 2304], stride=[2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             inputs=[ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_1', layout=FixedLayout('cuda', torch.float32, size=[8, 1024, 768], stride=[786432, 768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[8192, 768], stride=[768, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ), ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_2', layout=FixedLayout('cuda', torch.float32, size=[2304, 768], stride=[768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[768, 2304], stride=[1, 768]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             )],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             constant_args=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwargs={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             output_view=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name=extern_kernels.mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             cpp_kernel_name=at::mm_out,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ordered_kwargs_for_cpp_kernel=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             op_overload=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             arg_properties=[{}, {}],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwarg_properties=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             unbacked_bindings={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             mutation_outputs=[],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origin_node=mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         FixedLayout('cuda', torch.float32, size=[1, 8, 12, 1024, 64], stride=[768, 2359296, 64, 2304, 1], offset=1536),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         origins=OrderedSet([select_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       size=[8, 12, 1024, 64],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       reindex=lambda i0, i1, i2, i3: [0, i0, i1, i2, i3],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([select_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[3]: Subgraph(name='sdpa_score0', graph_module=<lambda>(), graph=None)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[4]: (TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_3', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_4', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_4])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_5', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_6])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_6', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_8])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf6', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf3, i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp1\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=convert_element_type,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([convert_element_type])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf7', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2, i3 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf5, i3 + 8 * i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int64, src_dtype=torch.int16)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp2 = ops.to_dtype(tmp1, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp2\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=clone_1,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([convert_element_type_1, clone_1, sort])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf13', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf10, i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp1\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=convert_element_type_2,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([convert_element_type_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf14', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2, i3 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf12, i3 + 8 * i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int64, src_dtype=torch.int16)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp2 = ops.to_dtype(tmp1, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp2\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=clone_3,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([clone_3, convert_element_type_3, sort_1])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), 128, 128, Subgraph(name='sdpa_mask0', graph_module=<lambda>(), graph=None))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[5]: 0.125\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[6]: {'ROWS_GUARANTEED_SAFE': False, 'PRESCALE_QK': False, 'OUTPUT_LOGSUMEXP': True}\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[7]: ()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[8]: ()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] \n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] The above exception was the direct cause of the following exception:\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] \n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] Traceback (most recent call last):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 1039, in __call__\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     result = self._inner_convert(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 514, in __call__\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return _compile(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 902, in _compile\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     guarded_code = compile_inner(code, one_graph, hooks, transform)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 653, in compile_inner\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return _compile_inner(code, one_graph, hooks, transform)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_utils_internal.py\", line 85, in wrapper_function\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return StrobelightCompileTimeProfiler.profile_compile_time(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_strobelight/compile_time_profiler.py\", line 129, in profile_compile_time\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return func(*args, **kwargs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 686, in _compile_inner\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     out_code = transform_code_object(code, transform)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/bytecode_transformation.py\", line 1322, in transform_code_object\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     transformations(instructions, code_options)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 208, in _fn\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return fn(*args, **kwargs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 622, in transform\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     tracer.run()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/symbolic_convert.py\", line 2731, in run\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     super().run()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/symbolic_convert.py\", line 958, in run\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     while self.step():\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/symbolic_convert.py\", line 870, in step\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     self.dispatch_table[inst.opcode](self, inst)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/symbolic_convert.py\", line 2922, in RETURN_VALUE\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     self._return(inst)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/symbolic_convert.py\", line 2907, in _return\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     self.output.compile_subgraph(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/output_graph.py\", line 1109, in compile_subgraph\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     self.compile_and_call_fx_graph(tx, list(reversed(stack_values)), root)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/output_graph.py\", line 1361, in compile_and_call_fx_graph\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_fn = self.call_user_compiler(gm)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/output_graph.py\", line 1408, in call_user_compiler\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return self._call_user_compiler(gm)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/output_graph.py\", line 1457, in _call_user_compiler\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     raise BackendCompilerFailed(self.compiler_fn, e) from e\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] torch._dynamo.exc.BackendCompilerFailed: backend='inductor' raised:\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] LoweringException: AttributeError: 'View' object has no attribute 'get_stride'\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   target: flex_attention\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[0]: TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     View(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           ExternKernelOut(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name='extern_kernels.mm',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             name=buf0,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             layout=FixedLayout('cuda', torch.float32, size=[8192, 2304], stride=[2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             inputs=[ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_1', layout=FixedLayout('cuda', torch.float32, size=[8, 1024, 768], stride=[786432, 768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[8192, 768], stride=[768, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ), ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_2', layout=FixedLayout('cuda', torch.float32, size=[2304, 768], stride=[768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[768, 2304], stride=[1, 768]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             )],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             constant_args=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwargs={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             output_view=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name=extern_kernels.mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             cpp_kernel_name=at::mm_out,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ordered_kwargs_for_cpp_kernel=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             op_overload=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             arg_properties=[{}, {}],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwarg_properties=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             unbacked_bindings={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             mutation_outputs=[],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origin_node=mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         FixedLayout('cuda', torch.float32, size=[1, 8, 12, 1024, 64], stride=[768, 2359296, 64, 2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         origins=OrderedSet([select])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       size=[8, 12, 1024, 64],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       reindex=lambda i0, i1, i2, i3: [0, i0, i1, i2, i3],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([select])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[1]: TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     View(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           ExternKernelOut(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name='extern_kernels.mm',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             name=buf0,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             layout=FixedLayout('cuda', torch.float32, size=[8192, 2304], stride=[2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             inputs=[ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_1', layout=FixedLayout('cuda', torch.float32, size=[8, 1024, 768], stride=[786432, 768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[8192, 768], stride=[768, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ), ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_2', layout=FixedLayout('cuda', torch.float32, size=[2304, 768], stride=[768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[768, 2304], stride=[1, 768]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             )],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             constant_args=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwargs={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             output_view=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name=extern_kernels.mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             cpp_kernel_name=at::mm_out,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ordered_kwargs_for_cpp_kernel=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             op_overload=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             arg_properties=[{}, {}],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwarg_properties=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             unbacked_bindings={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             mutation_outputs=[],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origin_node=mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         FixedLayout('cuda', torch.float32, size=[1, 8, 12, 1024, 64], stride=[768, 2359296, 64, 2304, 1], offset=768),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         origins=OrderedSet([select_1])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       size=[8, 12, 1024, 64],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       reindex=lambda i0, i1, i2, i3: [0, i0, i1, i2, i3],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([select_1])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[2]: TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     View(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           ExternKernelOut(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name='extern_kernels.mm',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             name=buf0,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             layout=FixedLayout('cuda', torch.float32, size=[8192, 2304], stride=[2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             inputs=[ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_1', layout=FixedLayout('cuda', torch.float32, size=[8, 1024, 768], stride=[786432, 768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[8192, 768], stride=[768, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ), ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_2', layout=FixedLayout('cuda', torch.float32, size=[2304, 768], stride=[768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[768, 2304], stride=[1, 768]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             )],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             constant_args=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwargs={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             output_view=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name=extern_kernels.mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             cpp_kernel_name=at::mm_out,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ordered_kwargs_for_cpp_kernel=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             op_overload=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             arg_properties=[{}, {}],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwarg_properties=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             unbacked_bindings={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             mutation_outputs=[],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origin_node=mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         FixedLayout('cuda', torch.float32, size=[1, 8, 12, 1024, 64], stride=[768, 2359296, 64, 2304, 1], offset=1536),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         origins=OrderedSet([select_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       size=[8, 12, 1024, 64],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       reindex=lambda i0, i1, i2, i3: [0, i0, i1, i2, i3],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([select_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[3]: Subgraph(name='sdpa_score0', graph_module=<lambda>(), graph=None)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[4]: (TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_3', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_4', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_4])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_5', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_6])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_6', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_8])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf6', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf3, i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp1\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=convert_element_type,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([convert_element_type])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf7', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2, i3 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf5, i3 + 8 * i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int64, src_dtype=torch.int16)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp2 = ops.to_dtype(tmp1, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp2\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=clone_1,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([convert_element_type_1, clone_1, sort])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf13', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf10, i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp1\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=convert_element_type_2,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([convert_element_type_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf14', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2, i3 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf12, i3 + 8 * i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int64, src_dtype=torch.int16)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp2 = ops.to_dtype(tmp1, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp2\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=clone_3,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([clone_3, convert_element_type_3, sort_1])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), 128, 128, Subgraph(name='sdpa_mask0', graph_module=<lambda>(), graph=None))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[5]: 0.125\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[6]: {'ROWS_GUARANTEED_SAFE': False, 'PRESCALE_QK': False, 'OUTPUT_LOGSUMEXP': True}\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[7]: ()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[8]: ()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] \n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] Set TORCH_LOGS=\"+dynamo\" and TORCHDYNAMO_VERBOSE=1 for more information\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] \n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] Traceback (most recent call last):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/output_graph.py\", line 1438, in _call_user_compiler\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_fn = compiler_fn(gm, self.example_inputs())\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/repro/after_dynamo.py\", line 129, in __call__\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_gm = compiler_fn(gm, example_inputs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/__init__.py\", line 2236, in __call__\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return compile_fx(model_, inputs_, config_patches=self.config)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 1507, in compile_fx\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return aot_autograd(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/backends/common.py\", line 72, in __call__\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     cg = aot_module_simplified(gm, example_inputs, **self.kwargs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_functorch/aot_autograd.py\", line 1033, in aot_module_simplified\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_fn = dispatch_and_compile()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_functorch/aot_autograd.py\", line 1022, in dispatch_and_compile\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_fn, _ = create_aot_dispatcher_function(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_functorch/aot_autograd.py\", line 435, in create_aot_dispatcher_function\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return _create_aot_dispatcher_function(flat_fn, flat_args, aot_config)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_functorch/aot_autograd.py\", line 736, in _create_aot_dispatcher_function\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_fn, fw_metadata = compiler_fn(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_functorch/_aot_autograd/jit_compile_runtime_wrappers.py\", line 564, in aot_dispatch_autograd\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_fw_func = aot_config.fw_compiler(fw_module, adjusted_flat_args)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 1336, in fw_compiler_base\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return _fw_compiler_base(model, example_inputs, is_inference)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 1407, in _fw_compiler_base\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return inner_compile(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 468, in compile_fx_inner\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return wrap_compiler_debug(_compile_fx_inner, compiler_name=\"inductor\")(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/repro/after_aot.py\", line 85, in debug_wrapper\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     inner_compiled_fn = compiler_fn(gm, example_inputs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 653, in _compile_fx_inner\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_graph = FxGraphCache.load(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/codecache.py\", line 1319, in load\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_graph = compile_fx_fn(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 563, in codegen_and_compile\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_graph = fx_codegen_and_compile(gm, example_inputs, **fx_kwargs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/compile_fx.py\", line 845, in fx_codegen_and_compile\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     graph.run(*example_inputs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/graph.py\", line 772, in run\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return super().run(*args)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/fx/interpreter.py\", line 147, in run\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     self.env[node] = self.run_node(node)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/graph.py\", line 1280, in run_node\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     result = super().run_node(n)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/fx/interpreter.py\", line 204, in run_node\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return getattr(self, n.op)(n.target, args, kwargs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/graph.py\", line 1037, in call_function\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     raise LoweringException(e, target, args, kwargs).with_traceback(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/graph.py\", line 1034, in call_function\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     out = lowerings[target](*args, **kwargs)  # type: ignore[index]\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/lowering.py\", line 323, in wrapped\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     out = decomp_fn(*args, **kwargs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/kernel/flex_attention.py\", line 627, in flex_attention\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     query.get_stride(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_inductor/ir.py\", line 6151, in __getattr__\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     fn = getattr(self.data, name)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] torch._inductor.exc.LoweringException: AttributeError: 'View' object has no attribute 'get_stride'\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   target: flex_attention\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[0]: TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     View(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           ExternKernelOut(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name='extern_kernels.mm',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             name=buf0,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             layout=FixedLayout('cuda', torch.float32, size=[8192, 2304], stride=[2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             inputs=[ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_1', layout=FixedLayout('cuda', torch.float32, size=[8, 1024, 768], stride=[786432, 768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[8192, 768], stride=[768, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ), ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_2', layout=FixedLayout('cuda', torch.float32, size=[2304, 768], stride=[768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[768, 2304], stride=[1, 768]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             )],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             constant_args=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwargs={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             output_view=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name=extern_kernels.mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             cpp_kernel_name=at::mm_out,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ordered_kwargs_for_cpp_kernel=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             op_overload=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             arg_properties=[{}, {}],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwarg_properties=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             unbacked_bindings={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             mutation_outputs=[],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origin_node=mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         FixedLayout('cuda', torch.float32, size=[1, 8, 12, 1024, 64], stride=[768, 2359296, 64, 2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         origins=OrderedSet([select])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       size=[8, 12, 1024, 64],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       reindex=lambda i0, i1, i2, i3: [0, i0, i1, i2, i3],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([select])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[1]: TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     View(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           ExternKernelOut(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name='extern_kernels.mm',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             name=buf0,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             layout=FixedLayout('cuda', torch.float32, size=[8192, 2304], stride=[2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             inputs=[ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_1', layout=FixedLayout('cuda', torch.float32, size=[8, 1024, 768], stride=[786432, 768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[8192, 768], stride=[768, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ), ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_2', layout=FixedLayout('cuda', torch.float32, size=[2304, 768], stride=[768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[768, 2304], stride=[1, 768]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             )],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             constant_args=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwargs={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             output_view=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name=extern_kernels.mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             cpp_kernel_name=at::mm_out,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ordered_kwargs_for_cpp_kernel=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             op_overload=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             arg_properties=[{}, {}],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwarg_properties=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             unbacked_bindings={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             mutation_outputs=[],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origin_node=mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         FixedLayout('cuda', torch.float32, size=[1, 8, 12, 1024, 64], stride=[768, 2359296, 64, 2304, 1], offset=768),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         origins=OrderedSet([select_1])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       size=[8, 12, 1024, 64],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       reindex=lambda i0, i1, i2, i3: [0, i0, i1, i2, i3],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([select_1])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[2]: TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     View(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           ExternKernelOut(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name='extern_kernels.mm',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             name=buf0,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             layout=FixedLayout('cuda', torch.float32, size=[8192, 2304], stride=[2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             inputs=[ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_1', layout=FixedLayout('cuda', torch.float32, size=[8, 1024, 768], stride=[786432, 768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[8192, 768], stride=[768, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ), ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_2', layout=FixedLayout('cuda', torch.float32, size=[2304, 768], stride=[768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[768, 2304], stride=[1, 768]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             )],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             constant_args=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwargs={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             output_view=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name=extern_kernels.mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             cpp_kernel_name=at::mm_out,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ordered_kwargs_for_cpp_kernel=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             op_overload=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             arg_properties=[{}, {}],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwarg_properties=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             unbacked_bindings={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             mutation_outputs=[],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origin_node=mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         FixedLayout('cuda', torch.float32, size=[1, 8, 12, 1024, 64], stride=[768, 2359296, 64, 2304, 1], offset=1536),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         origins=OrderedSet([select_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       size=[8, 12, 1024, 64],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       reindex=lambda i0, i1, i2, i3: [0, i0, i1, i2, i3],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([select_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[3]: Subgraph(name='sdpa_score0', graph_module=<lambda>(), graph=None)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[4]: (TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_3', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_4', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_4])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_5', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_6])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_6', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_8])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf6', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf3, i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp1\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=convert_element_type,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([convert_element_type])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf7', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2, i3 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf5, i3 + 8 * i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int64, src_dtype=torch.int16)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp2 = ops.to_dtype(tmp1, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp2\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=clone_1,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([convert_element_type_1, clone_1, sort])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf13', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf10, i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp1\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=convert_element_type_2,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([convert_element_type_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf14', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2, i3 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf12, i3 + 8 * i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int64, src_dtype=torch.int16)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp2 = ops.to_dtype(tmp1, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp2\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=clone_3,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([clone_3, convert_element_type_3, sort_1])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), 128, 128, Subgraph(name='sdpa_mask0', graph_module=<lambda>(), graph=None))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[5]: 0.125\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[6]: {'ROWS_GUARANTEED_SAFE': False, 'PRESCALE_QK': False, 'OUTPUT_LOGSUMEXP': True}\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[7]: ()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[8]: ()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] \n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] The above exception was the direct cause of the following exception:\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] \n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] Traceback (most recent call last):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 1039, in __call__\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     result = self._inner_convert(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 514, in __call__\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return _compile(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 902, in _compile\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     guarded_code = compile_inner(code, one_graph, hooks, transform)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 653, in compile_inner\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return _compile_inner(code, one_graph, hooks, transform)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_utils_internal.py\", line 85, in wrapper_function\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return StrobelightCompileTimeProfiler.profile_compile_time(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_strobelight/compile_time_profiler.py\", line 129, in profile_compile_time\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return func(*args, **kwargs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 686, in _compile_inner\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     out_code = transform_code_object(code, transform)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/bytecode_transformation.py\", line 1322, in transform_code_object\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     transformations(instructions, code_options)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 208, in _fn\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return fn(*args, **kwargs)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/convert_frame.py\", line 622, in transform\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     tracer.run()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/symbolic_convert.py\", line 2731, in run\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     super().run()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/symbolic_convert.py\", line 958, in run\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     while self.step():\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/symbolic_convert.py\", line 870, in step\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     self.dispatch_table[inst.opcode](self, inst)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/symbolic_convert.py\", line 2922, in RETURN_VALUE\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     self._return(inst)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/symbolic_convert.py\", line 2907, in _return\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     self.output.compile_subgraph(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/output_graph.py\", line 1109, in compile_subgraph\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     self.compile_and_call_fx_graph(tx, list(reversed(stack_values)), root)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/output_graph.py\", line 1361, in compile_and_call_fx_graph\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     compiled_fn = self.call_user_compiler(gm)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/output_graph.py\", line 1408, in call_user_compiler\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     return self._call_user_compiler(gm)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   File \"/usr/local/lib/python3.10/dist-packages/torch/_dynamo/output_graph.py\", line 1457, in _call_user_compiler\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     raise BackendCompilerFailed(self.compiler_fn, e) from e\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] torch._dynamo.exc.BackendCompilerFailed: backend='inductor' raised:\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] LoweringException: AttributeError: 'View' object has no attribute 'get_stride'\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   target: flex_attention\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[0]: TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     View(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           ExternKernelOut(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name='extern_kernels.mm',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             name=buf0,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             layout=FixedLayout('cuda', torch.float32, size=[8192, 2304], stride=[2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             inputs=[ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_1', layout=FixedLayout('cuda', torch.float32, size=[8, 1024, 768], stride=[786432, 768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[8192, 768], stride=[768, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ), ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_2', layout=FixedLayout('cuda', torch.float32, size=[2304, 768], stride=[768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[768, 2304], stride=[1, 768]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             )],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             constant_args=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwargs={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             output_view=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name=extern_kernels.mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             cpp_kernel_name=at::mm_out,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ordered_kwargs_for_cpp_kernel=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             op_overload=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             arg_properties=[{}, {}],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwarg_properties=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             unbacked_bindings={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             mutation_outputs=[],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origin_node=mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         FixedLayout('cuda', torch.float32, size=[1, 8, 12, 1024, 64], stride=[768, 2359296, 64, 2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         origins=OrderedSet([select])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       size=[8, 12, 1024, 64],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       reindex=lambda i0, i1, i2, i3: [0, i0, i1, i2, i3],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([select])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[1]: TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     View(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           ExternKernelOut(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name='extern_kernels.mm',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             name=buf0,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             layout=FixedLayout('cuda', torch.float32, size=[8192, 2304], stride=[2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             inputs=[ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_1', layout=FixedLayout('cuda', torch.float32, size=[8, 1024, 768], stride=[786432, 768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[8192, 768], stride=[768, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ), ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_2', layout=FixedLayout('cuda', torch.float32, size=[2304, 768], stride=[768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[768, 2304], stride=[1, 768]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             )],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             constant_args=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwargs={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             output_view=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name=extern_kernels.mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             cpp_kernel_name=at::mm_out,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ordered_kwargs_for_cpp_kernel=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             op_overload=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             arg_properties=[{}, {}],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwarg_properties=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             unbacked_bindings={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             mutation_outputs=[],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origin_node=mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         FixedLayout('cuda', torch.float32, size=[1, 8, 12, 1024, 64], stride=[768, 2359296, 64, 2304, 1], offset=768),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         origins=OrderedSet([select_1])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       size=[8, 12, 1024, 64],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       reindex=lambda i0, i1, i2, i3: [0, i0, i1, i2, i3],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([select_1])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[2]: TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     View(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           ExternKernelOut(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name='extern_kernels.mm',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             name=buf0,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             layout=FixedLayout('cuda', torch.float32, size=[8192, 2304], stride=[2304, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             inputs=[ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_1', layout=FixedLayout('cuda', torch.float32, size=[8, 1024, 768], stride=[786432, 768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[8192, 768], stride=[768, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ), ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]                 InputBuffer(name='primals_2', layout=FixedLayout('cuda', torch.float32, size=[2304, 768], stride=[768, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               FixedLayout('cuda', torch.float32, size=[768, 2304], stride=[1, 768]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]               origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             )],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             constant_args=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwargs={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             output_view=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             python_kernel_name=extern_kernels.mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             cpp_kernel_name=at::mm_out,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             ordered_kwargs_for_cpp_kernel=(),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             op_overload=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             arg_properties=[{}, {}],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             kwarg_properties=None,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             unbacked_bindings={},\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             mutation_outputs=[],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origin_node=mm,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]             origins=OrderedSet([mm])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         FixedLayout('cuda', torch.float32, size=[1, 8, 12, 1024, 64], stride=[768, 2359296, 64, 2304, 1], offset=1536),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         origins=OrderedSet([select_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       size=[8, 12, 1024, 64],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       reindex=lambda i0, i1, i2, i3: [0, i0, i1, i2, i3],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([select_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[3]: Subgraph(name='sdpa_score0', graph_module=<lambda>(), graph=None)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[4]: (TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_3', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_4', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_4])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_5', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_6])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ReinterpretView(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]         InputBuffer(name='primals_6', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]),\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([slice_8])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     )\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   ), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf6', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf3, i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp1\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=convert_element_type,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([convert_element_type])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf7', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2, i3 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf5, i3 + 8 * i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int64, src_dtype=torch.int16)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp2 = ops.to_dtype(tmp1, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp2\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=clone_1,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([convert_element_type_1, clone_1, sort])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf13', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8], stride=[8, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf10, i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp1\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=convert_element_type_2,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([convert_element_type_2])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), TensorBox(StorageBox(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ComputedBuffer(name='buf14', layout=FixedLayout('cuda', torch.int32, size=[1, 1, 8, 8], stride=[64, 64, 8, 1]), data=Pointwise(\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       'cuda',\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       torch.int32,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       def inner_fn(index):\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           _, _, i2, i3 = index\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp0 = ops.load(buf12, i3 + 8 * i2)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp1 = ops.to_dtype(tmp0, torch.int64, src_dtype=torch.int16)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           tmp2 = ops.to_dtype(tmp1, torch.int32, src_dtype=torch.int64)\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]           return tmp2\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       ranges=[1, 1, 8, 8],\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origin_node=clone_3,\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]       origins=OrderedSet([clone_3, convert_element_type_3, sort_1])\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]     ))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   )), 128, 128, Subgraph(name='sdpa_mask0', graph_module=<lambda>(), graph=None))\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[5]: 0.125\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[6]: {'ROWS_GUARANTEED_SAFE': False, 'PRESCALE_QK': False, 'OUTPUT_LOGSUMEXP': True}\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[7]: ()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100]   args[8]: ()\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] \n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] Set TORCH_LOGS=\"+dynamo\" and TORCHDYNAMO_VERBOSE=1 for more information\n",
-      "W0810 13:55:08.918000 21035 torch/_dynamo/convert_frame.py:1100] \n"
-     ]
-    },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -2732,40 +1638,12 @@
     }
    ],
    "source": [
-    "import torch._dynamo\n",
-    "torch._dynamo.config.suppress_errors = True\n",
-    "\n",
-    "def prepare_function(fn):\n",
-    "    fn = torch.compile(fn)\n",
-    "    return fn\n",
+    "execution_stats = [time_pytorch_function_forward_backward(prepare_function(fn), embeddings) for fn in functions.values()]\n",
+    "execution_means = [stat[0] for stat in execution_stats]\n",
+    "execution_stds = [stat[1] for stat in execution_stats]\n",
     "\n",
     "\n",
-    "execution_times = [time_pytorch_function_forward_backward(prepare_function(fn), embeddings_cuda) for name,fn in functions.items()]\n",
-    "\n",
-    "\n",
-    "# Plotting\n",
-    "\n",
-    "fig, ax = plt.subplots()\n",
-    "bars = plt.bar(functions.keys(), execution_times)\n",
-    "\n",
-    "plt.ylabel(\"Execution time (ms)\")\n",
-    "plt.xticks(rotation=45, ha=\"right\")\n",
-    "\n",
-    "# Calculate new ylim with a margin\n",
-    "max_execution_time = max(execution_times)\n",
-    "upper_ylim = max_execution_time + 0.2 * max_execution_time  # Adding a 20% margin\n",
-    "\n",
-    "plt.ylim(0, upper_ylim)  # Setting new ylim\n",
-    "\n",
-    "# Annotate bars with execution times\n",
-    "for bar in bars:\n",
-    "    yval = bar.get_height()\n",
-    "    plt.text(bar.get_x() + bar.get_width()/2, yval + (0.05 * upper_ylim), round(yval, 2), ha=\"center\", va=\"bottom\")\n",
-    "\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.savefig(\"3_forward-and-backward-compiled.pdf\")\n",
-    "plt.show()"
+    "plot_execution_times(functions, execution_means, execution_stds, filename=\"3_forward-and-backward-compiled.pdf\")"
    ]
   }
  ],
@@ -2790,7 +1668,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.10.14"
   }
  },
  "nbformat": 4,