Add files using upload-large-folder tool

README.md

@@ -84,75 +84,92 @@ brain-structure/
 
 # Example usage
 ```
-# install Hugging Face Datasets library
+# install Hugging Face Datasets
 pip install datasets
+
+# optional installs: NiBabel and PyTorch
+pip install nibabel
+pip install torch torchvision
 ```
 
 ```
 # load datasets
 from datasets import load_dataset
 
-ds_train = load_dataset("radiata-ai/brain-structure", name="all", split="train", trust_remote_code=True)
-ds_val   = load_dataset("radiata-ai/brain-structure", name="all", split="validation", trust_remote_code=True)
-ds_test  = load_dataset("radiata-ai/brain-structure", name="all", split="test", trust_remote_code=True)
+ds_train = load_dataset("radiata-ai/brain-structure", split="train", trust_remote_code=True)
+ds_val = load_dataset("radiata-ai/brain-structure", split="validation", trust_remote_code=True)
+ds_test = load_dataset("radiata-ai/brain-structure", split="test", trust_remote_code=True)
 ```
 
 ```
 # example PyTorch processing of images
+import nibabel as nib
 import torch
 import torch.nn.functional as F
 from torch.utils.data import Dataset
-import nibabel as nib
 
-class NiiDataset(Dataset):
+def preprocess_nifti(example):
     """
-    A PyTorch Dataset that wraps a Hugging Face Dataset containing
-    MRI .nii.gz file paths, and loads/normalizes/resamples each volume.
+    Loads a .nii.gz file, crops, normalizes, and resamples to 96^3.
+    Returns a numpy array (or tensor) in example["img"].
     """
-    def __init__(self, hf_dataset):
-        """
-        hf_dataset: a Hugging Face Dataset object, e.g. ds_train
-                    (each example should have a 'nii_filepath')
-        """
-        self.hf_dataset = hf_dataset
-
-    def __len__(self):
-        return len(self.hf_dataset)
-
-    def __getitem__(self, idx):
-        # Load the dataset example
-        example = self.hf_dataset[idx]
-        nii_path = example["nii_filepath"]  # e.g., "IXI/sub-017/ses-01/anat/sub-017_ses-01_T1w.nii.gz"
-
-        # Load the .nii.gz file with nibabel
-        cur_t1_file = nib.load(nii_path)
-        t1_data = cur_t1_file.get_fdata()
-
-        # Preprocess: example sub-volume
-        # (7:105, 8:132, :108) => shape: (98, 124, 108)
-        t1_data = t1_data[7:105, 8:132, :108]
-
-        # Normalize intensities
-        t1_data = t1_data / t1_data.max()
-
-        # Convert to PyTorch tensor, add two channel dims for volumetric interpolation
-        #    shape => (1, 1, 98, 124, 108)
-        t1_tensor = torch.from_numpy(t1_data).float().unsqueeze(0).unsqueeze(0)
-
-        # Downsample/resample to e.g. (96, 96, 96)
-        img_downsample = F.interpolate(
-            t1_tensor,
-            size=(96, 96, 96),
-            mode="trilinear",
-            align_corners=False
-        )
-        # shape => (1, 96, 96, 96)
-
-        # Squeeze out the channel dim if needed: shape => (96, 96, 96)
-        img_downsample = img_downsample.squeeze(0)
-
-        sample = {"img": img_downsample}
-        return sample
+    nii_path = example["nii_filepath"]
+    # Load volume data
+    vol = nib.load(nii_path).get_fdata()
+
+    # Crop sub-volume
+    vol = vol[7:105, 8:132, :108]  # shape: (98, 124, 108)
+
+    # Shift intensities to be non-negative
+    vol = vol + abs(vol.min())
+    # Normalize to [0,1]
+    vol = vol / vol.max()
+
+    # Convert to torch.Tensor: (1,1,D,H,W)
+    t_tensor = torch.from_numpy(vol).float().unsqueeze(0).unsqueeze(0)
+
+    # Scale factor based on (124 -> 96) for the y-dimension
+    scale_factor = 96 / 124
+    downsampled = F.interpolate(
+        t_tensor,
+        scale_factor=(scale_factor, scale_factor, scale_factor),
+        mode="trilinear",
+        align_corners=False
+    )
+
+    # Now pad each dimension to exactly 96 (symmetric padding)
+    _, _, d, h, w = downsampled.shape
+    pad_d = 96 - d
+    pad_h = 96 - h
+    pad_w = 96 - w
+    padding = (
+        pad_w // 2, pad_w - pad_w // 2,
+        pad_h // 2, pad_h - pad_h // 2,
+        pad_d // 2, pad_d - pad_d // 2
+    )
+    final_img = F.pad(downsampled, padding)  # shape => (1, 1, 96, 96, 96)
+    final_img = final_img.squeeze(0)
+
+    # Store as numpy or keep as torch.Tensor
+    example["img"] = final_img.numpy()
+    return example
+```
+
+```
+# Apply the preprocessing to each split
+ds_train = ds_train.map(preprocess_nifti)
+ds_val   = ds_val.map(preprocess_nifti)
+ds_test  = ds_test.map(preprocess_nifti)
+
+# Set the dataset format to return PyTorch tensors for the 'img' column
+ds_train.set_format(type='torch', columns=['img'])
+ds_val.set_format(type='torch', columns=['img'])
+ds_test.set_format(type='torch', columns=['img'])
+
+# Set up data loaders for model training
+train_loader = DataLoader(ds_train, batch_size=16, shuffle=True)
+val_loader   = DataLoader(ds_val, batch_size=16, shuffle=False)
+test_loader  = DataLoader(ds_test, batch_size=16, shuffle=False)
 ```
 
 
@@ -188,7 +205,7 @@ Scans were partitioned into train/validation/test datasets with a 80%/10%/10% sp
 ```
 @dataset{Radiata-Brain-Structure,
   author    = {Jesse Brown and Clayton Young},
-  title     = {Brain-Structure: A Collection of Processed Structural MRI Scans},
+  title     = {Brain-Structure: Processed Structural MRI Brain Scans Across the Lifespan},
   year      = {2025},
   url          = {https://huggingface.co/datasets/radiata-ai/brain-structure},
   note      = {Version 1.0},

brain-structure.py

@@ -102,6 +102,7 @@ class BrainStructure(datasets.GeneratorBasedBuilder):
         Hugging Face will place (or reference) files in this same folder context.
         """
         data_dir = "."  # The local folder containing subdirectories like IXI/, DLBS/, etc.
+        print(os.path.abspath(data_dir))
         logger.info(f"BrainStructure: scanning data in {os.path.abspath(data_dir)}")
 
         return [