refactored to enable sharding

SPIDER.py

@@ -16,7 +16,7 @@
 # Import packages
 import csv
 import os
-from typing import Dict, List, Mapping, Optional, Sequence, Tuple, Union
+from typing import Dict, List, Mapping, Optional, Sequence, Set, Tuple, Union
 
 import numpy as np
 import pandas as pd
@@ -35,6 +35,13 @@ def import_csv_data(filepath: str) -> List[Dict[str, str]]:
             results.append(line)
     return results
 
+def subset_file_list(all_files: List[str], subset_ids: Set[int]):
+    """Subset files pertaining to individuals in person_ids arg."""
+    return [
+        file for file in all_files
+        if any(str(id_val) == file.split('_')[0] for id_val in subset_ids)
+    ]
+
 def standardize_3D_image(
     image: np.ndarray,
     resize_shape: Tuple[int, int, int]
@@ -130,10 +137,21 @@ class CustomBuilderConfig(datasets.BuilderConfig):
         description: Optional[str] = None,
         scan_types: List[str] = DEFAULT_SCAN_TYPES,
         resize_shape: Tuple[int, int, int] = DEFAULT_RESIZE,
+        shuffle: bool = True,
     ):
         super().__init__(name, version, data_dir, data_files, description)
-        self.scan_types = scan_types
+        self.scan_types = self.validate_scan_types(scan_types)
         self.resize_shape = resize_shape
+        self.shuffle = shuffle
+        
+    def validate_scan_types(self, scan_types):
+        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.'
+                )
+        return scan_types
 
 
 class SPIDER(datasets.GeneratorBasedBuilder):
@@ -143,30 +161,44 @@ class SPIDER(datasets.GeneratorBasedBuilder):
     DEFAULT_WRITER_BATCH_SIZE = 16 # PyArrow default is too large for image data
     VERSION = datasets.Version("1.1.0")
     BUILDER_CONFIG_CLASS = CustomBuilderConfig
-
-    def __init__(
-        self,
-        *args,
-        scan_types: List[str] = DEFAULT_SCAN_TYPES,
-        resize_shape: Tuple[int, int, int] = DEFAULT_RESIZE,
-        **kwargs,
-    ):
-        super().__init__(*args, **kwargs)
-        self.scan_types = scan_types
-        self.resize_shape = resize_shape
+    BUILDER_CONFIGS = [
+        CustomBuilderConfig(
+            name="default",
+            description="Load the full dataset",
+        ),
+        CustomBuilderConfig(
+            name="demo",
+            description="Generate 10 examples for demonstration",
+        )
+    ]
+    DEFAULT_CONFIG_NAME = "default"
+
+    # def __init__(
+    #     self,
+    #     *args,
+    #     scan_types: List[str] = DEFAULT_SCAN_TYPES,
+    #     resize_shape: Tuple[int, int, int] = DEFAULT_RESIZE,
+    #     shuffle: bool = True,
+    #     **kwargs,
+    # ):
+    #     super().__init__(*args, **kwargs)
+    #     self.scan_types = self.config.scan_types
+    #     self.resize_shape = self.config.resize_shape
+    #     self.shuffle = self.config.shuffle
 
     def _info(self):
         """Specify datasets.DatasetInfo object containing information and typing
         for the dataset."""
 
-        image_size = self.config.resize_shape
         features = datasets.Features({
             "patient_id": datasets.Value("string"),
             "scan_type": datasets.Value("string"),
+            "image": datasets.Image(),
+            "mask": datasets.Image(),
+            # "image": datasets.Array3D(shape=self.config.resize_shape, dtype='uint8'),
+            # "mask": datasets.Array3D(shape=self.config.resize_shape, dtype='uint8'),
             "image_path": datasets.Value("string"),
             "mask_path": datasets.Value("string"),
-            "image_array": datasets.Array3D(shape=image_size, dtype='uint8'),
-            "mask_array": datasets.Array3D(shape=image_size, dtype='uint8'),
             "metadata": {
                 "num_vertebrae": datasets.Value(dtype="string"), #TODO: more specific types
                 "num_discs": datasets.Value(dtype="string"),
@@ -228,87 +260,31 @@ class SPIDER(datasets.GeneratorBasedBuilder):
             citation=_CITATION,
         )
 
-    def _split_generators(self, dl_manager):
-        """Download and extract data and define splits based on configuration."""
-
-        paths_dict = dl_manager.download_and_extract(_URLS)
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "paths_dict": paths_dict,
-                    "split": "train",
-                    "scan_types": self.scan_types,
-                    "resize_shape": self.resize_shape,
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.VALIDATION,
-                gen_kwargs={
-                    "paths_dict": paths_dict,
-                    "split": "validate",
-                    "scan_types": self.scan_types,
-                    "resize_shape": self.resize_shape,
-                },
-            ),
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={
-                    "paths_dict": paths_dict,
-                    "split": "test",
-                    "scan_types": self.scan_types,
-                    "resize_shape": self.resize_shape,
-                },
-            ),
-        ]
-
-    def _generate_examples(
+    def _split_generators(
         self,
-        paths_dict: Dict[str, str],
-        split: str,
-        scan_types: List[str],
-        resize_shape: Tuple[int, int, int],
+        dl_manager,
         validate_share: float = 0.2,
         test_share: float = 0.2,
         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.
+        Download and extract data and define splits based on configuration.
         
         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']
+            dl_manager: HuggingFace datasets download manager (automatically supplied)
             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)
-        
-        Yields
-            Tuple (unique patient-scan ID, dict of 
+            random_seed: seed for random draws of train/validate/test patient ids
         """
         # 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) \
@@ -327,6 +303,33 @@ class SPIDER(datasets.GeneratorBasedBuilder):
                 {test_share}.'
             )
 
+        # Download images (returns dictionary to local cache)
+        paths_dict = dl_manager.download_and_extract(_URLS)
+                    
+        # Get list of image and mask data files
+        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 files based on scan types
+        image_files = [
+            file for file in image_files 
+            if any(scan_type in file for scan_type in self.config.scan_types)
+        ]
+
+        mask_files = [
+            file for file in mask_files 
+            if any(scan_type in file for scan_type in self.config.scan_types)
+        ]
+
         # Generate train/validate/test partitions of patient IDs
         partition = np.random.choice(
             ['train', 'dev', 'test'],
@@ -339,6 +342,19 @@ class SPIDER(datasets.GeneratorBasedBuilder):
         test_ids = set(patient_ids[partition == 'test'])
         assert len(train_ids.union(validate_ids, test_ids)) == N_PATIENTS
 
+        # Subset train/validation/test partition images and mask files
+        train_image_files = subset_file_list(image_files, train_ids)
+        validate_image_files = subset_file_list(image_files, validate_ids)
+        test_image_files = subset_file_list(image_files, test_ids)
+        
+        train_mask_files = subset_file_list(mask_files, train_ids)
+        validate_mask_files = subset_file_list(mask_files, validate_ids)
+        test_mask_files = subset_file_list(mask_files, test_ids)
+
+        assert len(train_image_files) == len(train_mask_files)
+        assert len(validate_image_files) == len(validate_mask_files)
+        assert len(test_image_files) == len(test_mask_files)
+
         # Import patient/scanner data and radiological gradings data
         overview_data = import_csv_data(paths_dict['overview'])
         grades_data = import_csv_data(paths_dict['gradings'])
@@ -389,54 +405,74 @@ class SPIDER(datasets.GeneratorBasedBuilder):
                 if col not in ['Patient']
             }
 
-        # Get list of image and mask data files
-        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 files based on scan types
-        image_files = [
-            file for file in image_files 
-            if any(scan_type in file for scan_type in scan_types)
-        ]
+        # DEMO configuration: subset first 10 examples
+        if self.config.name == "demo":
+            train_image_files = train_image_files[:10]
+            train_mask_files = train_mask_files[:10]
+            validate_image_files = validate_image_files[:10]
+            validate_mask_files = validate_mask_files[:10]
+            test_image_files = test_image_files[:10]
+            test_mask_files = test_mask_files[:10]
 
-        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) == file.split('_')[0] for patient_id in subset_ids)
-        ]
-            
-        mask_files = [
-            file for file in mask_files
-            if any(str(patient_id) == file.split('_')[0] for patient_id in subset_ids)
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "paths_dict": paths_dict,
+                    "image_files": train_image_files,
+                    "mask_files": train_mask_files,
+                    "overview_dict": overview_dict,
+                    "grades_dict": grades_dict,
+                    "resize_shape": self.config.resize_shape,
+                    "shuffle": self.config.shuffle,
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={
+                    "paths_dict": paths_dict,
+                    "image_files": validate_image_files,
+                    "mask_files": validate_mask_files,
+                    "overview_dict": overview_dict,
+                    "grades_dict": grades_dict,
+                    "resize_shape": self.config.resize_shape,
+                    "shuffle": self.config.shuffle,
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "paths_dict": paths_dict,
+                    "image_files": test_image_files,
+                    "mask_files": test_mask_files,
+                    "overview_dict": overview_dict,
+                    "grades_dict": grades_dict,
+                    "resize_shape": self.config.resize_shape,
+                    "shuffle": self.config.shuffle,
+                },
+            ),
         ]
-        assert len(image_files) == len(mask_files), "The number of image files\
-            does not match the number of mask files--verify subsetting operation."
-        
+
+    def _generate_examples(
+        self,
+        paths_dict: Dict[str, str],
+        image_files: List[str],
+        mask_files: List[str],
+        overview_dict: Dict,
+        grades_dict: Dict,
+        resize_shape: Tuple[int, int, int],
+        shuffle: bool,
+    ) -> 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.
+        """
         # 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) 
+        if shuffle:
+            np.random.shuffle(image_files)
 
         ## Generate next example
         # ----------------------
@@ -483,10 +519,10 @@ class SPIDER(datasets.GeneratorBasedBuilder):
             return_dict = {
                 'patient_id':patient_id,
                 'scan_type':scan_type,
+                'image':image_array_standardized,
+                'mask':mask_array_standardized,
                 'image_path':image_path, 
                 'mask_path':mask_path, 
-                'image_array':image_array_standardized,
-                'mask_array':mask_array_standardized,
                 'metadata':image_overview,
                 'rad_gradings':patient_grades_dict,
             }