diff --git a/notebooks/export.ipynb b/notebooks/export.ipynb
new file mode 100644
index 0000000..d341545
--- /dev/null
+++ b/notebooks/export.ipynb
@@ -0,0 +1,971 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:49:49.372036Z",
+     "start_time": "2023-06-28T05:49:44.524625Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "LR SCALES: [0.08589934592000005, 0.10737418240000006, 0.13421772800000006, 0.1677721600000001, 0.20971520000000007, 0.2621440000000001, 0.3276800000000001, 0.4096000000000001, 0.5120000000000001, 0.6400000000000001, 0.8, 1.0]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<All keys matched successfully>"
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "\n",
+    "import numpy\n",
+    "import torch\n",
+    "sys.path.append(\"..\")\n",
+    "from mobile_encoder.setup_mobile_sam import setup_model\n",
+    "checkpoint = torch.load('../weights/mobile_sam.pt', map_location=torch.device('cpu'))\n",
+    "mobile_sam = setup_model()\n",
+    "mobile_sam.load_state_dict(checkpoint,strict=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "Sam(\n  (image_encoder): TinyViT(\n    (patch_embed): PatchEmbed(\n      (seq): Sequential(\n        (0): Conv2d_BN(\n          (c): Conv2d(3, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n          (bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n        )\n        (1): GELU(approximate='none')\n        (2): Conv2d_BN(\n          (c): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n          (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n        )\n      )\n    )\n    (layers): ModuleList(\n      (0): ConvLayer(\n        (blocks): ModuleList(\n          (0-1): 2 x MBConv(\n            (conv1): Conv2d_BN(\n              (c): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n              (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n            )\n            (act1): GELU(approximate='none')\n            (conv2): Conv2d_BN(\n              (c): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=256, bias=False)\n              (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n            )\n            (act2): GELU(approximate='none')\n            (conv3): Conv2d_BN(\n              (c): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n              (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n            )\n            (act3): GELU(approximate='none')\n            (drop_path): Identity()\n          )\n        )\n        (downsample): PatchMerging(\n          (act): GELU(approximate='none')\n          (conv1): Conv2d_BN(\n            (c): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n            (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n          )\n          (conv2): Conv2d_BN(\n            (c): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=128, bias=False)\n            (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n          )\n          (conv3): Conv2d_BN(\n            (c): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n            (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n          )\n        )\n      )\n      (1): BasicLayer(\n        dim=128, input_resolution=(128, 128), depth=2\n        (blocks): ModuleList(\n          (0-1): 2 x TinyViTBlock(\n            dim=128, input_resolution=(128, 128), num_heads=4, window_size=7, mlp_ratio=4.0\n            (drop_path): Identity()\n            (attn): Attention(\n              (norm): LayerNorm((128,), eps=1e-05, elementwise_affine=True)\n              (qkv): Linear(in_features=128, out_features=384, bias=True)\n              (proj): Linear(in_features=128, out_features=128, bias=True)\n            )\n            (mlp): Mlp(\n              (norm): LayerNorm((128,), eps=1e-05, elementwise_affine=True)\n              (fc1): Linear(in_features=128, out_features=512, bias=True)\n              (fc2): Linear(in_features=512, out_features=128, bias=True)\n              (act): GELU(approximate='none')\n              (drop): Dropout(p=0.0, inplace=False)\n            )\n            (local_conv): Conv2d_BN(\n              (c): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=128, bias=False)\n              (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n            )\n          )\n        )\n        (downsample): PatchMerging(\n          (act): GELU(approximate='none')\n          (conv1): Conv2d_BN(\n            (c): Conv2d(128, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)\n            (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n          )\n          (conv2): Conv2d_BN(\n            (c): Conv2d(160, 160, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=160, bias=False)\n            (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n          )\n          (conv3): Conv2d_BN(\n            (c): Conv2d(160, 160, kernel_size=(1, 1), stride=(1, 1), bias=False)\n            (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n          )\n        )\n      )\n      (2): BasicLayer(\n        dim=160, input_resolution=(64, 64), depth=6\n        (blocks): ModuleList(\n          (0-5): 6 x TinyViTBlock(\n            dim=160, input_resolution=(64, 64), num_heads=5, window_size=14, mlp_ratio=4.0\n            (drop_path): Identity()\n            (attn): Attention(\n              (norm): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n              (qkv): Linear(in_features=160, out_features=480, bias=True)\n              (proj): Linear(in_features=160, out_features=160, bias=True)\n            )\n            (mlp): Mlp(\n              (norm): LayerNorm((160,), eps=1e-05, elementwise_affine=True)\n              (fc1): Linear(in_features=160, out_features=640, bias=True)\n              (fc2): Linear(in_features=640, out_features=160, bias=True)\n              (act): GELU(approximate='none')\n              (drop): Dropout(p=0.0, inplace=False)\n            )\n            (local_conv): Conv2d_BN(\n              (c): Conv2d(160, 160, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=160, bias=False)\n              (bn): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n            )\n          )\n        )\n        (downsample): PatchMerging(\n          (act): GELU(approximate='none')\n          (conv1): Conv2d_BN(\n            (c): Conv2d(160, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)\n            (bn): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n          )\n          (conv2): Conv2d_BN(\n            (c): Conv2d(320, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=320, bias=False)\n            (bn): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n          )\n          (conv3): Conv2d_BN(\n            (c): Conv2d(320, 320, kernel_size=(1, 1), stride=(1, 1), bias=False)\n            (bn): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n          )\n        )\n      )\n      (3): BasicLayer(\n        dim=320, input_resolution=(64, 64), depth=2\n        (blocks): ModuleList(\n          (0-1): 2 x TinyViTBlock(\n            dim=320, input_resolution=(64, 64), num_heads=10, window_size=7, mlp_ratio=4.0\n            (drop_path): Identity()\n            (attn): Attention(\n              (norm): LayerNorm((320,), eps=1e-05, elementwise_affine=True)\n              (qkv): Linear(in_features=320, out_features=960, bias=True)\n              (proj): Linear(in_features=320, out_features=320, bias=True)\n            )\n            (mlp): Mlp(\n              (norm): LayerNorm((320,), eps=1e-05, elementwise_affine=True)\n              (fc1): Linear(in_features=320, out_features=1280, bias=True)\n              (fc2): Linear(in_features=1280, out_features=320, bias=True)\n              (act): GELU(approximate='none')\n              (drop): Dropout(p=0.0, inplace=False)\n            )\n            (local_conv): Conv2d_BN(\n              (c): Conv2d(320, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=320, bias=False)\n              (bn): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n            )\n          )\n        )\n      )\n    )\n    (norm_head): LayerNorm((320,), eps=1e-05, elementwise_affine=True)\n    (head): Linear(in_features=320, out_features=1000, bias=True)\n    (neck): Sequential(\n      (0): Conv2d(320, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n      (1): LayerNorm2d()\n      (2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n      (3): LayerNorm2d()\n    )\n  )\n  (prompt_encoder): PromptEncoder(\n    (pe_layer): PositionEmbeddingRandom()\n    (point_embeddings): ModuleList(\n      (0-3): 4 x Embedding(1, 256)\n    )\n    (not_a_point_embed): Embedding(1, 256)\n    (mask_downscaling): Sequential(\n      (0): Conv2d(1, 4, kernel_size=(2, 2), stride=(2, 2))\n      (1): LayerNorm2d()\n      (2): GELU(approximate='none')\n      (3): Conv2d(4, 16, kernel_size=(2, 2), stride=(2, 2))\n      (4): LayerNorm2d()\n      (5): GELU(approximate='none')\n      (6): Conv2d(16, 256, kernel_size=(1, 1), stride=(1, 1))\n    )\n    (no_mask_embed): Embedding(1, 256)\n  )\n  (mask_decoder): MaskDecoder(\n    (transformer): TwoWayTransformer(\n      (layers): ModuleList(\n        (0-1): 2 x TwoWayAttentionBlock(\n          (self_attn): Attention(\n            (q_proj): Linear(in_features=256, out_features=256, bias=True)\n            (k_proj): Linear(in_features=256, out_features=256, bias=True)\n            (v_proj): Linear(in_features=256, out_features=256, bias=True)\n            (out_proj): Linear(in_features=256, out_features=256, bias=True)\n          )\n          (norm1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n          (cross_attn_token_to_image): Attention(\n            (q_proj): Linear(in_features=256, out_features=128, bias=True)\n            (k_proj): Linear(in_features=256, out_features=128, bias=True)\n            (v_proj): Linear(in_features=256, out_features=128, bias=True)\n            (out_proj): Linear(in_features=128, out_features=256, bias=True)\n          )\n          (norm2): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n          (mlp): MLPBlock(\n            (lin1): Linear(in_features=256, out_features=2048, bias=True)\n            (lin2): Linear(in_features=2048, out_features=256, bias=True)\n            (act): ReLU()\n          )\n          (norm3): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n          (norm4): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n          (cross_attn_image_to_token): Attention(\n            (q_proj): Linear(in_features=256, out_features=128, bias=True)\n            (k_proj): Linear(in_features=256, out_features=128, bias=True)\n            (v_proj): Linear(in_features=256, out_features=128, bias=True)\n            (out_proj): Linear(in_features=128, out_features=256, bias=True)\n          )\n        )\n      )\n      (final_attn_token_to_image): Attention(\n        (q_proj): Linear(in_features=256, out_features=128, bias=True)\n        (k_proj): Linear(in_features=256, out_features=128, bias=True)\n        (v_proj): Linear(in_features=256, out_features=128, bias=True)\n        (out_proj): Linear(in_features=128, out_features=256, bias=True)\n      )\n      (norm_final_attn): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n    )\n    (iou_token): Embedding(1, 256)\n    (mask_tokens): Embedding(4, 256)\n    (output_upscaling): Sequential(\n      (0): ConvTranspose2d(256, 64, kernel_size=(2, 2), stride=(2, 2))\n      (1): LayerNorm2d()\n      (2): GELU(approximate='none')\n      (3): ConvTranspose2d(64, 32, kernel_size=(2, 2), stride=(2, 2))\n      (4): GELU(approximate='none')\n    )\n    (output_hypernetworks_mlps): ModuleList(\n      (0-3): 4 x MLP(\n        (layers): ModuleList(\n          (0-1): 2 x Linear(in_features=256, out_features=256, bias=True)\n          (2): Linear(in_features=256, out_features=32, bias=True)\n        )\n      )\n    )\n    (iou_prediction_head): MLP(\n      (layers): ModuleList(\n        (0-1): 2 x Linear(in_features=256, out_features=256, bias=True)\n        (2): Linear(in_features=256, out_features=4, bias=True)\n      )\n    )\n  )\n)"
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mobile_sam"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:49:49.381352Z",
+     "start_time": "2023-06-28T05:49:49.376802Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "outputs": [],
+   "source": [
+    "from segment_anything.utils.onnx import SimpleSamOnnxModel"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:02:43.543552Z",
+     "start_time": "2023-06-28T06:02:43.539234Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "outputs": [],
+   "source": [
+    "onnx_model = SimpleSamOnnxModel(model=mobile_sam)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:02:44.312372Z",
+     "start_time": "2023-06-28T06:02:44.299547Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "outputs": [],
+   "source": [
+    "#for n, m in onnx_model.named_modules():\n",
+    "#    if isinstance(m, torch.nn.GELU):\n",
+    "#        m.approximate = \"tanh\""
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:59:34.851326Z",
+     "start_time": "2023-06-28T05:59:34.835116Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "outputs": [],
+   "source": [
+    "from PIL import Image"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:59:35.405860Z",
+     "start_time": "2023-06-28T05:59:35.392740Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "(769, 770)"
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "image = Image.open('../notebooks/images/picture1.jpg')\n",
+    "image.size"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:59:39.196481Z",
+     "start_time": "2023-06-28T05:59:39.184546Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "outputs": [],
+   "source": [
+    "image = image.resize((1024,1024))"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:59:40.001242Z",
+     "start_time": "2023-06-28T05:59:39.963068Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "test_image = torch.Tensor(np.moveaxis(np.array(image).astype(np.float32), -1, 0))"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:59:40.772429Z",
+     "start_time": "2023-06-28T05:59:40.734145Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "outputs": [],
+   "source": [
+    "dynamic_axes = {\n",
+    "        \"point_coords\": {1: \"num_points\"},\n",
+    "    }\n",
+    "\n",
+    "embed_dim = mobile_sam.prompt_encoder.embed_dim\n",
+    "embed_size = mobile_sam.prompt_encoder.image_embedding_size\n",
+    "mask_input_size = [4 * x for x in embed_size]\n",
+    "dummy_inputs = {\n",
+    "    \"x\": test_image.unsqueeze(0),\n",
+    "    \"point_coords\": torch.Tensor([[[530.,265.], [530.,530]]]),#torch.randint(low=0, high=1024, size=(1, 1, 2), dtype=torch.float),\n",
+    "}"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:59:41.895883Z",
+     "start_time": "2023-06-28T05:59:41.885160Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "outputs": [],
+   "source": [
+    "out = onnx_model(**dummy_inputs)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:59:45.217564Z",
+     "start_time": "2023-06-28T05:59:42.693503Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "[256, 256]"
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mask_input_size"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:59:51.359576Z",
+     "start_time": "2023-06-28T05:59:51.340846Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "256"
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "embed_dim"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:59:52.259693Z",
+     "start_time": "2023-06-28T05:59:52.239940Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "torch.Size([1, 2, 2])"
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dummy_inputs[\"point_coords\"].shape"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:59:54.173267Z",
+     "start_time": "2023-06-28T05:59:54.109270Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<matplotlib.colorbar.Colorbar at 0x7fa1b16469a0>"
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 2 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "plt.show()\n",
+    "plt.imshow(torch.squeeze(out[0]))\n",
+    "plt.colorbar()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:59:55.846822Z",
+     "start_time": "2023-06-28T05:59:54.999379Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 720x1440 with 2 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(10,20))\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.imshow(torch.nn.functional.sigmoid(torch.squeeze(out[0])))\n",
+    "plt.plot([x*1024/770 for x in [400,400]], [x*1024/770 for x in [400,200]], 'ro')\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.imshow(image)\n",
+    "plt.plot([400], [400], 'ro')\n",
+    "plt.show()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T05:59:57.891796Z",
+     "start_time": "2023-06-28T05:59:57.487271Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "[<matplotlib.lines.Line2D at 0x7fa1900a33d0>]"
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(image)\n",
+    "plt.plot([400], [400], 'ro')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:00:00.048102Z",
+     "start_time": "2023-06-28T05:59:59.381930Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "579.00390625"
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(770/1024)*770"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:00:01.838588Z",
+     "start_time": "2023-06-28T06:00:01.818232Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "outputs": [],
+   "source": [
+    "output_names = [\"masks\", \"iou_predictions\", \"low_res_masks\"]"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:00:03.278109Z",
+     "start_time": "2023-06-28T06:00:03.239162Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Exporting onnx model to mobile_sam.onnx...\n",
+      "================ Diagnostic Run torch.onnx.export version 2.0.0 ================\n",
+      "verbose: False, log level: Level.ERROR\n",
+      "======================= 0 NONE 0 NOTE 0 WARNING 0 ERROR ========================\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import warnings\n",
+    "with warnings.catch_warnings():\n",
+    "    warnings.filterwarnings(\"ignore\", category=torch.jit.TracerWarning)\n",
+    "    warnings.filterwarnings(\"ignore\", category=UserWarning)\n",
+    "    output = \"mobile_sam.onnx\"\n",
+    "    with open(\"mobile_sam.onnx\", \"wb\") as f:\n",
+    "        print(f\"Exporting onnx model to {output}...\")\n",
+    "        torch.onnx.export(\n",
+    "            onnx_model,\n",
+    "            tuple(dummy_inputs.values()),\n",
+    "            f,\n",
+    "            export_params=True,\n",
+    "            verbose=False,\n",
+    "            opset_version=17,\n",
+    "            do_constant_folding=True,\n",
+    "            input_names=list(dummy_inputs.keys()),\n",
+    "            output_names=output_names,\n",
+    "            dynamic_axes=dynamic_axes,\n",
+    "        )"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:00:13.251332Z",
+     "start_time": "2023-06-28T06:00:03.949307Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.1/blocks.0/attn/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.1/blocks.0/attn/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.1/blocks.1/attn/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.1/blocks.1/attn/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.2/blocks.0/attn/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.2/blocks.0/attn/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.2/blocks.1/attn/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.2/blocks.1/attn/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.2/blocks.2/attn/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.2/blocks.2/attn/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.2/blocks.3/attn/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.2/blocks.3/attn/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.2/blocks.4/attn/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.2/blocks.4/attn/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.2/blocks.5/attn/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.2/blocks.5/attn/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.3/blocks.0/attn/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.3/blocks.0/attn/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.3/blocks.1/attn/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/image_encoder/layers.3/blocks.1/attn/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/layers.0/self_attn/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/layers.0/self_attn/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/layers.0/cross_attn_token_to_image/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/layers.0/cross_attn_token_to_image/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/layers.0/cross_attn_image_to_token/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/layers.0/cross_attn_image_to_token/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/layers.1/self_attn/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/layers.1/self_attn/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/layers.1/cross_attn_token_to_image/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/layers.1/cross_attn_token_to_image/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/layers.1/cross_attn_image_to_token/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/layers.1/cross_attn_image_to_token/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/final_attn_token_to_image/MatMul]\n",
+      "Ignore MatMul due to non constant B: /[/transformer/final_attn_token_to_image/MatMul_1]\n",
+      "Ignore MatMul due to non constant B: /[/MatMul_1]\n"
+     ]
+    }
+   ],
+   "source": [
+    "#assert onnxruntime_exists, \"onnxruntime is required to quantize the model.\"\n",
+    "from onnxruntime.quantization import QuantType  # type: ignore\n",
+    "from onnxruntime.quantization.quantize import quantize_dynamic  # type: ignore\n",
+    "\n",
+    "#print(f\"Quantizing model and writing to {args.quantize_out}...\")\n",
+    "quantize_dynamic(\n",
+    "    model_input=\"mobile_sam.onnx\",\n",
+    "    model_output=\"mobile_sam_8bit.onnx\",\n",
+    "    optimize_model=True,\n",
+    "    per_channel=False,\n",
+    "    reduce_range=False,\n",
+    "    weight_type=QuantType.QUInt8,\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:00:27.764268Z",
+     "start_time": "2023-06-28T06:00:24.639245Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-rw-r--r--  1 ishani  staff    42M Jun 27 23:00 mobile_sam.onnx\r\n",
+      "-rw-r--r--  1 ishani  staff    23M Jun 27 23:00 mobile_sam_8bit.onnx\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls -lh mobile_sam*.onnx"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:00:30.969188Z",
+     "start_time": "2023-06-28T06:00:30.790879Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "outputs": [],
+   "source": [
+    "import onnxruntime"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:00:31.669797Z",
+     "start_time": "2023-06-28T06:00:31.661067Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "outputs": [],
+   "source": [
+    "def to_numpy(tensor):\n",
+    "    return tensor.cpu().numpy()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:00:32.706876Z",
+     "start_time": "2023-06-28T06:00:32.691592Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "outputs": [],
+   "source": [
+    "ort_inputs = {k: to_numpy(v) for k, v in dummy_inputs.items()}\n",
+    "# set cpu provider default\n",
+    "providers = [\"CPUExecutionProvider\"]\n",
+    "ort_session = onnxruntime.InferenceSession(output, providers=providers)\n",
+    "out_onnx = ort_session.run(None, ort_inputs)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:00:34.868737Z",
+     "start_time": "2023-06-28T06:00:34.068885Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "plt.imshow(np.squeeze(out_onnx[0]))\n",
+    "plt.show()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:00:35.070710Z",
+     "start_time": "2023-06-28T06:00:34.869798Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Requirement already satisfied: coremltools in /Users/ishani/anaconda3/lib/python3.8/site-packages (6.3.0)\r\n",
+      "Requirement already satisfied: packaging in /Users/ishani/anaconda3/lib/python3.8/site-packages (from coremltools) (20.9)\r\n",
+      "Requirement already satisfied: tqdm in /Users/ishani/anaconda3/lib/python3.8/site-packages (from coremltools) (4.65.0)\r\n",
+      "Requirement already satisfied: sympy in /Users/ishani/anaconda3/lib/python3.8/site-packages (from coremltools) (1.8)\r\n",
+      "Requirement already satisfied: numpy>=1.14.5 in /Users/ishani/anaconda3/lib/python3.8/site-packages (from coremltools) (1.24.0)\r\n",
+      "Requirement already satisfied: protobuf<=4.0.0,>=3.1.0 in /Users/ishani/anaconda3/lib/python3.8/site-packages (from coremltools) (3.20.3)\r\n",
+      "Requirement already satisfied: pyparsing>=2.0.2 in /Users/ishani/anaconda3/lib/python3.8/site-packages (from packaging->coremltools) (2.4.7)\r\n",
+      "Requirement already satisfied: mpmath>=0.19 in /Users/ishani/anaconda3/lib/python3.8/site-packages (from sympy->coremltools) (1.2.1)\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install coremltools"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:00:41.652238Z",
+     "start_time": "2023-06-28T06:00:35.069834Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "outputs": [],
+   "source": [
+    "import coremltools as ct\n"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:00:50.307397Z",
+     "start_time": "2023-06-28T06:00:41.652569Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/ishani/Documents/GitHub/MobileSAM/mobile_encoder/tiny_vit_sam.py:336: TracerWarning: Converting a tensor to a Python boolean might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+      "  assert L == H * W, \"input feature has wrong size\"\n",
+      "/Users/ishani/Documents/GitHub/MobileSAM/mobile_encoder/tiny_vit_sam.py:136: TracerWarning: Using len to get tensor shape might cause the trace to be incorrect. Recommended usage would be tensor.shape[0]. Passing a tensor of different shape might lead to errors or silently give incorrect results.\n",
+      "  B = len(x)\n",
+      "/Users/ishani/Documents/GitHub/MobileSAM/segment_anything/utils/onnx.py:177: TracerWarning: torch.Tensor results are registered as constants in the trace. You can safely ignore this warning if you use this function to create tensors out of constant variables that would be the same every time you call this function. In any other case, this might cause the trace to be incorrect.\n",
+      "  orig_im_size = torch.Tensor([x.shape[-2], x.shape[-1]]).float()\n",
+      "/Users/ishani/Documents/GitHub/MobileSAM/segment_anything/utils/onnx.py:177: TracerWarning: Converting a tensor to a Python float might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+      "  orig_im_size = torch.Tensor([x.shape[-2], x.shape[-1]]).float()\n",
+      "/Users/ishani/Documents/GitHub/MobileSAM/segment_anything/utils/onnx.py:181: TracerWarning: torch.tensor results are registered as constants in the trace. You can safely ignore this warning if you use this function to create tensors out of constant variables that would be the same every time you call this function. In any other case, this might cause the trace to be incorrect.\n",
+      "  has_mask_input = torch.tensor([0], dtype=torch.float)\n",
+      "/Users/ishani/Documents/GitHub/MobileSAM/segment_anything/modeling/transformer.py:232: TracerWarning: Converting a tensor to a Python float might cause the trace to be incorrect. We can't record the data flow of Python values, so this value will be treated as a constant in the future. This means that the trace might not generalize to other inputs!\n",
+      "  attn = attn / math.sqrt(c_per_head)\n",
+      "/Users/ishani/Documents/GitHub/MobileSAM/segment_anything/utils/onnx.py:96: TracerWarning: torch.tensor results are registered as constants in the trace. You can safely ignore this warning if you use this function to create tensors out of constant variables that would be the same every time you call this function. In any other case, this might cause the trace to be incorrect.\n",
+      "  score_reweight = torch.tensor(\n"
+     ]
+    }
+   ],
+   "source": [
+    "with torch.no_grad():\n",
+    "    onnx_model.eval()\n",
+    "    model = onnx_model.cpu()\n",
+    "    model.requires_grad_(False)\n",
+    "    traced_model = torch.jit.trace(onnx_model, example_inputs=(dummy_inputs[\"x\"], dummy_inputs[\"point_coords\"]))"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:01:03.611995Z",
+     "start_time": "2023-06-28T06:00:50.215956Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "SimpleSamOnnxModel(\n  original_name=SimpleSamOnnxModel\n  (mask_decoder): MaskDecoder(\n    original_name=MaskDecoder\n    (transformer): TwoWayTransformer(\n      original_name=TwoWayTransformer\n      (layers): ModuleList(\n        original_name=ModuleList\n        (0): TwoWayAttentionBlock(\n          original_name=TwoWayAttentionBlock\n          (self_attn): Attention(\n            original_name=Attention\n            (q_proj): Linear(original_name=Linear)\n            (k_proj): Linear(original_name=Linear)\n            (v_proj): Linear(original_name=Linear)\n            (out_proj): Linear(original_name=Linear)\n          )\n          (norm1): LayerNorm(original_name=LayerNorm)\n          (cross_attn_token_to_image): Attention(\n            original_name=Attention\n            (q_proj): Linear(original_name=Linear)\n            (k_proj): Linear(original_name=Linear)\n            (v_proj): Linear(original_name=Linear)\n            (out_proj): Linear(original_name=Linear)\n          )\n          (norm2): LayerNorm(original_name=LayerNorm)\n          (mlp): MLPBlock(\n            original_name=MLPBlock\n            (lin1): Linear(original_name=Linear)\n            (lin2): Linear(original_name=Linear)\n            (act): ReLU(original_name=ReLU)\n          )\n          (norm3): LayerNorm(original_name=LayerNorm)\n          (norm4): LayerNorm(original_name=LayerNorm)\n          (cross_attn_image_to_token): Attention(\n            original_name=Attention\n            (q_proj): Linear(original_name=Linear)\n            (k_proj): Linear(original_name=Linear)\n            (v_proj): Linear(original_name=Linear)\n            (out_proj): Linear(original_name=Linear)\n          )\n        )\n        (1): TwoWayAttentionBlock(\n          original_name=TwoWayAttentionBlock\n          (self_attn): Attention(\n            original_name=Attention\n            (q_proj): Linear(original_name=Linear)\n            (k_proj): Linear(original_name=Linear)\n            (v_proj): Linear(original_name=Linear)\n            (out_proj): Linear(original_name=Linear)\n          )\n          (norm1): LayerNorm(original_name=LayerNorm)\n          (cross_attn_token_to_image): Attention(\n            original_name=Attention\n            (q_proj): Linear(original_name=Linear)\n            (k_proj): Linear(original_name=Linear)\n            (v_proj): Linear(original_name=Linear)\n            (out_proj): Linear(original_name=Linear)\n          )\n          (norm2): LayerNorm(original_name=LayerNorm)\n          (mlp): MLPBlock(\n            original_name=MLPBlock\n            (lin1): Linear(original_name=Linear)\n            (lin2): Linear(original_name=Linear)\n            (act): ReLU(original_name=ReLU)\n          )\n          (norm3): LayerNorm(original_name=LayerNorm)\n          (norm4): LayerNorm(original_name=LayerNorm)\n          (cross_attn_image_to_token): Attention(\n            original_name=Attention\n            (q_proj): Linear(original_name=Linear)\n            (k_proj): Linear(original_name=Linear)\n            (v_proj): Linear(original_name=Linear)\n            (out_proj): Linear(original_name=Linear)\n          )\n        )\n      )\n      (final_attn_token_to_image): Attention(\n        original_name=Attention\n        (q_proj): Linear(original_name=Linear)\n        (k_proj): Linear(original_name=Linear)\n        (v_proj): Linear(original_name=Linear)\n        (out_proj): Linear(original_name=Linear)\n      )\n      (norm_final_attn): LayerNorm(original_name=LayerNorm)\n    )\n    (iou_token): Embedding(original_name=Embedding)\n    (mask_tokens): Embedding(original_name=Embedding)\n    (output_upscaling): Sequential(\n      original_name=Sequential\n      (0): ConvTranspose2d(original_name=ConvTranspose2d)\n      (1): LayerNorm2d(original_name=LayerNorm2d)\n      (2): GELU(original_name=GELU)\n      (3): ConvTranspose2d(original_name=ConvTranspose2d)\n      (4): GELU(original_name=GELU)\n    )\n    (output_hypernetworks_mlps): ModuleList(\n      original_name=ModuleList\n      (0): MLP(\n        original_name=MLP\n        (layers): ModuleList(\n          original_name=ModuleList\n          (0): Linear(original_name=Linear)\n          (1): Linear(original_name=Linear)\n          (2): Linear(original_name=Linear)\n        )\n      )\n      (1): MLP(\n        original_name=MLP\n        (layers): ModuleList(\n          original_name=ModuleList\n          (0): Linear(original_name=Linear)\n          (1): Linear(original_name=Linear)\n          (2): Linear(original_name=Linear)\n        )\n      )\n      (2): MLP(\n        original_name=MLP\n        (layers): ModuleList(\n          original_name=ModuleList\n          (0): Linear(original_name=Linear)\n          (1): Linear(original_name=Linear)\n          (2): Linear(original_name=Linear)\n        )\n      )\n      (3): MLP(\n        original_name=MLP\n        (layers): ModuleList(\n          original_name=ModuleList\n          (0): Linear(original_name=Linear)\n          (1): Linear(original_name=Linear)\n          (2): Linear(original_name=Linear)\n        )\n      )\n    )\n    (iou_prediction_head): MLP(\n      original_name=MLP\n      (layers): ModuleList(\n        original_name=ModuleList\n        (0): Linear(original_name=Linear)\n        (1): Linear(original_name=Linear)\n        (2): Linear(original_name=Linear)\n      )\n    )\n  )\n  (model): Sam(\n    original_name=Sam\n    (image_encoder): TinyViT(\n      original_name=TinyViT\n      (patch_embed): PatchEmbed(\n        original_name=PatchEmbed\n        (seq): Sequential(\n          original_name=Sequential\n          (0): Conv2d_BN(\n            original_name=Conv2d_BN\n            (c): Conv2d(original_name=Conv2d)\n            (bn): BatchNorm2d(original_name=BatchNorm2d)\n          )\n          (1): GELU(original_name=GELU)\n          (2): Conv2d_BN(\n            original_name=Conv2d_BN\n            (c): Conv2d(original_name=Conv2d)\n            (bn): BatchNorm2d(original_name=BatchNorm2d)\n          )\n        )\n      )\n      (layers): ModuleList(\n        original_name=ModuleList\n        (0): ConvLayer(\n          original_name=ConvLayer\n          (blocks): ModuleList(\n            original_name=ModuleList\n            (0): MBConv(\n              original_name=MBConv\n              (conv1): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n              (act1): GELU(original_name=GELU)\n              (conv2): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n              (act2): GELU(original_name=GELU)\n              (conv3): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n              (act3): GELU(original_name=GELU)\n              (drop_path): Identity(original_name=Identity)\n            )\n            (1): MBConv(\n              original_name=MBConv\n              (conv1): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n              (act1): GELU(original_name=GELU)\n              (conv2): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n              (act2): GELU(original_name=GELU)\n              (conv3): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n              (act3): GELU(original_name=GELU)\n              (drop_path): Identity(original_name=Identity)\n            )\n          )\n          (downsample): PatchMerging(\n            original_name=PatchMerging\n            (act): GELU(original_name=GELU)\n            (conv1): Conv2d_BN(\n              original_name=Conv2d_BN\n              (c): Conv2d(original_name=Conv2d)\n              (bn): BatchNorm2d(original_name=BatchNorm2d)\n            )\n            (conv2): Conv2d_BN(\n              original_name=Conv2d_BN\n              (c): Conv2d(original_name=Conv2d)\n              (bn): BatchNorm2d(original_name=BatchNorm2d)\n            )\n            (conv3): Conv2d_BN(\n              original_name=Conv2d_BN\n              (c): Conv2d(original_name=Conv2d)\n              (bn): BatchNorm2d(original_name=BatchNorm2d)\n            )\n          )\n        )\n        (1): BasicLayer(\n          original_name=BasicLayer\n          (blocks): ModuleList(\n            original_name=ModuleList\n            (0): TinyViTBlock(\n              original_name=TinyViTBlock\n              (drop_path): Identity(original_name=Identity)\n              (attn): Attention(\n                original_name=Attention\n                (norm): LayerNorm(original_name=LayerNorm)\n                (qkv): Linear(original_name=Linear)\n                (proj): Linear(original_name=Linear)\n              )\n              (mlp): Mlp(\n                original_name=Mlp\n                (norm): LayerNorm(original_name=LayerNorm)\n                (fc1): Linear(original_name=Linear)\n                (fc2): Linear(original_name=Linear)\n                (act): GELU(original_name=GELU)\n                (drop): Dropout(original_name=Dropout)\n              )\n              (local_conv): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n            )\n            (1): TinyViTBlock(\n              original_name=TinyViTBlock\n              (drop_path): Identity(original_name=Identity)\n              (attn): Attention(\n                original_name=Attention\n                (norm): LayerNorm(original_name=LayerNorm)\n                (qkv): Linear(original_name=Linear)\n                (proj): Linear(original_name=Linear)\n              )\n              (mlp): Mlp(\n                original_name=Mlp\n                (norm): LayerNorm(original_name=LayerNorm)\n                (fc1): Linear(original_name=Linear)\n                (fc2): Linear(original_name=Linear)\n                (act): GELU(original_name=GELU)\n                (drop): Dropout(original_name=Dropout)\n              )\n              (local_conv): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n            )\n          )\n          (downsample): PatchMerging(\n            original_name=PatchMerging\n            (act): GELU(original_name=GELU)\n            (conv1): Conv2d_BN(\n              original_name=Conv2d_BN\n              (c): Conv2d(original_name=Conv2d)\n              (bn): BatchNorm2d(original_name=BatchNorm2d)\n            )\n            (conv2): Conv2d_BN(\n              original_name=Conv2d_BN\n              (c): Conv2d(original_name=Conv2d)\n              (bn): BatchNorm2d(original_name=BatchNorm2d)\n            )\n            (conv3): Conv2d_BN(\n              original_name=Conv2d_BN\n              (c): Conv2d(original_name=Conv2d)\n              (bn): BatchNorm2d(original_name=BatchNorm2d)\n            )\n          )\n        )\n        (2): BasicLayer(\n          original_name=BasicLayer\n          (blocks): ModuleList(\n            original_name=ModuleList\n            (0): TinyViTBlock(\n              original_name=TinyViTBlock\n              (drop_path): Identity(original_name=Identity)\n              (attn): Attention(\n                original_name=Attention\n                (norm): LayerNorm(original_name=LayerNorm)\n                (qkv): Linear(original_name=Linear)\n                (proj): Linear(original_name=Linear)\n              )\n              (mlp): Mlp(\n                original_name=Mlp\n                (norm): LayerNorm(original_name=LayerNorm)\n                (fc1): Linear(original_name=Linear)\n                (fc2): Linear(original_name=Linear)\n                (act): GELU(original_name=GELU)\n                (drop): Dropout(original_name=Dropout)\n              )\n              (local_conv): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n            )\n            (1): TinyViTBlock(\n              original_name=TinyViTBlock\n              (drop_path): Identity(original_name=Identity)\n              (attn): Attention(\n                original_name=Attention\n                (norm): LayerNorm(original_name=LayerNorm)\n                (qkv): Linear(original_name=Linear)\n                (proj): Linear(original_name=Linear)\n              )\n              (mlp): Mlp(\n                original_name=Mlp\n                (norm): LayerNorm(original_name=LayerNorm)\n                (fc1): Linear(original_name=Linear)\n                (fc2): Linear(original_name=Linear)\n                (act): GELU(original_name=GELU)\n                (drop): Dropout(original_name=Dropout)\n              )\n              (local_conv): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n            )\n            (2): TinyViTBlock(\n              original_name=TinyViTBlock\n              (drop_path): Identity(original_name=Identity)\n              (attn): Attention(\n                original_name=Attention\n                (norm): LayerNorm(original_name=LayerNorm)\n                (qkv): Linear(original_name=Linear)\n                (proj): Linear(original_name=Linear)\n              )\n              (mlp): Mlp(\n                original_name=Mlp\n                (norm): LayerNorm(original_name=LayerNorm)\n                (fc1): Linear(original_name=Linear)\n                (fc2): Linear(original_name=Linear)\n                (act): GELU(original_name=GELU)\n                (drop): Dropout(original_name=Dropout)\n              )\n              (local_conv): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n            )\n            (3): TinyViTBlock(\n              original_name=TinyViTBlock\n              (drop_path): Identity(original_name=Identity)\n              (attn): Attention(\n                original_name=Attention\n                (norm): LayerNorm(original_name=LayerNorm)\n                (qkv): Linear(original_name=Linear)\n                (proj): Linear(original_name=Linear)\n              )\n              (mlp): Mlp(\n                original_name=Mlp\n                (norm): LayerNorm(original_name=LayerNorm)\n                (fc1): Linear(original_name=Linear)\n                (fc2): Linear(original_name=Linear)\n                (act): GELU(original_name=GELU)\n                (drop): Dropout(original_name=Dropout)\n              )\n              (local_conv): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n            )\n            (4): TinyViTBlock(\n              original_name=TinyViTBlock\n              (drop_path): Identity(original_name=Identity)\n              (attn): Attention(\n                original_name=Attention\n                (norm): LayerNorm(original_name=LayerNorm)\n                (qkv): Linear(original_name=Linear)\n                (proj): Linear(original_name=Linear)\n              )\n              (mlp): Mlp(\n                original_name=Mlp\n                (norm): LayerNorm(original_name=LayerNorm)\n                (fc1): Linear(original_name=Linear)\n                (fc2): Linear(original_name=Linear)\n                (act): GELU(original_name=GELU)\n                (drop): Dropout(original_name=Dropout)\n              )\n              (local_conv): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n            )\n            (5): TinyViTBlock(\n              original_name=TinyViTBlock\n              (drop_path): Identity(original_name=Identity)\n              (attn): Attention(\n                original_name=Attention\n                (norm): LayerNorm(original_name=LayerNorm)\n                (qkv): Linear(original_name=Linear)\n                (proj): Linear(original_name=Linear)\n              )\n              (mlp): Mlp(\n                original_name=Mlp\n                (norm): LayerNorm(original_name=LayerNorm)\n                (fc1): Linear(original_name=Linear)\n                (fc2): Linear(original_name=Linear)\n                (act): GELU(original_name=GELU)\n                (drop): Dropout(original_name=Dropout)\n              )\n              (local_conv): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n            )\n          )\n          (downsample): PatchMerging(\n            original_name=PatchMerging\n            (act): GELU(original_name=GELU)\n            (conv1): Conv2d_BN(\n              original_name=Conv2d_BN\n              (c): Conv2d(original_name=Conv2d)\n              (bn): BatchNorm2d(original_name=BatchNorm2d)\n            )\n            (conv2): Conv2d_BN(\n              original_name=Conv2d_BN\n              (c): Conv2d(original_name=Conv2d)\n              (bn): BatchNorm2d(original_name=BatchNorm2d)\n            )\n            (conv3): Conv2d_BN(\n              original_name=Conv2d_BN\n              (c): Conv2d(original_name=Conv2d)\n              (bn): BatchNorm2d(original_name=BatchNorm2d)\n            )\n          )\n        )\n        (3): BasicLayer(\n          original_name=BasicLayer\n          (blocks): ModuleList(\n            original_name=ModuleList\n            (0): TinyViTBlock(\n              original_name=TinyViTBlock\n              (drop_path): Identity(original_name=Identity)\n              (attn): Attention(\n                original_name=Attention\n                (norm): LayerNorm(original_name=LayerNorm)\n                (qkv): Linear(original_name=Linear)\n                (proj): Linear(original_name=Linear)\n              )\n              (mlp): Mlp(\n                original_name=Mlp\n                (norm): LayerNorm(original_name=LayerNorm)\n                (fc1): Linear(original_name=Linear)\n                (fc2): Linear(original_name=Linear)\n                (act): GELU(original_name=GELU)\n                (drop): Dropout(original_name=Dropout)\n              )\n              (local_conv): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n            )\n            (1): TinyViTBlock(\n              original_name=TinyViTBlock\n              (drop_path): Identity(original_name=Identity)\n              (attn): Attention(\n                original_name=Attention\n                (norm): LayerNorm(original_name=LayerNorm)\n                (qkv): Linear(original_name=Linear)\n                (proj): Linear(original_name=Linear)\n              )\n              (mlp): Mlp(\n                original_name=Mlp\n                (norm): LayerNorm(original_name=LayerNorm)\n                (fc1): Linear(original_name=Linear)\n                (fc2): Linear(original_name=Linear)\n                (act): GELU(original_name=GELU)\n                (drop): Dropout(original_name=Dropout)\n              )\n              (local_conv): Conv2d_BN(\n                original_name=Conv2d_BN\n                (c): Conv2d(original_name=Conv2d)\n                (bn): BatchNorm2d(original_name=BatchNorm2d)\n              )\n            )\n          )\n        )\n      )\n      (norm_head): LayerNorm(original_name=LayerNorm)\n      (head): Linear(original_name=Linear)\n      (neck): Sequential(\n        original_name=Sequential\n        (0): Conv2d(original_name=Conv2d)\n        (1): LayerNorm2d(original_name=LayerNorm2d)\n        (2): Conv2d(original_name=Conv2d)\n        (3): LayerNorm2d(original_name=LayerNorm2d)\n      )\n    )\n    (prompt_encoder): PromptEncoder(\n      original_name=PromptEncoder\n      (pe_layer): PositionEmbeddingRandom(original_name=PositionEmbeddingRandom)\n      (point_embeddings): ModuleList(\n        original_name=ModuleList\n        (0): Embedding(original_name=Embedding)\n        (1): Embedding(original_name=Embedding)\n        (2): Embedding(original_name=Embedding)\n        (3): Embedding(original_name=Embedding)\n      )\n      (not_a_point_embed): Embedding(original_name=Embedding)\n      (mask_downscaling): Sequential(\n        original_name=Sequential\n        (0): Conv2d(original_name=Conv2d)\n        (1): LayerNorm2d(original_name=LayerNorm2d)\n        (2): GELU(original_name=GELU)\n        (3): Conv2d(original_name=Conv2d)\n        (4): LayerNorm2d(original_name=LayerNorm2d)\n        (5): GELU(original_name=GELU)\n        (6): Conv2d(original_name=Conv2d)\n      )\n      (no_mask_embed): Embedding(original_name=Embedding)\n    )\n    (mask_decoder): MaskDecoder(\n      original_name=MaskDecoder\n      (transformer): TwoWayTransformer(\n        original_name=TwoWayTransformer\n        (layers): ModuleList(\n          original_name=ModuleList\n          (0): TwoWayAttentionBlock(\n            original_name=TwoWayAttentionBlock\n            (self_attn): Attention(\n              original_name=Attention\n              (q_proj): Linear(original_name=Linear)\n              (k_proj): Linear(original_name=Linear)\n              (v_proj): Linear(original_name=Linear)\n              (out_proj): Linear(original_name=Linear)\n            )\n            (norm1): LayerNorm(original_name=LayerNorm)\n            (cross_attn_token_to_image): Attention(\n              original_name=Attention\n              (q_proj): Linear(original_name=Linear)\n              (k_proj): Linear(original_name=Linear)\n              (v_proj): Linear(original_name=Linear)\n              (out_proj): Linear(original_name=Linear)\n            )\n            (norm2): LayerNorm(original_name=LayerNorm)\n            (mlp): MLPBlock(\n              original_name=MLPBlock\n              (lin1): Linear(original_name=Linear)\n              (lin2): Linear(original_name=Linear)\n              (act): ReLU(original_name=ReLU)\n            )\n            (norm3): LayerNorm(original_name=LayerNorm)\n            (norm4): LayerNorm(original_name=LayerNorm)\n            (cross_attn_image_to_token): Attention(\n              original_name=Attention\n              (q_proj): Linear(original_name=Linear)\n              (k_proj): Linear(original_name=Linear)\n              (v_proj): Linear(original_name=Linear)\n              (out_proj): Linear(original_name=Linear)\n            )\n          )\n          (1): TwoWayAttentionBlock(\n            original_name=TwoWayAttentionBlock\n            (self_attn): Attention(\n              original_name=Attention\n              (q_proj): Linear(original_name=Linear)\n              (k_proj): Linear(original_name=Linear)\n              (v_proj): Linear(original_name=Linear)\n              (out_proj): Linear(original_name=Linear)\n            )\n            (norm1): LayerNorm(original_name=LayerNorm)\n            (cross_attn_token_to_image): Attention(\n              original_name=Attention\n              (q_proj): Linear(original_name=Linear)\n              (k_proj): Linear(original_name=Linear)\n              (v_proj): Linear(original_name=Linear)\n              (out_proj): Linear(original_name=Linear)\n            )\n            (norm2): LayerNorm(original_name=LayerNorm)\n            (mlp): MLPBlock(\n              original_name=MLPBlock\n              (lin1): Linear(original_name=Linear)\n              (lin2): Linear(original_name=Linear)\n              (act): ReLU(original_name=ReLU)\n            )\n            (norm3): LayerNorm(original_name=LayerNorm)\n            (norm4): LayerNorm(original_name=LayerNorm)\n            (cross_attn_image_to_token): Attention(\n              original_name=Attention\n              (q_proj): Linear(original_name=Linear)\n              (k_proj): Linear(original_name=Linear)\n              (v_proj): Linear(original_name=Linear)\n              (out_proj): Linear(original_name=Linear)\n            )\n          )\n        )\n        (final_attn_token_to_image): Attention(\n          original_name=Attention\n          (q_proj): Linear(original_name=Linear)\n          (k_proj): Linear(original_name=Linear)\n          (v_proj): Linear(original_name=Linear)\n          (out_proj): Linear(original_name=Linear)\n        )\n        (norm_final_attn): LayerNorm(original_name=LayerNorm)\n      )\n      (iou_token): Embedding(original_name=Embedding)\n      (mask_tokens): Embedding(original_name=Embedding)\n      (output_upscaling): Sequential(\n        original_name=Sequential\n        (0): ConvTranspose2d(original_name=ConvTranspose2d)\n        (1): LayerNorm2d(original_name=LayerNorm2d)\n        (2): GELU(original_name=GELU)\n        (3): ConvTranspose2d(original_name=ConvTranspose2d)\n        (4): GELU(original_name=GELU)\n      )\n      (output_hypernetworks_mlps): ModuleList(\n        original_name=ModuleList\n        (0): MLP(\n          original_name=MLP\n          (layers): ModuleList(\n            original_name=ModuleList\n            (0): Linear(original_name=Linear)\n            (1): Linear(original_name=Linear)\n            (2): Linear(original_name=Linear)\n          )\n        )\n        (1): MLP(\n          original_name=MLP\n          (layers): ModuleList(\n            original_name=ModuleList\n            (0): Linear(original_name=Linear)\n            (1): Linear(original_name=Linear)\n            (2): Linear(original_name=Linear)\n          )\n        )\n        (2): MLP(\n          original_name=MLP\n          (layers): ModuleList(\n            original_name=ModuleList\n            (0): Linear(original_name=Linear)\n            (1): Linear(original_name=Linear)\n            (2): Linear(original_name=Linear)\n          )\n        )\n        (3): MLP(\n          original_name=MLP\n          (layers): ModuleList(\n            original_name=ModuleList\n            (0): Linear(original_name=Linear)\n            (1): Linear(original_name=Linear)\n            (2): Linear(original_name=Linear)\n          )\n        )\n      )\n      (iou_prediction_head): MLP(\n        original_name=MLP\n        (layers): ModuleList(\n          original_name=ModuleList\n          (0): Linear(original_name=Linear)\n          (1): Linear(original_name=Linear)\n          (2): Linear(original_name=Linear)\n        )\n      )\n    )\n  )\n)"
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "traced_model"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:01:03.623601Z",
+     "start_time": "2023-06-28T06:01:03.618668Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "outputs": [],
+   "source": [
+    "input_shape = ct.Shape(shape=(1,\n",
+    "                              ct.RangeDim(lower_bound=1, upper_bound=10, default=1),\n",
+    "                              2\n",
+    "                              ))"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:01:03.625916Z",
+     "start_time": "2023-06-28T06:01:03.623959Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:coremltools:Tuple detected at graph output. This will be flattened in the converted model.\n",
+      "Converting PyTorch Frontend ==> MIL Ops:  62%|██████▏   | 1246/1994 [00:00<00:00, 2271.74 ops/s]\n"
+     ]
+    },
+    {
+     "ename": "RuntimeError",
+     "evalue": "PyTorch convert function for op 'repeat_interleave' not implemented.",
+     "output_type": "error",
+     "traceback": [
+      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
+      "\u001B[0;31mRuntimeError\u001B[0m                              Traceback (most recent call last)",
+      "\u001B[0;32m<ipython-input-35-ea767505fecd>\u001B[0m in \u001B[0;36m<module>\u001B[0;34m\u001B[0m\n\u001B[0;32m----> 1\u001B[0;31m ct.convert(traced_model,\n\u001B[0m\u001B[1;32m      2\u001B[0m        inputs=[ct.ImageType(\"image\", shape=[1,3,1024,1024], scale=1.0, bias=[0,0,0]),\n\u001B[1;32m      3\u001B[0m               ct.TensorType(shape=input_shape, name=\"inputs\")],\n\u001B[1;32m      4\u001B[0m            \u001B[0moutputs\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mct\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mImageType\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mname\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0;34m\"mask\"\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mcolor_layout\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0mct\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mcolorlayout\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mGRAYSCALE\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m      5\u001B[0m               )\n",
+      "\u001B[0;32m~/anaconda3/lib/python3.8/site-packages/coremltools/converters/_converters_entry.py\u001B[0m in \u001B[0;36mconvert\u001B[0;34m(model, source, inputs, outputs, classifier_config, minimum_deployment_target, convert_to, compute_precision, skip_model_load, compute_units, package_dir, debug, pass_pipeline)\u001B[0m\n\u001B[1;32m    490\u001B[0m         \u001B[0mspecification_version\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0m_set_default_specification_version\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mexact_target\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    491\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 492\u001B[0;31m     mlmodel = mil_convert(\n\u001B[0m\u001B[1;32m    493\u001B[0m         \u001B[0mmodel\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    494\u001B[0m         \u001B[0mconvert_from\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0mexact_source\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
+      "\u001B[0;32m~/anaconda3/lib/python3.8/site-packages/coremltools/converters/mil/converter.py\u001B[0m in \u001B[0;36mmil_convert\u001B[0;34m(model, convert_from, convert_to, compute_units, **kwargs)\u001B[0m\n\u001B[1;32m    186\u001B[0m         \u001B[0mSee\u001B[0m\u001B[0;31m \u001B[0m\u001B[0;31m`\u001B[0m\u001B[0mcoremltools\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mconverters\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mconvert\u001B[0m\u001B[0;31m`\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    187\u001B[0m     \"\"\"\n\u001B[0;32m--> 188\u001B[0;31m     \u001B[0;32mreturn\u001B[0m \u001B[0m_mil_convert\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mmodel\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mconvert_from\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mconvert_to\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mConverterRegistry\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mMLModel\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mcompute_units\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m**\u001B[0m\u001B[0mkwargs\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m    189\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    190\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n",
+      "\u001B[0;32m~/anaconda3/lib/python3.8/site-packages/coremltools/converters/mil/converter.py\u001B[0m in \u001B[0;36m_mil_convert\u001B[0;34m(model, convert_from, convert_to, registry, modelClass, compute_units, **kwargs)\u001B[0m\n\u001B[1;32m    210\u001B[0m         \u001B[0mkwargs\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0;34m\"weights_dir\"\u001B[0m\u001B[0;34m]\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mweights_dir\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mname\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    211\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 212\u001B[0;31m     proto, mil_program = mil_convert_to_proto(\n\u001B[0m\u001B[1;32m    213\u001B[0m                             \u001B[0mmodel\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    214\u001B[0m                             \u001B[0mconvert_from\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
+      "\u001B[0;32m~/anaconda3/lib/python3.8/site-packages/coremltools/converters/mil/converter.py\u001B[0m in \u001B[0;36mmil_convert_to_proto\u001B[0;34m(model, convert_from, convert_to, converter_registry, main_pipeline, **kwargs)\u001B[0m\n\u001B[1;32m    283\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    284\u001B[0m     \u001B[0mfrontend_converter\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mfrontend_converter_type\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 285\u001B[0;31m     \u001B[0mprog\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mfrontend_converter\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mmodel\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m**\u001B[0m\u001B[0mkwargs\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m    286\u001B[0m     \u001B[0mPipelineManager\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mapply_pipeline\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mprog\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mfrontend_pipeline\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    287\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n",
+      "\u001B[0;32m~/anaconda3/lib/python3.8/site-packages/coremltools/converters/mil/converter.py\u001B[0m in \u001B[0;36m__call__\u001B[0;34m(self, *args, **kwargs)\u001B[0m\n\u001B[1;32m    106\u001B[0m         \u001B[0;32mfrom\u001B[0m \u001B[0;34m.\u001B[0m\u001B[0mfrontend\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mtorch\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mload\u001B[0m \u001B[0;32mimport\u001B[0m \u001B[0mload\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    107\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 108\u001B[0;31m         \u001B[0;32mreturn\u001B[0m \u001B[0mload\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m*\u001B[0m\u001B[0margs\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m**\u001B[0m\u001B[0mkwargs\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m    109\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    110\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n",
+      "\u001B[0;32m~/anaconda3/lib/python3.8/site-packages/coremltools/converters/mil/frontend/torch/load.py\u001B[0m in \u001B[0;36mload\u001B[0;34m(model_spec, inputs, specification_version, debug, outputs, cut_at_symbols, **kwargs)\u001B[0m\n\u001B[1;32m     61\u001B[0m         \u001B[0mspecification_version\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     62\u001B[0m     )\n\u001B[0;32m---> 63\u001B[0;31m     \u001B[0;32mreturn\u001B[0m \u001B[0m_perform_torch_convert\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mconverter\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mdebug\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m     64\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     65\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n",
+      "\u001B[0;32m~/anaconda3/lib/python3.8/site-packages/coremltools/converters/mil/frontend/torch/load.py\u001B[0m in \u001B[0;36m_perform_torch_convert\u001B[0;34m(converter, debug)\u001B[0m\n\u001B[1;32m    108\u001B[0m             \u001B[0mprint\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m\"the following model ops are MISSING:\"\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    109\u001B[0m             \u001B[0mprint\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m\"\\n\"\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mjoin\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0;34m\"  \"\u001B[0m \u001B[0;34m+\u001B[0m \u001B[0mstr\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mx\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;32mfor\u001B[0m \u001B[0mx\u001B[0m \u001B[0;32min\u001B[0m \u001B[0msorted\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mmissing\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 110\u001B[0;31m         \u001B[0;32mraise\u001B[0m \u001B[0me\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m    111\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    112\u001B[0m     \u001B[0;32mreturn\u001B[0m \u001B[0mprog\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
+      "\u001B[0;32m~/anaconda3/lib/python3.8/site-packages/coremltools/converters/mil/frontend/torch/load.py\u001B[0m in \u001B[0;36m_perform_torch_convert\u001B[0;34m(converter, debug)\u001B[0m\n\u001B[1;32m    100\u001B[0m \u001B[0;32mdef\u001B[0m \u001B[0m_perform_torch_convert\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mconverter\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mdebug\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    101\u001B[0m     \u001B[0;32mtry\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 102\u001B[0;31m         \u001B[0mprog\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mconverter\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mconvert\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m    103\u001B[0m     \u001B[0;32mexcept\u001B[0m \u001B[0mRuntimeError\u001B[0m \u001B[0;32mas\u001B[0m \u001B[0me\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    104\u001B[0m         \u001B[0;32mif\u001B[0m \u001B[0mdebug\u001B[0m \u001B[0;32mand\u001B[0m \u001B[0;34m\"convert function\"\u001B[0m \u001B[0;32min\u001B[0m \u001B[0mstr\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0me\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
+      "\u001B[0;32m~/anaconda3/lib/python3.8/site-packages/coremltools/converters/mil/frontend/torch/converter.py\u001B[0m in \u001B[0;36mconvert\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m    282\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    283\u001B[0m             \u001B[0;31m# Add the rest of the operations\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m--> 284\u001B[0;31m             \u001B[0mconvert_nodes\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mcontext\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mgraph\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m    285\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m    286\u001B[0m             \u001B[0mgraph_outputs\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0;34m[\u001B[0m\u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mcontext\u001B[0m\u001B[0;34m[\u001B[0m\u001B[0mname\u001B[0m\u001B[0;34m]\u001B[0m \u001B[0;32mfor\u001B[0m \u001B[0mname\u001B[0m \u001B[0;32min\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mgraph\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0moutputs\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
+      "\u001B[0;32m~/anaconda3/lib/python3.8/site-packages/coremltools/converters/mil/frontend/torch/ops.py\u001B[0m in \u001B[0;36mconvert_nodes\u001B[0;34m(context, graph)\u001B[0m\n\u001B[1;32m     81\u001B[0m         \u001B[0mlogger\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0minfo\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m\"Converting op {} : {}\"\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mformat\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mnode\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mname\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mnode\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mkind\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     82\u001B[0m         \u001B[0;32mif\u001B[0m \u001B[0madd_op\u001B[0m \u001B[0;32mis\u001B[0m \u001B[0;32mNone\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m---> 83\u001B[0;31m             raise RuntimeError(\n\u001B[0m\u001B[1;32m     84\u001B[0m                 \u001B[0;34m\"PyTorch convert function for op '{}' not implemented.\"\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mformat\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mnode\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mkind\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     85\u001B[0m             )\n",
+      "\u001B[0;31mRuntimeError\u001B[0m: PyTorch convert function for op 'repeat_interleave' not implemented."
+     ]
+    }
+   ],
+   "source": [
+    "ct.convert(traced_model,\n",
+    "       inputs=[ct.ImageType(\"image\", shape=[1,3,1024,1024], scale=1.0, bias=[0,0,0]),\n",
+    "              ct.TensorType(shape=input_shape, name=\"inputs\")],\n",
+    "           outputs=[ct.ImageType(name=\"mask\", color_layout=ct.colorlayout.GRAYSCALE)]\n",
+    "              )"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-06-28T06:01:08.483710Z",
+     "start_time": "2023-06-28T06:01:03.688829Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "import torchvision.transforms as T"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "start_time": "2023-06-28T06:01:08.479268Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "img_tensor = T.ToTensor()(image)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "start_time": "2023-06-28T06:01:08.480905Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "x = mobile_sam.preprocess(img_tensor.unsqueeze(0))"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "start_time": "2023-06-28T06:01:08.483116Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "values = mobile_sam.image_encoder(x)"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "values"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "values.shape"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "embed_dim"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "embed_size"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "mobile_sam.pixel_mean"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "name": "python3",
+   "language": "python",
+   "display_name": "Python 3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/segment_anything/build_sam.py b/segment_anything/build_sam.py
index 37cd245..a74c16e 100644
--- a/segment_anything/build_sam.py
+++ b/segment_anything/build_sam.py
@@ -102,6 +102,6 @@ def _build_sam(
     sam.eval()
     if checkpoint is not None:
         with open(checkpoint, "rb") as f:
-            state_dict = torch.load(f)
+            state_dict = torch.load(f, map_location=None if torch.cuda.is_available() else torch.device('cpu'))
         sam.load_state_dict(state_dict)
     return sam
diff --git a/segment_anything/utils/onnx.py b/segment_anything/utils/onnx.py
index 3196bdf..03100c1 100644
--- a/segment_anything/utils/onnx.py
+++ b/segment_anything/utils/onnx.py
@@ -13,7 +13,6 @@
 from ..modeling import Sam
 from .amg import calculate_stability_score
 
-
 class SamOnnxModel(nn.Module):
     """
     This model should not be called directly, but is used in ONNX export.
@@ -142,3 +141,65 @@ def forward(
             return upscaled_masks, scores, stability_scores, areas, masks
 
         return upscaled_masks, scores, masks
+
+
+
+
+
+
+class SimpleSamOnnxModel(SamOnnxModel):
+    """
+    This model should not be called directly, but is used in ONNX export.
+    It combines the prompt encoder, mask decoder, and mask postprocessing of Sam,
+    with some functions modified to enable model tracing. Also supports extra
+    options controlling what information. See the ONNX export script for details.
+    """
+
+    def __init__(
+        self,
+        model: Sam,
+    ) -> None:
+        super().__init__(model=model,
+                         return_single_mask=True,
+                         return_extra_metrics=False,
+                         use_stability_score=True)
+
+    @torch.no_grad()
+    def forward(
+        self,
+        x: torch.Tensor,
+        point_coords: torch.Tensor
+    ):
+        #Generate the image embeddings in the model so it works end-to-end
+        img = self.model.preprocess(x)
+        image_embeddings = self.model.image_encoder(img)
+
+        orig_im_size = torch.Tensor([x.shape[-2], x.shape[-1]]).float()
+        #Remove these from arguments for simplicity
+        mask_input_size = [4 * x for x in self.model.prompt_encoder.image_embedding_size]
+        mask_input = torch.zeros(1,1,*mask_input_size, dtype=torch.float)
+        has_mask_input = torch.tensor([0], dtype=torch.float)
+
+        #Only returning a single mask, just add all labels as 1
+        point_labels = torch.ones(1, point_coords.shape[1], dtype=torch.long)
+        sparse_embedding = self._embed_points(point_coords, point_labels)
+        dense_embedding = self._embed_masks(mask_input, has_mask_input)
+
+        masks, scores = self.model.mask_decoder.predict_masks(
+            image_embeddings=image_embeddings,
+            image_pe=self.model.prompt_encoder.get_dense_pe(),
+            sparse_prompt_embeddings=sparse_embedding,
+            dense_prompt_embeddings=dense_embedding,
+        )
+
+
+        scores = calculate_stability_score(
+            masks, self.model.mask_threshold, self.stability_score_offset
+        )
+
+        masks, scores = self.select_masks(masks, scores, point_coords.shape[1])
+
+        upscaled_masks = self.mask_postprocessing(masks, orig_im_size)
+
+        #apply Sigmoid to the masks
+        return torch.sigmoid(upscaled_masks), scores, torch.sigmoid(masks)