Add some pre-processing and post-processing logic into a pytorch exported classification model

resnet18_include_preprocessing_postprocessing-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import onnx\n",
    "from onnx import AttributeProto, TensorProto, GraphProto\n",
    "import onnxruntime as ort\n",
    "\n",
    "import torch\n",
    "from torch.nn import functional as F\n",
    "from torchvision import models, transforms\n",
    "\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = models.resnet18(pretrained=True).eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "resize_size, crop_size = 256, 224\n",
    "\n",
    "mean=(0.485, 0.456, 0.406)\n",
    "std=(0.229, 0.224, 0.225)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_transform = transforms.Compose([\n",
    "    transforms.Resize(resize_size),\n",
    "    transforms.CenterCrop(crop_size),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(mean=mean, std=std),\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "hp = Image.open(\"hp.jpg\")\n",
    "#hp "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Show the image in `<img>` tag to reduce notebook size)\n",
    "<img src=\"hp.jpg\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess(img_list):\n",
    "    return torch.stack([test_transform(img) for img in img_list], dim=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 3, 224, 224])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "preprocess([hp]).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2, 1000])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch = preprocess([hp, hp])\n",
    "with torch.no_grad():\n",
    "    output = model(batch)\n",
    "output.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-1.9975, -0.4985,  1.3288,  2.8488,  1.7981,  3.1103,  2.1969, -2.0555,\n",
       "         -5.8161, -4.3162],\n",
       "        [-1.9975, -0.4985,  1.3288,  2.8488,  1.7981,  3.1103,  2.1969, -2.0555,\n",
       "         -5.8161, -4.3162]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output[:, :10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.return_types.topk(\n",
       "values=tensor([[15.8525, 12.1561, 11.8588, 10.9440, 10.8897],\n",
       "        [15.8525, 12.1561, 11.8588, 10.9440, 10.8897]]),\n",
       "indices=tensor([[917, 611, 476, 889, 921],\n",
       "        [917, 611, 476, 889, 921]]))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output.topk(dim=1, k=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 917: 'comic book',\n",
    "* 611: 'jigsaw puzzle',"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[917],\n",
       "        [917]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output.topk(dim=1, k=1).indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def postprocess(output):\n",
    "    # If we just want what the black-box guy usually want (and only \"know\"), classidx and somewhat \"score\"\n",
    "    indices = output.topk(dim=1, k=1).indices[:, 0] # while `argsort` is more suit here, topk is used to match onnx interface.\n",
    "    probs = F.softmax(output, dim=1)\n",
    "    return indices, probs[torch.arange(len(indices)), indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([917, 917]), tensor([0.9401, 0.9401]))"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "postprocess(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://pytorch.org/tutorials/advanced/super_resolution_with_onnxruntime.html\n",
    "\n",
    "torch.onnx.export(\n",
    "    model,\n",
    "    batch,\n",
    "    \"resnet18.onnx\",\n",
    "    export_params=True,\n",
    "    opset_version=13,\n",
    "    do_constant_folding=True,\n",
    "    input_names = ['input'],\n",
    "    output_names = ['output'],\n",
    "    dynamic_axes={'input' : {0 : 'batch_size'},    # variable lenght axes\n",
    "                                'output' : {0 : 'batch_size'}}\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "ort_session = ort.InferenceSession(\"resnet18.onnx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_py = batch.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_ort = ort_session.run([\"output\"], {\"input\": batch_py})[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.9975376, -0.4984647,  1.3288195,  2.8488164,  1.7981076,\n",
       "         3.1102755,  2.1968808, -2.055551 , -5.8161283, -4.3161545],\n",
       "       [-1.9975376, -0.4984647,  1.3288195,  2.8488164,  1.7981076,\n",
       "         3.1102755,  2.1968808, -2.055551 , -5.8161283, -4.3161545]],\n",
       "      dtype=float32)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output_ort[:, :10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([917, 917]), tensor([0.9401, 0.9401]))"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "postprocess(torch.tensor(output_ort))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_onnx = onnx.load(\"resnet18.onnx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "name: \"input\"\n",
       "type {\n",
       "  tensor_type {\n",
       "    elem_type: 1\n",
       "    shape {\n",
       "      dim {\n",
       "        dim_param: \"batch_size\"\n",
       "      }\n",
       "      dim {\n",
       "        dim_value: 3\n",
       "      }\n",
       "      dim {\n",
       "        dim_value: 224\n",
       "      }\n",
       "      dim {\n",
       "        dim_value: 224\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_onnx.graph.input[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[name: \"output\"\n",
       "type {\n",
       "  tensor_type {\n",
       "    elem_type: 1\n",
       "    shape {\n",
       "      dim {\n",
       "        dim_param: \"batch_size\"\n",
       "      }\n",
       "      dim {\n",
       "        dim_value: 1000\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "}\n",
       "]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_onnx.graph.output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_onnx = onnx.load(\"resnet18.onnx\")\n",
    "\n",
    "onnx.checker.check_model(model_onnx)\n",
    "\n",
    "top1_node = onnx.helper.make_node(\n",
    "    'TopK',\n",
    "    [\"output\", \"k\"],\n",
    "    ['values', 'indices'],\n",
    ")\n",
    "model_onnx.graph.node.append(top1_node)\n",
    "\n",
    "top1_tensor = onnx.helper.make_tensor(\"k\", TensorProto.INT64, [1], [1])\n",
    "model_onnx.graph.initializer.append(top1_tensor)\n",
    "\n",
    "prob_node = onnx.helper.make_node(\n",
    "    \"Softmax\",\n",
    "    inputs=['output'],\n",
    "    outputs=['probs'],\n",
    ")\n",
    "model_onnx.graph.node.append(prob_node)\n",
    "\n",
    "\n",
    "top1_value_info = onnx.helper.make_tensor_value_info(\"indices\", TensorProto.INT64, shape=[\"batch_size\", 1])\n",
    "model_onnx.graph.output.append(top1_value_info)\n",
    "\n",
    "probs_value_info = onnx.helper.make_tensor_value_info(\"probs\", TensorProto.FLOAT, shape=[\"batch_size\", 1000])\n",
    "model_onnx.graph.output.append(probs_value_info)\n",
    "\n",
    "gather_prob_node = onnx.helper.make_node(\n",
    "    'GatherElements',\n",
    "    [\"probs\", \"indices\"],\n",
    "    ['probs_top1'],\n",
    "    axis=1\n",
    ")\n",
    "model_onnx.graph.node.append(gather_prob_node)\n",
    "\n",
    "gather_probs_value_info = onnx.helper.make_tensor_value_info(\"probs_top1\", TensorProto.FLOAT, shape=[\"batch_size\", 1])\n",
    "model_onnx.graph.output.append(gather_probs_value_info)\n",
    "\n",
    "model_onnx.graph.node.append(\n",
    "    onnx.helper.make_node(\n",
    "        'Squeeze',\n",
    "        [\"probs_top1\", \"squeeze_dim\"],\n",
    "        ['probs_top1_1'],\n",
    "    )\n",
    ")\n",
    "model_onnx.graph.output.append(\n",
    "    onnx.helper.make_tensor_value_info(\n",
    "        \"probs_top1_1\",\n",
    "        TensorProto.FLOAT, \n",
    "        shape=[\"batch_size\"]\n",
    "    )\n",
    ")\n",
    "\n",
    "model_onnx.graph.node.append(\n",
    "    onnx.helper.make_node(\n",
    "        'Squeeze',\n",
    "        [\"indices\", \"squeeze_dim\"],\n",
    "        ['indices_1'],\n",
    "    )\n",
    ")\n",
    "model_onnx.graph.output.append(\n",
    "    onnx.helper.make_tensor_value_info(\n",
    "        \"indices_1\",\n",
    "        TensorProto.INT64, \n",
    "        shape=[\"batch_size\"]\n",
    "    )\n",
    ")\n",
    "\n",
    "model_onnx.graph.initializer.append(\n",
    "    onnx.helper.make_tensor(\n",
    "        \"squeeze_dim\", \n",
    "        TensorProto.INT64, \n",
    "        [1], \n",
    "        [1]\n",
    "    )\n",
    ")\n",
    "\n",
    "\n",
    "\n",
    "onnx.checker.check_model(model_onnx)\n",
    "onnx.checker.check_model(model_onnx, full_check=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "onnx.save(model_onnx, \"resnet18_rich_output.onnx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "ort_session_rich = ort.InferenceSession(\"resnet18_rich_output.onnx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_ort_rich = ort_session_rich.run(None, {\"input\": batch_py})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[-1.9975376 , -0.4984647 ,  1.3288195 , ..., -0.06410396,\n",
       "         -3.5900416 ,  0.20868209],\n",
       "        [-1.9975376 , -0.4984647 ,  1.3288195 , ..., -0.06410396,\n",
       "         -3.5900416 ,  0.20868209]], dtype=float32),\n",
       " array([[917],\n",
       "        [917]], dtype=int64),\n",
       " array([[1.66338516e-08, 7.44786774e-08, 4.63032251e-07, ...,\n",
       "         1.14993234e-07, 3.38358341e-09, 1.51057350e-07],\n",
       "        [1.66338516e-08, 7.44786774e-08, 4.63032251e-07, ...,\n",
       "         1.14993234e-07, 3.38358341e-09, 1.51057350e-07]], dtype=float32),\n",
       " array([[0.94007367],\n",
       "        [0.94007367]], dtype=float32),\n",
       " array([0.94007367, 0.94007367], dtype=float32),\n",
       " array([917, 917], dtype=int64)]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output_ort_rich"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['output', 'indices', 'probs', 'probs_top1', 'probs_top1_1', 'indices_1']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[o.name for o in ort_session_rich.get_outputs()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'input'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_rich = onnx.load(\"resnet18_rich_output.onnx\")\n",
    "onnx.checker.check_model(model_rich, full_check=True)\n",
    "\n",
    "assert len(model_rich.graph.input) == 1\n",
    "model_rich.graph.input[0].name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_rich = onnx.load(\"resnet18_rich_output.onnx\")\n",
    "\n",
    "model_rich.graph.node.insert(\n",
    "    0,\n",
    "    onnx.helper.make_node(\n",
    "        \"Transpose\",\n",
    "        inputs=['input_bwhc'],\n",
    "        outputs=[\"input\"],\n",
    "        perm=[0, 3, 1, 2]\n",
    "    )\n",
    ")\n",
    "model_rich.graph.node.insert(\n",
    "    0,\n",
    "    onnx.helper.make_node(\n",
    "        \"Div\",\n",
    "        inputs=[\"input_non_scaled\", \"std\"],\n",
    "        outputs=[\"input_bwhc\"]\n",
    "    )\n",
    ")\n",
    "model_rich.graph.node.insert(\n",
    "    0,\n",
    "    onnx.helper.make_node(\n",
    "        \"Sub\",\n",
    "        inputs=[\"input_non_centered_scaled\", \"mean\"],\n",
    "        outputs=[\"input_non_scaled\"]\n",
    "    )\n",
    ")\n",
    "model_rich.graph.node.insert(\n",
    "    0,\n",
    "    onnx.helper.make_node(\n",
    "        \"Div\",\n",
    "        inputs=[\"input_non_centered_scaled_255\", \"standard_cons\"],\n",
    "        outputs=[\"input_non_centered_scaled\"]\n",
    "    )\n",
    ")\n",
    "model_rich.graph.node.insert(\n",
    "    0,\n",
    "    onnx.helper.make_node(\n",
    "        \"Cast\",\n",
    "        inputs=[\"input_img_seq\"],\n",
    "        outputs=[\"input_non_centered_scaled_255\"],\n",
    "        to=TensorProto.FLOAT\n",
    "    )\n",
    ")\n",
    "\n",
    "# SSA don't allows a node to be able to be computed by another node or specified by input at the same time. \n",
    "model_rich.graph.input.remove(model_rich.graph.input[0])\n",
    "\n",
    "model_rich.graph.input.insert(\n",
    "    0,\n",
    "    onnx.helper.make_tensor_value_info(\n",
    "        \"input_img_seq\",\n",
    "        TensorProto.UINT8, \n",
    "        shape=[\"batch_size\", 224, 224, 3]\n",
    "    )\n",
    ")\n",
    "\n",
    "model_rich.graph.initializer.insert(\n",
    "    0,\n",
    "    onnx.helper.make_tensor(\n",
    "        \"std\", \n",
    "        TensorProto.FLOAT, \n",
    "        [3], \n",
    "        [0.229, 0.224, 0.225]\n",
    "    )\n",
    ")\n",
    "\n",
    "model_rich.graph.initializer.insert(\n",
    "    0,\n",
    "    onnx.helper.make_tensor(\n",
    "        \"mean\", \n",
    "        TensorProto.FLOAT, \n",
    "        [3], \n",
    "        [0.485, 0.456, 0.406]\n",
    "    )\n",
    ")\n",
    "model_rich.graph.initializer.insert(\n",
    "    0,\n",
    "    onnx.helper.make_tensor(\n",
    "        \"standard_cons\", \n",
    "        TensorProto.FLOAT, \n",
    "        [1], \n",
    "        [255]\n",
    "    )\n",
    ")\n",
    "\n",
    "\n",
    "onnx.checker.check_model(model_rich, full_check=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "onnx.save(model_rich, \"model_rich_convenient.onnx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "ort_session_conven = ort.InferenceSession(\"model_rich_convenient.onnx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "pure_image_transform = transforms.Compose([\n",
    "    transforms.Resize(resize_size),\n",
    "    transforms.CenterCrop(crop_size),\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2, 224, 224, 3), dtype('uint8'))"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch_conven = np.stack([np.array(pure_image_transform(hp)), np.array(pure_image_transform(hp))], axis=0)\n",
    "batch_conven.shape, batch_conven.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(nrows=1, ncols=2)\n",
    "axs[0].imshow(batch_conven[0])\n",
    "axs[1].imshow(batch_conven[1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['input_img_seq']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[n.name for n in ort_session_conven.get_inputs()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# output_ort_rich = ort_session_rich.run(None, {\"input\": batch_py})\n",
    "output_ort_conven = ort_session_conven.run(None, {\"input_img_seq\": batch_conven})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['output', 'indices', 'probs', 'probs_top1', 'probs_top1_1', 'indices_1']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[n.name for n in ort_session_conven.get_outputs()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[-1.9975376 , -0.4984647 ,  1.3288195 , ..., -0.06410396,\n",
       "         -3.5900416 ,  0.20868209],\n",
       "        [-1.9975376 , -0.4984647 ,  1.3288195 , ..., -0.06410396,\n",
       "         -3.5900416 ,  0.20868209]], dtype=float32),\n",
       " array([[917],\n",
       "        [917]], dtype=int64),\n",
       " array([[1.66338516e-08, 7.44786774e-08, 4.63032251e-07, ...,\n",
       "         1.14993234e-07, 3.38358341e-09, 1.51057350e-07],\n",
       "        [1.66338516e-08, 7.44786774e-08, 4.63032251e-07, ...,\n",
       "         1.14993234e-07, 3.38358341e-09, 1.51057350e-07]], dtype=float32),\n",
       " array([[0.94007367],\n",
       "        [0.94007367]], dtype=float32),\n",
       " array([0.94007367, 0.94007367], dtype=float32),\n",
       " array([917, 917], dtype=int64)]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output_ort_conven"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[-1.9975376 , -0.4984647 ,  1.3288195 , ..., -0.06410396,\n",
       "         -3.5900416 ,  0.20868209],\n",
       "        [-1.9975376 , -0.4984647 ,  1.3288195 , ..., -0.06410396,\n",
       "         -3.5900416 ,  0.20868209]], dtype=float32),\n",
       " array([[917],\n",
       "        [917]], dtype=int64),\n",
       " array([[1.66338516e-08, 7.44786774e-08, 4.63032251e-07, ...,\n",
       "         1.14993234e-07, 3.38358341e-09, 1.51057350e-07],\n",
       "        [1.66338516e-08, 7.44786774e-08, 4.63032251e-07, ...,\n",
       "         1.14993234e-07, 3.38358341e-09, 1.51057350e-07]], dtype=float32),\n",
       " array([[0.94007367],\n",
       "        [0.94007367]], dtype=float32),\n",
       " array([0.94007367, 0.94007367], dtype=float32),\n",
       " array([917, 917], dtype=int64)]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output_ort_rich"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.9975376 , -0.4984647 ,  1.3288195 , ..., -0.06410396,\n",
       "        -3.5900416 ,  0.20868209],\n",
       "       [-1.9975376 , -0.4984647 ,  1.3288195 , ..., -0.06410396,\n",
       "        -3.5900416 ,  0.20868209]], dtype=float32)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output_ort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}