Delete ccagt.py

ccagt.py

@@ -1,355 +0,0 @@
-import json
-import os
-from collections import OrderedDict, defaultdict
-from math import ceil
-
-import numpy as np
-import pandas as pd
-
-import datasets
-
-
-logger = datasets.logging.get_logger(__name__)
-
-CCAGT_CLASSES = OrderedDict(
-    {
-        1: "NUCLEUS",
-        2: "CLUSTER",
-        3: "SATELLITE",
-        4: "NUCLEUS_OUT_OF_FOCUS",
-        5: "OVERLAPPED_NUCLEI",
-        6: "NON_VIABLE_NUCLEUS",
-        7: "LEUKOCYTE_NUCLEUS",
-    }
-)
-
-_LICENSE = "CC BY NC 3.0 License"
-
-_CITATION = """\
-@misc{CCAgTDataset,
-  doi = {10.17632/WG4BPM33HJ.2},
-  url = {https://data.mendeley.com/datasets/wg4bpm33hj/2},
-  author =  {Jo{\\~{a}}o Gustavo Atkinson Amorim and Andr{\'{e}} Vict{\'{o}}ria Matias and Tainee Bottamedi and Vinícius Sanches and Ane Francyne Costa and Fabiana Botelho De Miranda Onofre and Alexandre Sherlley Casimiro Onofre and Aldo von Wangenheim},
-  title = {CCAgT: Images of Cervical Cells with AgNOR Stain Technique},
-  publisher = {Mendeley},
-  year = {2022},
-  copyright = {Attribution-NonCommercial 3.0 Unported}
-}
-"""
-
-_HOMEPAGE = "https://data.mendeley.com/datasets/wg4bpm33hj"
-
-_DESCRIPTION = """\
-The CCAgT (Images of Cervical Cells with AgNOR Stain Technique) dataset contains 9339 images (1600x1200 resolution where each pixel is 0.111µmX0.111µm) from 15 different slides stained using the AgNOR technique.
-Each image has at least one label. In total, this dataset has more than 63K instances of annotated object.
-The images are from the patients of the Gynecology and Colonoscopy Outpatient Clinic of the Polydoro Ernani de São Thiago University Hospital of the Universidade Federal de Santa Catarina (HU-UFSC).
-"""
-
-_DATA_URL = "https://md-datasets-cache-zipfiles-prod.s3.eu-west-1.amazonaws.com/wg4bpm33hj-2.zip"
-
-
-def tvt(ids, tvt_size, seed=1609):
-    """From a list of indexes/ids (int) will generate the train-validation-test data.
-
-    Based on `github.com/scikit-learn/scikit-learn/blob/37ac6788c9504ee409b75e5e24ff7d86c90c2ffb/sklearn/model_selection/_split.py#L2321`
-    """
-    n_samples = len(ids)
-
-    qtd = {
-        "valid": ceil(n_samples * tvt_size[1]),
-        "test": ceil(n_samples * tvt_size[2]),
-    }
-    qtd["train"] = int(n_samples - qtd["valid"] - qtd["test"])
-
-    rng = np.random.RandomState(seed)
-    permutatation = rng.permutation(ids)
-
-    out = {
-        "train": set(permutatation[: qtd["train"]]),
-        "valid": set(permutatation[qtd["train"] : qtd["train"] + qtd["valid"]]),
-        "test": set(permutatation[qtd["train"] + qtd["valid"] :]),
-    }
-
-    return out["train"], out["valid"], out["test"]
-
-
-def annotations_per_image(df):
-    """
-    based on: https://github.com/johnnv1/CCAgT-utils/blob/54ade78e4ddb2e2ed9507b8a1633940897767cac/CCAgT_utils/describe.py#L152
-    """
-    df_describe_images = df.groupby(["image_id", "category_id"]).size().reset_index().rename(columns={0: "count"})
-    df_describe_images = df_describe_images.pivot(columns=["category_id"], index="image_id")
-    df_describe_images = df_describe_images.rename(CCAGT_CLASSES, axis=1)
-    df_describe_images["qtd_annotations"] = df_describe_images.sum(axis=1)
-    df_describe_images = df_describe_images.fillna(0)
-    df_describe_images["NORs"] = (
-        df_describe_images[
-            "count",
-            CCAGT_CLASSES[2],
-        ]
-        + df_describe_images[
-            "count",
-            CCAGT_CLASSES[3],
-        ]
-    )
-
-    return df_describe_images
-
-
-def tvt_by_nors(df, tvt_size=(0.7, 0.15, 0.15), **kwargs):
-    """This will split the CCAgT annotations based on the number of NORs
-    into each image. With a silly separation, first will split
-    between each fold images with one or less NORs, after will split
-    images with the amount of NORs is between 2 and 7, and at least will
-    split images that have more than 7 NORs.
-
-    based on `https://github.com/johnnv1/CCAgT-utils/blob/54ade78e4ddb2e2ed9507b8a1633940897767cac/CCAgT_utils/split.py#L64`
-    """
-    if sum(tvt_size) != 1:
-        raise ValueError("The sum of `tvt_size` need to be equal to 1!")
-
-    df_describe_imgs = annotations_per_image(df)
-
-    img_ids = {}
-    img_ids["low_nors"] = df_describe_imgs.loc[(df_describe_imgs["NORs"] < 2)].index
-    img_ids["medium_nors"] = df_describe_imgs[(df_describe_imgs["NORs"] >= 2) * (df_describe_imgs["NORs"] <= 7)].index
-    img_ids["high_nors"] = df_describe_imgs[(df_describe_imgs["NORs"] > 7)].index
-
-    train_ids = set({})
-    valid_ids = set({})
-    test_ids = set({})
-
-    for k, ids in img_ids.items():
-        logger.info(f"Splitting {len(ids)} images with {k} quantity...")
-        if len(ids) == 0:
-            continue
-        _train, _valid, _test = tvt(ids, tvt_size, **kwargs)
-        logger.info(f">T: {len(_train)} V: {len(_valid)} T: {len(_test)}")
-        train_ids = train_ids.union(_train)
-        valid_ids = valid_ids.union(_valid)
-        test_ids = test_ids.union(_test)
-
-    return train_ids, valid_ids, test_ids
-
-
-def get_basename(path):
-    return os.path.splitext(os.path.basename(path))[0]
-
-
-def get_slide_id(path):
-    bn = get_basename(path)
-    slide_id = bn.split("_")[0]
-    return slide_id
-
-
-class CCAgTConfig(datasets.BuilderConfig):
-    """BuilderConfig for CCAgT."""
-
-    seed = 1609
-    tvt_size = (0.7, 0.15, 0.15)
-
-
-class CCAgT(datasets.GeneratorBasedBuilder):
-    """Images of Cervical Cells with AgNOR Stain Technique (CCAgT) dataset"""
-
-    test_dummy_data = False
-
-    VERSION = datasets.Version("2.0.0")
-
-    BUILDER_CONFIG_CLASS = CCAgTConfig
-    BUILDER_CONFIGS = [
-        CCAgTConfig(name="semantic_segmentation", version=VERSION, description="The semantic segmentation variant."),
-        CCAgTConfig(name="object_detection", version=VERSION, description="The object detection variant."),
-        CCAgTConfig(name="instance_segmentation", version=VERSION, description="The instance segmentation variant."),
-    ]
-
-    DEFAULT_CONFIG_NAME = "semantic_segmentation"
-
-    def _info(self):
-        assert len(CCAGT_CLASSES) == 7
-
-        if self.config.name == "semantic_segmentation":
-            features = datasets.Features(
-                {
-                    "image": datasets.Image(),
-                    "annotation": datasets.Image(),
-                }
-            )
-        elif self.config.name == "object_detection":
-            features = datasets.Features(
-                {
-                    "image": datasets.Image(),
-                    "objects": datasets.Sequence(
-                        {
-                            "bbox": datasets.Sequence(datasets.Value("float32"), length=4),
-                            "label": datasets.ClassLabel(names=list(CCAGT_CLASSES.values())),
-                        }
-                    ),
-                }
-            )
-        elif self.config.name == "instance_segmentation":
-            features = datasets.Features(
-                {
-                    "image": datasets.Image(),
-                    "objects": datasets.Sequence(
-                        {
-                            "bbox": datasets.Sequence(datasets.Value("float32"), length=4),
-                            "segment": datasets.Sequence(datasets.Sequence(datasets.Value("float32"))),
-                            "label": datasets.ClassLabel(names=list(CCAGT_CLASSES.values())),
-                        }
-                    ),
-                }
-            )
-        else:
-            raise NotImplementedError
-
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            homepage=_HOMEPAGE,
-            license=_LICENSE,
-            citation=_CITATION,
-        )
-
-    def _download_and_extract_all(self, dl_manager):
-        def extracted_by_slide(paths):
-            return {get_slide_id(path): dl_manager.extract(path) for path in paths}
-
-        data_dir = dl_manager.download_and_extract(_DATA_URL)
-        base_path = os.path.join(data_dir, "wg4bpm33hj-2")
-
-        logger.info("Extracting images...")
-        self.images_base_dir = os.path.join(base_path, "images")
-        images_to_extract = [
-            os.path.join(self.images_base_dir, fn) for fn in os.listdir(self.images_base_dir) if fn.endswith(".zip")
-        ]
-        self.images_extracted = extracted_by_slide(images_to_extract)
-
-        if self.config.name == "semantic_segmentation":
-            logger.info("Extracting masks...")
-            self.masks_base_dir = os.path.join(base_path, "masks")
-            masks_to_extract = [
-                os.path.join(self.masks_base_dir, fn) for fn in os.listdir(self.masks_base_dir) if fn.endswith(".zip")
-            ]
-            self.masks_extracted = extracted_by_slide(masks_to_extract)
-        elif self.config.name in {"object_detection", "instance_segmentation"}:
-            logger.info("Reading COCO OD file...")
-            ccagt_OD_COCO_path = os.path.join(base_path, "CCAgT_COCO_OD.json")
-            with open(ccagt_OD_COCO_path, "r", encoding="utf-8") as json_file:
-                coco_OD = json.load(json_file)
-
-            self._imageid_to_coco_OD_annotations = defaultdict(list)
-            for labels in coco_OD["annotations"]:
-                self._imageid_to_coco_OD_annotations[labels["image_id"]].append(labels)
-
-        logger.info("Loading dataset info...")
-        ccagt_raw_path = os.path.join(base_path, "CCAgT.parquet.gzip")
-        with open(ccagt_raw_path, "rb") as f:
-            self._ccagt_info = pd.read_parquet(f, columns=["image_name", "category_id", "image_id", "slide_id"])
-        self._bn_to_imageid = pd.Series(
-            self._ccagt_info["image_id"].values, index=self._ccagt_info["image_name"]
-        ).to_dict()
-
-    def _split_generators(self, dl_manager):
-        """Returns SplitGenerators."""
-
-        def build_path(basename, tp="images"):
-            slide = basename.split("_")[0]
-            if tp == "images":
-                dir_path = self.images_extracted[slide]
-                ext = ".jpg"
-            else:
-                dir_path = self.masks_extracted[slide]
-                ext = ".png"
-
-            return os.path.join(dir_path, slide, basename + ext)
-
-        def images_and_masks(basenames):
-            for bn in basenames:
-                yield build_path(bn), build_path(bn, "masks")
-
-        def images_and_boxes(basenames):
-            for bn in basenames:
-                image_id = self._bn_to_imageid[bn]
-                labels = [
-                    {"bbox": annotation["bbox"], "label": annotation["category_id"] - 1}
-                    for annotation in self._imageid_to_coco_OD_annotations[image_id]
-                ]
-
-                yield build_path(bn), labels
-
-        def images_and_instances(basenames):
-            for bn in basenames:
-                image_id = self._bn_to_imageid[bn]
-                instances = [
-                    {
-                        "bbox": annotation["bbox"],
-                        "label": annotation["category_id"] - 1,
-                        "segment": annotation["segmentation"],
-                    }
-                    for annotation in self._imageid_to_coco_OD_annotations[image_id]
-                ]
-
-                yield build_path(bn), instances
-
-        self._download_and_extract_all(dl_manager)
-
-        logger.info("Splitting dataset based on the NORs quantity by image...")
-        train_ids, valid_ids, test_ids = tvt_by_nors(
-            self._ccagt_info, tvt_size=self.config.tvt_size, seed=self.config.seed
-        )
-        train_bn_images = self._ccagt_info.loc[self._ccagt_info["image_id"].isin(train_ids), "image_name"].unique()
-        valid_bn_images = self._ccagt_info.loc[self._ccagt_info["image_id"].isin(valid_ids), "image_name"].unique()
-        test_bn_images = self._ccagt_info.loc[self._ccagt_info["image_id"].isin(test_ids), "image_name"].unique()
-
-        if self.config.name == "semantic_segmentation":
-            train_data = images_and_masks(train_bn_images)
-            valid_data = images_and_masks(valid_bn_images)
-            test_data = images_and_masks(test_bn_images)
-        elif self.config.name == "object_detection":
-            train_data = images_and_boxes(train_bn_images)
-            valid_data = images_and_boxes(valid_bn_images)
-            test_data = images_and_boxes(test_bn_images)
-        elif self.config.name == "instance_segmentation":
-            train_data = images_and_instances(train_bn_images)
-            valid_data = images_and_instances(valid_bn_images)
-            test_data = images_and_instances(test_bn_images)
-        else:
-            raise NotImplementedError
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={"data": train_data},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"data": test_data},
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={"data": valid_data},
-            ),
-        ]
-
-    def _generate_examples(self, data):
-        if self.config.name == "semantic_segmentation":
-            for img_path, msk_path in data:
-                img_basename = get_basename(img_path)
-                image_id = self._bn_to_imageid[img_basename]
-                yield image_id, {
-                    "image": img_path,
-                    "annotation": msk_path,
-                }
-        elif self.config.name == "object_detection":
-            for img_path, labels in data:
-                img_basename = get_basename(img_path)
-                image_id = self._bn_to_imageid[img_basename]
-                yield image_id, {"image": img_path, "objects": labels}
-        elif self.config.name == "instance_segmentation":
-            for img_path, instances in data:
-                img_basename = get_basename(img_path)
-                image_id = self._bn_to_imageid[img_basename]
-                yield image_id, {"image": img_path, "objects": instances}
-        else:
-            raise NotImplementedError