| 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 |
|
|
