careamics 0.0.19__py3-none-any.whl

careamics/dataset_ng/demos/demo_dataset.ipynb

@@ -0,0 +1,278 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import skimage\n",
+    "import tifffile\n",
+    "\n",
+    "from careamics.config.configuration_factories import (\n",
+    "    _create_ng_data_configuration,\n",
+    "    _list_spatial_augmentations,\n",
+    ")\n",
+    "from careamics.dataset_ng.dataset import Mode\n",
+    "from careamics.dataset_ng.factory import create_dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "example_data = skimage.data.human_mitosis()\n",
+    "\n",
+    "markers = np.zeros_like(example_data)\n",
+    "markers[example_data < 25] = 1\n",
+    "markers[example_data > 50] = 2\n",
+    "\n",
+    "elevation_map = skimage.filters.sobel(example_data)\n",
+    "segmentation = skimage.segmentation.watershed(elevation_map, markers)\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 2)\n",
+    "ax[0].imshow(example_data)\n",
+    "ax[1].imshow(segmentation)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2",
+   "metadata": {},
+   "source": [
+    "### 1. From an array "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 1. Train val from an array\n",
+    "\n",
+    "train_data_config = _create_ng_data_configuration(\n",
+    "    data_type=\"array\",\n",
+    "    axes=\"YX\",\n",
+    "    patch_size=(32, 32),\n",
+    "    batch_size=1,\n",
+    "    augmentations=_list_spatial_augmentations()\n",
+    ")\n",
+    "\n",
+    "val_data_config = _create_ng_data_configuration(\n",
+    "    data_type=\"array\",\n",
+    "    axes=\"YX\",\n",
+    "    patch_size=(32, 32),\n",
+    "    batch_size=1,\n",
+    "    augmentations=[],\n",
+    ")\n",
+    "\n",
+    "\n",
+    "train_dataset = create_dataset(\n",
+    "    config=train_data_config,\n",
+    "    mode=Mode.TRAINING,\n",
+    "    inputs=[example_data],\n",
+    "    targets=[segmentation],\n",
+    "    in_memory=True,\n",
+    ")\n",
+    "val_dataset = create_dataset(\n",
+    "    config=val_data_config,\n",
+    "    mode=Mode.VALIDATING,\n",
+    "    inputs=[example_data],\n",
+    "    targets=[segmentation],\n",
+    "    in_memory=True,\n",
+    ")\n",
+    "\n",
+    "fig, ax = plt.subplots(2, 5, figsize=(10, 5))\n",
+    "ax[0, 0].set_title(\"Train input\")\n",
+    "ax[1, 0].set_title(\"Train target\")\n",
+    "for i in range(5):\n",
+    "    sample, target = train_dataset[i]\n",
+    "    ax[0, i].imshow(sample.data[0])\n",
+    "    ax[1, i].imshow(target.data[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4",
+   "metadata": {},
+   "source": [
+    "### 2. From tiff "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tifffile.imwrite(\"example_data1.tiff\", example_data)\n",
+    "tifffile.imwrite(\"example_target1.tiff\", segmentation)\n",
+    "tifffile.imwrite(\"example_data2.tiff\", example_data[:256, :256])\n",
+    "tifffile.imwrite(\"example_target2.tiff\", segmentation[:256, :256])\n",
+    "\n",
+    "train_data_config = _create_ng_data_configuration(\n",
+    "    data_type=\"tiff\",\n",
+    "    axes=\"YX\",\n",
+    "    patch_size=(32, 32),\n",
+    "    batch_size=1,\n",
+    "    augmentations=_list_spatial_augmentations()\n",
+    ")\n",
+    "\n",
+    "val_data_config = _create_ng_data_configuration(\n",
+    "    data_type=\"tiff\",\n",
+    "    axes=\"YX\",\n",
+    "    patch_size=(32, 32),\n",
+    "    batch_size=1,\n",
+    "    augmentations=[],\n",
+    ")\n",
+    "\n",
+    "data = sorted(Path(\"./\").glob(\"example_data*.tiff\"))\n",
+    "targets = sorted(Path(\"./\").glob(\"example_target*.tiff\"))\n",
+    "train_dataset = create_dataset(\n",
+    "    config=train_data_config,\n",
+    "    mode=Mode.TRAINING,\n",
+    "    inputs=data,\n",
+    "    targets=targets,\n",
+    "    in_memory=True,\n",
+    ")\n",
+    "val_dataset = create_dataset(\n",
+    "    config=val_data_config,\n",
+    "    mode=Mode.VALIDATING,\n",
+    "    inputs=data,\n",
+    "    targets=targets,\n",
+    "    in_memory=True,\n",
+    ")\n",
+    "\n",
+    "fig, ax = plt.subplots(2, 5, figsize=(10, 5))\n",
+    "ax[0, 0].set_title(\"Train input\")\n",
+    "ax[1, 0].set_title(\"Train target\")\n",
+    "for i in range(5):\n",
+    "    sample, target = train_dataset[i]\n",
+    "    ax[0, i].imshow(sample.data[0])\n",
+    "    ax[1, i].imshow(target.data[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6",
+   "metadata": {},
+   "source": [
+    "### 3. Prediction from array"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from careamics.config.data import NGDataConfig\n",
+    "\n",
+    "prediction_config = NGDataConfig(\n",
+    "    data_type=\"array\",\n",
+    "    patching={\n",
+    "        \"name\": \"tiled\",\n",
+    "        \"patch_size\": (32, 32),\n",
+    "        \"overlaps\": (16, 16),\n",
+    "    },\n",
+    "    axes=\"YX\",\n",
+    "    batch_size=1,\n",
+    "    image_means=[example_data.mean()],\n",
+    "    image_stds=[example_data.std()],\n",
+    ")\n",
+    "\n",
+    "prediction_dataset = create_dataset(\n",
+    "    config=prediction_config,\n",
+    "    mode=Mode.PREDICTING,\n",
+    "    inputs=[example_data],\n",
+    "    targets=None,\n",
+    "    in_memory=True,\n",
+    ")\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 5, figsize=(10, 5))\n",
+    "ax[0].set_title(\"Prediction input\")\n",
+    "for i in range(5):\n",
+    "    sample, *_ = prediction_dataset[i]\n",
+    "    ax[i].imshow(sample.data[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8",
+   "metadata": {},
+   "source": [
+    "### 4. From custom data type "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data_config = _create_ng_data_configuration(\n",
+    "    data_type=\"custom\",\n",
+    "    axes=\"YX\",\n",
+    "    patch_size=(32, 32),\n",
+    "    batch_size=1,\n",
+    "    augmentations=_list_spatial_augmentations(),\n",
+    ")\n",
+    "\n",
+    "\n",
+    "def read_data_func_test(example_data):\n",
+    "    return 255 - example_data\n",
+    "\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 5, figsize=(10, 5))\n",
+    "train_dataset = create_dataset(\n",
+    "    config=train_data_config,\n",
+    "    mode=Mode.TRAINING,\n",
+    "    inputs=[example_data],\n",
+    "    targets=[segmentation],\n",
+    "    in_memory=True,\n",
+    "    read_func=read_data_func_test,\n",
+    "    read_kwargs={}\n",
+    ")\n",
+    "\n",
+    "for i in range(5):\n",
+    "    sample, _ = train_dataset[i]\n",
+    "    ax[i].imshow(sample.data[0])"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "czi",
+   "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.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

careamics/dataset_ng/demos/demo_patch_extractor.py

@@ -0,0 +1,51 @@
+# %%
+import numpy as np
+from careamics.dataset_ng.patch_extractor.image_stack import InMemoryImageStack
+
+# %%
+from careamics.dataset_ng.patch_extractor.patch_extractor_factory import (
+    create_array_extractor,
+)
+
+from careamics.dataset_ng.patching_strategies import RandomPatchingStrategy
+
+# %%
+array = np.arange(36).reshape(6, 6)
+image_stack = InMemoryImageStack.from_array(data=array, axes="YX")
+image_stack.extract_patch(sample_idx=0, coords=(2, 2), patch_size=(3, 3))
+
+# %%
+rng = np.random.default_rng()
+
+# %%
+# define example data
+array1 = np.arange(36).reshape(1, 6, 6)
+array2 = np.arange(50).reshape(2, 5, 5)
+target1 = rng.integers(0, 1, size=array1.shape, endpoint=True)
+target2 = rng.integers(0, 1, size=array2.shape, endpoint=True)
+
+# %%
+print(array1)
+print(array2)
+print(target1)
+print(target2)
+
+# %%
+# define example readers
+input_patch_extractor = create_array_extractor([array1, array2], axes="SYX")
+target_patch_extractor = create_array_extractor([target1, target2], axes="SYX")
+
+# %%
+# generate random patch specification
+data_shapes = [
+    image_stack.data_shape for image_stack in input_patch_extractor.image_stacks
+]
+patch_specs_generator = RandomPatchingStrategy(data_shapes, patch_size=(2, 2))
+patch_specs = patch_specs_generator.get_patch_spec(18)
+
+# %%
+# extract a subset of patches
+input_patch_extractor.extract_patch(**patch_specs)
+
+# %%
+target_patch_extractor.extract_patch(**patch_specs)

careamics/dataset_ng/demos/mouse_nuclei_demo.ipynb

@@ -0,0 +1,293 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from careamics_portfolio import PortfolioManager\n",
+    "\n",
+    "from careamics.config.configuration_factories import create_n2v_configuration\n",
+    "from careamics.config.support import SupportedTransform\n",
+    "from careamics.lightning.callbacks import HyperParametersCallback\n",
+    "from careamics.lightning.dataset_ng.data_module import CareamicsDataModule\n",
+    "from careamics.lightning.dataset_ng.lightning_modules import N2VModule"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "portfolio = PortfolioManager()\n",
+    "files = portfolio.denoiseg.MouseNuclei_n20.download()\n",
+    "files.sort()\n",
+    "\n",
+    "# load images\n",
+    "train_data = np.load(files[1])[\"X_train\"]\n",
+    "print(f\"Train data shape: {train_data.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "indices = [34, 293, 571, 783]\n",
+    "\n",
+    "fig, ax = plt.subplots(2, 2, figsize=(8, 8))\n",
+    "ax[0, 0].imshow(train_data[indices[0]], cmap=\"gray\")\n",
+    "ax[0, 0].set_title(f\"Image {indices[0]}\")\n",
+    "ax[0, 0].set_xticks([])\n",
+    "ax[0, 0].set_yticks([])\n",
+    "\n",
+    "ax[0, 1].imshow(train_data[indices[1]], cmap=\"gray\")\n",
+    "ax[0, 1].set_title(f\"Image {indices[1]}\")\n",
+    "ax[0, 1].set_xticks([])\n",
+    "ax[0, 1].set_yticks([])\n",
+    "\n",
+    "ax[1, 0].imshow(train_data[indices[2]], cmap=\"gray\")\n",
+    "ax[1, 0].set_title(f\"Image {indices[2]}\")\n",
+    "ax[1, 0].set_xticks([])\n",
+    "ax[1, 0].set_yticks([])\n",
+    "\n",
+    "ax[1, 1].imshow(train_data[indices[3]], cmap=\"gray\")\n",
+    "ax[1, 1].set_title(f\"Image {indices[3]}\")\n",
+    "ax[1, 1].set_xticks([])\n",
+    "ax[1, 1].set_yticks([])\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config = create_n2v_configuration(\n",
+    "    experiment_name=\"mouse_nuclei_n2v\",\n",
+    "    data_type=\"array\",\n",
+    "    axes=\"SYX\",\n",
+    "    patch_size=(64, 64),\n",
+    "    batch_size=16,\n",
+    "    num_epochs=10,\n",
+    ")\n",
+    "\n",
+    "print(config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Ensuring that transforms are set\n",
+    "config.data_config.transforms =[\n",
+    "    {\n",
+    "        \"name\": SupportedTransform.XY_FLIP.value,\n",
+    "        \"flip_x\": True,\n",
+    "        \"flip_y\": True,\n",
+    "    },\n",
+    "    {\n",
+    "        \"name\": SupportedTransform.XY_RANDOM_ROTATE90.value,\n",
+    "    },\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "train_data, val_data = train_test_split(train_data, test_size=0.1, random_state=42)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data_module = CareamicsDataModule(\n",
+    "    data_config=config.data_config,\n",
+    "    train_data=train_data,\n",
+    "    val_data=val_data,\n",
+    ")\n",
+    "\n",
+    "model = N2VModule(config.algorithm_config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pytorch_lightning import Trainer\n",
+    "from pytorch_lightning.callbacks import ModelCheckpoint\n",
+    "from pytorch_lightning.loggers import WandbLogger\n",
+    "\n",
+    "root = Path(\"nuclei_n2v\")\n",
+    "callbacks = [\n",
+    "    ModelCheckpoint(\n",
+    "        dirpath=root / \"checkpoints\",\n",
+    "        filename=\"nuclei_new_lightning_module\",\n",
+    "        save_last=True,\n",
+    "        monitor=\"val_loss\",\n",
+    "        mode=\"min\",\n",
+    "    ),\n",
+    "    HyperParametersCallback(config)\n",
+    "]\n",
+    "logger = WandbLogger(\n",
+    "    project=\"nuclei-n2v\", name=\"nuclei_new_lightning_module\"\n",
+    ")\n",
+    "\n",
+    "trainer = Trainer(\n",
+    "    max_epochs=10,\n",
+    "    default_root_dir=root,\n",
+    "    callbacks=callbacks,\n",
+    "    logger=logger\n",
+    ")\n",
+    "trainer.fit(model, datamodule=train_data_module)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from careamics.config.inference_model import InferenceConfig\n",
+    "\n",
+    "from careamics.dataset_ng.legacy_interoperability import imageregions_to_tileinfos\n",
+    "from careamics.prediction_utils import convert_outputs\n",
+    "\n",
+    "train_data = np.load(files[1])[\"X_train\"]\n",
+    "\n",
+    "config = InferenceConfig(\n",
+    "    model_config=config,\n",
+    "    data_type=\"array\",\n",
+    "    tile_size=(64, 64),\n",
+    "    tile_overlap=(32, 32),\n",
+    "    axes=\"SYX\",\n",
+    "    batch_size=1,\n",
+    "    image_means=train_data_module.train_dataset.input_stats.means,\n",
+    "    image_stds=train_data_module.train_dataset.input_stats.stds\n",
+    ")\n",
+    "\n",
+    "inf_data_module = CareamicsDataModule(\n",
+    "    data_config=config,\n",
+    "    pred_data=train_data\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "predictions = trainer.predict(model, datamodule=inf_data_module)\n",
+    "tile_infos = imageregions_to_tileinfos(predictions)\n",
+    "predictions = convert_outputs(tile_infos, tiled=True)\n",
+    "predictions = np.stack(predictions).squeeze()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "files = portfolio.denoiseg.MouseNuclei_n0.download()\n",
+    "files.sort()\n",
+    "\n",
+    "gt_data = np.load(files[1])[\"X_train\"]\n",
+    "print(f\"GT data shape: {gt_data.shape}\")\n",
+    "print(f\"Predictions shape: {predictions.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from careamics.utils.metrics import scale_invariant_psnr\n",
+    "\n",
+    "indices = [389, 621]\n",
+    "\n",
+    "for i in indices:\n",
+    "    # compute psnr\n",
+    "    psnr_noisy = scale_invariant_psnr(gt_data[i], train_data[i])\n",
+    "    psnr_denoised = scale_invariant_psnr(gt_data[i], predictions[i].squeeze())\n",
+    "\n",
+    "    # plot images\n",
+    "    fig, ax = plt.subplots(1, 3, figsize=(10, 10))\n",
+    "    ax[0].imshow(train_data[i], cmap=\"gray\")\n",
+    "    ax[0].set_title(f\"Noisy Image\\nPSNR: {psnr_noisy:.2f}\")\n",
+    "    ax[0].set_xticks([])\n",
+    "    ax[0].set_yticks([])\n",
+    "\n",
+    "    ax[1].imshow(predictions[i].squeeze(), cmap=\"gray\")\n",
+    "    ax[1].set_title(f\"Denoised Image\\nPSNR: {psnr_denoised:.2f}\")\n",
+    "    ax[1].set_xticks([])\n",
+    "    ax[1].set_yticks([])\n",
+    "\n",
+    "    ax[2].imshow(gt_data[i], cmap=\"gray\")\n",
+    "    ax[2].set_title(\"GT Image\")\n",
+    "    ax[2].set_xticks([])\n",
+    "    ax[2].set_yticks([])\n",
+    "\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "psnrs = np.zeros(gt_data.shape[0])\n",
+    "\n",
+    "for i in range(gt_data.shape[0]):\n",
+    "    psnrs[i] = scale_invariant_psnr(gt_data[i], predictions[i].squeeze())\n",
+    "\n",
+    "print(f\"PSNR: {np.mean(psnrs):.2f} ± {np.std(psnrs):.2f}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.9.20"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}