CCAgT.py

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