modified: yenthienviet.py

README.md

@@ -2,20 +2,24 @@
 pretty_name: YENTHIENVIET
 dataset_info:
   features:
-  - name: image
-    dtype: image
   - name: image_id
     dtype: int64
+  - name: image
+    dtype: image
+  - name: width
+    dtype: int32
+  - name: height
+    dtype: int32
   - name: objects
     sequence:
     - name: id
       dtype: int64
     - name: area
-      dtype: float64
+      dtype: int64
     - name: bbox
       sequence: float32
       length: 4
-    - name: label
+    - name: category
       dtype:
         class_label:
           names:
@@ -25,25 +29,22 @@ dataset_info:
             '3': hop_ytv
             '4': lo_kids
             '5': lo_ytv
-            '6': loc_ytv
-            '7': loc_kids
-            '8': loc_dln
-            '9': bot_dln
-            '10': loc_jn
-    - name: iscrowd
-      dtype: bool
+            '6': loc_dln
+            '7': loc_jn
+            '8': loc_kids
+            '9': loc_ytv
   splits:
   - name: train
-    num_bytes: 82367458
-    num_examples: 278
-  - name: val
-    num_bytes: 16692841
-    num_examples: 79
+    num_bytes: 649109264
+    num_examples: 1755
   - name: test
-    num_bytes: 17710143
-    num_examples: 76
-  download_size: 112352919
-  dataset_size: 116770442
+    num_bytes: 51031547
+    num_examples: 152
+  - name: val
+    num_bytes: 53894489
+    num_examples: 159
+  download_size: 727024589
+  dataset_size: 754035300
 ---
 
 # Dataset Card for Dataset Name

yenthienviet.py

@@ -1,42 +1,20 @@
-import json
 import os
-from pathlib import Path
-from typing import Any, Dict, Iterator, List, Tuple, Union
+import json
+import collections
 
 import datasets
-from datasets.download.download_manager import ArchiveIterable, DownloadManager
+from datasets import NamedSplit
+from datasets.download.download_manager import DownloadManager
 
-# Typing
-_TYPING_BOX = Tuple[float, float, float, float]
 
 _DESCRIPTION = """\
 This dataset contains all THIENVIET products images and annotations split in training
     and validation.
 """
 
-_URLS = {
-    "train": "https://huggingface.co/datasets/chanelcolgate/yenthienviet/resolve/main/data/coco2/train.zip",
-    "val": "https://huggingface.co/datasets/chanelcolgate/yenthienviet/resolve/main/data/coco2/val.zip",
-    "test": "https://huggingface.co/datasets/chanelcolgate/yenthienviet/resolve/main/data/coco2/test.zip",
-    "annotations": "https://huggingface.co/datasets/chanelcolgate/yenthienviet/resolve/main/data/coco2/annotations.zip",
-}
-
-_SPLITS = ["train", "val", "test"]
+_URL = "https://huggingface.co/datasets/chanelcolgate/yenthienviet/resolve/main/data/yenthienviet_coco_hf.zip"
 
-_PATHS = {
-    "annotations": {
-        "train": Path("_annotations.coco.train.json"),
-        "val": Path("_annotations.coco.val.json"),
-        "test": Path("_annotations.coco.test.json"),
-    },
-    "images": {
-        "train": Path("train"),
-        "val": Path("val"),
-        "test": Path("test"),
-    },
-}
-
-_CLASSES = [
+_CATEGORIES = [
     "hop_dln",
     "hop_jn",
     "hop_vtg",
@@ -50,163 +28,99 @@ _CLASSES = [
 ]
 
 
-def round_box_values(box, decimals=2):
-    return [round(val, decimals) for val in box]
-
-
-class COCOHelper:
-    """Helper class to load COCO annotations"""
-
-    def __init__(self, annotation_path: Path, images_dir: Path) -> None:
-        with open(annotation_path, "r") as file:
-            data = json.load(file)
-        self.data = data
-
-        dict_id2annot: Dict[int, Any] = {}
-        for annot in self.annotations:
-            dict_id2annot.setdefault(annot["image_id"], []).append(annot)
-
-        # Sort by id
-        dict_id2annot = {
-            k: list(sorted(v, key=lambda a: a["id"]))
-            for k, v in dict_id2annot.items()
-        }
-
-        self.dict_path2annot: Dict[str, Any] = {}
-        self.dict_path2id: Dict[str, Any] = {}
-        for img in self.images:
-            path_img = images_dir / str(img["file_name"])
-            path_img_str = str(path_img)
-            idx = int(img["id"])
-            annot = dict_id2annot.get(idx, [])
-            self.dict_path2annot[path_img_str] = annot
-            self.dict_path2id[path_img_str] = img["id"]
-
-    def __len__(self) -> int:
-        return len(self.data["images"])
+class Yenthienviet(datasets.GeneratorBasedBuilder):
+    """Yenthienviet dataset."""
 
-    @property
-    def images(self) -> List[Dict[str, Union[str, int]]]:
-        return self.data["images"]
+    VERSION = datasets.Version("1.0.0")
 
-    @property
-    def annotations(self) -> List[Any]:
-        return self.data["annotations"]
-
-    @property
-    def categories(self) -> List[Dict[str, Union[str, int]]]:
-        return self.data["categories"]
-
-    def get_annotations(self, image_path: str) -> List[Any]:
-        return self.dict_path2annot.get(image_path, [])
-
-    def get_image_id(self, image_path: str) -> int:
-        return self.dict_path2id.get(image_path, -1)
-
-
-class COCOThienviet(datasets.GeneratorBasedBuilder):
-    """COCO Thienviet dataset."""
-
-    VERSION = datasets.Version("1.0.1")
-
-    def _info(self) -> datasets.DatasetInfo:
-        """
-        Return the dataset metadata and features.
-
-        Returns:
-            DatasetInfo: Metadata and features of the dataset.
-        """
+    def _info(self):
+        features = datasets.Features(
+            {
+                "image_id": datasets.Value("int64"),
+                "image": datasets.Image(),
+                "width": datasets.Value("int32"),
+                "height": datasets.Value("int32"),
+                "objects": datasets.Sequence(
+                    {
+                        "id": datasets.Value("int64"),
+                        "area": datasets.Value("int64"),
+                        "bbox": datasets.Sequence(
+                            datasets.Value("float32"), length=4
+                        ),
+                        "category": datasets.ClassLabel(names=_CATEGORIES),
+                    }
+                ),
+            }
+        )
         return datasets.DatasetInfo(
             description=_DESCRIPTION,
-            features=datasets.Features(
-                {
-                    "image": datasets.Image(),
-                    "image_id": datasets.Value("int64"),
-                    "objects": datasets.Sequence(
-                        {
-                            "id": datasets.Value("int64"),
-                            "area": datasets.Value("float64"),
-                            "bbox": datasets.Sequence(
-                                datasets.Value("float32"), length=4
-                            ),
-                            "label": datasets.ClassLabel(names=_CLASSES),
-                            "iscrowd": datasets.Value("bool"),
-                        }
-                    ),
-                }
-            ),
+            features=features,
         )
 
-    def _split_generators(
-        self, dl_manager: DownloadManager
-    ) -> List[datasets.SplitGenerator]:
-        """
-        Provides the split information and downloads the data.
-
-        Args:
-            dl_manager (DownloadManager): The DownloadManager to use for downloading and
-                extracting data.
-
-        Returns:
-            List[SplitGenerator]: List of SplitGenerator objects representing the data splits.
-        """
-        archive_annots = dl_manager.download_and_extract(_URLS["annotations"])
-
-        splits = []
-        for split in _SPLITS:
-            archive_split = dl_manager.download(_URLS[split])
-            annotation_path = (
-                Path(archive_annots) / _PATHS["annotations"][split]
-            )
-            images = dl_manager.iter_archive(archive_split)
-            splits.append(
-                datasets.SplitGenerator(
-                    name=datasets.Split(split),
-                    gen_kwargs={
-                        "annotation_path": annotation_path,
-                        "images_dir": _PATHS["images"][split],
-                        "images": images,
-                    },
-                )
-            )
-        return splits
-
-    def _generate_examples(
-        self, annotation_path: Path, images_dir: Path, images: ArchiveIterable
-    ) -> Iterator:
-        """
-        Generates examples for the dataset.
-
-        Args:
-            annotation_path (Path): The path to the annotation file.
-            images_dir (Path): The path to the directory containing the images.
-            images: (ArchiveIterable): An iterable containing the images.
-
-        Yields:
-            Dict[str, Union[str, Image]]: A dictionary containing the generated examples.
-        """
-        coco_annotation = COCOHelper(annotation_path, images_dir)
-
-        for image_path, f in images:
-            annotations = coco_annotation.get_annotations(
-                os.path.normpath(image_path)
-            )
-            ret = {
-                "image": {"path": image_path, "bytes": f.read()},
-                "image_id": coco_annotation.get_image_id(
-                    os.path.normpath(image_path)
-                ),
-                "objects": [
-                    {
-                        "id": annot["id"],
-                        "area": annot["area"],
-                        "bbox": round_box_values(
-                            annot["bbox"], 2
-                        ),  # [x, y, w, h]
-                        "label": annot["category_id"],
-                        "iscrowd": bool(annot["iscrowd"]),
-                    }
-                    for annot in annotations
-                ],
+    def _split_generators(self, dl_manager: DownloadManager):
+        archive = dl_manager.download(_URL)
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "annotation_file_path": "annotations/train.json",
+                    "files": dl_manager.iter_archive(archive),
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "annotation_file_path": "annotations/test.json",
+                    "files": dl_manager.iter_archive(archive),
+                },
+            ),
+            datasets.SplitGenerator(
+                name=NamedSplit("val"),
+                gen_kwargs={
+                    "annotation_file_path": "annotations/val.json",
+                    "files": dl_manager.iter_archive(archive),
+                },
+            ),
+        ]
+
+    def _generate_examples(self, annotation_file_path, files):
+        def process_annot(annot, category_id_to_category):
+            return {
+                "id": annot["id"],
+                "area": annot["area"],
+                "bbox": annot["bbox"],
+                "category": category_id_to_category[annot["category_id"]],
             }
-            yield image_path, ret
+
+        image_id_to_image = []
+        idx = 0
+        # This loop relies on the ordering of the files in the archive:
+        # Annotation files come first, then the images.
+        for path, f in files:
+            file_name = os.path.basename(path)
+            if path == annotation_file_path:
+                annotations = json.load(f)
+                category_id_to_category = {
+                    category["id"]: category["name"]
+                    for category in annotations["categories"]
+                }
+                image_id_to_annotations = collections.defaultdict(list)
+                for annot in annotations["annotations"]:
+                    image_id_to_annotations[annot["image_id"]].append(annot)
+                image_id_to_image = {
+                    annot["file_name"]: annot for annot in annotations["images"]
+                }
+            elif file_name in image_id_to_image:
+                image = image_id_to_image[file_name]
+                objects = [
+                    process_annot(annot, category_id_to_category)
+                    for annot in image_id_to_annotations[image["id"]]
+                ]
+                yield idx, {
+                    "image_id": image["id"],
+                    "image": {"path": path, "bytes": f.read()},
+                    "width": image["width"],
+                    "height": image["height"],
+                    "objects": objects,
+                }
+                idx += 1