Upload 8 files

Datasets-Structure.md

@@ -0,0 +1,67 @@
+# Datasets-Structure
+
+**(YOLOv8 format)**
+
+The Yolov8 dataset for segmentation is usually structured as follows:
+```
+yolo_dataset/
+│
+├── train/
+│ ├── images/
+│ │ └── 🖼️ img_n # Example image 
+│ │
+│ └── labels/
+│   └── 📄 img_n_labels.txt # Example labels file 
+│
+├── valid/
+│ │ ... (similar)
+│
+└── 📄 data.yaml
+```
+
+Each ```img_x_labels.txt``` file contains multiple annotations (one per line) with corresponding class ID and segmentation coordinates:
+
+`<class-index> <x1> <y1> <x2> <y2> ... <xn> <yn>`
+
+The file `data.yaml` contains keys such as:
+ - names (the class names)
+ - nc (number or classes)
+ - train (path/to/train/images/)
+ - val (path/to/val/images/)
+
+
+**(COCO Instance Segmentation format)**
+```
+coco_dataset/
+│
+├── train/
+│  ├── 🖼️ img_n # Example image 
+│  └── 📄 annotations.json # The annotations json file
+│
+└── valid/ 
+   └── ... (similar)
+
+```
+
+The annotations json file contains a dictionary of lists:
+
+- images (a list of dictionaries)
+  - id - image ID
+  - file_name 
+  - height
+  - width
+
+
+- annotations (a list of dictionaries)
+  - id
+  - image_id
+  - category_id
+  - bbox 
+  - area
+  - segmentation (a segmentation polygon)
+  - iscrowd
+
+ 
+- categories (a list of dictionaries)
+  - id
+  - name

coco_format_to_parquet.ipynb

@@ -0,0 +1,988 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a333665e-77ee-43af-b539-8b2bc87c008c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import pandas as pd\n",
+    "from pathlib import Path\n",
+    "from PIL import Image, ImageDraw, ImageFile\n",
+    "import cv2\n",
+    "import io \n",
+    "import base64\n",
+    "import numpy as np\n",
+    "from pycocotools.coco import COCO\n",
+    "import os\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.patches as patches\n",
+    "from PIL import Image\n",
+    "ImageFile.LOAD_TRUNCATED_IMAGES = True\n",
+    "\n",
+    "import utils\n",
+    "\n",
+    "dataset_dir = './mskf_0/'\n",
+    "train_df, train_coco_data = utils.split_to_df(dataset_dir, 'train/')\n",
+    "valid_df, valid_coco_data = utils.split_to_df(dataset_dir, 'valid')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "0e0d5a99-4eba-49d4-931b-0128691631b1",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'id': 1,\n",
+       " 'license': 1,\n",
+       " 'file_name': 'S0505210301_M_png.rf.e47187e88c167fad1db290b0214e2175.jpg',\n",
+       " 'height': 512,\n",
+       " 'width': 512,\n",
+       " 'date_captured': '2024-05-08T06:13:06+00:00'}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_coco_data['images'][0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "df660d83-5afb-4b7c-83e4-f1f9d68577cd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1, 2, 3, 4, 5])"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.unique(train_df['category_id'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "51f26d8d-0116-48fe-8cea-d070350df333",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'image_id': array([<class 'int'>], dtype=object),\n",
+       " 'category_id': array([<class 'int'>], dtype=object),\n",
+       " 'bbox': array([<class 'list'>], dtype=object),\n",
+       " 'area': array([<class 'float'>], dtype=object),\n",
+       " 'segmentation': array([<class 'numpy.ndarray'>], dtype=object),\n",
+       " 'iscrowd': array([<class 'int'>], dtype=object),\n",
+       " 'width': array([<class 'int'>], dtype=object),\n",
+       " 'height': array([<class 'int'>], dtype=object),\n",
+       " 'observation': array([<class 'str'>], dtype=object),\n",
+       " 'image': array([<class 'numpy.ndarray'>], dtype=object),\n",
+       " 'annot_id': array([<class 'int'>], dtype=object)}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "unique_types = {col: train_df[col].apply(type).unique() for col in train_df.columns}\n",
+    "unique_types"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6f464df1-9e86-47ed-a8c6-d5116a71085e",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# train_df.head(20)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "3f4afc2a-2ee4-458d-95c0-19e8497653da",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "from collections import defaultdict\n",
+    "from datasets import Dataset, Features, Sequence\n",
+    "import datasets\n",
+    "from io import BytesIO\n",
+    "\n",
+    "cats_to_colours = { 1:('central-ring', (1,252,214)), \n",
+    "                    2:('other', (255,128,1)),\n",
+    "                    3:('read-out-streak', (20, 77, 158)), \n",
+    "                    4:('smoke-ring', (159,21,100)),\n",
+    "                    5:('star-loop', (255, 188, 248))}\n",
+    "\n",
+    "train_dataset=utils.df_to_dataset_dict(train_df, train_coco_data, cats_to_colours)\n",
+    "valid_dataset=utils.df_to_dataset_dict(valid_df, valid_coco_data, cats_to_colours)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e3ed2ab1-8632-4e49-a661-c306554bd010",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6ebf9675899e4ffcbcb3ebebbe7d6147",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Uploading the dataset shards:   0%|          | 0/1 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2bf3a5fcfc914785b99bc6e6892531be",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/87 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "871d1f3b21d242cf86e1d1f20295fa7d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Creating parquet from Arrow format:   0%|          | 0/1 [00:00<?, ?ba/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9376ea5e4c174f31827a0dd50a0af9b2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Uploading the dataset shards:   0%|          | 0/1 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f5a6d9c4be554f4f937b1afd82f934b9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Map:   0%|          | 0/88 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c2a692042a7748f9adea02a38012bb4c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Creating parquet from Arrow format:   0%|          | 0/1 [00:00<?, ?ba/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e2d0aec5b6f14da889ebb4876d6a6cc3",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "README.md:   0%|          | 0.00/5.71k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "CommitInfo(commit_url='https://huggingface.co/datasets/iulia-elisa/XMM_OM_AI_dataset/commit/e4f969ebf7e6b84ece6a91380cbe2dd2fc669261', commit_message='Upload dataset', commit_description='', oid='e4f969ebf7e6b84ece6a91380cbe2dd2fc669261', pr_url=None, pr_revision=None, pr_num=None)"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from datasets import DatasetDict\n",
+    "\n",
+    "dataset_dict = DatasetDict({\n",
+    "    'train': train_dataset,\n",
+    "    'valid': valid_dataset\n",
+    "})\n",
+    "\n",
+    "dataset_dict.push_to_hub('iulia-elisa/XMM_OM_AI_dataset', private=False)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "env_py311",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "state": {
+     "048f277744ff4c8f9fe447563d554654": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "08cf7cea944a4322ae9b6ef361862bb4": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_99548805c93d4e2bbccaf691aba88980",
+       "style": "IPY_MODEL_23e0985cd92e4db1a9006cab93b41a35",
+       "value": "Creating parquet from Arrow format: 100%"
+      }
+     },
+     "0e36fda6f39745ef85e3846289e165eb": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "0f6e7836683d40efa731e77aa6746fa5": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "11970b4573344669adcfd5d9df924aea": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "FloatProgressModel",
+      "state": {
+       "bar_style": "success",
+       "layout": "IPY_MODEL_e6ec6e37a6304a2590e81ec2b4a01e15",
+       "max": 1,
+       "style": "IPY_MODEL_a2c1ef897ce849d9a1f773724f617d40",
+       "value": 1
+      }
+     },
+     "1c7cfbd83be64f8eafa6d8ad98b08bc8": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "1fa82ba064f548319607a027721117d8": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_048f277744ff4c8f9fe447563d554654",
+       "style": "IPY_MODEL_5874491ff76a470e9db86621e2e5d1a7",
+       "value": " 1/1 [00:00&lt;00:00,  9.50ba/s]"
+      }
+     },
+     "23640986547d47b3900f002fe5522f39": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "23e0985cd92e4db1a9006cab93b41a35": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "2bf3a5fcfc914785b99bc6e6892531be": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_47be27d426034da9a97c49bae4626ddc",
+        "IPY_MODEL_71f517a070b643b3a5b6ad86c3710f95",
+        "IPY_MODEL_fb1c614683cf4531b6ac405a9373d74d"
+       ],
+       "layout": "IPY_MODEL_db5e0e8d61d742ef823112ebe06cd33b"
+      }
+     },
+     "2d56d23ee7804546ab50c8ceaddd2d05": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_0e36fda6f39745ef85e3846289e165eb",
+       "style": "IPY_MODEL_a591c55a93f84703b8070bcf65e957e6",
+       "value": "Map: 100%"
+      }
+     },
+     "2f221cdc0bb44e23ab02f00a658801bf": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "FloatProgressModel",
+      "state": {
+       "bar_style": "success",
+       "layout": "IPY_MODEL_e5f9516196b0461daf95817bb9408d7b",
+       "max": 5714,
+       "style": "IPY_MODEL_c38b2aa4bbd04b248b23de98a3fb3f04",
+       "value": 5714
+      }
+     },
+     "2f4e9a17492b430eb38dbf580a8f6112": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_692de2a4a32e4c009f021c3c604ee245",
+       "style": "IPY_MODEL_1c7cfbd83be64f8eafa6d8ad98b08bc8",
+       "value": " 1/1 [00:02&lt;00:00,  2.68s/it]"
+      }
+     },
+     "326fe11988d74d66b99b448cf2001714": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "3723e0afbc944b679032254d2b9d543c": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "38f0c8d251154e15ba2a621db92bbf89": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "391d57117eb649beae65ed7a6a79a18b": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "401d5cb498aa42ccbf4e7bc4aafacb11": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "46cba72f63ef469b82a4b1a96fb796ee": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "47be27d426034da9a97c49bae4626ddc": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_911d271807e8414da96305fdd80796a7",
+       "style": "IPY_MODEL_73726b2d576c4644acaf676b9b9ec34f",
+       "value": "Map: 100%"
+      }
+     },
+     "488243dfb6574985bcbf7e790134e744": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ProgressStyleModel",
+      "state": {
+       "description_width": ""
+      }
+     },
+     "4b35ce2957784c83a9444926b0a7e976": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_b90c8d0425ac4bcca937ea6b545e48cd",
+       "style": "IPY_MODEL_46cba72f63ef469b82a4b1a96fb796ee",
+       "value": " 88/88 [00:00&lt;00:00, 819.47 examples/s]"
+      }
+     },
+     "4f42920d671545ed8e0e7c5ceaedf8ed": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "52dfe57cd5b44d62889af8a4df9467e1": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ProgressStyleModel",
+      "state": {
+       "description_width": ""
+      }
+     },
+     "5874491ff76a470e9db86621e2e5d1a7": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "59ca0f5d7fff4b52a7051b923253c66f": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "5d9126ed84e347379beddb410cda4381": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "657e2016f007499cafa8ea389a461201": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "68409dd4c6a042899d8f32b8d426bd6c": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "FloatProgressModel",
+      "state": {
+       "bar_style": "success",
+       "layout": "IPY_MODEL_5d9126ed84e347379beddb410cda4381",
+       "max": 1,
+       "style": "IPY_MODEL_e7c643f02df04f39a6232d4ef37dbe53",
+       "value": 1
+      }
+     },
+     "692de2a4a32e4c009f021c3c604ee245": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "6ebf9675899e4ffcbcb3ebebbe7d6147": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_d753a4db07294b83a86784bfc211dcaf",
+        "IPY_MODEL_68409dd4c6a042899d8f32b8d426bd6c",
+        "IPY_MODEL_a056610c2b23491aba3f37c38f0ad8c5"
+       ],
+       "layout": "IPY_MODEL_920bced53c3d42099f1a87eed19ce05e"
+      }
+     },
+     "71f517a070b643b3a5b6ad86c3710f95": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "FloatProgressModel",
+      "state": {
+       "bar_style": "success",
+       "layout": "IPY_MODEL_dc80b5c47d4c4f9faab022f05b691228",
+       "max": 87,
+       "style": "IPY_MODEL_b9fb72eff10047289a9597d08009af95",
+       "value": 87
+      }
+     },
+     "73391c6e41d4483e93582af7934d1e54": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_e813397704674d81b3fe6dd3ce444e95",
+       "style": "IPY_MODEL_eaf483365e224158aad8fd8f604ac64b",
+       "value": "Uploading the dataset shards: 100%"
+      }
+     },
+     "73726b2d576c4644acaf676b9b9ec34f": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "76f47b25344e4f1db6549e268af826ba": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_d45797a1fbc54c7cb7b5a863972fb4b1",
+       "style": "IPY_MODEL_cbad9576bda8439d8fa5ae8391b31ff9",
+       "value": " 5.71k/5.71k [00:00&lt;00:00, 1.12MB/s]"
+      }
+     },
+     "7d6080218e2a4888bdfd0c184b7c5ffc": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "842b6cc23bcc485ba3d034f5f955f314": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "871d1f3b21d242cf86e1d1f20295fa7d": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_afbc23b673314807bd81dcc9bcf3e3df",
+        "IPY_MODEL_e5d66c90b5a842de84296f97abbdaae9",
+        "IPY_MODEL_1fa82ba064f548319607a027721117d8"
+       ],
+       "layout": "IPY_MODEL_0f6e7836683d40efa731e77aa6746fa5"
+      }
+     },
+     "911d271807e8414da96305fdd80796a7": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "920bced53c3d42099f1a87eed19ce05e": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "9376ea5e4c174f31827a0dd50a0af9b2": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_73391c6e41d4483e93582af7934d1e54",
+        "IPY_MODEL_acf8c82fec8f4360877e2f1ad3d41e74",
+        "IPY_MODEL_2f4e9a17492b430eb38dbf580a8f6112"
+       ],
+       "layout": "IPY_MODEL_ca406b13430643bdab8a048bdf35dd75"
+      }
+     },
+     "93b9ea63c9ee44cbbe4a266b83a86083": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_391d57117eb649beae65ed7a6a79a18b",
+       "style": "IPY_MODEL_657e2016f007499cafa8ea389a461201",
+       "value": "README.md: 100%"
+      }
+     },
+     "99133f4e57fe4309b610cdb4ce2a90bd": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "99548805c93d4e2bbccaf691aba88980": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "9b8ccb3e67354701a09c2a18ace98ad6": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "a056610c2b23491aba3f37c38f0ad8c5": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_3723e0afbc944b679032254d2b9d543c",
+       "style": "IPY_MODEL_9b8ccb3e67354701a09c2a18ace98ad6",
+       "value": " 1/1 [00:04&lt;00:00,  4.22s/it]"
+      }
+     },
+     "a2c1ef897ce849d9a1f773724f617d40": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ProgressStyleModel",
+      "state": {
+       "description_width": ""
+      }
+     },
+     "a33667021736405b82666b555a5493a8": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "a39e3942259747fd9c7759cbbba73d3d": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "FloatProgressModel",
+      "state": {
+       "bar_style": "success",
+       "layout": "IPY_MODEL_401d5cb498aa42ccbf4e7bc4aafacb11",
+       "max": 88,
+       "style": "IPY_MODEL_488243dfb6574985bcbf7e790134e744",
+       "value": 88
+      }
+     },
+     "a591c55a93f84703b8070bcf65e957e6": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "abc65776f8504948b9e91ea432ebe8ef": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "acf8c82fec8f4360877e2f1ad3d41e74": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "FloatProgressModel",
+      "state": {
+       "bar_style": "success",
+       "layout": "IPY_MODEL_59ca0f5d7fff4b52a7051b923253c66f",
+       "max": 1,
+       "style": "IPY_MODEL_52dfe57cd5b44d62889af8a4df9467e1",
+       "value": 1
+      }
+     },
+     "afbc23b673314807bd81dcc9bcf3e3df": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_f8cd90e4cb13496780c19d3a482fb43f",
+       "style": "IPY_MODEL_4f42920d671545ed8e0e7c5ceaedf8ed",
+       "value": "Creating parquet from Arrow format: 100%"
+      }
+     },
+     "b90c8d0425ac4bcca937ea6b545e48cd": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "b9fb72eff10047289a9597d08009af95": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ProgressStyleModel",
+      "state": {
+       "description_width": ""
+      }
+     },
+     "c2a692042a7748f9adea02a38012bb4c": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_08cf7cea944a4322ae9b6ef361862bb4",
+        "IPY_MODEL_11970b4573344669adcfd5d9df924aea",
+        "IPY_MODEL_fe70cc023aa049e0ba921c8eb1c65646"
+       ],
+       "layout": "IPY_MODEL_23640986547d47b3900f002fe5522f39"
+      }
+     },
+     "c38b2aa4bbd04b248b23de98a3fb3f04": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ProgressStyleModel",
+      "state": {
+       "description_width": ""
+      }
+     },
+     "c827c4d520c342a1bcb54966869a6edc": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "ca406b13430643bdab8a048bdf35dd75": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "cbad9576bda8439d8fa5ae8391b31ff9": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "d45797a1fbc54c7cb7b5a863972fb4b1": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "d753a4db07294b83a86784bfc211dcaf": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_326fe11988d74d66b99b448cf2001714",
+       "style": "IPY_MODEL_a33667021736405b82666b555a5493a8",
+       "value": "Uploading the dataset shards: 100%"
+      }
+     },
+     "db5e0e8d61d742ef823112ebe06cd33b": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "dc80b5c47d4c4f9faab022f05b691228": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "e2d0aec5b6f14da889ebb4876d6a6cc3": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_93b9ea63c9ee44cbbe4a266b83a86083",
+        "IPY_MODEL_2f221cdc0bb44e23ab02f00a658801bf",
+        "IPY_MODEL_76f47b25344e4f1db6549e268af826ba"
+       ],
+       "layout": "IPY_MODEL_f91d0f2d7018430fb1f6f9fef6d4bcb8"
+      }
+     },
+     "e5d66c90b5a842de84296f97abbdaae9": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "FloatProgressModel",
+      "state": {
+       "bar_style": "success",
+       "layout": "IPY_MODEL_7d6080218e2a4888bdfd0c184b7c5ffc",
+       "max": 1,
+       "style": "IPY_MODEL_ea8839476ee147bcbdbd484c04e1e829",
+       "value": 1
+      }
+     },
+     "e5f9516196b0461daf95817bb9408d7b": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "e6ec6e37a6304a2590e81ec2b4a01e15": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "e7c643f02df04f39a6232d4ef37dbe53": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ProgressStyleModel",
+      "state": {
+       "description_width": ""
+      }
+     },
+     "e813397704674d81b3fe6dd3ce444e95": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "ea8839476ee147bcbdbd484c04e1e829": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ProgressStyleModel",
+      "state": {
+       "description_width": ""
+      }
+     },
+     "eaf483365e224158aad8fd8f604ac64b": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "f5a6d9c4be554f4f937b1afd82f934b9": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_2d56d23ee7804546ab50c8ceaddd2d05",
+        "IPY_MODEL_a39e3942259747fd9c7759cbbba73d3d",
+        "IPY_MODEL_4b35ce2957784c83a9444926b0a7e976"
+       ],
+       "layout": "IPY_MODEL_abc65776f8504948b9e91ea432ebe8ef"
+      }
+     },
+     "f8cd90e4cb13496780c19d3a482fb43f": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "f91d0f2d7018430fb1f6f9fef6d4bcb8": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "fb1c614683cf4531b6ac405a9373d74d": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_842b6cc23bcc485ba3d034f5f955f314",
+       "style": "IPY_MODEL_c827c4d520c342a1bcb54966869a6edc",
+       "value": " 87/87 [00:00&lt;00:00, 1110.37 examples/s]"
+      }
+     },
+     "fe70cc023aa049e0ba921c8eb1c65646": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_99133f4e57fe4309b610cdb4ce2a90bd",
+       "style": "IPY_MODEL_38f0c8d251154e15ba2a621db92bbf89",
+       "value": " 1/1 [00:00&lt;00:00,  6.98ba/s]"
+      }
+     }
+    },
+    "version_major": 2,
+    "version_minor": 0
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

dataset_archive.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64f01c9672784cc26cc266287f3276757727bf4ad618b6b207fc05b3b90d3136
+size 133

id2label.json

@@ -0,0 +1 @@
+{"1": "central-ring", "2": "other", "3": "read-out-streak", "4": "smoke-ring", "5":"star-loop"}

load_and_visualise_dataset.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cfd90e91aa9df0f7e65a33b6ec24b5c3ca30a7fca2f62dbe4ca958a80efb5d91
+size 15765

utils.py

@@ -0,0 +1,322 @@
+import os
+import json
+from shutil import copy
+import pandas as pd
+from pathlib import Path
+from PIL import Image, ImageDraw
+import cv2
+import numpy as np
+import re
+import datasets
+from datasets import Value
+from io import BytesIO
+from PIL import Image, ImageDraw, ImageFont
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+
+def create_directories_and_copy_files(images_dir, coco_data, image_data, k):
+    base_dir = os.path.join(images_dir, f'mskf_{k}')
+    os.makedirs(base_dir, exist_ok=True)
+
+    for split in np.unique(image_data['SPLIT']):
+        split_dir = os.path.join(base_dir, split)
+        os.makedirs(split_dir, exist_ok=True)
+
+        # Filter the annotations
+        split_ids = image_data[image_data['SPLIT'] == split]['IMADE_ID'].tolist()
+        annotations = {
+            'images': [img for img in coco_data['images'] if img['id'] in split_ids],
+            'annotations': [ann for ann in coco_data['annotations'] if ann['image_id'] in split_ids],
+            'categories': coco_data['categories']
+        }
+            
+        # Write the filtered annotations to a file
+        with open(os.path.join(split_dir, '_annotations.coco.json'), 'w') as f:
+            json.dump(annotations, f, indent=4)
+        
+        # Copy the images
+        split_data = image_data[image_data['SPLIT'] == split]
+        for _, row in split_data.iterrows():
+            source = row['IMAGE_PATH']
+            destination = os.path.join(split_dir, os.path.basename(source))
+            copy(source, destination)
+            
+    print(f'Dataset split for mskf_{k} was successful.')
+
+def split_to_df(dataset_dir, split):
+    annotations_path = Path(dataset_dir+split+'/_annotations.coco.json')
+    
+    with annotations_path.open('r') as f:
+        coco_data = json.load(f)
+    
+    def image_from_path(file_path):
+        image = cv2.imread(file_path)
+        return image
+    
+    def gen_segmentation(segmentation, width, height):
+        mask_img = np.zeros((height, width, 3), dtype=np.uint8)
+        for segment in segmentation:
+            pts = np.array(segment, np.int32).reshape((-1, 1, 2))
+            cv2.fillPoly(mask_img, [pts], (255, 255, 255))  # Fill color in BGR
+        
+        return mask_img
+        
+    images_df = pd.DataFrame(coco_data['images'][5:25], columns=['id', 'file_name', 'width', 'height'])
+    annotations_df = pd.DataFrame(coco_data['annotations'])
+    df = pd.merge(annotations_df, images_df, left_on='image_id', right_on='id')
+    image_folder = annotations_path.parent 
+    df['file_path'] = df['file_name'].apply(lambda x: str(image_folder / x))
+    df['observation'] = df['file_name'].apply(lambda x: x.split('.')[0].replace('_png', ''))
+    df['image'] = df['file_path'].apply(image_from_path)
+    df['segmentation'] = df.apply(lambda row: gen_segmentation(row['segmentation'], row['width'], row['height']), axis=1)
+    df = df.drop('file_path', axis=1)
+    df = df.drop('file_name', axis=1)
+    df['annot_id'] = df['id_x'] 
+    df = df.drop('id_x', axis=1)
+    df = df.drop('id_y', axis=1)
+    
+    # take image fro df, and the corresponging annotations and plot them on image
+    # for i in range(5):
+    #     img = df['image'][i]
+    #     annot_id = df['annot_id'][i]
+    #     # plot the image with the annotation using plt
+    #     if img.dtype != np.uint8:
+    #         img = img.astype(np.uint8)
+    #     # plot
+    #     segm_polygon = df['segmentation'][i]
+    #     plt.imshow(segm_polygon)
+    #     plt.axis('off')
+    #     plt.show()
+    #     plt.close()
+    
+    return df, coco_data
+	
+def df_to_dataset_dict(df, coco_data, cats_to_colours):
+
+    def annot_on_image(annot_id, img_array, cat_id, annot_type='segm'):
+        if img_array.dtype != np.uint8:
+            img_array = img_array.astype(np.uint8)
+    
+        pil_image = Image.fromarray(img_array)
+        draw = ImageDraw.Draw(pil_image)
+        if annot_type=='bbox':
+            bbox = [annot for annot in coco_data['annotations'] if annot['id'] == annot_id][0]['bbox']
+            x_min, y_min, width, height = bbox
+            top_left = (x_min, y_min)
+            bottom_right = (x_min + width, y_min + height)
+            
+            draw.rectangle([top_left, bottom_right], outline=cats_to_colours[cat_id][1], width=2)
+        else:
+            # look for the annotation in coco_data that corresponds to the annot_id
+            segm_polygon = [annot for annot in coco_data['annotations'] if annot['id'] == annot_id][0]['segmentation'][0]
+            polygon = [(segm_polygon[i], segm_polygon[i+1]) for i in range(0, len(segm_polygon), 2)]
+            draw.polygon(polygon, outline=cats_to_colours[cat_id][1], width=2)  
+         
+        # plt.imshow(pil_image)
+        # plt.axis('off')
+        # plt.show()
+        # plt.close()
+           
+        byte_io = BytesIO()
+        pil_image.save(byte_io, 'PNG')
+        byte_io.seek(0)
+        png_image = Image.open(byte_io)
+    
+        return png_image
+    
+    dictionary = df.to_dict(orient='list')
+    feats=datasets.Features({"observation id":Value(dtype='string'), \
+                             'segmentation': datasets.Image(), \
+                             'bbox':datasets.Image() , \
+                             'label': Value(dtype='string'),\
+                             'area':Value(dtype='string'), 
+                             'image shape':Value(dtype='string')})
+    
+    dataset_data = {"observation id":dictionary['observation'],  \
+                  'segmentation': [annot_on_image(dictionary['annot_id'][i], dictionary['image'][i], dictionary['category_id'][i]) \
+                      for i in range(len(dictionary['segmentation']))], \
+                  'bbox': [annot_on_image(dictionary['annot_id'][i], dictionary['image'][i], dictionary['category_id'][i], annot_type='bbox') \
+                      for i in range(len(dictionary['bbox']))], \
+                  'label': [cats_to_colours[cat][0] for cat in dictionary['category_id']],\
+                  'area':['%.3f'%(value) for value in dictionary['area']], \
+                  'image shape':[f"({dictionary['width'][i]}, {dictionary['height'][i]})" for i in range(len(dictionary['width']))]}
+    the_dataset=datasets.Dataset.from_dict(dataset_data,features=feats)
+
+    return the_dataset
+
+def merge_coco_jsons(first_json, second_json, output_path):
+        
+    # Load the first JSON file
+    with open(first_json) as f:
+        coco1 = json.load(f)
+
+    # Load the second JSON file
+    with open(second_json) as f:
+        coco2 = json.load(f)
+
+    # Update IDs in coco2 to ensure they are unique and do not overlap with coco1
+    max_image_id = max(image['id'] for image in coco1['images'])
+    max_annotation_id = max(annotation['id'] for annotation in coco1['annotations'])
+    max_category_id = max(category['id'] for category in coco1['categories'])
+
+    # Add an offset to the second coco IDs
+    image_id_offset = max_image_id + 1
+    annotation_id_offset = max_annotation_id + 1
+    # category_id_offset = max_category_id + 1
+
+    # Apply offset to images, annotations, and categories in the second JSON
+    for image in coco2['images']:
+        image['id'] += image_id_offset
+
+    for annotation in coco2['annotations']:
+        annotation['id'] += annotation_id_offset
+        annotation['image_id'] += image_id_offset  # Update the image_id reference
+
+    # Merge the two datasets
+    merged_coco = {
+        'images': coco1['images'] + coco2['images'],
+        'annotations': coco1['annotations'] + coco2['annotations'],
+        'categories': coco1['categories']  # If categories are the same; otherwise, merge as needed
+    }
+
+    # Save the merged annotations to a new JSON file
+    with open(output_path, 'w') as f:
+        json.dump(merged_coco, f)
+
+def percentages(n_splits, image_ids, labels):
+    labels_percentages = {}
+    for i in range(n_splits):
+        train_k, valid_k = 0, 0
+        train_labels_counts = {'0':0, '1':0, '2':0, '3':0, '4':0, '5':0}
+        valid_labels_counts = {'0':0, '1':0, '2':0, '3':0, '4':0, '5':0}
+        for j in range(len(image_ids[i]['train'])):
+            for cat in list(labels[i]['train'][j]):
+                train_labels_counts[cat] += 1
+                train_k+=1
+        
+        for j in range(len(image_ids[i]['valid'])):
+            for cat in list(labels[i]['valid'][j]):
+                valid_labels_counts[cat] += 1
+                valid_k+=1
+    
+        train_labels_counts = {cat:counts * 1.0/train_k for cat, counts in train_labels_counts.items()}
+        valid_labels_counts = {cat:counts * 1.0/valid_k for cat, counts in valid_labels_counts.items()}
+                
+        labels_percentages[i] = {'train':train_labels_counts, 'valid':  valid_labels_counts}
+        
+    return labels_percentages
+
+def make_split(data_in, train_index, valid_index):
+    
+    data_in_train = data_in.copy()
+    data_in_valid = data_in.copy()
+    
+    data_in_train['images'] = [data_in['images'][train_index[i][0]] for i in range(len(train_index))]
+    data_in_valid['images'] = [data_in['images'][valid_index[i][0]] for i in range(len(valid_index))]
+    train_annot_ids, valid_annot_ids = [], []
+    
+    for img_i in data_in_train['images']:
+        annotation_ids = [annot['id'] for annot in data_in_train['annotations'] if annot['image_id'] == img_i['id']]
+        train_annot_ids +=annotation_ids
+        
+    for img_i in data_in_valid['images']:
+        annotation_ids = [annot['id'] for annot in data_in_valid['annotations'] if annot['image_id'] == img_i['id']]
+        valid_annot_ids +=annotation_ids
+        
+    data_in_train['annotations'] = [data_in_train['annotations'][id] for id in train_annot_ids]
+    data_in_valid['annotations'] = [data_in_valid['annotations'][id] for id in valid_annot_ids]
+    
+    print(len(data_in_train['images']), len(data_in_valid['images']))
+    return data_in_train, data_in_valid
+
+def correct_bboxes(annotations):
+        for ann in annotations:
+            # If the segmentation is in polygon format (COCO polygon)
+            if isinstance(ann['segmentation'], list):
+    
+                points = np.array(ann['segmentation']).reshape(-1, 2)
+                x_min, y_min = np.inf, np.inf
+                x_max, y_max = -np.inf, -np.inf
+                x_min = min(x_min, points[:, 0].min())
+                y_min = min(y_min, points[:, 1].min())
+                x_max = max(x_max, points[:, 0].max())
+                y_max = max(y_max, points[:, 1].max())
+        
+                width = x_max - x_min
+                height = y_max - y_min
+            
+                # The bbox in COCO format [x_min, y_min, width, height]
+                bbox = [x_min, y_min, width, height]
+                x, y, w, h = map(int, bbox)
+                ann['bbox'] = [x, y, w, h]
+    
+        return annotations
+    
+def highlight_max(s):
+    is_max = s == s.max()
+    return ['background-color: yellow' if v else '' for v in is_max]
+
+def highlight_max_str(s):
+    
+    cats = []
+    for cat in s:
+        cats.append([float(match) for match in re.findall(r"[-+]?[0-9]*\.?[0-9]+", cat)][0])
+        
+    is_max = cats == np.max(cats)
+    return ['background-color: yellow' if v else '' for v in is_max]
+
+def read_yolo_annotations(annotation_file):
+    with open(annotation_file, 'r') as file:
+        lines = file.readlines()
+
+    annotations = []
+    for line in lines:
+        parts = line.strip().split()
+        class_id = int(parts[0])
+        points = list(map(float, parts[1:]))
+        annotations.append((class_id, points))
+    
+    return annotations
+
+def display_image_with_annotations(coco, cat_names, image_id):
+    img = coco.loadImgs(image_id)[0]
+    image_path = os.path.join('./mskf_0/train/', img['file_name'])
+    I = Image.open(image_path)
+    plt.imshow(I); plt.axis('off')
+    ann_ids = coco.getAnnIds(imgIds=img['id'], iscrowd=None)
+    anns = coco.loadAnns(ann_ids)
+    ax = plt.gca()
+    
+    for ann in anns:
+        bbox = ann['bbox']
+        rect = patches.Rectangle((bbox[0], bbox[1]), bbox[2], bbox[3],
+                                 linewidth=2, edgecolor='b', facecolor='none')
+        ax.add_patch(rect)
+        ax.text(bbox[0], bbox[1] - 5, cat_names[ann['category_id']],
+                color='blue', fontsize=12, bbox=dict(facecolor='white', alpha=0.5))
+
+    plt.show()
+
+def plot_segmentations(image_path, annotations, category_mapping):
+    image = Image.open(image_path)
+    width, height = image.size
+    draw = ImageDraw.Draw(image)
+
+    try:
+        font = ImageFont.truetype("DejaVuSans.ttf", 16)  # Load a font
+    except IOError:
+        font = ImageFont.load_default()
+
+    for class_id, points in annotations:
+        # Scale points from normalized coordinates to image dimensions
+        scaled_points = [(p[0] * width, p[1] * height) for p in zip(points[0::2], points[1::2])]
+        draw.polygon(scaled_points, outline='green', fill=None)  
+
+        category_name = category_mapping[class_id][0]
+        centroid_x = sum([p[0] for p in scaled_points]) / len(scaled_points)
+        centroid_y = sum([p[1] for p in scaled_points]) / len(scaled_points)
+        draw.text((centroid_x, centroid_y), category_name, fill='red', font=font, anchor='ms')
+
+    plt.imshow(image)
+    plt.axis('off')
+    plt.show()