diff --git "a/data/data_tests.ipynb" "b/data/data_tests.ipynb" deleted file mode 100644--- "a/data/data_tests.ipynb" +++ /dev/null @@ -1,480 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 29, - "id": "d24403fa-8761-49bf-bcf2-1fcd9147da68", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "58\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "\n", - "# get FCD ids\n", - "df = pd.read_csv(\"participants.tsv\", sep=\"\\t\") \n", - "fcd_ids = df[df['group']=='fcd']['participant_id']\n", - "\n", - "# get train/test\n", - "train = df[(df['group'] == 'fcd') & (df['split'] == 'train')]\n", - "print(len(train))\n", - "\n", - "# update with new splits\n", - "\n", - "# filter FCD samples\n", - "fcd_df = df[df['group'] == 'fcd'].copy()\n", - "# shuffle indices\n", - "fcd_df = fcd_df.sample(frac=1, random_state=42).reset_index(drop=True)\n", - "# compute split index\n", - "n_train = int(len(fcd_df) * 0.9)\n", - "# assign split labels\n", - "fcd_df.loc[:n_train-1, 'split'] = 'train'\n", - "fcd_df.loc[n_train:, 'split'] = 'val'\n", - "#update\n", - "df.loc[fcd_df.index, 'split'] = fcd_df['split']" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "71e9d162-723e-4b95-9ab2-21125186cdc0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "76\n" - ] - } - ], - "source": [ - "# new train amount\n", - "train = df[(df['group'] == 'fcd') & (df['split'] == 'train')]\n", - "print(len(train))" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "0e490262-844a-43e9-b82f-483916aa9ba7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 sub-00058\n", - "1 sub-00043\n", - "2 sub-00133\n", - "3 sub-00120\n", - "4 sub-00060\n", - "Name: participant_id, dtype: object" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# get train ids\n", - "train_ids = df[(df['group'] == 'fcd') & (df['split'] == 'train')]['participant_id']\n", - "train_ids.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "01297c73-a56d-4ee3-b35e-7d487577c89f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "9\n" - ] - } - ], - "source": [ - "val = df[(df['group'] == 'fcd') & (df['split'] == 'val')]\n", - "print(len(val))" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "fabf94d3-f4b8-4722-94af-974dd9ab3655", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "76 sub-00081\n", - "77 sub-00034\n", - "78 sub-00080\n", - "79 sub-00103\n", - "80 sub-00145\n", - "Name: participant_id, dtype: object" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# get train ids\n", - "val_ids = df[(df['group'] == 'fcd') & (df['split'] == 'val')]['participant_id']\n", - "val_ids.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "d7f3358e-6d57-4e76-9c64-9927ec6ce268", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "85 85 85\n" - ] - } - ], - "source": [ - "from pathlib import Path\n", - "import re\n", - "\n", - "masks = 0\n", - "t1w = 0\n", - "flair = 0\n", - "\n", - "# how many have masks\n", - "for id in fcd_ids:\n", - " folder = Path(f\"{id}/anat/\")\n", - " pattern = re.compile(r\".*_roi\\.nii\\.gz$\") # ← regex: any name ending exactly in “_roi.nii.gz”\n", - " roi_exists = any(pattern.fullmatch(p.name) for p in folder.iterdir())\n", - " if roi_exists:\n", - " masks += 1\n", - "\n", - "# how many have t1w\n", - "for id in fcd_ids:\n", - " folder = Path(f\"{id}/anat/\")\n", - " pattern = re.compile(r\".*_T1w\\.nii\\.gz$\") # ← regex: any name ending exactly in “_roi.nii.gz”\n", - " roi_exists = any(pattern.fullmatch(p.name) for p in folder.iterdir())\n", - " if roi_exists:\n", - " t1w += 1\n", - "\n", - "# how many have flair\n", - "for id in fcd_ids:\n", - " folder = Path(f\"{id}/anat/\")\n", - " pattern = re.compile(r\".*_FLAIR\\.nii\\.gz$\") # ← regex: any name ending exactly in “_roi.nii.gz”\n", - " roi_exists = any(pattern.fullmatch(p.name) for p in folder.iterdir())\n", - " if roi_exists:\n", - " flair += 1\n", - "\n", - "print(masks, t1w, flair)" - ] - }, - { - "cell_type": "code", - "execution_count": 112, - "id": "9c3cac5c-f91a-47e9-a1b3-e0230dc3f48e", - "metadata": {}, - "outputs": [], - "source": [ - "import os, nibabel, torch, numpy as np\n", - "import torch.nn as nn\n", - "from torch.utils.data import Dataset\n", - "import pandas as pd\n", - "import re\n", - "\n", - "\n", - "class InpaintVolumes(Dataset):\n", - " \"\"\"\n", - " Y : float32 [C, D, H, W] full multi-modal MRI stack\n", - " M : float32 [1, D, H, W] binary in-painting mask (shared by all mods)\n", - " Y_void = Y * (1 - M) context with lesion region blanked\n", - " name : identifier string\n", - " \"\"\"\n", - "\n", - " # ------------------------------------------------------------\n", - " def __init__(self,\n", - " root_dir: str,\n", - " subset: str = 'train', # 'train' | 'val'\n", - " img_size: int = 256, # 128 or 256 cube\n", - " modalities: tuple = ('T1w',), # order defines channel order\n", - " normalize=None):\n", - " super().__init__()\n", - " self.root_dir = os.path.expanduser(root_dir)\n", - " self.subset = subset\n", - " self.img_size = img_size\n", - " self.modalities = modalities \n", - " self.normalize = normalize or (lambda x: x)\n", - " self.cases = self._index_cases() # ⇒ list[dict]\n", - "\n", - " # ------------------------------------------------------------\n", - " def _index_cases(self):\n", - " \"\"\"\n", - " Build a list like:\n", - " {'img': {'T1w': path, 'FLAIR': path, ...},\n", - " 'mask': path,\n", - " 'name': case_id}\n", - " Edit only this block to suit your folder / filename scheme.\n", - " \"\"\"\n", - " cases = []\n", - " \n", - " # metadata\n", - " df = pd.read_csv(f\"{self.root_dir}/participants.tsv\", sep=\"\\t\") \n", - " # update with new splits\n", - " \n", - " # filter FCD samples\n", - " fcd_df = df[df['group'] == 'fcd'].copy()\n", - " # shuffle indices\n", - " fcd_df = fcd_df.sample(frac=1, random_state=42).reset_index(drop=True)\n", - " # compute split index\n", - " n_train = int(len(fcd_df) * 0.9)\n", - " # assign split labels\n", - " fcd_df.loc[:n_train-1, 'split'] = 'train'\n", - " fcd_df.loc[n_train:, 'split'] = 'val'\n", - " #update\n", - " df.loc[fcd_df.index, 'split'] = fcd_df['split']\n", - "\n", - " missing = []\n", - " \n", - " for participant_id in df[(df['split']==self.subset) & (df['group']=='fcd')]['participant_id']:\n", - " case_dir = f\"{self.root_dir}/{participant_id}/anat/\"\n", - " files = os.listdir(case_dir)\n", - " \n", - " img_dict = {}\n", - " for mod in self.modalities:\n", - " pattern = re.compile(rf\"^{re.escape(participant_id)}.*{re.escape(mod)}\\.nii\\.gz$\")\n", - " matches = [f for f in files if pattern.match(f)]\n", - " assert matches, f\"Missing {mod} for {participant_id} in {case_dir}\"\n", - " img_dict[mod] = os.path.join(case_dir, matches[0])\n", - "\n", - " mask_matches = [f for f in files if re.match(rf\"^{re.escape(participant_id)}.*roi\\.nii\\.gz$\", f)]\n", - " mask_path = os.path.join(case_dir, mask_matches[0])\n", - "\n", - " cases.append({'img': img_dict, 'mask': mask_path, 'name': participant_id})\n", - " \n", - " return cases\n", - "\n", - " # ------------------------------------------------------------\n", - " def _pad_to_cube(self, vol, fill=0.0):\n", - " \"\"\"Symmetric 3-D pad to [img_size³]. `vol` is [*, D, H, W].\"\"\"\n", - " D, H, W = vol.shape[-3:]\n", - " pad_D, pad_H, pad_W = self.img_size - D, self.img_size - H, self.img_size - W\n", - " pad = (pad_W // 2, pad_W - pad_W // 2,\n", - " pad_H // 2, pad_H - pad_H // 2,\n", - " pad_D // 2, pad_D - pad_D // 2)\n", - " return nn.functional.pad(vol, pad, value=fill)\n", - "\n", - " # ------------------------------------------------------------\n", - " def __getitem__(self, idx):\n", - " rec = self.cases[idx]\n", - " name = rec['name']\n", - "\n", - " # ---------- load C modalities --------------------------\n", - " vols = []\n", - " for mod in self.modalities: \n", - " mod_path = rec['img'][mod] \n", - " arr = nibabel.load(mod_path).get_fdata().astype(np.float32)\n", - " \n", - " # robust min-max clipping and normalization\n", - " lo, hi = np.quantile(arr, [0.001, 0.999])\n", - " arr = np.clip(arr, lo, hi)\n", - " arr = (arr - lo) / (hi - lo + 1e-6)\n", - " \n", - " vols.append(torch.from_numpy(arr))\n", - "\n", - " first_mod = self.modalities[0]\n", - " nii_obj = nibabel.load(rec['img'][first_mod])\n", - " affine = nii_obj.affine\n", - " \n", - " Y = torch.stack(vols, dim=0) # [C, D, H, W]\n", - "\n", - " # ---------- load mask ----------------------------------\n", - " M_arr = nibabel.load(rec['mask']).get_fdata().astype(np.uint8)\n", - " M = torch.from_numpy(M_arr).unsqueeze(0) # [1, D, H, W]\n", - " M = (M > 0).to(Y.dtype)\n", - "\n", - " # ---------- pad (and optional downsample) --------------\n", - " Y = self._pad_to_cube(Y, fill=0.0)\n", - " M = self._pad_to_cube(M, fill=0.0)\n", - " if self.img_size == 128:\n", - " pool = nn.AvgPool3d(2, 2)\n", - " Y = pool(Y); M = pool(M)\n", - "\n", - " # ---------- derive context image -----------------------\n", - " Y_void = Y * (1 - M)\n", - "\n", - " return Y, M, Y_void, name, affine # shapes: [C, D, H, W], [1, D, H, W], [C, D, H, W], ...\n", - "\n", - " # ------------------------------------------------------------\n", - " def __len__(self):\n", - " return len(self.cases)" - ] - }, - { - "cell_type": "code", - "execution_count": 131, - "id": "eed75460-a6a3-4961-bb73-bd447a3fcce2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "case: sub-00078\n", - "Y : torch.Size([1, 1, 256, 256, 256]) torch.float64 min=0.000 max=1.000\n", - "M : torch.Size([1, 1, 256, 256, 256]) torch.float64 mask voxels=889.0\n", - "Y_void : torch.Size([1, 1, 256, 256, 256]) torch.float64\n", - "torch.Size([1, 256, 256, 256]) torch.Size([1, 256, 256, 256])\n", - "tensor([[[ 9.9966e-01, -1.1434e-02, -2.3301e-02, -7.7819e+01],\n", - " [ 1.4245e-02, 9.9215e-01, 1.2428e-01, -9.6401e+01],\n", - " [ 2.1697e-02, -1.2457e-01, 9.9197e-01, -1.5050e+02],\n", - " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, 1.0000e+00]]],\n", - " dtype=torch.float64)\n", - "✅ dataloader sanity-check passed\n" - ] - } - ], - "source": [ - "# Test cell ───────────────────────────────────────────────────\n", - "from pathlib import Path\n", - "from torch.utils.data import DataLoader\n", - "import numpy as np\n", - "\n", - "root = Path(\"\") # ← update\n", - "dl = InpaintVolumes(\n", - " root_dir=root,\n", - " subset='train',\n", - " img_size=256,\n", - " modalities=('T1w',))\n", - "\n", - "loader = DataLoader(dl, batch_size=1, shuffle=True, num_workers=0)\n", - "\n", - "print(type(loader))\n", - "\n", - "# grab one sample\n", - "Y, M, Y_void, name, affine = next(iter(loader))\n", - "\n", - "print(\"case:\", name[0])\n", - "print(\"Y :\", Y.shape, Y.dtype, f\"min={Y.min():.3f}\", f\"max={Y.max():.3f}\")\n", - "print(\"M :\", M.shape, M.dtype, f\"mask voxels={M.sum().item()}\")\n", - "print(\"Y_void :\", Y_void.shape, Y_void.dtype)\n", - "\n", - "# quick assertions\n", - "C = len(dl.modalities)\n", - "print(Y.shape[1:], M.shape[1:])\n", - "assert Y.shape[1:] == M.shape[1:], \"spatial mismatch\"\n", - "assert Y.shape[0] == C, \"channel count mismatch\"\n", - "assert torch.allclose(Y * (1-M), Y_void), \"Y_void incorrect\"\n", - "\n", - "print(affine)\n", - "\n", - "print(\"✅ dataloader sanity-check passed\")" - ] - }, - { - "cell_type": "code", - "execution_count": 133, - "id": "40a64585-d02c-4b4d-a868-a2cb4301859b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "saved to /Users/renner/sts/data/tmp_niftis\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "affine = affine[0]\n", - "\n", - "import nibabel as nib\n", - "from pathlib import Path\n", - "\n", - "# ------------------------------------------------------------------\n", - "# 1. build filenames\n", - "outdir = Path(\"tmp_niftis\"); outdir.mkdir(exist_ok=True)\n", - "case = name[0]\n", - "fn_y = outdir / f\"{case}_T1w_norm.nii.gz\"\n", - "fn_yvoid = outdir / f\"{case}_T1w_void.nii.gz\"\n", - "fn_mask = outdir / f\"{case}_mask.nii.gz\"\n", - "\n", - "# ------------------------------------------------------------------\n", - "# 2. drop the leading singleton (shape: (1, 1, D, H, W) → (D, H, W))\n", - "vol_y = Y.squeeze().numpy() # float32 (0–1)\n", - "vol_yvoid = Y_void.squeeze().numpy() # float32\n", - "vol_mask = M.squeeze().numpy().astype(np.uint8) # uint8 0/1\n", - "\n", - "# ------------------------------------------------------------------\n", - "# 3. save\n", - "nib.save(nib.Nifti1Image(vol_y, affine), fn_y)\n", - "nib.save(nib.Nifti1Image(vol_yvoid, affine), fn_yvoid)\n", - "nib.save(nib.Nifti1Image(vol_mask, affine), fn_mask)\n", - "\n", - "print(\"saved to\", outdir.resolve())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b9e0eb57-a9c7-46d7-8d9c-4ba9e13da0c0", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f532345f-bffe-4423-945a-51ca8ab9ec79", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}