onnx/onnx.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating ONNX models from scratch\n",
    "\n",
    "[Open Neural Network Exchange (ONNX)](https://onnx.ai/) is an open format created to share neural networks created by different deep learning (DL) frameworks. It defines a set of operators (Add, MatMul, Conv, etc.), a standard file format to exchange the model ([protobuf](https://github.com/protocolbuffers/protobuf) is used), and a runtime to make inferences. Even accelerators are available using [execution providers](https://onnxruntime.ai/docs/execution-providers/) like CUDA, OpenVINO, CoreML, etc, for the runtime.\n",
    "\n",
    "With ONNX, we can train a model using Tensorflow, convert the trained model to ONNX, and use it from any programming language where the ONNX runtime is available.\n",
    "\n",
    "This notebook will show how to create a model from scratch. Usually, we use a [converter](https://onnx.ai/onnx/intro/converters.html) to translate from a DL framework, but I won't use any.\n",
    "The idea is to show how it works. We will create a model to calculate the following equation:\n",
    "\n",
    "**_Y = (X * A) + (T * A) + B_**\n",
    "\n",
    "\n",
    "First, we must install the package with the following command and then import some modules.\n",
    "\n",
    "_NOTE: this notebook content is based on the official ONNX documentation._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install onnx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from onnx import TensorProto, numpy_helper\n",
    "from onnx.checker import check_model\n",
    "from onnx.helper import make_model, make_node, make_graph, make_tensor_value_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An ONNX model is composed of:\n",
    "\n",
    "1. a set of input Tensors.\n",
    "2. a set of output Tensors.\n",
    "3. a set of nodes, where each node is of a type and represents an action to be taken (Add, MatMul, Conv, etc).\n",
    "4. connections between the nodes.\n",
    "5. initialized variables created during the training process.\n",
    "\n",
    "From data structures, we call it a [**directed acyclic graph (DAG)**](https://en.wikipedia.org/wiki/Directed_acyclic_graph).\n",
    "\n",
    "A Tensor has a **type** and a **shape**. The **type** defines the ranges of values allowed for all elements in the Tensor (FLOAT32, FLOAT64, etc.), and the **shape** defines how many dimensions the Tensor has and the number of elements at each dimension.\n",
    "\n",
    "The code below defines five Tensors. The type of them is **FLOAT**, and the shape has two dimensions with two elements at each."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = make_tensor_value_info('A', TensorProto.FLOAT, [2, 2])\n",
    "B = make_tensor_value_info('B', TensorProto.FLOAT, [2, 2])\n",
    "T = make_tensor_value_info('T', TensorProto.FLOAT, [2, 2])\n",
    "X = make_tensor_value_info('X', TensorProto.FLOAT, [2, 2])\n",
    "Y = make_tensor_value_info('Y', TensorProto.FLOAT, [2, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's define the nodes. The code below does that, and in this case, we are creating two nodes to execute a matrix multiplication (one node for X * A and another for T * A). \n",
    "The result of both nodes will be added together, and the result will be added to B, generating Y.\n",
    "\n",
    "As already said, ONNX provides several different operators for the common operations in DL. You can find the list of operators [here](https://onnx.ai/onnx/operators/).\n",
    "At each new version, ONNX adds more operators, and the supported operators are represented by an operator set id, called **opset**. So, if you have a model where the opset is 19, the ONNX runtime must support at least this version to execute the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create multiXA and multiTA nodes, which will multiply X and A, and T and A . The results will be stored in XA and TA.\n",
    "multiXA = make_node('MatMul', ['X', 'A'], ['XA'])\n",
    "multiTA = make_node('MatMul', ['T', 'A'], ['TA'])\n",
    "\n",
    "# Create addXATA and addXATAB, which will add XA (the previous result) and B. The result will be stored in Y.\n",
    "addXATA  = make_node('Add', ['XA', 'TA'], ['XATA'])\n",
    "addXATAB = make_node('Add', ['XATA', 'B'], ['Y'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final component is the graph where the nodes, inputs and outputs are connected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "graph = make_graph(\n",
    "    [multiXA, multiTA, addXATA, addXATAB],                  # nodes\n",
    "    'sample equation',                                      # name\n",
    "    [X, T, A, B],                                           # inputs\n",
    "    [Y, A],                                                 # outputs\n",
    "    doc_string = 'calculate Y = (X * A) + (T * A) + B'      # docstring\n",
    ")  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the ONNX model, check its consistency, and print its architecture. An intermediate representation (IR) is created for the model with all the details. This is the model representation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ir_version: 9\n",
      "producer_name: \"glzbcrt\"\n",
      "producer_version: \"2.3\"\n",
      "model_version: 4\n",
      "graph {\n",
      "  node {\n",
      "    input: \"X\"\n",
      "    input: \"A\"\n",
      "    output: \"XA\"\n",
      "    op_type: \"MatMul\"\n",
      "  }\n",
      "  node {\n",
      "    input: \"T\"\n",
      "    input: \"A\"\n",
      "    output: \"TA\"\n",
      "    op_type: \"MatMul\"\n",
      "  }\n",
      "  node {\n",
      "    input: \"XA\"\n",
      "    input: \"TA\"\n",
      "    output: \"XATA\"\n",
      "    op_type: \"Add\"\n",
      "  }\n",
      "  node {\n",
      "    input: \"XATA\"\n",
      "    input: \"B\"\n",
      "    output: \"Y\"\n",
      "    op_type: \"Add\"\n",
      "  }\n",
      "  name: \"sample equation\"\n",
      "  doc_string: \"calculate Y = (X * A) + (T * A) + B\"\n",
      "  input {\n",
      "    name: \"X\"\n",
      "    type {\n",
      "      tensor_type {\n",
      "        elem_type: 1\n",
      "        shape {\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "        }\n",
      "      }\n",
      "    }\n",
      "  }\n",
      "  input {\n",
      "    name: \"T\"\n",
      "    type {\n",
      "      tensor_type {\n",
      "        elem_type: 1\n",
      "        shape {\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "        }\n",
      "      }\n",
      "    }\n",
      "  }\n",
      "  input {\n",
      "    name: \"A\"\n",
      "    type {\n",
      "      tensor_type {\n",
      "        elem_type: 1\n",
      "        shape {\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "        }\n",
      "      }\n",
      "    }\n",
      "  }\n",
      "  input {\n",
      "    name: \"B\"\n",
      "    type {\n",
      "      tensor_type {\n",
      "        elem_type: 1\n",
      "        shape {\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "        }\n",
      "      }\n",
      "    }\n",
      "  }\n",
      "  output {\n",
      "    name: \"Y\"\n",
      "    type {\n",
      "      tensor_type {\n",
      "        elem_type: 1\n",
      "        shape {\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "        }\n",
      "      }\n",
      "    }\n",
      "  }\n",
      "  output {\n",
      "    name: \"A\"\n",
      "    type {\n",
      "      tensor_type {\n",
      "        elem_type: 1\n",
      "        shape {\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "        }\n",
      "      }\n",
      "    }\n",
      "  }\n",
      "}\n",
      "opset_import {\n",
      "  version: 19\n",
      "}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "onnx_model = make_model(graph)\n",
    "\n",
    "onnx_model.model_version = 4\n",
    "onnx_model.producer_name  = \"glzbcrt\"\n",
    "onnx_model.producer_version = \"2.3\"\n",
    "\n",
    "check_model(onnx_model)\n",
    "print(onnx_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save the model as **model.onnx**, and load it on [Netron](https://netron.app/) to visualize."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"model.onnx\", \"wb\") as f:\n",
    "    f.write(onnx_model.SerializeToString())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The screenshot below shows the model we created. As you can see, the inputs, outputs, nodes, and connections are all listed.\n",
    "We can also see that a model can have any number of inputs and outputs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"align: center\" src=\"data:image/png;base64,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\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, the model we created does not contain any data learned during the training process. It will only execute the nodes and expect all the parameters (A, B, X, and T) to be provided externally.\n",
    "However, when we train a model using an optimizer algorithm, a loss algorithm, and lots of data, we will find the best values for these parameters, in this case, A, B, X, and T.\n",
    "\n",
    "To have a fully working mode,l we need to copy this \"knowledge\" to the model. Let's do it!\n",
    "\n",
    "We are using the same model we previously created, but in this version, the tensors A and B will have their values inside the model.\n",
    "Only the inputs T and X will need to be provided externally.\n",
    "\n",
    "In this case, we are converting two numpy arrays (A and B) as ONNX tensors. These two arrays have two dimensions with two values.\n",
    "Note that the values will be contained inside the **raw_data** property in the intermediate representation. It is up to the ONNX runtime to extract this data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ir_version: 9\n",
      "producer_name: \"glzbcrt\"\n",
      "producer_version: \"2.3\"\n",
      "model_version: 4\n",
      "graph {\n",
      "  node {\n",
      "    input: \"X\"\n",
      "    input: \"A\"\n",
      "    output: \"XA\"\n",
      "    op_type: \"MatMul\"\n",
      "  }\n",
      "  node {\n",
      "    input: \"T\"\n",
      "    input: \"A\"\n",
      "    output: \"TA\"\n",
      "    op_type: \"MatMul\"\n",
      "  }\n",
      "  node {\n",
      "    input: \"XA\"\n",
      "    input: \"TA\"\n",
      "    output: \"XATA\"\n",
      "    op_type: \"Add\"\n",
      "  }\n",
      "  node {\n",
      "    input: \"XATA\"\n",
      "    input: \"B\"\n",
      "    output: \"Y\"\n",
      "    op_type: \"Add\"\n",
      "  }\n",
      "  name: \"sample equation\"\n",
      "  initializer {\n",
      "    dims: 2\n",
      "    dims: 2\n",
      "    data_type: 1\n",
      "    name: \"A\"\n",
      "    raw_data: \"\\000\\000@@\\000\\000\\240@\\000\\000\\200?\\000\\000\\000@\"\n",
      "  }\n",
      "  initializer {\n",
      "    dims: 2\n",
      "    dims: 2\n",
      "    data_type: 1\n",
      "    name: \"B\"\n",
      "    raw_data: \"\\000\\000\\200@\\000\\000\\300@\\000\\000\\340@\\000\\000\\000A\"\n",
      "  }\n",
      "  doc_string: \"calculate Y = (X * A) + (T * A) + B\"\n",
      "  input {\n",
      "    name: \"X\"\n",
      "    type {\n",
      "      tensor_type {\n",
      "        elem_type: 1\n",
      "        shape {\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "        }\n",
      "      }\n",
      "    }\n",
      "  }\n",
      "  input {\n",
      "    name: \"T\"\n",
      "    type {\n",
      "      tensor_type {\n",
      "        elem_type: 1\n",
      "        shape {\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "        }\n",
      "      }\n",
      "    }\n",
      "  }\n",
      "  output {\n",
      "    name: \"Y\"\n",
      "    type {\n",
      "      tensor_type {\n",
      "        elem_type: 1\n",
      "        shape {\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "          dim {\n",
      "            dim_value: 2\n",
      "          }\n",
      "        }\n",
      "      }\n",
      "    }\n",
      "  }\n",
      "}\n",
      "opset_import {\n",
      "  version: 19\n",
      "}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "A = numpy_helper.from_array(\n",
    "    np.array([\n",
    "        [3.0, 5.0],\n",
    "        [1.0, 2.0],\n",
    "    ], dtype=np.float32), \n",
    "    name='A'\n",
    ")\n",
    "\n",
    "B = numpy_helper.from_array(\n",
    "    np.array([\n",
    "        [4.0, 6.0],\n",
    "        [7.0, 8.0],\n",
    "    ], dtype=np.float32), \n",
    "    name='B'\n",
    ")\n",
    "\n",
    "T = make_tensor_value_info('T', TensorProto.FLOAT, [2, 2])\n",
    "X = make_tensor_value_info('X', TensorProto.FLOAT, [2, 2])\n",
    "Y = make_tensor_value_info('Y', TensorProto.FLOAT, [2, 2])\n",
    "\n",
    "# Create multiXA and multiTA nodes, which will multiply X and A, and T and A . The results will be stored in XA and TA.\n",
    "multiXA = make_node('MatMul', ['X', 'A'], ['XA'])\n",
    "multiTA = make_node('MatMul', ['T', 'A'], ['TA'])\n",
    "\n",
    "# Create addXATA and addXATAB, which will add XA (the previous result) and B. The result will be stored in Y.\n",
    "addXATA  = make_node('Add', ['XA', 'TA'], ['XATA'])\n",
    "addXATAB = make_node('Add', ['XATA', 'B'], ['Y'])\n",
    "\n",
    "node1 = make_node('MatMul', ['X', 'A'], ['AX'])\n",
    "node2 = make_node('Add', ['AX', 'B'], ['Y'])\n",
    "\n",
    "graph = make_graph(\n",
    "    [multiXA, multiTA, addXATA, addXATAB],                  # nodes\n",
    "    'sample equation',                                      # name\n",
    "    [X, T],                                                 # inputs\n",
    "    [Y],                                                    # outputs\n",
    "    [A, B],                                                 # initializers\n",
    "    doc_string = 'calculate Y = (X * A) + (T * A) + B'      # docstring\n",
    ")    \n",
    "\n",
    "onnx_model = make_model(graph)\n",
    "\n",
    "onnx_model.model_version = 4\n",
    "onnx_model.producer_name  = \"glzbcrt\"\n",
    "onnx_model.producer_version = \"2.3\"\n",
    "\n",
    "check_model(onnx_model)\n",
    "print(onnx_model)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save the model again. Open it on Netron and view the model structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"model_initializers.onnx\", \"wb\") as f:\n",
    "    f.write(onnx_model.SerializeToString())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that two inputs have been converted to have their values stored inside the model, we do not need them externally, the general architecture of the model changed a little bit.\n",
    "The image below shows the new architecture and the values for the B tensor inside the model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"data:image/png;base64,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\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An ONNX converter, like [tensorflow-onnx](https://github.com/onnx/tensorflow-onnx), will take a model and, using this API shown here, convert it to an ONNX model. This ONNX model can then be used by any language with an ONNX runtime available to make inferences.\n",
    "\n",
    "The advantage is that we can use any framework (Tensorflow, PyTorch, MXNet, etc) to create, train a model, and then use a totally different programming language to make inferences.\n",
    "\n",
    "**Hope you enjoyed this notebook!** 😀\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "vision-q1p-sRqt",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}