commit 6cd06a7a8607c54bddd1a96fc4bd4af9849d1bc9
Author: yadonglu <yadonglu@microsoft.com>
Date:   Fri Sep 20 15:49:30 2024 -0700

    first commit

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..63e1ca5
--- /dev/null
+++ b/README.md
@@ -0,0 +1,32 @@
+# OmniParser: Screen Parsing tool for Pure Vision Based GUI Agent
+
+![Logo](imgs/logo.png)
+[![arXiv](https://img.shields.io/badge/Paper-green)](https://arxiv.org/abs/2408.00203)
+[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**OmniParser** is a comprehensive method for parsing user interface screenshots into structured and easy-to-understand elements, which significantly enhances the ability of GPT-4V to generate actions that can be accurately grounded in the corresponding regions of the interface. 
+
+## Examples:
+We put together a few simple examples in the demo.ipynb. 
+
+## Gradio Demo
+To run gradio demo, simply run:
+```python
+python gradion_demo.py
+```
+
+
+## 📚 Citation
+Our technical report can be found [here](https://arxiv.org/abs/2408.00203).
+If you find our work useful, please consider citing our work:
+```
+@misc{lu2024omniparserpurevisionbased,
+      title={OmniParser for Pure Vision Based GUI Agent}, 
+      author={Yadong Lu and Jianwei Yang and Yelong Shen and Ahmed Awadallah},
+      year={2024},
+      eprint={2408.00203},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2408.00203}, 
+}
+```
diff --git a/demo.ipynb b/demo.ipynb
new file mode 100644
index 0000000..780a7ab
--- /dev/null
+++ b/demo.ipynb
@@ -0,0 +1,542 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/yadonglu/anaconda3/envs/pilot/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "/home/yadonglu/anaconda3/envs/pilot/lib/python3.9/site-packages/transformers/utils/generic.py:485: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
+      "  _torch_pytree._register_pytree_node(\n"
+     ]
+    }
+   ],
+   "source": [
+    "from utils import get_som_labeled_img, check_ocr_box, get_caption_model_processor,  get_dino_model, get_yolo_model\n",
+    "import torch\n",
+    "from ultralytics import YOLO\n",
+    "from PIL import Image\n",
+    "device = 'cpu'\n",
+    "\n",
+    "# dino_model = get_dino_model(load_hf_model=True, device=device)\n",
+    "som_model = get_yolo_model(model_path='finetuned_icon_detect.pt')\n",
+    "\n",
+    "# caption_model_processor = get_caption_model_processor(\"Salesforce/blip2-opt-2.7b\", device=device)\n",
+    "# caption_model_processor['model'].to(torch.float32)\n",
+    "# som_model.to(device)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(device(type='cpu'), ultralytics.models.yolo.model.YOLO)"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "som_model.device, type(som_model) #, type(dino_model['model']), isinstance(som_model, YOLO) dino_model['model'].device, "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "image 1/1 /home/yadonglu/sandbox/screenparsing_collab/screenparsing/omniparser/examples/pc_1.png: 800x1280 210 icons, 69.9ms\n",
+      "Speed: 7.7ms preprocess, 69.9ms inference, 1.7ms postprocess per image at shape (1, 3, 800, 1280)\n",
+      "boxes cpu\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "platform = 'pc'\n",
+    "cnt = 0\n",
+    "image_path = 'imgs/pc_1.png'\n",
+    "# image_path = 'imgs/mobile_4.png'\n",
+    "# get dino labeled image\n",
+    "if platform == 'pc':\n",
+    "    draw_bbox_config = {\n",
+    "        'text_scale': 0.8,\n",
+    "        'text_thickness': 2,\n",
+    "        'text_padding': 3,\n",
+    "        'thickness': 3,\n",
+    "    }\n",
+    "    BOX_TRESHOLD = 0.05\n",
+    "elif platform == 'web':\n",
+    "    draw_bbox_config = {\n",
+    "        'text_scale': 0.8,\n",
+    "        'text_thickness': 2,\n",
+    "        'text_padding': 3,\n",
+    "        'thickness': 3,\n",
+    "    }\n",
+    "    BOX_TRESHOLD = 0.05\n",
+    "elif platform == 'mobile':\n",
+    "    draw_bbox_config = {\n",
+    "        'text_scale': 0.8,\n",
+    "        'text_thickness': 2,\n",
+    "        'text_padding': 3,\n",
+    "        'thickness': 3,\n",
+    "    }\n",
+    "    BOX_TRESHOLD = 0.05\n",
+    "image = Image.open(image_path)\n",
+    "image_rgb = image.convert('RGB')\n",
+    "\n",
+    "ocr_bbox_rslt, is_goal_filtered = check_ocr_box(image_path, display_img = False, output_bb_format='xyxy', goal_filtering=None, easyocr_args={'paragraph': False, 'text_threshold':0.9})\n",
+    "text, ocr_bbox = ocr_bbox_rslt\n",
+    "\n",
+    "dino_labled_img, label_coordinates, parsed_content_list = get_som_labeled_img(image_path, som_model, BOX_TRESHOLD = BOX_TRESHOLD, output_coord_in_ratio=False, ocr_bbox=ocr_bbox,draw_bbox_config=draw_bbox_config, caption_model_processor=None, ocr_text=text,use_local_semantics=False)\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "({'0': array([         94,          38,          95,          24], dtype=float32),\n",
+       "  '1': array([        628,          35,         153,          30], dtype=float32),\n",
+       "  '2': array([        813,          35,         125,          27], dtype=float32),\n",
+       "  '3': array([        985,          35,         100,          27], dtype=float32),\n",
+       "  '4': array([       1362,          33,          85,          29], dtype=float32),\n",
+       "  '5': array([       2578,          34,          77,          32], dtype=float32),\n",
+       "  '6': array([         38,         114,          47,          29], dtype=float32),\n",
+       "  '7': array([        129,         114,          80,          29], dtype=float32),\n",
+       "  '8': array([        241,         114,          74,          29], dtype=float32),\n",
+       "  '9': array([        347,         114,          70,          29], dtype=float32),\n",
+       "  '10': array([        445,         113,          92,          36], dtype=float32),\n",
+       "  '11': array([        570,         111,         133,          32], dtype=float32),\n",
+       "  '12': array([        739,         111,         141,          32], dtype=float32),\n",
+       "  '13': array([        911,         111,         138,          32], dtype=float32),\n",
+       "  '14': array([       1081,         114,          87,          29], dtype=float32),\n",
+       "  '15': array([       1202,         114,          90,          29], dtype=float32),\n",
+       "  '16': array([       1321,         114,          65,          29], dtype=float32),\n",
+       "  '17': array([       1415,         114,          62,          32], dtype=float32),\n",
+       "  '18': array([       2584,         114,          88,          27], dtype=float32),\n",
+       "  '19': array([       2736,         111,         204,          30], dtype=float32),\n",
+       "  '20': array([       3063,         111,          72,          30], dtype=float32),\n",
+       "  '21': array([        456,         176,          86,          36], dtype=float32),\n",
+       "  '22': array([       1109,         180,          97,          51], dtype=float32),\n",
+       "  '23': array([       1404,         184,         175,          44], dtype=float32),\n",
+       "  '24': array([       2030,         174,          77,          38], dtype=float32),\n",
+       "  '25': array([       2296,         177,          55,          27], dtype=float32),\n",
+       "  '26': array([         51,         246,          62,          26], dtype=float32),\n",
+       "  '27': array([        256,         243,          54,          27], dtype=float32),\n",
+       "  '28': array([        337,         246,          67,          24], dtype=float32),\n",
+       "  '29': array([        461,         230,          64,          27], dtype=float32),\n",
+       "  '30': array([       1594,         222,          46,          41], dtype=float32),\n",
+       "  '31': array([       1704,         241,         183,          37], dtype=float32),\n",
+       "  '32': array([       1904,         243,          69,          27], dtype=float32),\n",
+       "  '33': array([       2030,         226,         165,          37], dtype=float32),\n",
+       "  '34': array([       2298,         230,          88,          30], dtype=float32),\n",
+       "  '35': array([       2465,         243,          80,          29], dtype=float32),\n",
+       "  '36': array([       2577,         238,         120,          39], dtype=float32),\n",
+       "  '37': array([       2731,         243,          90,          27], dtype=float32),\n",
+       "  '38': array([       2853,         243,         194,          32], dtype=float32),\n",
+       "  '39': array([        726,         250,          43,          39], dtype=float32),\n",
+       "  '40': array([        964,         256,          68,          29], dtype=float32),\n",
+       "  '41': array([       1345,         246,         162,          51], dtype=float32),\n",
+       "  '42': array([        238,         273,          62,          30], dtype=float32),\n",
+       "  '43': array([        334,         273,          70,          30], dtype=float32),\n",
+       "  '44': array([        458,         281,          88,          27], dtype=float32),\n",
+       "  '45': array([       1891,         276,          70,          29], dtype=float32),\n",
+       "  '46': array([       2106,         281,          77,          27], dtype=float32),\n",
+       "  '47': array([       2296,         281,          75,          27], dtype=float32),\n",
+       "  '48': array([         58,         324,          98,          27], dtype=float32),\n",
+       "  '49': array([        380,         324,          59,          27], dtype=float32),\n",
+       "  '50': array([        874,         328,          45,          19], dtype=float32),\n",
+       "  '51': array([       1390,         324,         100,          29], dtype=float32),\n",
+       "  '52': array([       1905,         322,          85,          32], dtype=float32),\n",
+       "  '53': array([       2305,         322,          74,          32], dtype=float32),\n",
+       "  '54': array([       2476,         324,          57,          27], dtype=float32),\n",
+       "  '55': array([       2587,         324,         103,          27], dtype=float32),\n",
+       "  '56': array([       2734,         324,          80,          27], dtype=float32),\n",
+       "  '57': array([       1367,         978,        1067,         146], dtype=float32),\n",
+       "  '58': array([       1617,        1187,         564,          63], dtype=float32),\n",
+       "  '59': array([        602,        1944,         242,          32], dtype=float32),\n",
+       "  '60': array([       2034,         277,          68,          39], dtype=float32),\n",
+       "  '61': array([     2965.8,      11.372,       73.33,      65.827], dtype=float32),\n",
+       "  '62': array([     2963.6,      104.42,      45.381,      45.756], dtype=float32),\n",
+       "  '63': array([     198.97,      28.516,      79.805,      38.483], dtype=float32),\n",
+       "  '64': array([     608.18,      181.26,      342.97,      50.053], dtype=float32),\n",
+       "  '65': array([     1300.6,         250,      33.767,      35.427], dtype=float32),\n",
+       "  '66': array([     304.13,      30.349,      37.342,      36.602], dtype=float32),\n",
+       "  '67': array([     667.74,      241.55,      47.529,      53.978], dtype=float32),\n",
+       "  '68': array([     822.62,       244.9,      47.754,      51.829], dtype=float32),\n",
+       "  '69': array([     770.31,      244.16,      46.905,      51.143], dtype=float32),\n",
+       "  '70': array([     1248.1,      251.22,       31.97,       32.78], dtype=float32),\n",
+       "  '71': array([     1048.9,      244.81,      45.524,          47], dtype=float32),\n",
+       "  '72': array([     438.99,      28.466,      35.963,      37.508], dtype=float32),\n",
+       "  '73': array([     954.49,      181.67,      94.131,      49.485], dtype=float32),\n",
+       "  '74': array([     363.65,      29.569,      32.883,      36.315], dtype=float32),\n",
+       "  '75': array([     497.99,      28.813,      32.513,      34.289], dtype=float32),\n",
+       "  '76': array([     1332.3,       188.4,      32.144,      34.772], dtype=float32),\n",
+       "  '77': array([     1137.5,      251.92,      34.499,      34.152], dtype=float32),\n",
+       "  '78': array([     880.41,      249.27,      39.986,       37.76], dtype=float32),\n",
+       "  '79': array([     954.73,      33.853,      23.966,      27.856], dtype=float32),\n",
+       "  '80': array([       2888,      21.725,      45.384,        44.9], dtype=float32),\n",
+       "  '81': array([     1997.3,      222.31,      34.341,      34.824], dtype=float32),\n",
+       "  '82': array([     625.14,      249.45,      29.211,      36.318], dtype=float32),\n",
+       "  '83': array([     554.33,      25.136,       36.99,       42.99], dtype=float32),\n",
+       "  '84': array([     2786.6,      22.758,      52.631,      49.663], dtype=float32),\n",
+       "  '85': array([     1812.5,       176.7,      57.761,      59.091], dtype=float32),\n",
+       "  '86': array([     3170.5,      26.987,      44.986,      46.376], dtype=float32),\n",
+       "  '87': array([     1284.7,      182.54,      32.466,      49.088], dtype=float32),\n",
+       "  '88': array([     423.68,       280.2,      28.832,      30.261], dtype=float32),\n",
+       "  '89': array([     1716.8,      179.54,      59.374,      50.265], dtype=float32),\n",
+       "  '90': array([      344.3,      185.95,      54.543,      42.996], dtype=float32),\n",
+       "  '91': array([     1515.7,      252.05,      33.876,      33.092], dtype=float32),\n",
+       "  '92': array([     1090.8,      243.67,      36.191,      50.504], dtype=float32),\n",
+       "  '93': array([     1248.6,      189.02,      32.175,      33.261], dtype=float32),\n",
+       "  '94': array([     963.23,      254.24,      40.774,      33.985], dtype=float32),\n",
+       "  '95': array([     1717.4,      174.03,      52.504,      48.792], dtype=float32),\n",
+       "  '96': array([     3075.8,      30.369,      39.574,      38.682], dtype=float32),\n",
+       "  '97': array([     3187.4,      107.39,      33.734,       40.21], dtype=float32),\n",
+       "  '98': array([     2966.8,       168.2,      91.261,       105.9], dtype=float32),\n",
+       "  '99': array([     30.782,      33.378,        33.3,      31.807], dtype=float32),\n",
+       "  '100': array([     1196.9,      324.51,      27.192,      25.869], dtype=float32),\n",
+       "  '101': array([     3172.2,      310.76,      44.785,      39.261], dtype=float32),\n",
+       "  '102': array([     1998.4,      173.44,      30.627,      32.274], dtype=float32),\n",
+       "  '103': array([     787.33,      241.95,      64.931,      57.226], dtype=float32),\n",
+       "  '104': array([     2692.7,      21.129,      51.957,      55.543], dtype=float32),\n",
+       "  '105': array([     1170.2,      247.59,      34.892,      42.735], dtype=float32),\n",
+       "  '106': array([     1910.2,      174.37,      58.716,      53.398], dtype=float32),\n",
+       "  '107': array([     2259.9,      225.75,      31.152,       32.17], dtype=float32),\n",
+       "  '108': array([     254.78,       181.7,      56.533,      44.474], dtype=float32),\n",
+       "  '109': array([     1047.4,      182.75,      71.279,      49.489], dtype=float32),\n",
+       "  '110': array([     424.87,      175.44,      29.783,      28.272], dtype=float32),\n",
+       "  '111': array([     892.42,      233.03,      55.596,      76.345], dtype=float32),\n",
+       "  '112': array([     2873.1,      180.61,      62.642,      47.626], dtype=float32),\n",
+       "  '113': array([     1996.8,      278.17,      31.037,      31.622], dtype=float32),\n",
+       "  '114': array([     11.883,      368.91,      564.39,      1578.2], dtype=float32),\n",
+       "  '115': array([     422.86,      225.74,      29.434,      28.735], dtype=float32),\n",
+       "  '116': array([     1794.2,      209.55,      92.729,       62.57], dtype=float32),\n",
+       "  '117': array([     1702.6,      235.84,      84.464,      33.964], dtype=float32)},\n",
+       " 'AutoSave')"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "label_coordinates, parsed_content_list[0].split(': ')[1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7fefc0b52f10>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x1200 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot dino_labled_img it is in base64\n",
+    "import base64\n",
+    "import matplotlib.pyplot as plt\n",
+    "import io\n",
+    "plt.figure(figsize=(12,12))\n",
+    "\n",
+    "image = Image.open(io.BytesIO(base64.b64decode(dino_labled_img)))\n",
+    "plt.axis('off')\n",
+    "\n",
+    "plt.imshow(image)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# wrapped Omniparser"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Parsing image: examples/pc_1.png\n",
+      "\n",
+      "image 1/1 /home/yadonglu/sandbox/screenparsing_collab/screenparsing/omniparser/examples/pc_1.png: 800x1280 210 icons, 55.6ms\n",
+      "Speed: 7.7ms preprocess, 55.6ms inference, 1.5ms postprocess per image at shape (1, 3, 800, 1280)\n",
+      "boxes cpu\n",
+      "Time taken for Omniparser on cpu: 2.029506206512451\n"
+     ]
+    }
+   ],
+   "source": [
+    "from utils import get_som_labeled_img, check_ocr_box, get_caption_model_processor,  get_dino_model, get_yolo_model\n",
+    "import torch\n",
+    "from ultralytics import YOLO\n",
+    "from PIL import Image\n",
+    "from typing import Dict, Tuple, List\n",
+    "import io\n",
+    "import base64\n",
+    "\n",
+    "\n",
+    "config = {\n",
+    "    'som_model_path': 'finetuned_icon_detect.pt',\n",
+    "    'device': 'cpu',\n",
+    "    'caption_model_path': 'Salesforce/blip2-opt-2.7b',\n",
+    "    'draw_bbox_config': {\n",
+    "        'text_scale': 0.8,\n",
+    "        'text_thickness': 2,\n",
+    "        'text_padding': 3,\n",
+    "        'thickness': 3,\n",
+    "    },\n",
+    "    'BOX_TRESHOLD': 0.05\n",
+    "}\n",
+    "\n",
+    "\n",
+    "class Omniparser(object):\n",
+    "    def __init__(self, config: Dict):\n",
+    "        self.config = config\n",
+    "        \n",
+    "        self.som_model = get_yolo_model(model_path=config['som_model_path'])\n",
+    "        # self.caption_model_processor = get_caption_model_processor(config['caption_model_path'], device=cofig['device'])\n",
+    "        # self.caption_model_processor['model'].to(torch.float32)\n",
+    "\n",
+    "    def parse(self, image_path: str):\n",
+    "        print('Parsing image:', image_path)\n",
+    "        ocr_bbox_rslt, is_goal_filtered = check_ocr_box(image_path, display_img = False, output_bb_format='xyxy', goal_filtering=None, easyocr_args={'paragraph': False, 'text_threshold':0.9})\n",
+    "        text, ocr_bbox = ocr_bbox_rslt\n",
+    "\n",
+    "        draw_bbox_config = self.config['draw_bbox_config']\n",
+    "        BOX_TRESHOLD = self.config['BOX_TRESHOLD']\n",
+    "        dino_labled_img, label_coordinates, parsed_content_list = get_som_labeled_img(image_path, self.som_model, BOX_TRESHOLD = BOX_TRESHOLD, output_coord_in_ratio=False, ocr_bbox=ocr_bbox,draw_bbox_config=draw_bbox_config, caption_model_processor=None, ocr_text=text,use_local_semantics=False)\n",
+    "        \n",
+    "        image = Image.open(io.BytesIO(base64.b64decode(dino_labled_img)))\n",
+    "        # formating output\n",
+    "        return_list = [{'from': 'omniparser', 'shape': {'x':coord[0], 'y':coord[1], 'width':coord[2], 'height':coord[3]},\n",
+    "                        'text': parsed_content_list[i].split(': ')[1], 'type':'text'} for i, (k, coord) in enumerate(label_coordinates.items()) if i < len(parsed_content_list)]\n",
+    "        return_list.extend(\n",
+    "            [{'from': 'omniparser', 'shape': {'x':coord[0], 'y':coord[1], 'width':coord[2], 'height':coord[3]},\n",
+    "                        'text': 'None', 'type':'icon'} for i, (k, coord) in enumerate(label_coordinates.items()) if i >= len(parsed_content_list)]\n",
+    "              )\n",
+    "\n",
+    "        return [image, return_list]\n",
+    "    \n",
+    "parser = Omniparser(config)\n",
+    "image_path = 'imgs/pc_1.png'\n",
+    "\n",
+    "#  time the parser\n",
+    "import time\n",
+    "s = time.time()\n",
+    "image, parsed_content_list = parser.parse(image_path)\n",
+    "device = config['device']\n",
+    "print(f'Time taken for Omniparser on {device}:', time.time() - s)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0: 800x1280 210 icons, 49.4ms\n",
+      "Speed: 5.7ms preprocess, 49.4ms inference, 1.1ms postprocess per image at shape (1, 3, 800, 1280)\n",
+      "boxes cpu\n",
+      "Time taken for Omniparser finetuned YOLO module on cpu: 0.2898883819580078\n"
+     ]
+    }
+   ],
+   "source": [
+    "from utils import get_som_labeled_img, check_ocr_box, get_caption_model_processor,  get_dino_model, get_yolo_model, predict_yolo\n",
+    "import torch\n",
+    "from ultralytics import YOLO\n",
+    "from PIL import Image\n",
+    "from typing import Dict, Tuple, List\n",
+    "import io\n",
+    "import base64\n",
+    "\n",
+    "\n",
+    "config = {\n",
+    "    'som_model_path': 'finetuned_icon_detect.pt',\n",
+    "    'device': 'cpu',\n",
+    "    'caption_model_path': 'Salesforce/blip2-opt-2.7b',\n",
+    "    'draw_bbox_config': {\n",
+    "        'text_scale': 0.8,\n",
+    "        'text_thickness': 2,\n",
+    "        'text_padding': 3,\n",
+    "        'thickness': 3,\n",
+    "    },\n",
+    "    'BOX_TRESHOLD': 0.05\n",
+    "}\n",
+    "\n",
+    "class OmniparserYOLO(object):\n",
+    "    def __init__(self, config: Dict):\n",
+    "        self.config = config\n",
+    "        self.som_model = get_yolo_model(model_path=config['som_model_path'])\n",
+    "\n",
+    "    def parse(self, image):\n",
+    "        draw_bbox_config = self.config['draw_bbox_config']\n",
+    "        BOX_TRESHOLD = self.config['BOX_TRESHOLD']\n",
+    "        xyxy, logits, phrases = predict_yolo(model=self.som_model, image_path=image, box_threshold=BOX_TRESHOLD)\n",
+    "        # print('xyxy:', xyxy)\n",
+    "        xyxy = xyxy.tolist()\n",
+    "        # formating output\n",
+    "        return_list = [{'from': 'omniparserYOLO', 'shape': {'x':coord[0], 'y':coord[1], 'width':coord[2]-coord[0], 'height':coord[3] - coord[1]},\n",
+    "                        'text': 'None', 'type':'icon'} for i, coord in enumerate(xyxy)]\n",
+    "        \n",
+    "        return [None, return_list]\n",
+    "    \n",
+    "parser = OmniparserYOLO(config)\n",
+    "image_path = 'imgs/pc_1.png'\n",
+    "image = Image.open(image_path)\n",
+    "\n",
+    "#  time the parser\n",
+    "import time\n",
+    "s = time.time()\n",
+    "_, parsed_content_list = parser.parse(image)\n",
+    "device = config['device']\n",
+    "print(f'Time taken for Omniparser finetuned YOLO module on {device}:', time.time() - s)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# florence caption model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/yadonglu/anaconda3/envs/pilot/lib/python3.9/site-packages/transformers/utils/generic.py:342: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
+      "  _torch_pytree._register_pytree_node(\n",
+      "/home/yadonglu/anaconda3/envs/pilot/lib/python3.9/site-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import AutoProcessor, AutoModelForCausalLM \n",
+    "import torch\n",
+    "device = 'cpu'\n",
+    "torch_dtype = torch.float16 if device == 'cuda' else torch.float32\n",
+    "model = AutoModelForCausalLM.from_pretrained(\"/home/yadonglu/sandbox/data/orca/florence-2-base-ft-fft_rai_win_ep5/epoch_5\", torch_dtype=torch_dtype, trust_remote_code=True).to(device)\n",
+    "processor = AutoProcessor.from_pretrained(\"microsoft/Florence-2-base\", trust_remote_code=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['settings or configuration options.']"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from PIL import Image\n",
+    "prompt = \"<CAPTION>\"\n",
+    "image_path = 'imgs/settings.png'\n",
+    "image = [Image.open(image_path).convert('RGB')]\n",
+    "inputs = processor(images=image, text=[prompt]*len(image), return_tensors=\"pt\").to(device=device)\n",
+    "generated_ids = model.generate(input_ids=inputs[\"input_ids\"],pixel_values=inputs[\"pixel_values\"],max_new_tokens=1024,num_beams=3, do_sample=False)\n",
+    "generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)\n",
+    "generated_text = [gen.strip() for gen in generated_text]\n",
+    "generated_text"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pilot",
+   "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.9.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/gradio_demo.py b/gradio_demo.py
new file mode 100644
index 0000000..62408c0
--- /dev/null
+++ b/gradio_demo.py
@@ -0,0 +1,104 @@
+from typing import Optional
+
+import gradio as gr
+import numpy as np
+import torch
+from PIL import Image
+import io
+
+
+import base64, os
+from utils import check_ocr_box, get_yolo_model, get_caption_model_processor, get_som_labeled_img
+import torch
+from PIL import Image
+
+yolo_model = get_yolo_model()
+caption_model_processor = get_caption_model_processor('florence', device='cuda') # 'blip2-opt-2.7b-ui', phi3v_ui florence
+platform = 'pc'
+if platform == 'pc':
+    draw_bbox_config = {
+        'text_scale': 0.8,
+        'text_thickness': 2,
+        'text_padding': 2,
+        'thickness': 2,
+    }
+    BOX_TRESHOLD = 0.05
+elif platform == 'web':
+    draw_bbox_config = {
+        'text_scale': 0.8,
+        'text_thickness': 2,
+        'text_padding': 3,
+        'thickness': 3,
+    }
+    BOX_TRESHOLD = 0.05
+elif platform == 'mobile':
+    draw_bbox_config = {
+        'text_scale': 0.8,
+        'text_thickness': 2,
+        'text_padding': 3,
+        'thickness': 3,
+    }
+    BOX_TRESHOLD = 0.05
+
+
+
+MARKDOWN = """
+# OmniParser for Pure Vision Based General GUI Agent 🔥
+<div>
+    <a href="https://arxiv.org/pdf/2408.00203">
+        <img src="https://img.shields.io/badge/arXiv-2408.00203-b31b1b.svg" alt="Arxiv" style="display:inline-block;">
+    </a>
+</div>
+
+OmniParser is a screen parsing tool to convert general GUI screen to structured elements.  **Trained models will be released soon**
+"""
+
+DEVICE = torch.device('cuda')
+
+# @spaces.GPU
+# @torch.inference_mode()
+# @torch.autocast(device_type="cuda", dtype=torch.bfloat16)
+def process(
+    image_input,
+    prompt: str = None
+) -> Optional[Image.Image]:
+
+    image_path = "/home/yadonglu/sandbox/data/omniparser_demo/image_input.png"
+    image_input.save(image_path)
+    # import pdb; pdb.set_trace()
+
+    ocr_bbox_rslt, is_goal_filtered = check_ocr_box(image_path, display_img = False, output_bb_format='xyxy', goal_filtering=None, easyocr_args={'paragraph': False, 'text_threshold':0.9})
+    text, ocr_bbox = ocr_bbox_rslt
+    print('prompt:', prompt)
+    dino_labled_img, label_coordinates, parsed_content_list = get_som_labeled_img(image_path, yolo_model, BOX_TRESHOLD = BOX_TRESHOLD, output_coord_in_ratio=True, ocr_bbox=ocr_bbox,draw_bbox_config=draw_bbox_config, caption_model_processor=caption_model_processor, ocr_text=text,iou_threshold=0.3,prompt=prompt)
+    image = Image.open(io.BytesIO(base64.b64decode(dino_labled_img)))
+    print('finish processing')
+    parsed_content_list = '\n'.join(parsed_content_list)
+    return image, str(parsed_content_list)
+
+
+
+with gr.Blocks() as demo:
+    gr.Markdown(MARKDOWN)
+    with gr.Row():
+        with gr.Column():
+            image_input_component = gr.Image(
+                type='pil', label='Upload image')
+            prompt_input_component = gr.Textbox(label='Prompt', placeholder='')
+            submit_button_component = gr.Button(
+                value='Submit', variant='primary')
+        with gr.Column():
+            image_output_component = gr.Image(type='pil', label='Image Output')
+            text_output_component = gr.Textbox(label='Parsed screen elements', placeholder='Text Output')
+
+    submit_button_component.click(
+        fn=process,
+        inputs=[
+            image_input_component,
+            prompt_input_component,
+        ],
+        outputs=[image_output_component, text_output_component]
+    )
+
+# demo.launch(debug=False, show_error=True, share=True)
+demo.launch(share=True, server_port=7861, server_name='0.0.0.0')
\ No newline at end of file
diff --git a/imgs/logo.png b/imgs/logo.png
new file mode 100644
index 0000000..11dd2c0
Binary files /dev/null and b/imgs/logo.png differ
diff --git a/imgs/mobile_4.png b/imgs/mobile_4.png
new file mode 100644
index 0000000..6dddef8
Binary files /dev/null and b/imgs/mobile_4.png differ
diff --git a/imgs/pc_1.png b/imgs/pc_1.png
new file mode 100644
index 0000000..fc15669
Binary files /dev/null and b/imgs/pc_1.png differ
diff --git a/imgs/settings.png b/imgs/settings.png
new file mode 100644
index 0000000..3b343f9
Binary files /dev/null and b/imgs/settings.png differ
diff --git a/omniparser.py b/omniparser.py
new file mode 100644
index 0000000..37b7780
--- /dev/null
+++ b/omniparser.py
@@ -0,0 +1,60 @@
+from utils import get_som_labeled_img, check_ocr_box, get_caption_model_processor,  get_dino_model, get_yolo_model
+import torch
+from ultralytics import YOLO
+from PIL import Image
+from typing import Dict, Tuple, List
+import io
+import base64
+
+
+config = {
+    'som_model_path': 'finetuned_icon_detect.pt',
+    'device': 'cpu',
+    'caption_model_path': 'Salesforce/blip2-opt-2.7b',
+    'draw_bbox_config': {
+        'text_scale': 0.8,
+        'text_thickness': 2,
+        'text_padding': 3,
+        'thickness': 3,
+    },
+    'BOX_TRESHOLD': 0.05
+}
+
+
+class Omniparser(object):
+    def __init__(self, config: Dict):
+        self.config = config
+        
+        self.som_model = get_yolo_model(model_path=config['som_model_path'])
+        # self.caption_model_processor = get_caption_model_processor(config['caption_model_path'], device=cofig['device'])
+        # self.caption_model_processor['model'].to(torch.float32)
+
+    def parse(self, image_path: str):
+        print('Parsing image:', image_path)
+        ocr_bbox_rslt, is_goal_filtered = check_ocr_box(image_path, display_img = False, output_bb_format='xyxy', goal_filtering=None, easyocr_args={'paragraph': False, 'text_threshold':0.9})
+        text, ocr_bbox = ocr_bbox_rslt
+
+        draw_bbox_config = self.config['draw_bbox_config']
+        BOX_TRESHOLD = self.config['BOX_TRESHOLD']
+        dino_labled_img, label_coordinates, parsed_content_list = get_som_labeled_img(image_path, self.som_model, BOX_TRESHOLD = BOX_TRESHOLD, output_coord_in_ratio=False, ocr_bbox=ocr_bbox,draw_bbox_config=draw_bbox_config, caption_model_processor=None, ocr_text=text,use_local_semantics=False)
+        
+        image = Image.open(io.BytesIO(base64.b64decode(dino_labled_img)))
+        # formating output
+        return_list = [{'from': 'omniparser', 'shape': {'x':coord[0], 'y':coord[1], 'width':coord[2], 'height':coord[3]},
+                        'text': parsed_content_list[i].split(': ')[1], 'type':'text'} for i, (k, coord) in enumerate(label_coordinates.items()) if i < len(parsed_content_list)]
+        return_list.extend(
+            [{'from': 'omniparser', 'shape': {'x':coord[0], 'y':coord[1], 'width':coord[2], 'height':coord[3]},
+                        'text': 'None', 'type':'icon'} for i, (k, coord) in enumerate(label_coordinates.items()) if i >= len(parsed_content_list)]
+              )
+
+        return [image, return_list]
+    
+parser = Omniparser(config)
+image_path = 'examples/pc_1.png'
+
+#  time the parser
+import time
+s = time.time()
+image, parsed_content_list = parser.parse(image_path)
+device = config['device']
+print(f'Time taken for Omniparser on {device}:', time.time() - s)
diff --git a/requirement.txt b/requirement.txt
new file mode 100644
index 0000000..b447efb
--- /dev/null
+++ b/requirement.txt
@@ -0,0 +1,14 @@
+torch==2.2.2
+easyocr==1.7.1
+torchvision==0.17.2
+supervision==0.18.0
+openai==1.3.5
+transformers==4.40.2
+ultralytics==8.1.24
+azure-identity
+numpy
+opencv-python==4.8.1.78
+opencv-python-headless==4.8.0.74
+supervision==0.18.0
+gradio==4.40.0
+
diff --git a/util/__init__.py b/util/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/util/__pycache__/__init__.cpython-39.pyc b/util/__pycache__/__init__.cpython-39.pyc
new file mode 100644
index 0000000..b576813
Binary files /dev/null and b/util/__pycache__/__init__.cpython-39.pyc differ
diff --git a/util/__pycache__/action_matching.cpython-39.pyc b/util/__pycache__/action_matching.cpython-39.pyc
new file mode 100644
index 0000000..aac3447
Binary files /dev/null and b/util/__pycache__/action_matching.cpython-39.pyc differ
diff --git a/util/__pycache__/box_annotator.cpython-39.pyc b/util/__pycache__/box_annotator.cpython-39.pyc
new file mode 100644
index 0000000..ea1949b
Binary files /dev/null and b/util/__pycache__/box_annotator.cpython-39.pyc differ
diff --git a/util/action_matching.py b/util/action_matching.py
new file mode 100644
index 0000000..fa986b4
--- /dev/null
+++ b/util/action_matching.py
@@ -0,0 +1,425 @@
+'''
+Adapted from https://github.com/google-research/google-research/tree/master/android_in_the_wild
+'''
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+# import action_type as action_type_lib
+import enum
+
+class ActionType(enum.IntEnum):
+    # Placeholders for unused enum values
+    UNUSED_0 = 0
+    UNUSED_1 = 1
+    UNUSED_2 = 2
+    UNUSED_8 = 8
+    UNUSED_9 = 9
+
+    ########### Agent actions ###########
+
+    # A type action that sends text to the emulator. Note that this simply sends
+    # text and does not perform any clicks for element focus or enter presses for
+    # submitting text.
+    TYPE = 3
+
+    # The dual point action used to represent all gestures.
+    DUAL_POINT = 4
+
+    # These actions differentiate pressing the home and back button from touches.
+    # They represent explicit presses of back and home performed using ADB.
+    PRESS_BACK = 5
+    PRESS_HOME = 6
+
+    # An action representing that ADB command for hitting enter was performed.
+    PRESS_ENTER = 7
+
+    ########### Episode status actions ###########
+
+    # An action used to indicate the desired task has been completed and resets
+    # the environment. This action should also be used in the case that the task
+    # has already been completed and there is nothing to do.
+    # e.g. The task is to turn on the Wi-Fi when it is already on
+    STATUS_TASK_COMPLETE = 10
+
+    # An action used to indicate that desired task is impossible to complete and
+    # resets the environment. This can be a result of many different things
+    # including UI changes, Android version differences, etc.
+    STATUS_TASK_IMPOSSIBLE = 11
+
+
+_TAP_DISTANCE_THRESHOLD = 0.14  # Fraction of the screen
+ANNOTATION_WIDTH_AUGMENT_FRACTION = 1.4
+ANNOTATION_HEIGHT_AUGMENT_FRACTION = 1.4
+
+# Interval determining if an action is a tap or a swipe.
+_SWIPE_DISTANCE_THRESHOLD = 0.04
+
+
+def _yx_in_bounding_boxes(
+    yx, bounding_boxes
+):
+  """Check if the (y,x) point is contained in each bounding box.
+
+  Args:
+    yx: The (y, x) coordinate in pixels of the point.
+    bounding_boxes: A 2D int array of shape (num_bboxes, 4), where each row
+      represents a bounding box: (y_top_left, x_top_left, box_height,
+      box_width). Note: containment is inclusive of the bounding box edges.
+
+  Returns:
+    is_inside: A 1D bool array where each element specifies if the point is
+      contained within the respective box.
+  """
+  y, x = yx
+
+  # `bounding_boxes` has shape (n_elements, 4); we extract each array along the
+  # last axis into shape (n_elements, 1), then squeeze unneeded dimension.
+  top, left, height, width = [
+      jnp.squeeze(v, axis=-1) for v in jnp.split(bounding_boxes, 4, axis=-1)
+  ]
+
+  # The y-axis is inverted for AndroidEnv, so bottom = top + height.
+  bottom, right = top + height, left + width
+
+  return jnp.logical_and(y >= top, y <= bottom) & jnp.logical_and(
+      x >= left, x <= right)
+
+
+def _resize_annotation_bounding_boxes(
+    annotation_positions, annotation_width_augment_fraction,
+    annotation_height_augment_fraction):
+  """Resize the bounding boxes by the given fractions.
+
+  Args:
+    annotation_positions: Array of shape (N, 4), where each row represents the
+      (y, x, height, width) of the bounding boxes.
+    annotation_width_augment_fraction: The fraction to augment the box widths,
+      E.g., 1.4 == 240% total increase.
+    annotation_height_augment_fraction: Same as described for width, but for box
+      height.
+
+  Returns:
+    Resized bounding box.
+
+  """
+  height_change = (
+      annotation_height_augment_fraction * annotation_positions[:, 2])
+  width_change = (
+      annotation_width_augment_fraction * annotation_positions[:, 3])
+
+  # Limit bounding box positions to the screen.
+  resized_annotations = jnp.stack([
+      jnp.maximum(0, annotation_positions[:, 0] - (height_change / 2)),
+      jnp.maximum(0, annotation_positions[:, 1] - (width_change / 2)),
+      jnp.minimum(1, annotation_positions[:, 2] + height_change),
+      jnp.minimum(1, annotation_positions[:, 3] + width_change),
+  ],
+                                  axis=1)
+  return resized_annotations
+
+
+def is_tap_action(normalized_start_yx,
+                  normalized_end_yx):
+  distance = jnp.linalg.norm(
+      jnp.array(normalized_start_yx) - jnp.array(normalized_end_yx))
+  return distance <= _SWIPE_DISTANCE_THRESHOLD
+
+
+def _is_non_dual_point_action(action_type):
+  return jnp.not_equal(action_type, ActionType.DUAL_POINT)
+
+
+def _check_tap_actions_match(
+    tap_1_yx,
+    tap_2_yx,
+    annotation_positions,
+    matching_tap_distance_threshold_screen_percentage,
+    annotation_width_augment_fraction,
+    annotation_height_augment_fraction,
+):
+  """Determines if two tap actions are the same."""
+  resized_annotation_positions = _resize_annotation_bounding_boxes(
+      annotation_positions,
+      annotation_width_augment_fraction,
+      annotation_height_augment_fraction,
+  )
+
+  # Check if the ground truth tap action falls in an annotation's bounding box.
+  tap1_in_box = _yx_in_bounding_boxes(tap_1_yx, resized_annotation_positions)
+  tap2_in_box = _yx_in_bounding_boxes(tap_2_yx, resized_annotation_positions)
+  both_in_box = jnp.max(tap1_in_box & tap2_in_box)
+
+  # If the ground-truth tap action falls outside any of the annotation
+  # bounding boxes or one of the actions is inside a bounding box and the other
+  # is outside bounding box or vice versa, compare the points using Euclidean
+  # distance.
+  within_threshold = (
+      jnp.linalg.norm(jnp.array(tap_1_yx) - jnp.array(tap_2_yx))
+      <= matching_tap_distance_threshold_screen_percentage
+  )
+  return jnp.logical_or(both_in_box, within_threshold)
+
+
+def _check_drag_actions_match(
+    drag_1_touch_yx,
+    drag_1_lift_yx,
+    drag_2_touch_yx,
+    drag_2_lift_yx,
+):
+  """Determines if two drag actions are the same."""
+  # Store drag deltas (the change in the y and x coordinates from touch to
+  # lift), magnitudes, and the index of the main axis, which is the axis with
+  # the greatest change in coordinate value (e.g. a drag starting at (0, 0) and
+  # ending at (0.3, 0.5) has a main axis index of 1).
+  drag_1_deltas = drag_1_lift_yx - drag_1_touch_yx
+  drag_1_magnitudes = jnp.abs(drag_1_deltas)
+  drag_1_main_axis = np.argmax(drag_1_magnitudes)
+  drag_2_deltas = drag_2_lift_yx - drag_2_touch_yx
+  drag_2_magnitudes = jnp.abs(drag_2_deltas)
+  drag_2_main_axis = np.argmax(drag_2_magnitudes)
+
+  return jnp.equal(drag_1_main_axis, drag_2_main_axis)
+
+
+def check_actions_match(
+    action_1_touch_yx,
+    action_1_lift_yx,
+    action_1_action_type,
+    action_2_touch_yx,
+    action_2_lift_yx,
+    action_2_action_type,
+    annotation_positions,
+    tap_distance_threshold = _TAP_DISTANCE_THRESHOLD,
+    annotation_width_augment_fraction = ANNOTATION_WIDTH_AUGMENT_FRACTION,
+    annotation_height_augment_fraction = ANNOTATION_HEIGHT_AUGMENT_FRACTION,
+):
+  """Determines if two actions are considered to be the same.
+
+  Two actions being "the same" is defined here as two actions that would result
+  in a similar screen state.
+
+  Args:
+    action_1_touch_yx: The (y, x) coordinates of the first action's touch.
+    action_1_lift_yx: The (y, x) coordinates of the first action's lift.
+    action_1_action_type: The action type of the first action.
+    action_2_touch_yx: The (y, x) coordinates of the second action's touch.
+    action_2_lift_yx: The (y, x) coordinates of the second action's lift.
+    action_2_action_type: The action type of the second action.
+    annotation_positions: The positions of the UI annotations for the screen. It
+      is A 2D int array of shape (num_bboxes, 4), where each row represents a
+      bounding box: (y_top_left, x_top_left, box_height, box_width). Note that
+      containment is inclusive of the bounding box edges.
+    tap_distance_threshold: The threshold that determines if two taps result in
+      a matching screen state if they don't fall the same bounding boxes.
+    annotation_width_augment_fraction: The fraction to increase the width of the
+      bounding box by.
+    annotation_height_augment_fraction: The fraction to increase the height of
+      of the bounding box by.
+
+  Returns:
+    A boolean representing whether the two given actions are the same or not.
+  """
+  action_1_touch_yx = jnp.asarray(action_1_touch_yx)
+  action_1_lift_yx = jnp.asarray(action_1_lift_yx)
+  action_2_touch_yx = jnp.asarray(action_2_touch_yx)
+  action_2_lift_yx = jnp.asarray(action_2_lift_yx)
+
+  # Checks if at least one of the actions is global (i.e. not DUAL_POINT),
+  # because if that is the case, only the actions' types need to be compared.
+  has_non_dual_point_action = jnp.logical_or(
+      _is_non_dual_point_action(action_1_action_type),
+      _is_non_dual_point_action(action_2_action_type),
+  )
+  #print("non dual point: "+str(has_non_dual_point_action))
+
+  different_dual_point_types = jnp.logical_xor(
+      is_tap_action(action_1_touch_yx, action_1_lift_yx),
+      is_tap_action(action_2_touch_yx, action_2_lift_yx),
+  )
+  #print("different dual type: "+str(different_dual_point_types))
+
+  is_tap = jnp.logical_and(
+      is_tap_action(action_1_touch_yx, action_1_lift_yx),
+      is_tap_action(action_2_touch_yx, action_2_lift_yx),
+  )
+  #print("is tap: "+str(is_tap))
+
+  taps_match = _check_tap_actions_match(
+      action_1_touch_yx,
+      action_2_touch_yx,
+      annotation_positions,
+      tap_distance_threshold,
+      annotation_width_augment_fraction,
+      annotation_height_augment_fraction,
+  )
+  #print("tap match: "+str(taps_match))
+
+  taps_match = jnp.logical_and(is_tap, taps_match)
+  #print("tap match: "+str(taps_match))
+
+  drags_match = _check_drag_actions_match(
+      action_1_touch_yx, action_1_lift_yx, action_2_touch_yx, action_2_lift_yx
+  )
+  drags_match = jnp.where(is_tap, False, drags_match)
+  #print("drag match: "+str(drags_match))
+
+  return jnp.where(
+      has_non_dual_point_action,
+      jnp.equal(action_1_action_type, action_2_action_type),
+      jnp.where(
+          different_dual_point_types,
+          False,
+          jnp.logical_or(taps_match, drags_match),
+      ),
+  )
+
+
+def action_2_format(step_data):
+    # 把test数据集中的动作格式转换为计算matching score的格式
+    action_type = step_data["action_type_id"]
+
+    if action_type == 4:
+        if step_data["action_type_text"] == 'click':  # 点击
+            touch_point = step_data["touch"]
+            lift_point = step_data["lift"]
+        else:  # 上下左右滑动
+            if step_data["action_type_text"] == 'scroll down':
+                touch_point = [0.5, 0.8]
+                lift_point = [0.5, 0.2]
+            elif step_data["action_type_text"] == 'scroll up':
+                touch_point = [0.5, 0.2]
+                lift_point = [0.5, 0.8]
+            elif step_data["action_type_text"] == 'scroll left':
+                touch_point = [0.2, 0.5]
+                lift_point = [0.8, 0.5]
+            elif step_data["action_type_text"] == 'scroll right':
+                touch_point = [0.8, 0.5]
+                lift_point = [0.2, 0.5]
+    else:
+        touch_point = [-1.0, -1.0]
+        lift_point = [-1.0, -1.0]
+
+    if action_type == 3:
+        typed_text = step_data["type_text"]
+    else:
+        typed_text = ""
+
+    action = {"action_type": action_type, "touch_point": touch_point, "lift_point": lift_point,
+              "typed_text": typed_text}
+
+    action["touch_point"] = [action["touch_point"][1], action["touch_point"][0]]
+    action["lift_point"] = [action["lift_point"][1], action["lift_point"][0]]
+    action["typed_text"] = action["typed_text"].lower()
+
+    return action
+
+
+def pred_2_format(step_data):
+    # 把模型输出的内容转换为计算action_matching的格式
+    action_type = step_data["action_type"]
+
+    if action_type == 4:  # 点击
+        action_type_new = 4
+        touch_point = step_data["click_point"]
+        lift_point = step_data["click_point"]
+        typed_text = ""
+    elif action_type == 0:
+        action_type_new = 4
+        touch_point = [0.5, 0.8]
+        lift_point = [0.5, 0.2]
+        typed_text = ""
+    elif action_type == 1:
+        action_type_new = 4
+        touch_point = [0.5, 0.2]
+        lift_point = [0.5, 0.8]
+        typed_text = ""
+    elif action_type == 8:
+        action_type_new = 4
+        touch_point = [0.2, 0.5]
+        lift_point = [0.8, 0.5]
+        typed_text = ""
+    elif action_type == 9:
+        action_type_new = 4
+        touch_point = [0.8, 0.5]
+        lift_point = [0.2, 0.5]
+        typed_text = ""
+    else:
+        action_type_new = action_type
+        touch_point = [-1.0, -1.0]
+        lift_point = [-1.0, -1.0]
+        typed_text = ""
+        if action_type_new == 3:
+            typed_text = step_data["typed_text"]
+
+    action = {"action_type": action_type_new, "touch_point": touch_point, "lift_point": lift_point,
+              "typed_text": typed_text}
+
+    action["touch_point"] = [action["touch_point"][1], action["touch_point"][0]]
+    action["lift_point"] = [action["lift_point"][1], action["lift_point"][0]]
+    action["typed_text"] = action["typed_text"].lower()
+
+    return action
+
+
+def pred_2_format_simplified(step_data):
+    # 把模型输出的内容转换为计算action_matching的格式
+    action_type = step_data["action_type"]
+
+    if action_type == 'click' :  # 点击
+        action_type_new = 4
+        touch_point = step_data["click_point"]
+        lift_point = step_data["click_point"]
+        typed_text = ""
+    elif action_type == 'scroll' and step_data["direction"] == 'down':
+        action_type_new = 4
+        touch_point = [0.5, 0.8]
+        lift_point = [0.5, 0.2]
+        typed_text = ""
+    elif action_type == 'scroll' and step_data["direction"] == 'up':
+        action_type_new = 4
+        touch_point = [0.5, 0.2]
+        lift_point = [0.5, 0.8]
+        typed_text = ""
+    elif action_type == 'scroll' and step_data["direction"] == 'left':
+        action_type_new = 4
+        touch_point = [0.2, 0.5]
+        lift_point = [0.8, 0.5]
+        typed_text = ""
+    elif action_type == 'scroll' and step_data["direction"] == 'right':
+        action_type_new = 4
+        touch_point = [0.8, 0.5]
+        lift_point = [0.2, 0.5]
+        typed_text = ""
+    elif action_type == 'type':
+        action_type_new = 3
+        touch_point = [-1.0, -1.0]
+        lift_point = [-1.0, -1.0]
+        typed_text = step_data["text"]
+    elif action_type == 'navigate_back':
+        action_type_new = 5
+        touch_point = [-1.0, -1.0]
+        lift_point = [-1.0, -1.0]
+        typed_text = ""
+    elif action_type == 'navigate_home':
+        action_type_new = 6
+        touch_point = [-1.0, -1.0]
+        lift_point = [-1.0, -1.0]
+        typed_text = ""
+    else:
+        action_type_new = action_type
+        touch_point = [-1.0, -1.0]
+        lift_point = [-1.0, -1.0]
+        typed_text = ""
+        # if action_type_new == 'type':
+        #     typed_text = step_data["text"]
+
+    action = {"action_type": action_type_new, "touch_point": touch_point, "lift_point": lift_point,
+              "typed_text": typed_text}
+
+    action["touch_point"] = [action["touch_point"][1], action["touch_point"][0]]
+    action["lift_point"] = [action["lift_point"][1], action["lift_point"][0]]
+    action["typed_text"] = action["typed_text"].lower()
+
+    return action
\ No newline at end of file
diff --git a/util/action_type.py b/util/action_type.py
new file mode 100644
index 0000000..e11e5a3
--- /dev/null
+++ b/util/action_type.py
@@ -0,0 +1,45 @@
+'''
+Adapted from https://github.com/google-research/google-research/tree/master/android_in_the_wild
+'''
+
+import enum
+
+class ActionType(enum.IntEnum):
+
+  # Placeholders for unused enum values
+  UNUSED_0 = 0
+  UNUSED_1 = 1
+  UNUSED_2 = 2
+  UNUSED_8 = 8
+  UNUSED_9 = 9
+
+  ########### Agent actions ###########
+
+  # A type action that sends text to the emulator. Note that this simply sends
+  # text and does not perform any clicks for element focus or enter presses for
+  # submitting text.
+  TYPE = 3
+
+  # The dual point action used to represent all gestures.
+  DUAL_POINT = 4
+
+  # These actions differentiate pressing the home and back button from touches.
+  # They represent explicit presses of back and home performed using ADB.
+  PRESS_BACK = 5
+  PRESS_HOME = 6
+
+  # An action representing that ADB command for hitting enter was performed.
+  PRESS_ENTER = 7
+
+  ########### Episode status actions ###########
+
+  # An action used to indicate the desired task has been completed and resets
+  # the environment. This action should also be used in the case that the task
+  # has already been completed and there is nothing to do.
+  # e.g. The task is to turn on the Wi-Fi when it is already on
+  STATUS_TASK_COMPLETE = 10
+
+  # An action used to indicate that desired task is impossible to complete and
+  # resets the environment. This can be a result of many different things
+  # including UI changes, Android version differences, etc.
+  STATUS_TASK_IMPOSSIBLE = 11
\ No newline at end of file
diff --git a/util/box_annotator.py b/util/box_annotator.py
new file mode 100644
index 0000000..82f7116
--- /dev/null
+++ b/util/box_annotator.py
@@ -0,0 +1,262 @@
+from typing import List, Optional, Union, Tuple
+
+import cv2
+import numpy as np
+
+from supervision.detection.core import Detections
+from supervision.draw.color import Color, ColorPalette
+
+
+class BoxAnnotator:
+    """
+    A class for drawing bounding boxes on an image using detections provided.
+
+    Attributes:
+        color (Union[Color, ColorPalette]): The color to draw the bounding box,
+            can be a single color or a color palette
+        thickness (int): The thickness of the bounding box lines, default is 2
+        text_color (Color): The color of the text on the bounding box, default is white
+        text_scale (float): The scale of the text on the bounding box, default is 0.5
+        text_thickness (int): The thickness of the text on the bounding box,
+            default is 1
+        text_padding (int): The padding around the text on the bounding box,
+            default is 5
+
+    """
+
+    def __init__(
+        self,
+        color: Union[Color, ColorPalette] = ColorPalette.DEFAULT,
+        thickness: int = 3, # 1 for seeclick 2 for mind2web and 3 for demo
+        text_color: Color = Color.BLACK,
+        text_scale: float = 0.5, # 0.8 for mobile/web, 0.3 for desktop # 0.4 for mind2web
+        text_thickness: int = 2, #1, # 2 for demo
+        text_padding: int = 10,
+        avoid_overlap: bool = True,
+    ):
+        self.color: Union[Color, ColorPalette] = color
+        self.thickness: int = thickness
+        self.text_color: Color = text_color
+        self.text_scale: float = text_scale
+        self.text_thickness: int = text_thickness
+        self.text_padding: int = text_padding
+        self.avoid_overlap: bool = avoid_overlap
+
+    def annotate(
+        self,
+        scene: np.ndarray,
+        detections: Detections,
+        labels: Optional[List[str]] = None,
+        skip_label: bool = False,
+        image_size: Optional[Tuple[int, int]] = None,
+    ) -> np.ndarray:
+        """
+        Draws bounding boxes on the frame using the detections provided.
+
+        Args:
+            scene (np.ndarray): The image on which the bounding boxes will be drawn
+            detections (Detections): The detections for which the
+                bounding boxes will be drawn
+            labels (Optional[List[str]]): An optional list of labels
+                corresponding to each detection. If `labels` are not provided,
+                corresponding `class_id` will be used as label.
+            skip_label (bool): Is set to `True`, skips bounding box label annotation.
+        Returns:
+            np.ndarray: The image with the bounding boxes drawn on it
+
+        Example:
+            ```python
+            import supervision as sv
+
+            classes = ['person', ...]
+            image = ...
+            detections = sv.Detections(...)
+
+            box_annotator = sv.BoxAnnotator()
+            labels = [
+                f"{classes[class_id]} {confidence:0.2f}"
+                for _, _, confidence, class_id, _ in detections
+            ]
+            annotated_frame = box_annotator.annotate(
+                scene=image.copy(),
+                detections=detections,
+                labels=labels
+            )
+            ```
+        """
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        for i in range(len(detections)):
+            x1, y1, x2, y2 = detections.xyxy[i].astype(int)
+            class_id = (
+                detections.class_id[i] if detections.class_id is not None else None
+            )
+            idx = class_id if class_id is not None else i
+            color = (
+                self.color.by_idx(idx)
+                if isinstance(self.color, ColorPalette)
+                else self.color
+            )
+            cv2.rectangle(
+                img=scene,
+                pt1=(x1, y1),
+                pt2=(x2, y2),
+                color=color.as_bgr(),
+                thickness=self.thickness,
+            )
+            if skip_label:
+                continue
+
+            text = (
+                f"{class_id}"
+                if (labels is None or len(detections) != len(labels))
+                else labels[i]
+            )
+
+            text_width, text_height = cv2.getTextSize(
+                text=text,
+                fontFace=font,
+                fontScale=self.text_scale,
+                thickness=self.text_thickness,
+            )[0]
+
+            if not self.avoid_overlap:
+                text_x = x1 + self.text_padding
+                text_y = y1 - self.text_padding
+
+                text_background_x1 = x1
+                text_background_y1 = y1 - 2 * self.text_padding - text_height
+
+                text_background_x2 = x1 + 2 * self.text_padding + text_width
+                text_background_y2 = y1
+                # text_x = x1 - self.text_padding - text_width
+                # text_y = y1 + self.text_padding + text_height
+                # text_background_x1 = x1 - 2 * self.text_padding - text_width
+                # text_background_y1 = y1
+                # text_background_x2 = x1
+                # text_background_y2 = y1 + 2 * self.text_padding + text_height
+            else:
+                text_x, text_y, text_background_x1, text_background_y1, text_background_x2, text_background_y2 = get_optimal_label_pos(self.text_padding, text_width, text_height, x1, y1, x2, y2, detections, image_size)
+
+            cv2.rectangle(
+                img=scene,
+                pt1=(text_background_x1, text_background_y1),
+                pt2=(text_background_x2, text_background_y2),
+                color=color.as_bgr(),
+                thickness=cv2.FILLED,
+            )
+            # import pdb; pdb.set_trace()
+            box_color = color.as_rgb()
+            luminance = 0.299 * box_color[0] + 0.587 * box_color[1] + 0.114 * box_color[2]
+            text_color = (0,0,0) if luminance > 160 else (255,255,255)
+            cv2.putText(
+                img=scene,
+                text=text,
+                org=(text_x, text_y),
+                fontFace=font,
+                fontScale=self.text_scale,
+                # color=self.text_color.as_rgb(),
+                color=text_color,
+                thickness=self.text_thickness,
+                lineType=cv2.LINE_AA,
+            )
+        return scene
+    
+
+def box_area(box):
+        return (box[2] - box[0]) * (box[3] - box[1])
+
+def intersection_area(box1, box2):
+    x1 = max(box1[0], box2[0])
+    y1 = max(box1[1], box2[1])
+    x2 = min(box1[2], box2[2])
+    y2 = min(box1[3], box2[3])
+    return max(0, x2 - x1) * max(0, y2 - y1)
+
+def IoU(box1, box2, return_max=True):
+    intersection = intersection_area(box1, box2)
+    union = box_area(box1) + box_area(box2) - intersection
+    if box_area(box1) > 0 and box_area(box2) > 0:
+        ratio1 = intersection / box_area(box1)
+        ratio2 = intersection / box_area(box2)
+    else:
+        ratio1, ratio2 = 0, 0
+    if return_max:
+        return max(intersection / union, ratio1, ratio2)
+    else:
+        return intersection / union
+
+
+def get_optimal_label_pos(text_padding, text_width, text_height, x1, y1, x2, y2, detections, image_size):
+    """ check overlap of text and background detection box, and get_optimal_label_pos, 
+        pos: str, position of the text, must be one of 'top left', 'top right', 'outer left', 'outer right' TODO: if all are overlapping, return the last one, i.e. outer right
+        Threshold: default to 0.3
+    """
+
+    def get_is_overlap(detections, text_background_x1, text_background_y1, text_background_x2, text_background_y2, image_size):
+        is_overlap = False
+        for i in range(len(detections)):
+            detection = detections.xyxy[i].astype(int)
+            if IoU([text_background_x1, text_background_y1, text_background_x2, text_background_y2], detection) > 0.3:
+                is_overlap = True
+                break
+        # check if the text is out of the image
+        if text_background_x1 < 0 or text_background_x2 > image_size[0] or text_background_y1 < 0 or text_background_y2 > image_size[1]:
+            is_overlap = True
+        return is_overlap
+    
+    # if pos == 'top left':
+    text_x = x1 + text_padding
+    text_y = y1 - text_padding
+
+    text_background_x1 = x1
+    text_background_y1 = y1 - 2 * text_padding - text_height
+
+    text_background_x2 = x1 + 2 * text_padding + text_width
+    text_background_y2 = y1
+    is_overlap = get_is_overlap(detections, text_background_x1, text_background_y1, text_background_x2, text_background_y2, image_size)
+    if not is_overlap:
+        return text_x, text_y, text_background_x1, text_background_y1, text_background_x2, text_background_y2
+    
+    # elif pos == 'outer left':
+    text_x = x1 - text_padding - text_width
+    text_y = y1 + text_padding + text_height
+
+    text_background_x1 = x1 - 2 * text_padding - text_width
+    text_background_y1 = y1
+
+    text_background_x2 = x1
+    text_background_y2 = y1 + 2 * text_padding + text_height
+    is_overlap = get_is_overlap(detections, text_background_x1, text_background_y1, text_background_x2, text_background_y2, image_size)
+    if not is_overlap:
+        return text_x, text_y, text_background_x1, text_background_y1, text_background_x2, text_background_y2
+    
+
+    # elif pos == 'outer right':
+    text_x = x2 + text_padding
+    text_y = y1 + text_padding + text_height
+
+    text_background_x1 = x2
+    text_background_y1 = y1
+
+    text_background_x2 = x2 + 2 * text_padding + text_width
+    text_background_y2 = y1 + 2 * text_padding + text_height
+
+    is_overlap = get_is_overlap(detections, text_background_x1, text_background_y1, text_background_x2, text_background_y2, image_size)
+    if not is_overlap:
+        return text_x, text_y, text_background_x1, text_background_y1, text_background_x2, text_background_y2
+
+    # elif pos == 'top right':
+    text_x = x2 - text_padding - text_width
+    text_y = y1 - text_padding
+
+    text_background_x1 = x2 - 2 * text_padding - text_width
+    text_background_y1 = y1 - 2 * text_padding - text_height
+
+    text_background_x2 = x2
+    text_background_y2 = y1
+
+    is_overlap = get_is_overlap(detections, text_background_x1, text_background_y1, text_background_x2, text_background_y2, image_size)
+    if not is_overlap:
+        return text_x, text_y, text_background_x1, text_background_y1, text_background_x2, text_background_y2
+
+    return text_x, text_y, text_background_x1, text_background_y1, text_background_x2, text_background_y2
diff --git a/utils.py b/utils.py
new file mode 100755
index 0000000..8184e26
--- /dev/null
+++ b/utils.py
@@ -0,0 +1,607 @@
+# from ultralytics import YOLO
+import os
+import io
+import base64
+import time
+from PIL import Image, ImageDraw, ImageFont
+import json
+import requests
+# utility function
+import os
+from openai import AzureOpenAI
+
+import json
+import sys
+import os
+import cv2
+import numpy as np
+# %matplotlib inline
+from matplotlib import pyplot as plt
+import easyocr
+reader = easyocr.Reader(['en']) # this needs to run only once to load the model into memory # 'ch_sim',
+import time
+import base64
+
+import os
+import ast
+import torch
+from typing import Tuple, List
+from torchvision.ops import box_convert
+import re
+from torchvision.transforms import ToPILImage
+import supervision as sv
+import torchvision.transforms as T
+
+
+def get_caption_model_processor(model_name="Salesforce/blip2-opt-2.7b", device=None):
+    if not device:
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+    if model_name == "Salesforce/blip2-opt-2.7b":
+        from transformers import Blip2Processor, Blip2ForConditionalGeneration
+        processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b")
+        model = Blip2ForConditionalGeneration.from_pretrained(
+            "Salesforce/blip2-opt-2.7b", device_map=None, torch_dtype=torch.float16
+            # '/home/yadonglu/sandbox/data/orca/blipv2_ui_merge', device_map=None, torch_dtype=torch.float16
+        )  
+    elif model_name == "blip2-opt-2.7b-ui":
+        from transformers import Blip2Processor, Blip2ForConditionalGeneration
+        processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b")
+        if device == 'cpu':
+            model = Blip2ForConditionalGeneration.from_pretrained(
+            '/home/yadonglu/sandbox/data/orca/blipv2_ui_merge', device_map=None, torch_dtype=torch.float32
+        ) 
+        else:
+            model = Blip2ForConditionalGeneration.from_pretrained(
+            '/home/yadonglu/sandbox/data/orca/blipv2_ui_merge', device_map=None, torch_dtype=torch.float16
+        )
+    elif model_name == "florence":
+        from transformers import AutoProcessor, AutoModelForCausalLM 
+        processor = AutoProcessor.from_pretrained("microsoft/Florence-2-base", trust_remote_code=True)
+        if device == 'cpu':
+            model = AutoModelForCausalLM.from_pretrained("/home/yadonglu/sandbox/data/orca/florence-2-base-ft-fft_ep1_rai", torch_dtype=torch.float32, trust_remote_code=True)#.to(device)
+        else:
+            model = AutoModelForCausalLM.from_pretrained("/home/yadonglu/sandbox/data/orca/florence-2-base-ft-fft_ep1_rai_win_ep5_fixed", torch_dtype=torch.float16, trust_remote_code=True).to(device)
+    elif model_name == 'phi3v_ui':
+        from transformers import AutoModelForCausalLM, AutoProcessor
+        model_id = "microsoft/Phi-3-vision-128k-instruct" 
+        model = AutoModelForCausalLM.from_pretrained('/home/yadonglu/sandbox/data/orca/phi3v_ui', device_map=device, trust_remote_code=True, torch_dtype="auto")
+        processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True) 
+    elif model_name == 'phi3v':
+        from transformers import AutoModelForCausalLM, AutoProcessor
+        model_id = "microsoft/Phi-3-vision-128k-instruct" 
+        model = AutoModelForCausalLM.from_pretrained(model_id, device_map=device, trust_remote_code=True, torch_dtype="auto")
+        processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
+    return {'model': model.to(device), 'processor': processor}
+
+
+def get_yolo_model():
+    from ultralytics import YOLO
+    # Load the model.
+    # model = YOLO('/home/yadonglu/sandbox/data/yolo/runs/detect/yolov8n_v8_xcyc/weights/best.pt')
+    model = YOLO('/home/yadonglu/sandbox/data/yolo/runs/detect/yolov8n_v8_seq_xcyc_b32_n4_office_ep20/weights/best.pt')
+    return model
+
+
+def get_parsed_content_icon(filtered_boxes, ocr_bbox, image_source, caption_model_processor, prompt=None):
+    to_pil = ToPILImage()
+    if ocr_bbox:
+        non_ocr_boxes = filtered_boxes[len(ocr_bbox):]
+    else:
+        non_ocr_boxes = filtered_boxes
+    croped_pil_image = []
+    for i, coord in enumerate(non_ocr_boxes):
+        xmin, xmax = int(coord[0]*image_source.shape[1]), int(coord[2]*image_source.shape[1])
+        ymin, ymax = int(coord[1]*image_source.shape[0]), int(coord[3]*image_source.shape[0])
+        cropped_image = image_source[ymin:ymax, xmin:xmax, :]
+        croped_pil_image.append(to_pil(cropped_image))
+
+    # import pdb; pdb.set_trace()
+    model, processor = caption_model_processor['model'], caption_model_processor['processor']
+    if not prompt:
+        if 'florence' in model.config.name_or_path:
+            prompt = "<CAPTION>"
+        else:
+            prompt = "The image shows"
+            # prompt = "NO gender!NO gender!NO gender! The image shows a icon:"
+
+    batch_size = 10  # Number of samples per batch
+    generated_texts = []
+    device = model.device
+
+    for i in range(0, len(croped_pil_image), batch_size):
+        batch = croped_pil_image[i:i+batch_size]
+        if model.device.type == 'cuda':
+            inputs = processor(images=batch, text=[prompt]*len(batch), return_tensors="pt").to(device=device, dtype=torch.float16)
+        else:
+            inputs = processor(images=batch, text=[prompt]*len(batch), return_tensors="pt").to(device=device)
+        if 'florence' in model.config.name_or_path:
+            generated_ids = model.generate(input_ids=inputs["input_ids"],pixel_values=inputs["pixel_values"],max_new_tokens=1024,num_beams=3, do_sample=False)
+        else:
+            generated_ids = model.generate(**inputs, max_length=100, num_beams=5, no_repeat_ngram_size=2, early_stopping=True, num_return_sequences=1) # temperature=0.01, do_sample=True,
+        generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)
+        generated_text = [gen.strip() for gen in generated_text]
+        generated_texts.extend(generated_text)
+
+    return generated_texts
+
+
+
+def get_parsed_content_icon_phi3v(filtered_boxes, ocr_bbox, image_source, caption_model_processor):
+    to_pil = ToPILImage()
+    if ocr_bbox:
+        non_ocr_boxes = filtered_boxes[len(ocr_bbox):]
+    else:
+        non_ocr_boxes = filtered_boxes
+    croped_pil_image = []
+    for i, coord in enumerate(non_ocr_boxes):
+        xmin, xmax = int(coord[0]*image_source.shape[1]), int(coord[2]*image_source.shape[1])
+        ymin, ymax = int(coord[1]*image_source.shape[0]), int(coord[3]*image_source.shape[0])
+        cropped_image = image_source[ymin:ymax, xmin:xmax, :]
+        croped_pil_image.append(to_pil(cropped_image))
+
+    model, processor = caption_model_processor['model'], caption_model_processor['processor']
+    device = model.device
+    messages = [{"role": "user", "content": "<|image_1|>\ndescribe the icon in one sentence"}] 
+    prompt = processor.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+
+    batch_size = 5  # Number of samples per batch
+    generated_texts = []
+
+    for i in range(0, len(croped_pil_image), batch_size):
+        images = croped_pil_image[i:i+batch_size]
+        image_inputs = [processor.image_processor(x, return_tensors="pt") for x in images]
+        inputs ={'input_ids': [], 'attention_mask': [], 'pixel_values': [], 'image_sizes': []}
+        texts = [prompt] * len(images)
+        for i, txt in enumerate(texts):
+            input = processor._convert_images_texts_to_inputs(image_inputs[i], txt, return_tensors="pt")
+            inputs['input_ids'].append(input['input_ids'])
+            inputs['attention_mask'].append(input['attention_mask'])
+            inputs['pixel_values'].append(input['pixel_values'])
+            inputs['image_sizes'].append(input['image_sizes'])
+        max_len = max([x.shape[1] for x in inputs['input_ids']])
+        for i, v in enumerate(inputs['input_ids']):
+            inputs['input_ids'][i] = torch.cat([processor.tokenizer.pad_token_id * torch.ones(1, max_len - v.shape[1], dtype=torch.long), v], dim=1)
+            inputs['attention_mask'][i] = torch.cat([torch.zeros(1, max_len - v.shape[1], dtype=torch.long), inputs['attention_mask'][i]], dim=1)
+        inputs_cat = {k: torch.concatenate(v).to(device) for k, v in inputs.items()}
+
+        generation_args = { 
+            "max_new_tokens": 25, 
+            "temperature": 0.01, 
+            "do_sample": False, 
+        } 
+        generate_ids = model.generate(**inputs_cat, eos_token_id=processor.tokenizer.eos_token_id, **generation_args) 
+        # # remove input tokens 
+        generate_ids = generate_ids[:, inputs_cat['input_ids'].shape[1]:]
+        response = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)
+        response = [res.strip('\n').strip() for res in response]
+        generated_texts.extend(response)
+
+    return generated_texts
+
+def remove_overlap(boxes, iou_threshold, ocr_bbox=None):
+    assert ocr_bbox is None or isinstance(ocr_bbox, List)
+
+    def box_area(box):
+        return (box[2] - box[0]) * (box[3] - box[1])
+
+    def intersection_area(box1, box2):
+        x1 = max(box1[0], box2[0])
+        y1 = max(box1[1], box2[1])
+        x2 = min(box1[2], box2[2])
+        y2 = min(box1[3], box2[3])
+        return max(0, x2 - x1) * max(0, y2 - y1)
+
+    def IoU(box1, box2):
+        intersection = intersection_area(box1, box2)
+        union = box_area(box1) + box_area(box2) - intersection + 1e-6
+        if box_area(box1) > 0 and box_area(box2) > 0:
+            ratio1 = intersection / box_area(box1)
+            ratio2 = intersection / box_area(box2)
+        else:
+            ratio1, ratio2 = 0, 0
+        return max(intersection / union, ratio1, ratio2)
+
+    boxes = boxes.tolist()
+    filtered_boxes = []
+    if ocr_bbox:
+        filtered_boxes.extend(ocr_bbox)
+    # print('ocr_bbox!!!', ocr_bbox)
+    for i, box1 in enumerate(boxes):
+        # if not any(IoU(box1, box2) > iou_threshold and box_area(box1) > box_area(box2) for j, box2 in enumerate(boxes) if i != j):
+        is_valid_box = True
+        for j, box2 in enumerate(boxes):
+            if i != j and IoU(box1, box2) > iou_threshold and box_area(box1) > box_area(box2):
+                is_valid_box = False
+                break
+        if is_valid_box:
+            # add the following 2 lines to include ocr bbox
+            if ocr_bbox:
+                if not any(IoU(box1, box3) > iou_threshold for k, box3 in enumerate(ocr_bbox)):
+                    filtered_boxes.append(box1)
+            else:
+                filtered_boxes.append(box1)
+    return torch.tensor(filtered_boxes)
+
+def load_image(image_path: str) -> Tuple[np.array, torch.Tensor]:
+    transform = T.Compose(
+        [
+            T.RandomResize([800], max_size=1333),
+            T.ToTensor(),
+            T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+        ]
+    )
+    image_source = Image.open(image_path).convert("RGB")
+    image = np.asarray(image_source)
+    image_transformed, _ = transform(image_source, None)
+    return image, image_transformed
+
+
+def annotate(image_source: np.ndarray, boxes: torch.Tensor, logits: torch.Tensor, phrases: List[str], text_scale: float, 
+             text_padding=5, text_thickness=2, thickness=3) -> np.ndarray:
+    """    
+    This function annotates an image with bounding boxes and labels.
+
+    Parameters:
+    image_source (np.ndarray): The source image to be annotated.
+    boxes (torch.Tensor): A tensor containing bounding box coordinates. in cxcywh format, pixel scale
+    logits (torch.Tensor): A tensor containing confidence scores for each bounding box.
+    phrases (List[str]): A list of labels for each bounding box.
+    text_scale (float): The scale of the text to be displayed. 0.8 for mobile/web, 0.3 for desktop # 0.4 for mind2web
+
+    Returns:
+    np.ndarray: The annotated image.
+    """
+    h, w, _ = image_source.shape
+    boxes = boxes * torch.Tensor([w, h, w, h])
+    xyxy = box_convert(boxes=boxes, in_fmt="cxcywh", out_fmt="xyxy").numpy()
+    xywh = box_convert(boxes=boxes, in_fmt="cxcywh", out_fmt="xywh").numpy()
+    detections = sv.Detections(xyxy=xyxy)
+
+    labels = [f"{phrase}" for phrase in range(boxes.shape[0])]
+
+    from util.box_annotator import BoxAnnotator 
+    box_annotator = BoxAnnotator(text_scale=text_scale, text_padding=text_padding,text_thickness=text_thickness,thickness=thickness) # 0.8 for mobile/web, 0.3 for desktop # 0.4 for mind2web
+    annotated_frame = image_source.copy()
+    annotated_frame = box_annotator.annotate(scene=annotated_frame, detections=detections, labels=labels, image_size=(w,h))
+
+    label_coordinates = {f"{phrase}": v for phrase, v in zip(phrases, xywh)}
+    return annotated_frame, label_coordinates
+
+
+def predict(model, image, caption, box_threshold, text_threshold):
+    """ Use huggingface model to replace the original model
+    """
+    model, processor = model['model'], model['processor']
+    device = model.device
+
+    inputs = processor(images=image, text=caption, return_tensors="pt").to(device)
+    with torch.no_grad():
+        outputs = model(**inputs)
+
+    results = processor.post_process_grounded_object_detection(
+        outputs,
+        inputs.input_ids,
+        box_threshold=box_threshold, # 0.4,
+        text_threshold=text_threshold, # 0.3,
+        target_sizes=[image.size[::-1]]
+    )[0]
+    boxes, logits, phrases = results["boxes"], results["scores"], results["labels"]
+    return boxes, logits, phrases
+
+
+def predict_yolo(model, image_path, box_threshold):
+    """ Use huggingface model to replace the original model
+    """
+    # model = model['model']
+    
+    result = model.predict(
+    source=image_path,
+    conf=box_threshold,
+    # iou=0.5, # default 0.7
+    )
+    boxes = result[0].boxes.xyxy#.tolist() # in pixel space
+    conf = result[0].boxes.conf
+    phrases = [str(i) for i in range(len(boxes))]
+
+    return boxes, conf, phrases
+
+
+def get_som_labeled_img(img_path, model=None, BOX_TRESHOLD = 0.01, output_coord_in_ratio=False, ocr_bbox=None, text_scale=0.4, text_padding=5, draw_bbox_config=None, caption_model_processor=None, ocr_text=[], use_local_semantics=True, iou_threshold=0.9,prompt=None):
+    """ ocr_bbox: list of xyxy format bbox
+    """
+    TEXT_PROMPT = "clickable buttons on the screen"
+    # BOX_TRESHOLD = 0.02 # 0.05/0.02 for web and 0.1 for mobile
+    TEXT_TRESHOLD = 0.01 # 0.9 # 0.01
+    image_source = Image.open(img_path).convert("RGB")
+    w, h = image_source.size
+    # import pdb; pdb.set_trace()
+    if False: # TODO
+        xyxy, logits, phrases = predict(model=model, image=image_source, caption=TEXT_PROMPT, box_threshold=BOX_TRESHOLD, text_threshold=TEXT_TRESHOLD)
+    else:
+        xyxy, logits, phrases = predict_yolo(model=model, image_path=img_path, box_threshold=BOX_TRESHOLD)
+    xyxy = xyxy / torch.Tensor([w, h, w, h]).to(xyxy.device)
+    image_source = np.asarray(image_source)
+    phrases = [str(i) for i in range(len(phrases))]
+
+    # annotate the image with labels
+    h, w, _ = image_source.shape
+    if ocr_bbox:
+        ocr_bbox = torch.tensor(ocr_bbox) / torch.Tensor([w, h, w, h])
+        ocr_bbox=ocr_bbox.tolist()
+    else:
+        print('no ocr bbox!!!')
+        ocr_bbox = None
+    filtered_boxes = remove_overlap(boxes=xyxy, iou_threshold=iou_threshold, ocr_bbox=ocr_bbox)
+    
+    # get parsed icon local semantics
+    if use_local_semantics:
+        caption_model = caption_model_processor['model']
+        if 'phi3_v' in caption_model.config.model_type: 
+            parsed_content_icon = get_parsed_content_icon_phi3v(filtered_boxes, ocr_bbox, image_source, caption_model_processor)
+        else:
+            parsed_content_icon = get_parsed_content_icon(filtered_boxes, ocr_bbox, image_source, caption_model_processor, prompt=prompt)
+        ocr_text = [f"Text Box ID {i}: {txt}" for i, txt in enumerate(ocr_text)]
+        icon_start = len(ocr_text)
+        parsed_content_icon_ls = []
+        for i, txt in enumerate(parsed_content_icon):
+            parsed_content_icon_ls.append(f"Icon Box ID {str(i+icon_start)}: {txt}")
+        parsed_content_merged = ocr_text + parsed_content_icon_ls
+    else:
+        ocr_text = [f"Text Box ID {i}: {txt}" for i, txt in enumerate(ocr_text)]
+        parsed_content_merged = ocr_text
+
+    filtered_boxes = box_convert(boxes=filtered_boxes, in_fmt="xyxy", out_fmt="cxcywh")
+
+    phrases = [i for i in range(len(filtered_boxes))]
+    
+    # draw boxes
+    if draw_bbox_config:
+        annotated_frame, label_coordinates = annotate(image_source=image_source, boxes=filtered_boxes, logits=logits, phrases=phrases, **draw_bbox_config)
+    else:
+        annotated_frame, label_coordinates = annotate(image_source=image_source, boxes=filtered_boxes, logits=logits, phrases=phrases, text_scale=text_scale, text_padding=text_padding)
+    
+    pil_img = Image.fromarray(annotated_frame)
+    buffered = io.BytesIO()
+    pil_img.save(buffered, format="PNG")
+    encoded_image = base64.b64encode(buffered.getvalue()).decode('ascii')
+    if output_coord_in_ratio:
+        # h, w, _ = image_source.shape
+        label_coordinates = {k: [v[0]/w, v[1]/h, v[2]/w, v[3]/h] for k, v in label_coordinates.items()}
+        assert w == annotated_frame.shape[1] and h == annotated_frame.shape[0]
+
+    return encoded_image, label_coordinates, parsed_content_merged
+
+
+def get_xywh(input):
+    x, y, w, h = input[0][0], input[0][1], input[2][0] - input[0][0], input[2][1] - input[0][1]
+    x, y, w, h = int(x), int(y), int(w), int(h)
+    return x, y, w, h
+
+def get_xyxy(input):
+    x, y, xp, yp = input[0][0], input[0][1], input[2][0], input[2][1]
+    x, y, xp, yp = int(x), int(y), int(xp), int(yp)
+    return x, y, xp, yp
+
+def get_xywh_yolo(input):
+    x, y, w, h = input[0], input[1], input[2] - input[0], input[3] - input[1]
+    x, y, w, h = int(x), int(y), int(w), int(h)
+    return x, y, w, h
+    
+
+def run_api(body, max_tokens=1024):
+    '''
+    API call, check https://platform.openai.com/docs/guides/vision for the latest api usage. 
+    '''
+    max_num_trial = 3
+    num_trial = 0
+    while num_trial < max_num_trial:
+        try:
+            response = client.chat.completions.create(
+                                    model=deployment,
+                                    messages=body,
+                                    temperature=0.01,
+                                    max_tokens=max_tokens,
+                                )
+            return response.choices[0].message.content
+        except:
+            print('retry call gptv', num_trial)
+            num_trial += 1
+            time.sleep(10)
+    return ''
+
+def call_gpt4v_new(message_text, image_path=None, max_tokens=2048):
+    if image_path:
+        try:
+            with open(image_path, "rb") as img_file:
+                encoded_image = base64.b64encode(img_file.read()).decode('ascii')
+        except: 
+            encoded_image = image_path
+    
+    if image_path:
+        content = [{"type": "image_url","image_url": {"url": f"data:image/jpeg;base64,{encoded_image}"}}, {"type": "text","text": message_text},]
+    else:
+        content = [{"type": "text","text": message_text},]
+
+    max_num_trial = 3
+    num_trial = 0
+    call_api_success = True
+
+    while num_trial < max_num_trial:
+        try:
+            response = client.chat.completions.create(
+                            model=deployment,
+                            messages=[
+                                        {
+                                        "role": "system",
+                                        "content": [
+                                            {
+                                            "type": "text",
+                                            "text": "You are an AI assistant that is good at making plans and analyzing screens, and helping people find information."
+                                            },
+                                        ]
+                                        },
+                                        {
+                                        "role": "user",
+                                        "content": content
+                                        }
+                                    ],
+                            temperature=0.01,
+                            max_tokens=max_tokens,
+                        )
+            ans_1st_pass = response.choices[0].message.content
+            break
+        except:
+            print('retry call gptv', num_trial)
+            num_trial += 1
+            ans_1st_pass = ''
+            time.sleep(10)
+    if num_trial == max_num_trial:
+        call_api_success = False
+    return ans_1st_pass, call_api_success
+
+
+def check_ocr_box(image_path, display_img = True, output_bb_format='xywh', goal_filtering=None, easyocr_args=None):
+    if easyocr_args is None:
+        easyocr_args = {}
+    result = reader.readtext(image_path, **easyocr_args)
+    is_goal_filtered = False
+    if goal_filtering:
+        ocr_filter_fs = "Example 1:\n Based on task and ocr results, ```In summary, the task related bboxes are: [([[3060, 111], [3135, 111], [3135, 141], [3060, 141]], 'Share', 0.949013667261589), ([[3068, 197], [3135, 197], [3135, 227], [3068, 227]], 'Link _', 0.3567054243152049), ([[3006, 321], [3178, 321], [3178, 354], [3006, 354]], 'Manage Access', 0.8800734456437066)] ``` \n Example 2:\n Based on task and ocr results, ```In summary, the task related bboxes are: [([[3060, 111], [3135, 111], [3135, 141], [3060, 141]], 'Search Google or type a URL', 0.949013667261589)] ```"
+        # message_text = f"Based on the ocr results which contains text+bounding box in a dictionary, please filter it so that it only contains the task related bboxes. The task is: {goal_filtering}, the ocr results are: {str(result)}. Your final answer should be in the exact same format as the ocr results, please do not include any other redundant information, please do not include any analysis."
+        message_text = f"Based on the task and ocr results which contains text+bounding box in a dictionary, please filter it so that it only contains the task related bboxes.  Requirement: 1. first give a brief analysis. 2. provide an answer in the format: ```In summary, the task related bboxes are: ..```, you must put it inside ``` ```.  Do not include any info after ```.\n {ocr_filter_fs}\n The task is: {goal_filtering}, the ocr results are: {str(result)}."
+
+        prompt = [{"role":"system", "content": "You are an AI assistant that helps people find the correct way to operate computer or smartphone."}, {"role":"user","content": message_text},]
+        print('[Perform OCR filtering by goal] ongoing ...')
+        # pred, _, _ = call_gpt4(prompt)
+        pred, _, = call_gpt4v(message_text)
+        # import pdb; pdb.set_trace()
+        try:
+            # match = re.search(r"```(.*?)```", pred, re.DOTALL)
+            # result = match.group(1).strip()
+            # pred = result.split('In summary, the task related bboxes are:')[-1].strip()
+            pred = pred.split('In summary, the task related bboxes are:')[-1].strip().strip('```')
+            result = ast.literal_eval(pred)
+            print('[Perform OCR filtering by goal] success!!! Filtered buttons: ', pred)
+            is_goal_filtered = True
+        except:
+            print('[Perform OCR filtering by goal] failed or unused!!!')
+            pass
+            # added_prompt = [{"role":"assistant","content":pred},
+            #        {"role":"user","content": "given the previous answers, please provide the final answer in the exact same format as the ocr results, please do not include any other redundant information, please do not include any analysis."}]
+            # prompt.extend(added_prompt)
+            # pred, _, _ = call_gpt4(prompt)
+            # print('goal filtering pred 2nd:', pred)
+            # result = ast.literal_eval(pred)
+    # print('goal filtering pred:', result[-5:])
+    coord = [item[0] for item in result]
+    text = [item[1] for item in result]
+    # confidence = [item[2] for item in result]
+    # if confidence_filtering:
+    #     coord = [coord[i] for i in range(len(coord)) if confidence[i] > confidence_filtering]
+    #     text = [text[i] for i in range(len(text)) if confidence[i] > confidence_filtering]
+    # read the image using cv2
+    if display_img:
+        opencv_img = cv2.imread(image_path)
+        opencv_img = cv2.cvtColor(opencv_img, cv2.COLOR_RGB2BGR)
+        bb = []
+        for item in coord:
+            x, y, a, b = get_xywh(item)
+            # print(x, y, a, b)
+            bb.append((x, y, a, b))
+            cv2.rectangle(opencv_img, (x, y), (x+a, y+b), (0, 255, 0), 2)
+        
+        # Display the image
+        plt.imshow(opencv_img)
+    else:
+        if output_bb_format == 'xywh':
+            bb = [get_xywh(item) for item in coord]
+        elif output_bb_format == 'xyxy':
+            bb = [get_xyxy(item) for item in coord]
+        # print('bounding box!!!', bb)
+    return (text, bb), is_goal_filtered
+
+
+def get_pred_gptv(message_text, yolo_labled_img, label_coordinates, summarize_history=True, verbose=True, history=None, id_key='Click ID'):
+    """ This func first 
+    1. call gptv(yolo_labled_img, text bbox+task) -> ans_1st_cal
+    2. call gpt4(ans_1st_cal, label_coordinates) -> final ans
+    """
+
+    # Configuration
+    encoded_image = yolo_labled_img
+    
+    # Payload for the request
+    if not history:
+        messages = [
+            {"role": "system", "content": [{"type": "text","text": "You are an AI assistant that is great at interpreting screenshot and predict action."},]},
+            {"role": "user","content": [{"type": "text","text": message_text}, {"type": "image_url","image_url": {"url": f"data:image/jpeg;base64,{encoded_image}"}},]}
+            ]
+    else:
+        messages = [
+            {"role": "system", "content": [{"type": "text","text": "You are an AI assistant that is great at interpreting screenshot and predict action."},]},
+            history,
+            {"role": "user","content": [{"type": "image_url","image_url": {"url": f"data:image/jpeg;base64,{encoded_image}"}},{"type": "text","text": message_text},]}
+            ]
+
+    payload = {
+        "messages": messages,
+        "temperature": 0.01, # 0.01
+        "top_p": 0.95,
+        "max_tokens": 800
+        }
+
+    max_num_trial = 3
+    num_trial = 0
+    call_api_success = True
+    while num_trial < max_num_trial:
+        try:
+            # response = requests.post(GPT4V_ENDPOINT, headers=headers, json=payload)
+            # response.raise_for_status()  # Will raise an HTTPError if the HTTP request returned an unsuccessful status code
+            # ans_1st_pass = response.json()['choices'][0]['message']['content']
+            response = client.chat.completions.create(
+                            model=deployment,
+                            messages=messages,
+                            temperature=0.01,
+                            max_tokens=512,
+                        )
+            ans_1st_pass = response.choices[0].message.content
+            break
+        except requests.RequestException as e:
+            print('retry call gptv', num_trial)
+            num_trial += 1
+            ans_1st_pass = ''
+            time.sleep(30)
+            # raise SystemExit(f"Failed to make the request. Error: {e}")
+    if num_trial == max_num_trial:
+        call_api_success = False
+    if verbose:
+        print('Answer by GPTV: ', ans_1st_pass)
+    # extract by simple parsing
+    try: 
+        match = re.search(r"```(.*?)```", ans_1st_pass, re.DOTALL)
+        if match:
+            result = match.group(1).strip()
+            pred = result.split('In summary, the next action I will perform is:')[-1].strip().replace('\\', '')
+            pred = ast.literal_eval(pred)
+        else:
+            pred = ans_1st_pass.split('In summary, the next action I will perform is:')[-1].strip().replace('\\', '')
+            pred = ast.literal_eval(pred)
+
+        if id_key in pred:
+            icon_id = pred[id_key]
+            bbox = label_coordinates[str(icon_id)]
+            pred['click_point'] = [bbox[0] + bbox[2]/2, bbox[1] + bbox[3]/2]
+    except:
+        # import pdb; pdb.set_trace()
+        print('gptv action regex extract fail!!!')
+        print('ans_1st_pass:', ans_1st_pass)
+        pred = {'action_type': 'CLICK', 'click_point': [0, 0], 'value': 'None', 'is_completed': False}
+
+    step_pred_summary = None
+    if summarize_history:
+        step_pred_summary, _ = call_gpt4v_new('Summarize what action you decide to perform in the current step, in one sentence, and do not include any icon box number: ' + ans_1st_pass, max_tokens=128)
+        print('step_pred_summary', step_pred_summary)
+    return pred, [call_api_success, ans_1st_pass, None, step_pred_summary]
+    # return pred, [call_api_success, message_2nd, completion_2nd.choices[0].message.content, step_pred_summary]
+
+