mlc-ai-notebooks/6_Integration_with_Machine_Learning_Frameworks.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "Mpn1ti5Urdsv"
      },
      "source": [
        "# Ep6: Integration with Machine Learning Frameworks\n",
        "\n",
        "对应 DL 框架的模型\n",
        "\n",
        "relax 前端只支持了 pytorch。relay 支持的多一些。"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "BBIuE2jc1DaU"
      },
      "source": [
        "## Preparations\n",
        "\n",
        "To begin with, we will import necessary dependencies.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "BVp0fHyRkYj6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tvm versin: 0.13.dev0\n"
          ]
        }
      ],
      "source": [
        "import tvm\n",
        "from tvm.ir.module import IRModule\n",
        "\n",
        "from tvm.script import tir as T, relax as R\n",
        "from tvm import te\n",
        "\n",
        "from tvm import relax\n",
        "# This is needed for deferring annotation parsing in TVMScript\n",
        "from __future__ import annotations \n",
        "\n",
        "import numpy as np\n",
        "import pickle\n",
        "\n",
        "print('tvm versin: %s' % tvm.__version__)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "6saIbYSCrZF7"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch import fx\n",
        "from torch.nn import functional as F"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "8yH4IMSMvF9o"
      },
      "source": [
        "## Build an IRModule Through a Builder"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "GWg6lEgR5P7i"
      },
      "source": [
        "`te.compute` takes the signature `te.compute(output_shape, fcompute)`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "zlvL1Zfkt9A4"
      },
      "outputs": [],
      "source": [
        "def te_matmul(A: te.Tensor, B: te.Tensor) -> te.Tensor:\n",
        "    assert A.shape[1] == B.shape[0]\n",
        "    n = A.shape[0]\n",
        "    m = B.shape[1]\n",
        "    k = te.reduce_axis((0, A.shape[1]), name=\"k\")\n",
        "    return te.compute((n, m), lambda i, j: te.sum(A[i, k] * B[k, j], axis=k), name=\"matmul\")\n",
        "\n",
        "def te_relu(A: te.Tensor) -> te.Tensor:\n",
        "    return te.compute(A.shape, lambda *i: te.max(A(*i), 0), name=\"relu\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "GSeib3RT778t"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "# from tvm.script import tir as T\n",
              "\n",
              "@T.prim_func\n",
              "def main(X1: T.Buffer((10, 20), \"float32\"), relu: T.Buffer((10, 20), \"float32\")):\n",
              "    T.func_attr({\"global_symbol\": \"main\", \"tir.noalias\": T.bool(True)})\n",
              "    # with T.block(\"root\"):\n",
              "    for i0, i1 in T.grid(10, 20):\n",
              "        with T.block(\"relu\"):\n",
              "            v_i0, v_i1 = T.axis.remap(\"SS\", [i0, i1])\n",
              "            T.reads(X1[v_i0, v_i1])\n",
              "            T.writes(relu[v_i0, v_i1])\n",
              "            relu[v_i0, v_i1] = T.max(X1[v_i0, v_i1], T.float32(0))"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "X1 = te.placeholder((10,), name=\"X1\", dtype=\"float32\")\n",
        "Y1 = te_relu(X1)\n",
        "te.create_prim_func([X1, Y1])\n",
        "\n",
        "X2 = te.placeholder((10, 20), name=\"X1\", dtype=\"float32\")\n",
        "Y2 = te_relu(X2)\n",
        "te.create_prim_func([X2, Y2])"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "1slxb7C6-FT3"
      },
      "source": [
        "One final thing that `te` API allows us to do is to compose operations and create \"fused\" operators. For example, we can take the result of matmul and apply relu again. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "5h7i20Qd9pEA"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "# from tvm.script import tir as T\n",
              "\n",
              "@T.prim_func\n",
              "def main(A: T.Buffer((128, 128), \"float32\"), B: T.Buffer((128, 128), \"float32\"), relu: T.Buffer((128, 128), \"float32\")):\n",
              "    T.func_attr({\"global_symbol\": \"main\", \"tir.noalias\": T.bool(True)})\n",
              "    # with T.block(\"root\"):\n",
              "    matmul = T.alloc_buffer((128, 128))\n",
              "    for i, j, k in T.grid(128, 128, 128):\n",
              "        with T.block(\"matmul\"):\n",
              "            v_i, v_j, v_k = T.axis.remap(\"SSR\", [i, j, k])\n",
              "            T.reads(A[v_i, v_k], B[v_k, v_j])\n",
              "            T.writes(matmul[v_i, v_j])\n",
              "            with T.init():\n",
              "                matmul[v_i, v_j] = T.float32(0)\n",
              "            matmul[v_i, v_j] = matmul[v_i, v_j] + A[v_i, v_k] * B[v_k, v_j]\n",
              "    for i0, i1 in T.grid(128, 128):\n",
              "        with T.block(\"relu\"):\n",
              "            v_i0, v_i1 = T.axis.remap(\"SS\", [i0, i1])\n",
              "            T.reads(matmul[v_i0, v_i1])\n",
              "            T.writes(relu[v_i0, v_i1])\n",
              "            relu[v_i0, v_i1] = T.max(matmul[v_i0, v_i1], T.float32(0))"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "A = te.placeholder((128, 128), name=\"A\", dtype=\"float32\")\n",
        "B = te.placeholder((128, 128), name=\"B\", dtype=\"float32\")\n",
        "\n",
        "# C = te_matmul(A, B)\n",
        "# func = te.create_prim_func([A, B, C])\n",
        "# func.show()\n",
        "\n",
        "C = te_matmul(A, B)\n",
        "D = te_relu(C)\n",
        "te.create_prim_func([A, B, D])"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "oOTcJQDB7EeJ"
      },
      "source": [
        "### Use BlockBuilder to Create an IRModule"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "Vm71Tp87Qz8M"
      },
      "source": [
        "So far, we have created a single TensorIR function. In order to build end-to-end model execution, we also need to be able to connect multiple TensorIR functions through a computational graph.\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "SnaE0Szgu5cq"
      },
      "source": [
        "Let us first create a block builder, which helps us incrementally build a `relax.Function`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hz4UojV8vT8Y",
        "outputId": "e7cb31e3-d7f3-4cba-9042-f1ea5a140d36"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<div class=\"highlight\" style=\"background: \"><pre style=\"line-height: 125%;\"><span></span><span style=\"color: #007979; font-style: italic\"># from tvm.script import ir as I</span>\n",
              "<span style=\"color: #007979; font-style: italic\"># from tvm.script import tir as T</span>\n",
              "<span style=\"color: #007979; font-style: italic\"># from tvm.script import relax as R</span>\n",
              "\n",
              "\n",
              "<span style=\"color: #AA22FF\">@I</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>ir_module\n",
              "<span style=\"color: #008000; font-weight: bold\">class</span> <span style=\"color: #0000FF; font-weight: bold\">Module</span>:\n",
              "    <span style=\"color: #AA22FF\">@T</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>prim_func\n",
              "    <span style=\"color: #008000; font-weight: bold\">def</span> <span style=\"color: #0000FF\">te_matmul</span>(\n",
              "        A: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        B: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        matmul: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "    ):\n",
              "        T<span style=\"color: #AA22FF; font-weight: bold\">.</span>func_attr({<span style=\"color: #BA2121\">&quot;tir.noalias&quot;</span>: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>bool(<span style=\"color: #008000; font-weight: bold\">True</span>)})\n",
              "        <span style=\"color: #007979; font-style: italic\"># with T.block(&quot;root&quot;):</span>\n",
              "        <span style=\"color: #008000; font-weight: bold\">for</span> i, j, k <span style=\"color: #008000; font-weight: bold\">in</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>grid(T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)):\n",
              "            <span style=\"color: #008000; font-weight: bold\">with</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>block(<span style=\"color: #BA2121\">&quot;matmul&quot;</span>):\n",
              "                v_i, v_j, v_k <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>axis<span style=\"color: #AA22FF; font-weight: bold\">.</span>remap(<span style=\"color: #BA2121\">&quot;SSR&quot;</span>, [i, j, k])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>reads(A[v_i, v_k], B[v_k, v_j])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>writes(matmul[v_i, v_j])\n",
              "                <span style=\"color: #008000; font-weight: bold\">with</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>init():\n",
              "                    matmul[v_i, v_j] <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>float32(<span style=\"color: #008000\">0</span>)\n",
              "                matmul[v_i, v_j] <span style=\"color: #AA22FF; font-weight: bold\">=</span> matmul[v_i, v_j] <span style=\"color: #AA22FF; font-weight: bold\">+</span> A[v_i, v_k] <span style=\"color: #AA22FF; font-weight: bold\">*</span> B[v_k, v_j]\n",
              "\n",
              "    <span style=\"color: #AA22FF\">@T</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>prim_func\n",
              "    <span style=\"color: #008000; font-weight: bold\">def</span> <span style=\"color: #0000FF\">te_relu</span>(\n",
              "        A: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        relu: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "    ):\n",
              "        T<span style=\"color: #AA22FF; font-weight: bold\">.</span>func_attr({<span style=\"color: #BA2121\">&quot;tir.noalias&quot;</span>: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>bool(<span style=\"color: #008000; font-weight: bold\">True</span>)})\n",
              "        <span style=\"color: #007979; font-style: italic\"># with T.block(&quot;root&quot;):</span>\n",
              "        <span style=\"color: #008000; font-weight: bold\">for</span> i0, i1 <span style=\"color: #008000; font-weight: bold\">in</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>grid(T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)):\n",
              "            <span style=\"color: #008000; font-weight: bold\">with</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>block(<span style=\"color: #BA2121\">&quot;relu&quot;</span>):\n",
              "                v_i0, v_i1 <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>axis<span style=\"color: #AA22FF; font-weight: bold\">.</span>remap(<span style=\"color: #BA2121\">&quot;SS&quot;</span>, [i0, i1])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>reads(A[v_i0, v_i1])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>writes(relu[v_i0, v_i1])\n",
              "                relu[v_i0, v_i1] <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>max(A[v_i0, v_i1], T<span style=\"color: #AA22FF; font-weight: bold\">.</span>float32(<span style=\"color: #008000\">0</span>))\n",
              "\n",
              "    <span style=\"color: #AA22FF\">@R</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>function\n",
              "    <span style=\"color: #008000; font-weight: bold\">def</span> <span style=\"color: #0000FF\">main</span>(\n",
              "        A: R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">128</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        B: R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">128</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "    ) <span style=\"color: #AA22FF; font-weight: bold\">-&gt;</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">128</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>):\n",
              "        cls <span style=\"color: #AA22FF; font-weight: bold\">=</span> Module\n",
              "        <span style=\"color: #008000; font-weight: bold\">with</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>dataflow():\n",
              "            lv <span style=\"color: #AA22FF; font-weight: bold\">=</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>call_tir(\n",
              "                cls<span style=\"color: #AA22FF; font-weight: bold\">.</span>te_matmul, (A, B), out_sinfo<span style=\"color: #AA22FF; font-weight: bold\">=</span>R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">128</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>)\n",
              "            )\n",
              "            lv1 <span style=\"color: #AA22FF; font-weight: bold\">=</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>call_tir(\n",
              "                cls<span style=\"color: #AA22FF; font-weight: bold\">.</span>te_relu, (lv,), out_sinfo<span style=\"color: #AA22FF; font-weight: bold\">=</span>R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">128</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>)\n",
              "            )\n",
              "            gv: R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">128</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>) <span style=\"color: #AA22FF; font-weight: bold\">=</span> lv1\n",
              "            R<span style=\"color: #AA22FF; font-weight: bold\">.</span>output(gv)\n",
              "        <span style=\"color: #008000; font-weight: bold\">return</span> gv\n",
              "</pre></div>\n"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "A = relax.Var(\"A\", relax.TensorStructInfo((128, 128), 'float32'))\n",
        "B = relax.Var(\"B\", relax.TensorStructInfo((128, 128), 'float32'))\n",
        "# B = relax.Var(\"B\", (128, 128), relax.DynTensorType(2, \"float32\"))\n",
        "\n",
        "bb = relax.BlockBuilder()\n",
        "\n",
        "with bb.function(\"main\"):\n",
        "    with bb.dataflow():\n",
        "        C = bb.emit_te(te_matmul, A, B)\n",
        "        D = bb.emit_te(te_relu, C)\n",
        "        R = bb.emit_output(D)\n",
        "    bb.emit_func_output(R, params=[A, B])\n",
        "\n",
        "MyModule = bb.get()\n",
        "MyModule.show()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "2yBnEX5C2lG5"
      },
      "source": [
        "### Deep Dive into Block Builder APIs\n",
        "\n",
        "Now let us do a deep dive into each block builder API. It is helpful to put the block builder code and the resulting module side by side."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "nzJgNT4kyh3i"
      },
      "source": [
        "![Screen Shot 2022-07-29 at 11.16.24 PM.png](data:image/png;base64,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)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "erv3pnzy25-7"
      },
      "source": [
        "The block builder comes with scopes that correspond to the scopes in the relax function. For example, `bb.dataflow()` creates a dataflow\n",
        "block where all the block builder calls inside the scope belonging to the dataflow scope. \n",
        "\n",
        "```python\n",
        "with bb.function(\"main\"):\n",
        "    with bb.dataflow():\n",
        "        # every emit call generates a variable inside a dataflow block.\n",
        "```"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "LA-0uerSAnUC"
      },
      "source": [
        "Each intermediate result is a `relax.Var` corresponding to a variable that stores the result of the computation. `DataflowVar` indicates that the var is an intermediate step inside a dataflow block (computational graph)."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "f61-biEx82nr"
      },
      "source": [
        "Each line in the relax function is generated by an `emit_te` call. For example, \n",
        "\n",
        "```python\n",
        "lv = R.call_tir(te_matmul, (A, B), (128, 128), dtype=\"float32\")\n",
        "```\n",
        "is generated by \n",
        "```python\n",
        "C = bb.emit_te(te_matmul, A, B).\n",
        "```\n",
        "Under the hood, the bb.emit_te does the following things:\n",
        "- Create an input `te.placeholder` for A and B\n",
        "- Run them through `te_matmul` function.\n",
        "- Call into `te.create_prim_func` to create a TensorIR function.\n",
        "- Generate a call into the function via `call_tir`.\n",
        "\n",
        "We can find that the result is a computational graph with two intermediate values, with one node corresponding to the te_matmul operation and another one corresponding to `te_relu`."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "hWd1GbGHBZlt"
      },
      "source": [
        "We can create output variable of each dataflow block through `bb.emit_output`.\n",
        "\n",
        "```python\n",
        "with bb.dataflow():\n",
        "    ...\n",
        "    R = bb.emit_output(D)\n",
        "```\n",
        "The above code marks that D is a variable that can be referred to outside of the dataflow block.\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "FrqQCHu3BrGC"
      },
      "source": [
        "Finally, the function output is marked by `bb.emit_func_output`. We can only call `emit_func_output` once in each function scope.\n",
        "\n",
        "Notably, we can specify the list of parameters of the function in the output emission stage. Doing so helps us in cases where we collect the list of parameters on the fly.\n",
        "\n",
        "```python\n",
        "with bb.function(\"main\"):\n",
        "    ...\n",
        "    # specify parameters in the end\n",
        "    bb.emit_func_output(R, params=[A, B])\n",
        "```\n",
        "Alternatively, we can specify the list of parameters at the beginning of the function scope.\n",
        "```python\n",
        "# specify parameters in the beginning.\n",
        "with bb.function(\"main\", params=[A, B]):\n",
        "    ...\n",
        "    bb.emit_func_output(R)\n",
        "```\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "a-c8N-7sEa1M"
      },
      "source": [
        "## Import Model From PyTorch"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "PUcCRU2IQPm-"
      },
      "source": [
        "Now that we have learned the tools to construct an IRModule programmatically. Let us use them to bring a model from PyTorch into the IRModule format.\n",
        "\n",
        "Most machine learning framework comes with computational graph abstractions, where each node corresponds to an operation, and the edges correspond to the dependency among them. We will take a PyTorch model, obtain a computational graph in PyTorch's native format, and translate that into IRModule.\n",
        "\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "HJFs5zDkGAOU"
      },
      "source": [
        "Let us begin by defining a model in PyTorch. To keep the example consistent, we will use matmul relu example."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "F6gzwCFfF6V9"
      },
      "outputs": [],
      "source": [
        "class MyModel(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(MyModel, self).__init__()\n",
        "        self.weight = nn.Parameter(torch.randn(128, 128))\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = torch.matmul(x, self.weight)\n",
        "        x = torch.relu(x)\n",
        "        return x"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "PoX9dyqVG0ZB"
      },
      "source": [
        "### Create TorchFX GraphModule\n",
        "\n",
        "We use TorchFX to trace a graph from the PyTorch module."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4vGt8XleGH5q",
        "outputId": "1ffd6f09-38c4-4902-b4bf-76ccf99d6ad4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "torch.fx.graph_module.GraphModule.__new__.<locals>.GraphModuleImpl"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model = MyModel()\n",
        "fx_module = fx.symbolic_trace(model)\n",
        "type(fx_module)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "eYJUSv2qHm5x"
      },
      "source": [
        "The `fx_module` contains a simple computation graph view that can be printed as tabular data. Our goal is to translate this graph into an IRModule."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oxvS3jjmGztF",
        "outputId": "970a7536-c672-48fa-9b8e-fadeffb8edf1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "opcode         name    target                                                  args         kwargs\n",
            "-------------  ------  ------------------------------------------------------  -----------  --------\n",
            "placeholder    x       x                                                       ()           {}\n",
            "get_attr       weight  weight                                                  ()           {}\n",
            "call_function  matmul  <built-in method matmul of type object at 0x16e8d0850>  (x, weight)  {}\n",
            "call_function  relu    <built-in method relu of type object at 0x16e8d0850>    (matmul,)    {}\n",
            "output         output  output                                                  (relu,)      {}\n"
          ]
        }
      ],
      "source": [
        "fx_module.graph.print_tabular()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "RjVbP-mmIdUs"
      },
      "source": [
        "### Create Map Function\n",
        "\n",
        "Let us define the overall high-level translation logic. The main flow is as follows:\n",
        "- Create a `node_map` that maps `fx.Node` to the corresponding `relax.Var` that represents the translated node in IRModule.\n",
        "- Iterate over the nodes in the fx graph in topological order.\n",
        "- Compute the mapped output of the node given the mapped inputs."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "U6t1bQ7kOmLs"
      },
      "outputs": [],
      "source": [
        "def map_param(param: nn.Parameter):\n",
        "    ndim = len(param.data.shape)\n",
        "    return relax.const(\n",
        "        param.data.cpu().numpy(), relax.DynTensorType(ndim, \"float32\")\n",
        "    )\n",
        "\n",
        "def fetch_attr(fx_mod, target: str):\n",
        "    \"\"\"Helper function to fetch an attr\"\"\"\n",
        "    target_atoms = target.split('.')\n",
        "    attr_itr = fx_mod\n",
        "    for i, atom in enumerate(target_atoms):\n",
        "        if not hasattr(attr_itr, atom):\n",
        "            raise RuntimeError(f\"Node referenced nonexistant target {'.'.join(target_atoms[:i])}\")\n",
        "        attr_itr = getattr(attr_itr, atom)\n",
        "    return attr_itr\n",
        "\n",
        "def from_fx(fx_mod, input_shapes, call_function_map, call_module_map):\n",
        "    input_index = 0\n",
        "    node_map = {}\n",
        "    named_modules = dict(fx_mod.named_modules())\n",
        "\n",
        "    bb = relax.BlockBuilder()\n",
        "\n",
        "    fn_inputs = []\n",
        "    fn_output = None\n",
        "    with bb.function(\"main\"):\n",
        "        with bb.dataflow():\n",
        "            for node in fx_mod.graph.nodes:\n",
        "                if node.op == \"placeholder\":\n",
        "                    # create input placeholder\n",
        "                    shape = input_shapes[input_index]\n",
        "                    input_index += 1 \n",
        "                    input_var = relax.Var(\n",
        "                        # node.target, shape, relax.DynTensorType(len(shape), \"float32\")\n",
        "                        node.target, relax.TensorStructInfo(shape, \"float32\")\n",
        "                    )\n",
        "                    fn_inputs.append(input_var)\n",
        "                    node_map[node] = input_var\n",
        "                elif node.op == \"get_attr\":\n",
        "                    node_map[node] = map_param(fetch_attr(fx_mod, node.target))\n",
        "                elif node.op == \"call_function\":\n",
        "                    node_map[node] = call_function_map[node.target](bb, node_map, node)\n",
        "                elif node.op == \"call_module\":\n",
        "                    named_module = named_modules[node.target]\n",
        "                    node_map[node] = call_module_map[type(named_module)](bb, node_map, node, named_module)\n",
        "                elif node.op == \"output\":\n",
        "                    output = node_map[node.args[0]]\n",
        "                    assert fn_output is None\n",
        "                    fn_output = bb.emit_output(output)\n",
        "        # output and finalize the function\n",
        "        bb.emit_func_output(output, fn_inputs)\n",
        "    return bb.get()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "HBlaVkysfrCu"
      },
      "source": [
        "We did not define the function map in the `from_fx` function. We will supply the translation rule of each torch function via a map. Specifically, the following code block shows how we can do that through the `emit_te` API."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CKqkz9jrfrbh",
        "outputId": "cbd008cf-6862-48fe-db45-59931c0fd68c"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<div class=\"highlight\" style=\"background: \"><pre style=\"line-height: 125%;\"><span></span><span style=\"color: #007979; font-style: italic\"># from tvm.script import ir as I</span>\n",
              "<span style=\"color: #007979; font-style: italic\"># from tvm.script import tir as T</span>\n",
              "<span style=\"color: #007979; font-style: italic\"># from tvm.script import relax as R</span>\n",
              "\n",
              "\n",
              "<span style=\"color: #AA22FF\">@I</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>ir_module\n",
              "<span style=\"color: #008000; font-weight: bold\">class</span> <span style=\"color: #0000FF; font-weight: bold\">Module</span>:\n",
              "    <span style=\"color: #AA22FF\">@T</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>prim_func\n",
              "    <span style=\"color: #008000; font-weight: bold\">def</span> <span style=\"color: #0000FF\">te_matmul</span>(\n",
              "        A: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        B: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        matmul: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "    ):\n",
              "        T<span style=\"color: #AA22FF; font-weight: bold\">.</span>func_attr({<span style=\"color: #BA2121\">&quot;tir.noalias&quot;</span>: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>bool(<span style=\"color: #008000; font-weight: bold\">True</span>)})\n",
              "        <span style=\"color: #007979; font-style: italic\"># with T.block(&quot;root&quot;):</span>\n",
              "        <span style=\"color: #008000; font-weight: bold\">for</span> i, j, k <span style=\"color: #008000; font-weight: bold\">in</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>grid(T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)):\n",
              "            <span style=\"color: #008000; font-weight: bold\">with</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>block(<span style=\"color: #BA2121\">&quot;matmul&quot;</span>):\n",
              "                v_i, v_j, v_k <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>axis<span style=\"color: #AA22FF; font-weight: bold\">.</span>remap(<span style=\"color: #BA2121\">&quot;SSR&quot;</span>, [i, j, k])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>reads(A[v_i, v_k], B[v_k, v_j])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>writes(matmul[v_i, v_j])\n",
              "                <span style=\"color: #008000; font-weight: bold\">with</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>init():\n",
              "                    matmul[v_i, v_j] <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>float32(<span style=\"color: #008000\">0</span>)\n",
              "                matmul[v_i, v_j] <span style=\"color: #AA22FF; font-weight: bold\">=</span> matmul[v_i, v_j] <span style=\"color: #AA22FF; font-weight: bold\">+</span> A[v_i, v_k] <span style=\"color: #AA22FF; font-weight: bold\">*</span> B[v_k, v_j]\n",
              "\n",
              "    <span style=\"color: #AA22FF\">@T</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>prim_func\n",
              "    <span style=\"color: #008000; font-weight: bold\">def</span> <span style=\"color: #0000FF\">te_relu</span>(\n",
              "        A: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        relu: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "    ):\n",
              "        T<span style=\"color: #AA22FF; font-weight: bold\">.</span>func_attr({<span style=\"color: #BA2121\">&quot;tir.noalias&quot;</span>: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>bool(<span style=\"color: #008000; font-weight: bold\">True</span>)})\n",
              "        <span style=\"color: #007979; font-style: italic\"># with T.block(&quot;root&quot;):</span>\n",
              "        <span style=\"color: #008000; font-weight: bold\">for</span> i0, i1 <span style=\"color: #008000; font-weight: bold\">in</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>grid(T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)):\n",
              "            <span style=\"color: #008000; font-weight: bold\">with</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>block(<span style=\"color: #BA2121\">&quot;relu&quot;</span>):\n",
              "                v_i0, v_i1 <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>axis<span style=\"color: #AA22FF; font-weight: bold\">.</span>remap(<span style=\"color: #BA2121\">&quot;SS&quot;</span>, [i0, i1])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>reads(A[v_i0, v_i1])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>writes(relu[v_i0, v_i1])\n",
              "                relu[v_i0, v_i1] <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>max(A[v_i0, v_i1], T<span style=\"color: #AA22FF; font-weight: bold\">.</span>float32(<span style=\"color: #008000\">0</span>))\n",
              "\n",
              "    <span style=\"color: #AA22FF\">@R</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>function\n",
              "    <span style=\"color: #008000; font-weight: bold\">def</span> <span style=\"color: #0000FF\">main</span>(\n",
              "        x: R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">1</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>)\n",
              "    ) <span style=\"color: #AA22FF; font-weight: bold\">-&gt;</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">1</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>):\n",
              "        cls <span style=\"color: #AA22FF; font-weight: bold\">=</span> Module\n",
              "        <span style=\"color: #008000; font-weight: bold\">with</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>dataflow():\n",
              "            lv <span style=\"color: #AA22FF; font-weight: bold\">=</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>call_tir(\n",
              "                cls<span style=\"color: #AA22FF; font-weight: bold\">.</span>te_matmul,\n",
              "                (x, metadata[<span style=\"color: #BA2121\">&quot;relax.expr.Constant&quot;</span>][<span style=\"color: #008000\">0</span>]),\n",
              "                out_sinfo<span style=\"color: #AA22FF; font-weight: bold\">=</span>R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">1</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "            )\n",
              "            lv1 <span style=\"color: #AA22FF; font-weight: bold\">=</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>call_tir(\n",
              "                cls<span style=\"color: #AA22FF; font-weight: bold\">.</span>te_relu, (lv,), out_sinfo<span style=\"color: #AA22FF; font-weight: bold\">=</span>R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">1</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>)\n",
              "            )\n",
              "            gv: R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">1</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>) <span style=\"color: #AA22FF; font-weight: bold\">=</span> lv1\n",
              "            R<span style=\"color: #AA22FF; font-weight: bold\">.</span>output(gv)\n",
              "        <span style=\"color: #008000; font-weight: bold\">return</span> lv1\n",
              "\n",
              "\n",
              "<span style=\"color: #007979; font-style: italic\"># Metadata omitted. Use show_meta=True in script() method to show it.</span>\n",
              "</pre></div>\n"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def map_matmul(bb, node_map, node: fx.Node):\n",
        "    A = node_map[node.args[0]]\n",
        "    B = node_map[node.args[1]]\n",
        "    return bb.emit_te(te_matmul, A, B)\n",
        "\n",
        "def map_relu(bb, node_map, node: fx.Node):\n",
        "    A = node_map[node.args[0]]\n",
        "    return bb.emit_te(te_relu, A)\n",
        "\n",
        "MyModule = from_fx(\n",
        "    fx_module, \n",
        "    input_shapes = [(1, 128)], \n",
        "    call_function_map = {\n",
        "      torch.matmul: map_matmul,\n",
        "      torch.relu: map_relu, \n",
        "    },\n",
        "    call_module_map={},\n",
        ")\n",
        "\n",
        "MyModule.show()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "6OBLhELUgpBT"
      },
      "source": [
        "## Coming back to FashionMNIST Example"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "o1JM175Ri_hq"
      },
      "outputs": [],
      "source": [
        "param_file = 'fasionmnist_mlp_params.pkl'\n",
        "mlp_params = pickle.load(open(param_file, \"rb\"))\n",
        "\n",
        "class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n",
        "               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
        "\n",
        "image_filename = 'fasionmnist_image_Trouser.pkl'\n",
        "label = 1\n",
        "\n",
        "with open(image_filename, 'rb') as f:\n",
        "    img = pickle.load(f)\n",
        "\n",
        "data_nd = tvm.nd.array(img.reshape(1, 784))\n",
        "nd_params = {k: tvm.nd.array(v) for k, v in mlp_params.items()}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 287
        },
        "id": "VOoQL7r7i_qf",
        "outputId": "3685c1c1-2121-47e1-c297-40624727763f"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Class: Trouser\n"
          ]
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.figure()\n",
        "plt.imshow(img)\n",
        "plt.colorbar()\n",
        "plt.grid(False)\n",
        "plt.show()\n",
        "\n",
        "print(\"Class:\", class_names[label])"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "Vqh3yklvjquJ"
      },
      "source": [
        "The above is our model of interest, we can build the PyTorch model as follows"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "OqbgbCtEgfoV"
      },
      "outputs": [],
      "source": [
        "class MLP(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(MLP, self).__init__()\n",
        "        self.linear0 = nn.Linear(784, 128, bias=True)\n",
        "        self.relu = nn.ReLU()\n",
        "        self.linear1 = nn.Linear(128, 10, bias=True)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.linear0(x)\n",
        "        x = self.relu(x)\n",
        "        x = self.linear1(x)\n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "usBESp0ojUdc"
      },
      "outputs": [],
      "source": [
        "import pickle as pkl\n",
        "mlp_model = MLP()\n",
        "\n",
        "mlp_params = pkl.load(open(\"fasionmnist_mlp_params.pkl\", \"rb\"))\n",
        "mlp_model.linear0.weight.data = torch.from_numpy(mlp_params[\"w0\"])\n",
        "mlp_model.linear0.bias.data = torch.from_numpy(mlp_params[\"b0\"])\n",
        "mlp_model.linear1.weight.data = torch.from_numpy(mlp_params[\"w1\"])\n",
        "mlp_model.linear1.bias.data = torch.from_numpy(mlp_params[\"b1\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MDKt0OAWk3Jr",
        "outputId": "8686b68c-bc0e-4eb9-8916-7d96b86c3ed4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Torch Prediction: Trouser\n"
          ]
        }
      ],
      "source": [
        "torch_res = mlp_model(torch.from_numpy(img.reshape(1, 784)))\n",
        "\n",
        "pred_kind = np.argmax(torch_res.detach().numpy(), axis=1)\n",
        "print(\"Torch Prediction:\", class_names[pred_kind[0]])"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "6BEuhKdzqlUW"
      },
      "source": [
        "Let us try to translate from fx by defining mapping functions for the corresponding `nn.Module`. Here we are reusing pre-defined TE libraries from TVM `topi` instead of defining our own tensor expression.\n",
        "\n",
        "- `topi.nn.dense(x, w)` performs transposed matrix multiplication `x @ w.T`\n",
        "- `topi.add` performs broadcast add.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0YmBlh3ClbNX",
        "outputId": "a498fa9b-6ea7-4c2f-8a91-146a30cf5940"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<div class=\"highlight\" style=\"background: \"><pre style=\"line-height: 125%;\"><span></span><span style=\"color: #007979; font-style: italic\"># from tvm.script import ir as I</span>\n",
              "<span style=\"color: #007979; font-style: italic\"># from tvm.script import tir as T</span>\n",
              "<span style=\"color: #007979; font-style: italic\"># from tvm.script import relax as R</span>\n",
              "\n",
              "\n",
              "<span style=\"color: #AA22FF\">@I</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>ir_module\n",
              "<span style=\"color: #008000; font-weight: bold\">class</span> <span style=\"color: #0000FF; font-weight: bold\">Module</span>:\n",
              "    <span style=\"color: #AA22FF\">@T</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>prim_func\n",
              "    <span style=\"color: #008000; font-weight: bold\">def</span> <span style=\"color: #0000FF\">add</span>(\n",
              "        A: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        B: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>),), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        T_add: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "    ):\n",
              "        T<span style=\"color: #AA22FF; font-weight: bold\">.</span>func_attr({<span style=\"color: #BA2121\">&quot;tir.noalias&quot;</span>: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>bool(<span style=\"color: #008000; font-weight: bold\">True</span>)})\n",
              "        <span style=\"color: #007979; font-style: italic\"># with T.block(&quot;root&quot;):</span>\n",
              "        <span style=\"color: #008000; font-weight: bold\">for</span> ax0, ax1 <span style=\"color: #008000; font-weight: bold\">in</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>grid(T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)):\n",
              "            <span style=\"color: #008000; font-weight: bold\">with</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>block(<span style=\"color: #BA2121\">&quot;T_add&quot;</span>):\n",
              "                v_ax0, v_ax1 <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>axis<span style=\"color: #AA22FF; font-weight: bold\">.</span>remap(<span style=\"color: #BA2121\">&quot;SS&quot;</span>, [ax0, ax1])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>reads(A[v_ax0, v_ax1], B[v_ax1])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>writes(T_add[v_ax0, v_ax1])\n",
              "                T_add[v_ax0, v_ax1] <span style=\"color: #AA22FF; font-weight: bold\">=</span> A[v_ax0, v_ax1] <span style=\"color: #AA22FF; font-weight: bold\">+</span> B[v_ax1]\n",
              "\n",
              "    <span style=\"color: #AA22FF\">@T</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>prim_func\n",
              "    <span style=\"color: #008000; font-weight: bold\">def</span> <span style=\"color: #0000FF\">add1</span>(\n",
              "        A: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">10</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        B: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">10</span>),), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        T_add: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">10</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "    ):\n",
              "        T<span style=\"color: #AA22FF; font-weight: bold\">.</span>func_attr({<span style=\"color: #BA2121\">&quot;tir.noalias&quot;</span>: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>bool(<span style=\"color: #008000; font-weight: bold\">True</span>)})\n",
              "        <span style=\"color: #007979; font-style: italic\"># with T.block(&quot;root&quot;):</span>\n",
              "        <span style=\"color: #008000; font-weight: bold\">for</span> ax0, ax1 <span style=\"color: #008000; font-weight: bold\">in</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>grid(T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">10</span>)):\n",
              "            <span style=\"color: #008000; font-weight: bold\">with</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>block(<span style=\"color: #BA2121\">&quot;T_add&quot;</span>):\n",
              "                v_ax0, v_ax1 <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>axis<span style=\"color: #AA22FF; font-weight: bold\">.</span>remap(<span style=\"color: #BA2121\">&quot;SS&quot;</span>, [ax0, ax1])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>reads(A[v_ax0, v_ax1], B[v_ax1])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>writes(T_add[v_ax0, v_ax1])\n",
              "                T_add[v_ax0, v_ax1] <span style=\"color: #AA22FF; font-weight: bold\">=</span> A[v_ax0, v_ax1] <span style=\"color: #AA22FF; font-weight: bold\">+</span> B[v_ax1]\n",
              "\n",
              "    <span style=\"color: #AA22FF\">@T</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>prim_func\n",
              "    <span style=\"color: #008000; font-weight: bold\">def</span> <span style=\"color: #0000FF\">dense</span>(\n",
              "        A: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">784</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        B: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">784</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        T_matmul_NT: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "    ):\n",
              "        T<span style=\"color: #AA22FF; font-weight: bold\">.</span>func_attr({<span style=\"color: #BA2121\">&quot;layout_free_buffers&quot;</span>: [<span style=\"color: #008000\">1</span>], <span style=\"color: #BA2121\">&quot;tir.noalias&quot;</span>: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>bool(<span style=\"color: #008000; font-weight: bold\">True</span>)})\n",
              "        <span style=\"color: #007979; font-style: italic\"># with T.block(&quot;root&quot;):</span>\n",
              "        <span style=\"color: #008000; font-weight: bold\">for</span> i, j, k <span style=\"color: #008000; font-weight: bold\">in</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>grid(T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">784</span>)):\n",
              "            <span style=\"color: #008000; font-weight: bold\">with</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>block(<span style=\"color: #BA2121\">&quot;T_matmul_NT&quot;</span>):\n",
              "                v_i, v_j, v_k <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>axis<span style=\"color: #AA22FF; font-weight: bold\">.</span>remap(<span style=\"color: #BA2121\">&quot;SSR&quot;</span>, [i, j, k])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>reads(A[v_i, v_k], B[v_j, v_k])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>writes(T_matmul_NT[v_i, v_j])\n",
              "                <span style=\"color: #008000; font-weight: bold\">with</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>init():\n",
              "                    T_matmul_NT[v_i, v_j] <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>float32(<span style=\"color: #008000\">0</span>)\n",
              "                T_matmul_NT[v_i, v_j] <span style=\"color: #AA22FF; font-weight: bold\">=</span> (\n",
              "                    T_matmul_NT[v_i, v_j] <span style=\"color: #AA22FF; font-weight: bold\">+</span> A[v_i, v_k] <span style=\"color: #AA22FF; font-weight: bold\">*</span> B[v_j, v_k]\n",
              "                )\n",
              "\n",
              "    <span style=\"color: #AA22FF\">@T</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>prim_func\n",
              "    <span style=\"color: #008000; font-weight: bold\">def</span> <span style=\"color: #0000FF\">dense1</span>(\n",
              "        A: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        B: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">10</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        T_matmul_NT: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">10</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "    ):\n",
              "        T<span style=\"color: #AA22FF; font-weight: bold\">.</span>func_attr({<span style=\"color: #BA2121\">&quot;layout_free_buffers&quot;</span>: [<span style=\"color: #008000\">1</span>], <span style=\"color: #BA2121\">&quot;tir.noalias&quot;</span>: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>bool(<span style=\"color: #008000; font-weight: bold\">True</span>)})\n",
              "        <span style=\"color: #007979; font-style: italic\"># with T.block(&quot;root&quot;):</span>\n",
              "        <span style=\"color: #008000; font-weight: bold\">for</span> i, j, k <span style=\"color: #008000; font-weight: bold\">in</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>grid(T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">10</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)):\n",
              "            <span style=\"color: #008000; font-weight: bold\">with</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>block(<span style=\"color: #BA2121\">&quot;T_matmul_NT&quot;</span>):\n",
              "                v_i, v_j, v_k <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>axis<span style=\"color: #AA22FF; font-weight: bold\">.</span>remap(<span style=\"color: #BA2121\">&quot;SSR&quot;</span>, [i, j, k])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>reads(A[v_i, v_k], B[v_j, v_k])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>writes(T_matmul_NT[v_i, v_j])\n",
              "                <span style=\"color: #008000; font-weight: bold\">with</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>init():\n",
              "                    T_matmul_NT[v_i, v_j] <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>float32(<span style=\"color: #008000\">0</span>)\n",
              "                T_matmul_NT[v_i, v_j] <span style=\"color: #AA22FF; font-weight: bold\">=</span> (\n",
              "                    T_matmul_NT[v_i, v_j] <span style=\"color: #AA22FF; font-weight: bold\">+</span> A[v_i, v_k] <span style=\"color: #AA22FF; font-weight: bold\">*</span> B[v_j, v_k]\n",
              "                )\n",
              "\n",
              "    <span style=\"color: #AA22FF\">@T</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>prim_func\n",
              "    <span style=\"color: #008000; font-weight: bold\">def</span> <span style=\"color: #0000FF\">te_relu</span>(\n",
              "        A: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "        relu: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>Buffer((T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)), <span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "    ):\n",
              "        T<span style=\"color: #AA22FF; font-weight: bold\">.</span>func_attr({<span style=\"color: #BA2121\">&quot;tir.noalias&quot;</span>: T<span style=\"color: #AA22FF; font-weight: bold\">.</span>bool(<span style=\"color: #008000; font-weight: bold\">True</span>)})\n",
              "        <span style=\"color: #007979; font-style: italic\"># with T.block(&quot;root&quot;):</span>\n",
              "        <span style=\"color: #008000; font-weight: bold\">for</span> i0, i1 <span style=\"color: #008000; font-weight: bold\">in</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>grid(T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">1</span>), T<span style=\"color: #AA22FF; font-weight: bold\">.</span>int64(<span style=\"color: #008000\">128</span>)):\n",
              "            <span style=\"color: #008000; font-weight: bold\">with</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>block(<span style=\"color: #BA2121\">&quot;relu&quot;</span>):\n",
              "                v_i0, v_i1 <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>axis<span style=\"color: #AA22FF; font-weight: bold\">.</span>remap(<span style=\"color: #BA2121\">&quot;SS&quot;</span>, [i0, i1])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>reads(A[v_i0, v_i1])\n",
              "                T<span style=\"color: #AA22FF; font-weight: bold\">.</span>writes(relu[v_i0, v_i1])\n",
              "                relu[v_i0, v_i1] <span style=\"color: #AA22FF; font-weight: bold\">=</span> T<span style=\"color: #AA22FF; font-weight: bold\">.</span>max(A[v_i0, v_i1], T<span style=\"color: #AA22FF; font-weight: bold\">.</span>float32(<span style=\"color: #008000\">0</span>))\n",
              "\n",
              "    <span style=\"color: #AA22FF\">@R</span><span style=\"color: #AA22FF; font-weight: bold\">.</span>function\n",
              "    <span style=\"color: #008000; font-weight: bold\">def</span> <span style=\"color: #0000FF\">main</span>(\n",
              "        x: R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">1</span>, <span style=\"color: #008000\">784</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>)\n",
              "    ) <span style=\"color: #AA22FF; font-weight: bold\">-&gt;</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">1</span>, <span style=\"color: #008000\">10</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>):\n",
              "        cls <span style=\"color: #AA22FF; font-weight: bold\">=</span> Module\n",
              "        <span style=\"color: #008000; font-weight: bold\">with</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>dataflow():\n",
              "            lv <span style=\"color: #AA22FF; font-weight: bold\">=</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>call_tir(\n",
              "                cls<span style=\"color: #AA22FF; font-weight: bold\">.</span>dense,\n",
              "                (x, metadata[<span style=\"color: #BA2121\">&quot;relax.expr.Constant&quot;</span>][<span style=\"color: #008000\">0</span>]),\n",
              "                out_sinfo<span style=\"color: #AA22FF; font-weight: bold\">=</span>R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">1</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "            )\n",
              "            lv1 <span style=\"color: #AA22FF; font-weight: bold\">=</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>call_tir(\n",
              "                cls<span style=\"color: #AA22FF; font-weight: bold\">.</span>add,\n",
              "                (lv, metadata[<span style=\"color: #BA2121\">&quot;relax.expr.Constant&quot;</span>][<span style=\"color: #008000\">1</span>]),\n",
              "                out_sinfo<span style=\"color: #AA22FF; font-weight: bold\">=</span>R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">1</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "            )\n",
              "            lv2 <span style=\"color: #AA22FF; font-weight: bold\">=</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>call_tir(\n",
              "                cls<span style=\"color: #AA22FF; font-weight: bold\">.</span>te_relu, (lv1,), out_sinfo<span style=\"color: #AA22FF; font-weight: bold\">=</span>R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">1</span>, <span style=\"color: #008000\">128</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>)\n",
              "            )\n",
              "            lv3 <span style=\"color: #AA22FF; font-weight: bold\">=</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>call_tir(\n",
              "                cls<span style=\"color: #AA22FF; font-weight: bold\">.</span>dense1,\n",
              "                (lv2, metadata[<span style=\"color: #BA2121\">&quot;relax.expr.Constant&quot;</span>][<span style=\"color: #008000\">2</span>]),\n",
              "                out_sinfo<span style=\"color: #AA22FF; font-weight: bold\">=</span>R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">1</span>, <span style=\"color: #008000\">10</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "            )\n",
              "            lv4 <span style=\"color: #AA22FF; font-weight: bold\">=</span> R<span style=\"color: #AA22FF; font-weight: bold\">.</span>call_tir(\n",
              "                cls<span style=\"color: #AA22FF; font-weight: bold\">.</span>add1,\n",
              "                (lv3, metadata[<span style=\"color: #BA2121\">&quot;relax.expr.Constant&quot;</span>][<span style=\"color: #008000\">3</span>]),\n",
              "                out_sinfo<span style=\"color: #AA22FF; font-weight: bold\">=</span>R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">1</span>, <span style=\"color: #008000\">10</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>),\n",
              "            )\n",
              "            gv: R<span style=\"color: #AA22FF; font-weight: bold\">.</span>Tensor((<span style=\"color: #008000\">1</span>, <span style=\"color: #008000\">10</span>), dtype<span style=\"color: #AA22FF; font-weight: bold\">=</span><span style=\"color: #BA2121\">&quot;float32&quot;</span>) <span style=\"color: #AA22FF; font-weight: bold\">=</span> lv4\n",
              "            R<span style=\"color: #AA22FF; font-weight: bold\">.</span>output(gv)\n",
              "        <span style=\"color: #008000; font-weight: bold\">return</span> lv4\n",
              "\n",
              "\n",
              "<span style=\"color: #007979; font-style: italic\"># Metadata omitted. Use show_meta=True in script() method to show it.</span>\n",
              "</pre></div>\n"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from tvm import topi\n",
        "\n",
        "def map_nn_linear(bb, node_map, node, nn_mod):\n",
        "    x = node_map[node.args[0]]\n",
        "    w = map_param(nn_mod.weight)\n",
        "    if nn_mod.bias is not None:\n",
        "        b = map_param(nn_mod.bias)\n",
        "    y = bb.emit_te(topi.nn.dense, x, w)\n",
        "    return bb.emit_te(topi.add, y, b)\n",
        "\n",
        "def map_nn_relu(bb, node_map, node, nn_mod):\n",
        "    return map_relu(bb, node_map, node)\n",
        "\n",
        "\n",
        "MLPModule = from_fx(\n",
        "    fx.symbolic_trace(mlp_model), \n",
        "    input_shapes = [(1, 784)], \n",
        "    call_function_map={\n",
        "    },\n",
        "    call_module_map={\n",
        "        torch.nn.Linear: map_nn_linear,\n",
        "        torch.nn.ReLU: map_nn_relu,\n",
        "    },\n",
        ")\n",
        "\n",
        "MLPModule.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WAg9RZV2lbbK",
        "outputId": "476cd64c-6dca-4e3f-e9da-94cf81eb02be"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "MLPModule Prediction: Trouser\n"
          ]
        }
      ],
      "source": [
        "ex = relax.build(MLPModule, target=\"llvm\")\n",
        "vm = relax.VirtualMachine(ex, tvm.cpu())\n",
        "data_nd = tvm.nd.array(img.reshape(1, 784))\n",
        "\n",
        "nd_res = vm[\"main\"](data_nd)\n",
        "\n",
        "pred_kind = np.argmax(nd_res.numpy(), axis=1)\n",
        "print(\"MLPModule Prediction:\", class_names[pred_kind[0]])"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "3BSOnEbUgu60"
      },
      "source": [
        "## Remark: Translating into High-level Operators\n",
        "\n",
        "In most machine learning frameworks, it is sometimes helpful to first translate into high-level built-in primitive operators. The following code block gives an example to do that.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YOo0H-5mhOGl",
        "outputId": "e3bca65f-6504-41c2-b41a-4120bf4e5ab9"
      },
      "outputs": [
        {
          "ename": "AttributeError",
          "evalue": "module 'tvm.relax.op' has no attribute 'dense'",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "Cell \u001b[0;32mIn[27], line 13\u001b[0m\n\u001b[1;32m     10\u001b[0m     y \u001b[39m=\u001b[39m bb\u001b[39m.\u001b[39memit(relax\u001b[39m.\u001b[39mop\u001b[39m.\u001b[39mdense(x, w))\n\u001b[1;32m     11\u001b[0m     \u001b[39mreturn\u001b[39;00m bb\u001b[39m.\u001b[39memit(relax\u001b[39m.\u001b[39mop\u001b[39m.\u001b[39madd(y, b))\n\u001b[0;32m---> 13\u001b[0m MLPModuleHighLevel \u001b[39m=\u001b[39m from_fx(\n\u001b[1;32m     14\u001b[0m     fx\u001b[39m.\u001b[39;49msymbolic_trace(mlp_model), \n\u001b[1;32m     15\u001b[0m     input_shapes \u001b[39m=\u001b[39;49m [(\u001b[39m1\u001b[39;49m, \u001b[39m784\u001b[39;49m)], \n\u001b[1;32m     16\u001b[0m     call_function_map\u001b[39m=\u001b[39;49m{\n\u001b[1;32m     17\u001b[0m     },\n\u001b[1;32m     18\u001b[0m     call_module_map\u001b[39m=\u001b[39;49m{\n\u001b[1;32m     19\u001b[0m         torch\u001b[39m.\u001b[39;49mnn\u001b[39m.\u001b[39;49mLinear: map_nn_linear_op,\n\u001b[1;32m     20\u001b[0m         torch\u001b[39m.\u001b[39;49mnn\u001b[39m.\u001b[39;49mReLU: map_nn_relu_op,\n\u001b[1;32m     21\u001b[0m     },\n\u001b[1;32m     22\u001b[0m )\n\u001b[1;32m     24\u001b[0m MLPModuleHighLevel\u001b[39m.\u001b[39mshow()\n",
            "Cell \u001b[0;32mIn[15], line 45\u001b[0m, in \u001b[0;36mfrom_fx\u001b[0;34m(fx_mod, input_shapes, call_function_map, call_module_map)\u001b[0m\n\u001b[1;32m     43\u001b[0m \u001b[39melif\u001b[39;00m node\u001b[39m.\u001b[39mop \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mcall_module\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[1;32m     44\u001b[0m     named_module \u001b[39m=\u001b[39m named_modules[node\u001b[39m.\u001b[39mtarget]\n\u001b[0;32m---> 45\u001b[0m     node_map[node] \u001b[39m=\u001b[39m call_module_map[\u001b[39mtype\u001b[39;49m(named_module)](bb, node_map, node, named_module)\n\u001b[1;32m     46\u001b[0m \u001b[39melif\u001b[39;00m node\u001b[39m.\u001b[39mop \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39moutput\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[1;32m     47\u001b[0m     output \u001b[39m=\u001b[39m node_map[node\u001b[39m.\u001b[39margs[\u001b[39m0\u001b[39m]]\n",
            "Cell \u001b[0;32mIn[27], line 10\u001b[0m, in \u001b[0;36mmap_nn_linear_op\u001b[0;34m(bb, node_map, node, nn_mod)\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[39mif\u001b[39;00m nn_mod\u001b[39m.\u001b[39mbias \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m      9\u001b[0m     b \u001b[39m=\u001b[39m map_param(nn_mod\u001b[39m.\u001b[39mbias)\n\u001b[0;32m---> 10\u001b[0m y \u001b[39m=\u001b[39m bb\u001b[39m.\u001b[39memit(relax\u001b[39m.\u001b[39;49mop\u001b[39m.\u001b[39;49mdense(x, w))\n\u001b[1;32m     11\u001b[0m \u001b[39mreturn\u001b[39;00m bb\u001b[39m.\u001b[39memit(relax\u001b[39m.\u001b[39mop\u001b[39m.\u001b[39madd(y, b))\n",
            "\u001b[0;31mAttributeError\u001b[0m: module 'tvm.relax.op' has no attribute 'dense'"
          ]
        }
      ],
      "source": [
        "def map_nn_relu_op(bb, node_map, node, nn_mod):\n",
        "    A = node_map[node.args[0]]\n",
        "    return bb.emit(relax.op.relu(A))\n",
        "\n",
        "def map_nn_linear_op(bb, node_map, node, nn_mod):\n",
        "    x = node_map[node.args[0]]\n",
        "    w = map_param(nn_mod.weight)\n",
        "    if nn_mod.bias is not None:\n",
        "        b = map_param(nn_mod.bias)\n",
        "    y = bb.emit(relax.op.dense(x, w))\n",
        "    return bb.emit(relax.op.add(y, b))\n",
        "\n",
        "MLPModuleHighLevel = from_fx(\n",
        "    fx.symbolic_trace(mlp_model), \n",
        "    input_shapes = [(1, 784)], \n",
        "    call_function_map={\n",
        "    },\n",
        "    call_module_map={\n",
        "        torch.nn.Linear: map_nn_linear_op,\n",
        "        torch.nn.ReLU: map_nn_relu_op,\n",
        "    },\n",
        ")\n",
        "\n",
        "MLPModuleHighLevel.show()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "eQvtGR0rqci1"
      },
      "source": [
        "After we get the model into IRModule with those built-in operator calls.\n",
        "These built-in operators are **higher-level abstraction** than the TensorIR functions. There can be different opportunities to further translate these primitive operators into either library or TensorIR functions.\n",
        "\n",
        "In most cases, it can be helpful to translate into high-level builtins when they are available. However, there are many cases where we cannot find the corresponding high-level built-in or when we want to specify the TensorIR function directly. In those cases, we can customize the translation logic or transformation to generate `call_tir` or call into the library functions. Usually, we can get the best result by combining the high-level op, TensorIR, and library abstractions. We will discuss the tradeoffs in the follow-up lectures."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "pZGWq5EjJ0BA"
      },
      "source": [
        "## Summary\n",
        "\n",
        "- Tensor expression API allows us to create a primitive TensorIR function.\n",
        "- BlockBuilder API creates IRModule through `emit_te` and other functions.\n",
        "- Integrate with existing machine learning frameworks by transforming models into an IRModule."
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "include_colab_link": true,
      "name": "6 Integration with Machine Learning Frameworks.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.16"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}