Add files via upload

onnx_models/torch_to_onnx.ipynb

@@ -0,0 +1,272 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "Copy of torch_to_onnx.ipynb",
+      "provenance": [],
+      "collapsed_sections": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xAk44VAUMcI4"
+      },
+      "source": [
+        "### The goal is to export  the DevoLearn nucleus segmentation model to ONNX and run inference using ONNX runtime.\n",
+        "\n",
+        "Link to tutorial - https://pytorch.org/tutorials/advanced/super_resolution_with_onnxruntime.html"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "1cvIRtSg1xPj"
+      },
+      "source": [
+        "!pip install segmentation-models-pytorch\n",
+        "!pip install onnx\n",
+        "!git clone https://github.com/DevoLearn/devolearn.git\n",
+        "!pip install onnxruntime"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "P9r-q1crDZ74"
+      },
+      "source": [
+        "### Import Libraries:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "bo1ngsVb1mhk"
+      },
+      "source": [
+        "import torch\n",
+        "import segmentation_models_pytorch as smp\n",
+        "import torch.onnx\n",
+        "import numpy as np\n",
+        "import onnx\n",
+        "import onnxruntime as ort\n",
+        "\n",
+        "import cv2\n",
+        "import matplotlib.pyplot as plt\n",
+        "from PIL import Image"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "plqmhQ3IDfIg"
+      },
+      "source": [
+        "### Load model:\n",
+        "`model.eval()` sets model to inference mode -\n",
+        "* Normalization layers use running stats.\n",
+        "* deactivate dropout layers"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Ah3kvIEh1fT4"
+      },
+      "source": [
+        "model = torch.load('/content/devolearn/devolearn/cell_nucleus_segmentor/cell_nucleus_segmentation_model.pth', map_location='cpu')\n",
+        "model.eval()"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ahpQaPJkELZi"
+      },
+      "source": [
+        "### Define sample input `x` :\n",
+        "* The values in this can be random as long as it is the right type and size.\n",
+        "* In this case, `x` is a tensor, that corresponds to a batch of one single channel, 256x256 image.\n",
+        "* Make sure `out` is valid."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "v6aHqHs21vSK",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "4b0e31ec-daa2-465b-cb9b-295ff168f904"
+      },
+      "source": [
+        "x = torch.randn(1, 1, 256, 256, requires_grad=False)\n",
+        "out=model(x)"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "/usr/local/lib/python3.7/dist-packages/torch/nn/functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at  /pytorch/c10/core/TensorImpl.h:1156.)\n",
+            "  return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)\n"
+          ],
+          "name": "stderr"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "J5adRnBxFvr9"
+      },
+      "source": [
+        "### Export model:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "Cgn1VgKi30dT",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "4d19e8dc-5344-4c43-8071-ec13c8d665d2"
+      },
+      "source": [
+        "torch.onnx.export(model,                     # model being run\n",
+        "                  x,                         # model input (or a tuple for multiple inputs)\n",
+        "                  \"nucleus_segmentor.onnx\", # where to save the model (can be a file or file-like object)\n",
+        "                  export_params=True,        # store the trained parameter weights inside the model file\n",
+        "                  opset_version=11,          # the ONNX version to export the model to\n",
+        "                  do_constant_folding=True,  # whether to execute constant folding for optimization\n",
+        "                  input_names = ['input'],   # the model's input names\n",
+        "                  output_names = ['output'], # the model's output names\n",
+        "                  dynamic_axes={'input' : {0 : 'batch_size'},    # variable length axes\n",
+        "                                'output' : {0 : 'batch_size'}})"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "/usr/local/lib/python3.7/dist-packages/torch/_tensor.py:575: UserWarning: floor_divide is deprecated, and will be removed in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values.\n",
+            "To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor'). (Triggered internally at  /pytorch/aten/src/ATen/native/BinaryOps.cpp:467.)\n",
+            "  return torch.floor_divide(self, other)\n"
+          ],
+          "name": "stderr"
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "RYPqPCKhGRzJ"
+      },
+      "source": [
+        "### Define `expand_dims_twice`:\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "vfHgRLatcbY3"
+      },
+      "source": [
+        "def expand_dims_twice(arr):\n",
+        "    norm=(arr-np.min(arr))/(np.max(arr)-np.min(arr)) #normalize\n",
+        "    ret = np.expand_dims(np.expand_dims(norm, axis=0), axis=0)\n",
+        "    return(ret)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "mOY7WkrEI7xi"
+      },
+      "source": [
+        "### Run inference from ONNX file:\n",
+        "The output image below the following cell is inferred from the ONNX model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "dfAoZNQk4l9r",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 305
+        },
+        "outputId": "5f2a4e6c-bb8d-4862-8d7e-a51ec94a26a6"
+      },
+      "source": [
+        "ort_session = ort.InferenceSession('nucleus_segmentor.onnx')\n",
+        "\n",
+        "img = cv2.imread(\"/content/devolearn/devolearn/tests/sample_data/images/nucleus_seg_sample.png\",0)\n",
+        "resized = cv2.resize(img, (256,256),\n",
+        "               interpolation = cv2.INTER_NEAREST)\n",
+        "\n",
+        "print(\"dims before expand_dims_twice - \", resized.shape)\n",
+        "img_unsqueeze = expand_dims_twice(resized)\n",
+        "print(\"dims after expand_dims_twice - \", img_unsqueeze.shape)\n",
+        "\n",
+        "onnx_outputs = ort_session.run(None, {'input': img_unsqueeze.astype('float32')})\n",
+        "plt.imshow(onnx_outputs[0][0][0])\n",
+        "plt.show()"
+      ],
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "text": [
+            "dims before expand_dims_twice -  (256, 256)\n",
+            "dims after expand_dims_twice -  (1, 1, 256, 256)\n"
+          ],
+          "name": "stdout"
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "tags": [],
+            "needs_background": "light"
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "YtmfEX4oqbCT"
+      },
+      "source": [
+        ""
+      ],
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}