| import os |
| import json |
| from pathlib import Path |
| from typing import Dict, Any, List, Union, Iterator, Tuple |
|
|
| import datasets |
| from datasets.download.download_manager import DownloadManager, ArchiveIterable |
|
|
| |
| _TYPING_BOX = Tuple[float, float, float, float] |
|
|
| _DESCRIPTION = """\ |
| Training image sets and labels/bounding box coordinates for detecting brain |
| tumors in MR images. |
| - The datasets JPGs exported at their native size and are separated by plan |
| (Axial, Coronal and Sagittal). |
| - Tumors were hand labeled using https://makesense.ai |
| - Bounding box coordinates and MGMT positive labels were marked on ~400 images |
| for each plane in the T1wCE series from the RSNA-MICCAI competition data. |
| """ |
|
|
| _URLS = { |
| "train": "https://huggingface.co/datasets/chanelcolgate/tumorsbrain/resolve/main/data/train.zip", |
| "test": "https://huggingface.co/datasets/chanelcolgate/tumorsbrain/resolve/main/data/test.zip", |
| "annotations": "https://huggingface.co/datasets/chanelcolgate/tumorsbrain/resolve/main/data/annotations.zip", |
| } |
|
|
| _PATHS = { |
| "annotations": { |
| "train": Path("_annotations.coco.train.json"), |
| "test": Path("_annotations.coco.test.json"), |
| }, |
| "images": {"train": Path("train"), "test": Path("test")}, |
| } |
|
|
| _CLASSES = ["negative", "positive"] |
|
|
| _SPLITS = ["train", "test"] |
|
|
|
|
| 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) |
|
|
| |
| 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"]) |
|
|
| @property |
| def images(self) -> List[Dict[str, Union[str, int]]]: |
| return self.data["images"] |
|
|
| @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. |
| """ |
| 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"), |
| } |
| ), |
| } |
| ), |
| ) |
|
|
| 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) |
| if split == "train": |
| splits.append( |
| datasets.SplitGenerator( |
| name=datasets.Split.TRAIN, |
| gen_kwargs={ |
| "annotation_path": annotation_path, |
| "images_dir": _PATHS["images"][split], |
| "images": images, |
| }, |
| ) |
| ) |
| else: |
| splits.append( |
| datasets.SplitGenerator( |
| name=datasets.Split.TEST, |
| 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 |
| ), |
| "label": annot["category_id"], |
| "iscrowd": bool(annot["iscrowd"]), |
| } |
| for annot in annotations |
| ], |
| } |
| yield image_path, ret |
|
|
