SPIDER.py

# 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.
# TODO: Address all TODOs and remove all explanatory comments
"""TODO: Add a description here."""

# Import packages
import csv
import json
import os
from typing import Dict, List, Mapping, Optional, Set, Sequence, Tuple, Union

import numpy as np

import datasets
import SimpleITK as sitk

# Define functions
def import_csv_data(filepath: str) -> List[Dict[str, str]]:
    """Import all rows of CSV file."""
    results = []
    with open(filepath, encoding='utf-8') as f:
        reader = csv.DictReader(f)
        for line in reader:
            results.append(line)
    return results

# Define constants
N_PATIENTS = 257

# TODO: Add BibTeX citation
# Find for instance the citation on arxiv or on the dataset repo/website
_CITATION = """\
@InProceedings{huggingface:dataset,
title = {A great new dataset},
author={huggingface, Inc.
},
year={2020}
}
"""

# TODO: Add description of the dataset here
# You can copy an official description
_DESCRIPTION = """\
This new dataset is designed to solve this great NLP task and is crafted with a lot of care.
"""

_HOMEPAGE = "https://zenodo.org/records/10159290"

_LICENSE = """Creative Commons Attribution 4.0 International License \
(https://creativecommons.org/licenses/by/4.0/legalcode)"""

# TODO: Add link to the official dataset URLs here
# The HuggingFace Datasets library doesn't host the datasets but only points to the original files.
# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
_URLS = {
    "images":"https://zenodo.org/records/10159290/files/images.zip",
    "masks":"https://zenodo.org/records/10159290/files/masks.zip",
    "overview":"https://zenodo.org/records/10159290/files/overview.csv",
    "gradings":"https://zenodo.org/records/10159290/files/radiological_gradings.csv",
}

class CustomBuilderConfig(datasets.BuilderConfig):
    
    def __init__(
        self,
        name: str = 'default',
        version: str = '0.0.0',
        data_dir: Optional[str] = None,
        data_files: Optional[Union[str, Sequence, Mapping]] = None,
        description: Optional[str] = None,
        scan_types: List[str] = ['t1', 't2', 't2_SPACE'],
    ):
        super().__init__(name, version, data_dir, data_files, description)
        self.scan_types = scan_types


class SPIDER(datasets.GeneratorBasedBuilder):
    """TODO: Short description of my dataset."""

    VERSION = datasets.Version("1.1.0")

    # This is an example of a dataset with multiple configurations.
    # If you don't want/need to define several sub-sets in your dataset,
    # just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.

    # If you need to make complex sub-parts in the datasets with configurable options
    # You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
    BUILDER_CONFIG_CLASS = CustomBuilderConfig

    # You will be able to load one or the other configurations in the following list with
    # data = datasets.load_dataset('my_dataset', 'first_domain')
    # data = datasets.load_dataset('my_dataset', 'second_domain')
    BUILDER_CONFIGS = [
        CustomBuilderConfig(
            name="all_scan_types",
            version=VERSION,
            description="Use images of all scan types (t1, t2, t2 SPACE)",
            scan_types=['t1', 't2', 't2_SPACE'],
        ),
        CustomBuilderConfig(
            name="t1_scan_types",
            version=VERSION,
            description="Use images of t1 scan types only",
            scan_types=['t1'],
        ),
        CustomBuilderConfig(
            name="t2_scan_types",
            version=VERSION,
            description="Use images of t2 scan types only",
            scan_types=['t2'],
        ),
        CustomBuilderConfig(
            name="t2_SPACE_scan_types",
            version=VERSION,
            description="Use images of t2 SPACE scan types only",
            scan_types=['t2_SPACE'],
        ),
    ]

    DEFAULT_CONFIG_NAME = "all_scan_types"

    def _info(self):
        """
        This method specifies the datasets.DatasetInfo object which contains 
        informations and typings for the dataset.
        """
        features = datasets.Features(
            {
                "sentence": datasets.Value("string"),
                "option1": datasets.Value("string"),
                "answer": datasets.Value("string")
                # These are the features of your dataset like images, labels ...
            }
        )

        return datasets.DatasetInfo(
            # This is the description that will appear on the datasets page.
            description=_DESCRIPTION,
            # This defines the different columns of the dataset and their types
            features=features,  # Here we define them above because they are different between the two configurations
            # If there's a common (input, target) tuple from the features, uncomment supervised_keys line below and
            # specify them. They'll be used if as_supervised=True in builder.as_dataset.
            # supervised_keys=("sentence", "label"),
            # Homepage of the dataset for documentation
            homepage=_HOMEPAGE,
            # License for the dataset if available
            license=_LICENSE,
            # Citation for the dataset
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager):
        """
        This method is tasked with downloading/extracting the data 
        and defining the splits depending on the configuration
        If several configurations are possible (listed in BUILDER_CONFIGS), 
        the configuration selected by the user is in self.config.name
        """

        # dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLS
        # It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
        # By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
        paths_dict = dl_manager.download_and_extract(_URLS)
        scan_types = self.config.scan_types
        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "paths_dict": paths_dict,
                    "split": "train",
                    "scan_types": scan_types,
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                gen_kwargs={
                    "paths_dict": paths_dict,
                    "split": "validate",
                    "scan_types": scan_types,
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "paths_dict": paths_dict,
                    "split": "test",
                    "scan_types": scan_types,
                },
            ),
        ]

    def _generate_examples(
        self,
        paths_dict: Dict[str, str],
        split: str = 'train',
        scan_types: List[str] = ['t1', 't2', 't2_SPACE'],
        validate_share: float = 0.3,
        test_share: float = 0.2,
        raw_image: bool = True,
        numeric_array: bool = True,
        metadata: bool = True,
        rad_gradings: bool = True,
        random_seed: int = 9999,
    ) -> Tuple[str, Dict]:
        """
        This method handles input defined in _split_generators to yield 
        (key, example) tuples from the dataset. The `key` is for legacy reasons 
        (tfds) and is not important in itself, but must be unique for each example.
        
        Args
            paths_dict: mapping of data element name to temporary file location
            split: specify training, validation, or testing set;
                options = 'train', 'validate', OR 'test'
            scan_types: list of sagittal scan types to use in examples; 
                options = ['t1', 't2', 't2_SPACE']
            validate_share: float indicating share of data to use for validation;
                must be in range (0.0, 1.0); note that training share is 
                calculated as (1 - validate_share - test_share)
            test_share: float indicating share of data to use for testing;
                must be in range (0.0, 1.0); note that training share is 
                calculated as (1 - validate_share - test_share)
            raw_image: indicates whether to include .mha image file in example
            numeric_array: indicates whether to include numpy numeric array of
                image in example
            metadata: indicates whether to include patient and scanner metadata
                with image example
            rad_gradings: indicates whether to include patient's radiological
                gradings with image example
        
        Yields
            Tuple (unique patient-scan ID, dict of 
        """
        # Set constants
        train_share = (1.0 - validate_share - test_share)
        np.random.seed(int(random_seed))

        # Validate params
        for item in scan_types:
            if item not in ['t1', 't2', 't2_SPACE']:
                raise ValueError(
                    'Scan type "{item}" not recognized as valid scan type.\
                    Verify scan type argument.'
                )
        if split not in ['train', 'validate', 'test']:
            raise ValueError( 
                f'Split argument "{split}" is not recognized. \
                Please enter one of ["train", "validate", "test"]'
            )
        if train_share <= 0.0:
            raise ValueError(
                f'Training share is calculated as (1 - validate_share - test_share) \
                and must be greater than 0. Current calculated value is \
                {round(train_share, 3)}. Adjust validate_share and/or \
                test_share parameters.'
            )
        if validate_share > 1.0 or validate_share < 0.0:
            raise ValueError(
                f'Validation share must be between (0, 1). Current value is \
                {validate_share}.'
            )
        if test_share > 1.0 or test_share < 0.0:
            raise ValueError(
                f'Testing share must be between (0, 1). Current value is \
                {test_share}.'
            )

        # Generate train/validate/test partitions of patient IDs
        partition = np.random.choice(
            ['train', 'dev', 'test'],
            p=[train_share, validate_share, test_share],
            size=N_PATIENTS,
        )
        patient_ids = (np.arange(N_PATIENTS) + 1)
        train_ids = set(patient_ids[partition == 'train'])
        validate_ids = set(patient_ids[partition == 'dev'])
        test_ids = set(patient_ids[partition == 'test'])
        assert len(train_ids.union(validate_ids, test_ids)) == N_PATIENTS

        # Import patient/scanner data and radiological gradings data
        overview_data = import_csv_data(paths_dict['overview'])
        grades_data = import_csv_data(paths_dict['gradings'])
        
        # Convert overview data list of dicts to dict of dicts
        overview_dict = {}
        for item in overview_data:
            key = item['new_file_name']
            overview_dict[key] = item
        
        # Merge patient records for radiological gradings data
        grades_dict = {}
        for patient_id in patient_ids:
            patient_grades = [
                x for x in grades_data if x['Patient'] == str(patient_id)
            ]
            if patient_grades:
                grades_dict[str(patient_id)] = patient_grades
    
        # Import image and mask data
        image_files = [
            file for file in os.listdir(os.path.join(paths_dict['images'], 'images'))
            if file.endswith('.mha')
        ]
        assert len(image_files) > 0, "No image files found--check directory path."
        
        mask_files = [
            file for file in os.listdir(os.path.join(paths_dict['masks'], 'masks'))
            if file.endswith('.mha')
        ]
        assert len(mask_files) > 0, "No mask files found--check directory path."
        
        # Filter image and mask data based on scan types
        image_files = [
            file for file in image_files 
            if any(scan_type in file for scan_type in scan_types)
        ]

        mask_files = [
            file for file in mask_files 
            if any(scan_type in file for scan_type in scan_types)
        ]
        
        # Subset train/validation/test partition images and mask files
        if split == 'train':
            subset_ids = train_ids
        elif split == 'validate':
            subset_ids = validate_ids
        elif split == 'test':
            subset_ids = test_ids
        
        image_files = [
            file for file in image_files
            if any(str(patient_id) in file.split('_')[0] for patient_id in subset_ids)
        ]
            
        mask_files = [
            file for file in mask_files
            if any(str(patient_id) in file.split('_')[0] for patient_id in subset_ids)
        ]
        assert len(image_files) == len(mask_files), "The number of image files\
            does not match the number of mask files--verify subsetting operation."
        
        # Shuffle order of patient scans
        # (note that only images need to be shuffled since masks and metadata
        # will be linked to the selected image)
        np.random.shuffle(image_files) 
        
        ## Generate next example
        # ----------------------
        for example in image_files:
            
            # Extract linking data
            scan_id = example.replace('.mha', '')
            patient_id = scan_id.split('_')[0]
            scan_type = '_'.join(scan_id.split('_')[1:])

            # Load .mha file
            image_path = os.path.join(paths_dict['images'], 'images', example)
            image = sitk.ReadImage(image_path)
            
            # Convert .mha image to numeric array
            image_array = sitk.GetArrayFromImage(image)
            
            # Extract overview data corresponding to image
            image_overview = overview_dict[scan_id]

            # Extract patient radiological gradings corresponding to patient
            patient_grades_dict = {}
            for item in grades_dict[patient_id]:
                key = f'IVD{item["IVD label"]}'
                value = {
                    k:v for k,v in item.items() 
                    if k not in ['Patient', 'IVD label']
                }
                patient_grades_dict[key] = value
        
            # Prepare example return dict
            return_dict = {'patient_id':patient_id, 'scan_type':scan_type}
            if raw_image:
                return_dict['raw_image'] = image
            if numeric_array:
                return_dict['numeric_array'] = image_array
            if metadata:
                return_dict['metadata'] = image_overview
            if rad_gradings:
                return_dict['rad_gradings'] = patient_grades_dict
            
            # Yield example
            yield (scan_id, return_dict)