NuCLS_dataset / NuCLS_dataset.py
minhanhto09's picture
Update BuilderConfig
f64c774 verified
raw
history blame
12.1 kB
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 12 16:13:56 2024
@author: tominhanh
"""
# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import pandas as pd
from PIL import Image as PilImage # Import PIL Image with an alias
import datasets
from datasets import DatasetBuilder, GeneratorBasedBuilder, DownloadManager, DatasetInfo, Features, Image, ClassLabel, Value, Sequence, load_dataset, SplitGenerator, BuilderConfig
import os
import io
from typing import Tuple, Dict, List
import numpy as np
import zipfile
import requests
import random
from io import BytesIO
import csv
_CITATION = """\
https://arxiv.org/abs/2102.09099
"""
_DESCRIPTION = """\
The comprehensive dataset contains over 220,000 single-rater and multi-rater labeled nuclei from breast cancer images
obtained from TCGA, making it one of the largest datasets for nucleus detection, classification, and segmentation in hematoxylin and eosin-stained
digital slides of breast cancer. This version of the dataset is a revised single-rater dataset, featuring over 125,000 nucleus csvs.
These nuclei were annotated through a collaborative effort involving pathologists, pathology residents, and medical students, using the Digital Slide Archive.
"""
_HOMEPAGE = "https://sites.google.com/view/nucls/home?authuser=0"
_LICENSE = "CC0 1.0 license"
_URL = "https://www.dropbox.com/scl/fi/zsm9l3bkwx808wfryv5zm/NuCLS_dataset.zip?rlkey=x3358slgrxt00zpn7zpkpjr2h&dl=1"
class NuCLSDatasetConfig(BuilderConfig):
def __init__(self, use_fold_999=False, **kwargs):
super(NuCLSDatasetConfig, self).__init__(**kwargs)
self.use_fold_999 = use_fold_999
class NuCLSDataset(GeneratorBasedBuilder):
# Define multiple configurations for your dataset
BUILDER_CONFIGS = [
NuCLSDatasetConfig(
name="default",
version=datasets.Version("1.1.0"),
description="Default configuration with the full dataset",
),
NuCLSDatasetConfig(
name="debug",
version=datasets.Version("1.1.0"),
description="Debug configuration which uses fold 999 for quick tests",
use_fold_999=True
),
]
DEFAULT_CONFIG_NAME = "default"
def _info(self):
"""Returns the dataset info."""
# Define the classes for the classifications
raw_classification = ClassLabel(names=[
'apoptotic_body', 'ductal_epithelium', 'eosinophil','fibroblast', 'lymphocyte',
'macrophage', 'mitotic_figure', 'myoepithelium', 'neutrophil',
'plasma_cell','tumor', 'unlabeled', 'vascular_endothelium'
])
main_classification = ClassLabel(names=[
'AMBIGUOUS', 'lymphocyte', 'macrophage', 'nonTILnonMQ_stromal',
'plasma_cell', 'tumor_mitotic', 'tumor_nonMitotic',
])
super_classification = ClassLabel(names=[
'AMBIGUOUS','nonTIL_stromal','sTIL', 'tumor_any',
])
type = ClassLabel(names=['rectangle', 'polyline'])
# Define features
features = Features({
'file_name': Value("string"),
'rgb_image': Image(decode=True),
'mask_image': Image(decode=True),
'visualization_image': Image(decode=True),
'annotation_coordinates': Features({
'raw_classification': Sequence(Value("string")),
'main_classification': Sequence(Value("string")),
'super_classification': Sequence(Value("string")),
'type': Sequence(Value("string")),
'xmin': Sequence(Value('int64')),
'ymin': Sequence(Value('int64')),
'xmax': Sequence(Value('int64')),
'ymax': Sequence(Value('int64')),
'coords_x': Sequence(Sequence(Value('int64'))), # Lists of integers
'coords_y': Sequence(Sequence(Value('int64'))), # Lists of integers
})
})
return DatasetInfo(
description=_DESCRIPTION,
features=features,
supervised_keys=None,
homepage=_HOMEPAGE,
license=_LICENSE,
citation=_CITATION,
)
def _split_generators(self, dl_manager: DownloadManager):
# Download source data
data_dir = dl_manager.download_and_extract(_URL)
# Directory paths
base_dir = os.path.join(data_dir, "NuCLS_dataset")
rgb_dir = os.path.join(base_dir, "rgb")
visualization_dir = os.path.join(base_dir, "visualization")
mask_dir = os.path.join(base_dir, "mask")
csv_dir = os.path.join(base_dir, "csv")
split_dir = os.path.join(base_dir, "train_test_splits")
# Generate a list of unique filenames (without extensions)
unique_filenames = [os.path.splitext(f)[0] for f in os.listdir(rgb_dir)]
# Process train/test split files to get slide names for each split and fold
if self.config.use_fold_999:
# Generate the split generators for fold 999
split_slide_names = self._process_train_test_split_files(split_dir, specific_fold = '999')
else:
# Generate the split generators for all folds
split_slide_names = self._process_train_test_split_files(split_dir)
# Create the split generators for each fold
split_generators = []
for fold in split_slide_names:
train_slide_names, test_slide_names = split_slide_names[fold]
# Filter unique filenames based on slide names
train_filenames = [fn for fn in unique_filenames if any(sn in fn for sn in train_slide_names)]
test_filenames = [fn for fn in unique_filenames if any(sn in fn for sn in test_slide_names)]
# Map filenames to file paths
train_filepaths = self._map_filenames_to_paths(train_filenames, rgb_dir, visualization_dir, mask_dir, csv_dir)
test_filepaths = self._map_filenames_to_paths(test_filenames, rgb_dir, visualization_dir, mask_dir, csv_dir)
# Add split generators for the fold
split_generators.append(
datasets.SplitGenerator(
name=f"{datasets.Split.TRAIN}_fold_{fold}",
gen_kwargs={"filepaths": train_filepaths}
)
)
split_generators.append(
datasets.SplitGenerator(
name=f"{datasets.Split.TEST}_fold_{fold}",
gen_kwargs={"filepaths": test_filepaths}
)
)
return split_generators
def _process_train_test_split_files(self, split_dir, specific_fold=None):
"""Reads the train/test split CSV files and returns a dictionary with fold numbers as keys and tuple of train/test slide names as values."""
split_slide_names = {}
for split_file in os.listdir(split_dir):
fold_number = split_file.split('_')[1] # Assumes file naming format "fold_X_[train/test].csv"
# If specific_fold is set, skip all other folds
if specific_fold is not None and fold_number != specific_fold:
continue
file_path = os.path.join(split_dir, split_file)
fold_number = split_file.split('_')[1] # Assumes file naming format "fold_X_[train/test].csv"
with open(file_path, 'r') as f:
csv_reader = csv.reader(f)
next(csv_reader) # Skip header
for row in csv_reader:
slide_name = row[1] # Assuming slide_name is in the first column
if "train" in split_file:
split_slide_names.setdefault(fold_number, ([], []))[0].append(slide_name)
elif "test" in split_file:
split_slide_names.setdefault(fold_number, ([], []))[1].append(slide_name)
return split_slide_names
def _map_filenames_to_paths(self, filenames, rgb_dir, visualization_dir, mask_dir, csv_dir):
"""Maps filenames to file paths for each split."""
filepaths = {}
for filename in filenames:
filepaths[filename] = {
'rgb': os.path.join(rgb_dir, filename + '.png'),
'visualization': os.path.join(visualization_dir, filename + '.png'),
'mask': os.path.join(mask_dir, filename + '.png'),
'csv': os.path.join(csv_dir, filename + '.csv'),
'file_name': filename
}
return filepaths
def _generate_examples(self, filepaths):
"""Yield examples as (key, example) tuples."""
for key, paths in filepaths.items():
# Extract the file name
file_name = paths['file_name']
# Read the images using a method to handle the image files
rgb_image = self._read_image_file(paths['rgb'])
mask_image = self._read_image_file(paths['mask'])
visualization_image = self._read_image_file(paths['visualization'])
# Read the CSV and format the data as per the defined features
annotation_coordinates = self._read_csv_file(paths['csv'])
# Yield the example
yield key, {
'file_name': file_name,
'rgb_image': rgb_image,
'mask_image': mask_image,
'visualization_image': visualization_image,
'annotation_coordinates': annotation_coordinates,
}
def _read_image_file(self, file_path: str, ) -> bytes:
"""Reads an image file and returns it as a bytes_like object."""
try:
with open(file_path, 'rb') as f:
return f.read()
except Exception as e:
print(f"Error reading image file {file_path}: {e}")
return None
def _read_csv_file(self, filepath):
"""Reads the annotation CSV file and formats the data."""
with open(filepath, 'r', encoding='utf-8') as csvfile:
reader = csv.DictReader(csvfile)
annotations = {
'raw_classification': [],
'main_classification': [],
'super_classification': [],
'type': [],
'xmin': [],
'ymin': [],
'xmax': [],
'ymax': [],
'coords_x': [],
'coords_y': []
}
for row in reader:
annotations['raw_classification'].append(row.get('raw_classification', ''))
annotations['main_classification'].append(row.get('main_classification', ''))
annotations['super_classification'].append(row.get('super_classification', ''))
annotations['type'].append(row.get('type', ''))
annotations['xmin'].append(int(row.get('xmin', 0)))
annotations['ymin'].append(int(row.get('ymin', 0)))
annotations['xmax'].append(int(row.get('xmax', 0)))
annotations['ymax'].append(int(row.get('ymax', 0)))
# Handle coords_x and coords_y safely
coords_x = row.get('coords_x', '')
coords_y = row.get('coords_y', '')
annotations['coords_x'].append([int(coord) if coord.isdigit() else 0 for coord in coords_x.split(',')])
annotations['coords_y'].append([int(coord) if coord.isdigit() else 0 for coord in coords_y.split(',')])
return annotations