exercise.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "49ef91a1",
   "metadata": {},
   "source": [
    "# Exercise 04: Instance Segmentation :D\n",
    "\n",
    "So far, we were only interested in `semantic` classes, e.g. foreground / background etc.\n",
    "But in many cases we not only want to know if a certain pixel belongs to a specific class, but also to which unique object (i.e. the task of `instance segmentation`).\n",
    "\n",
    "For isolated objects, this is trivial, all connected foreground pixels form one instance, yet often instances are very close together or even overlapping. Thus we need to think a bit more how to formulate the targets / loss of our network.\n",
    "\n",
    "Furthermore, in instance segmentation the specific value of each label is arbitrary. Here we label each cell with a number and assign a color to each number giving us a segmentation mask. `Mask 1` and `Mask 2` are equivalently good segmentations even though the specific label of each cell is arbitrary.\n",
    "\n",
    "| Image | Mask 1| Mask 2|\n",
    "| :-: | :-: | :-: |\n",
    "| ![image](static/figure1/01_instance_image.png) | ![mask1](static/figure1/02_instance_teaser.png) | ![mask2](static/figure1/03_instance_teaser.png) |\n",
    "\n",
    "Once again: THE SPECIFIC VALUES OF THE LABELS ARE ARBITRARY\n",
    "\n",
    "This means that the model will not be able to learn, if tasked to predict the labels directly.\n",
    "\n",
    "Therefore we split the task of instance segmentation in two and introduce an intermediate target which must be:\n",
    "  1) learnable\n",
    "  2) post-processable into an instance segmentation\n",
    "\n",
    "In this exercise we will go over two common intermediate targets (signed distance transform and affinities),\n",
    "as well as the necessary pre and post-processing for obtaining the final segmentations.\n",
    "\n",
    "At the end of the exercise we will also compare to a pre-trained cellpose model."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05e18e91",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "<b>Conda Kernel</b>: Please use the kernel `04-instance-segmentation` for this exercise\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8775b938",
   "metadata": {},
   "source": [
    "## Section 0: Imports and Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64a68e08",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "## Import Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c2d9df9",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [],
   "source": [
    "from matplotlib.colors import ListedColormap\n",
    "import numpy as np\n",
    "import os\n",
    "import torch\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data import Dataset\n",
    "from torchvision.transforms import v2\n",
    "from scipy.ndimage import distance_transform_edt, map_coordinates\n",
    "from local import train, plot_two, plot_three, plot_four\n",
    "from dlmbl_unet import UNet\n",
    "from tqdm import tqdm\n",
    "import tifffile\n",
    "import mwatershed as mws\n",
    "\n",
    "from skimage.filters import threshold_otsu\n",
    "from skimage.morphology import remove_small_objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53a9aa95",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set some variables that are specific to the hardware being run on\n",
    "# this should be optimized for the compute nodes once available.\n",
    "device = \"cuda\"  # 'cuda', 'cpu', 'mps'\n",
    "NUM_THREADS = 8\n",
    "NUM_EPOCHS = 80\n",
    "# make sure gpu is available. Please call a TA if this cell fails\n",
    "assert torch.cuda.is_available()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f24bdcd",
   "metadata": {
    "lines_to_next_cell": 1
   },
   "outputs": [],
   "source": [
    "# Create a custom label color map for showing instances\n",
    "np.random.seed(1)\n",
    "colors = [[0, 0, 0]] + [list(np.random.choice(range(256), size=3)) for _ in range(254)]\n",
    "label_cmap = ListedColormap(colors)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6344d941",
   "metadata": {},
   "source": [
    "## Section 1: Signed Distance Transform (SDT)\n",
    "\n",
    "First, we will use the signed distance transform as an intermediate learning objective.\n",
    "\n",
    "<i>What is the signed distance transform?</i>\n",
    "<br>  - The Signed Distance Transform indicates the distance from each specific pixel to the boundary of objects.\n",
    "<br>  - It is positive for pixels inside objects and negative for pixels outside objects (i.e. in the background).\n",
    "<br>  - Remember that deep learning models work best with normalized values, therefore it is important to scale the distance\n",
    "           transform. For simplicity, things are often scaled between -1 and 1.\n",
    "<br>  - As an example, here, you see the SDT (right) of the target mask (middle), below."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72ec1e22",
   "metadata": {},
   "source": [
    "![image](static/figure2/04_instance_sdt.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f1e1fdf",
   "metadata": {},
   "source": [
    "We will now add the code for preparing our data to learn the signed distance transform."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "380cac87",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [],
   "source": [
    "\n",
    "def compute_sdt(labels: np.ndarray, scale: int = 5):\n",
    "    \"\"\"Function to compute a signed distance transform.\"\"\"\n",
    "    dims = len(labels.shape)\n",
    "    # Create a placeholder array of infinite distances\n",
    "    distances = np.ones(labels.shape, dtype=np.float32) * np.inf\n",
    "    for axis in range(dims):\n",
    "        # Here we compute the boundaries by shifting the labels and comparing to the original labels\n",
    "        # This can be visualized in 1D as:\n",
    "        # a a a b b c c c\n",
    "        #   a a a b b c c c\n",
    "        #   1 1 0 1 0 1 1\n",
    "        # Applying a half pixel shift makes the result more obvious:\n",
    "        # a a a b b c c c\n",
    "        #  1 1 0 1 0 1 1\n",
    "        bounds = (\n",
    "            labels[*[slice(None) if a != axis else slice(1, None) for a in range(dims)]]\n",
    "            == labels[\n",
    "                *[slice(None) if a != axis else slice(None, -1) for a in range(dims)]\n",
    "            ]\n",
    "        )\n",
    "        # pad to account for the lost pixel\n",
    "        bounds = np.pad(\n",
    "            bounds,\n",
    "            [(1, 1) if a == axis else (0, 0) for a in range(dims)],\n",
    "            mode=\"constant\",\n",
    "            constant_values=1,\n",
    "        )\n",
    "        # compute distances on the boundary mask\n",
    "        axis_distances = distance_transform_edt(bounds)\n",
    "\n",
    "        # compute the coordinates of each original pixel relative to the boundary mask and distance transform.\n",
    "        # Its just a half pixel shift in the axis we computed boundaries for.\n",
    "        coordinates = np.meshgrid(\n",
    "            *[\n",
    "                range(axis_distances.shape[a])\n",
    "                if a != axis\n",
    "                else np.linspace(0.5, axis_distances.shape[a] - 1.5, labels.shape[a])\n",
    "                for a in range(dims)\n",
    "            ],\n",
    "            indexing=\"ij\",\n",
    "        )\n",
    "        coordinates = np.stack(coordinates)\n",
    "\n",
    "        # Interpolate the distances to the original pixel coordinates\n",
    "        sampled = map_coordinates(\n",
    "            axis_distances,\n",
    "            coordinates=coordinates,\n",
    "            order=3,\n",
    "        )\n",
    "\n",
    "        # Update the distances with the minimum distance to a boundary in this axis\n",
    "        distances = np.minimum(distances, sampled)\n",
    "\n",
    "    # Normalize the distances to be between -1 and 1\n",
    "    distances = np.tanh(distances / scale)\n",
    "\n",
    "    # Invert the distances for pixels in the background\n",
    "    distances[labels == 0] *= -1\n",
    "    return distances"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "289d434c",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Task 1.1</b>: Explain the `compute_sdt` from the cell above.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e563cce9",
   "metadata": {
    "tags": [
     "task"
    ]
   },
   "source": [
    "1. _Why do we need to loop over dimensions? Couldn't we compute all at once?_\n",
    "\n",
    "2. _What is the purpose of the pad?_\n",
    "\n",
    "3. _What does meshgrid do?_\n",
    "\n",
    "4. _Why do we use `map_coordinates`?_\n",
    "\n",
    "5. _bonus question: Is the pad sufficient to give us accurate distances at the edge of our image?_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af81abb2",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "Below is a quick visualization of the signed distance transform (SDT).\n",
    "<br> Note that the output of the signed distance transform is not binary, a significant difference from semantic segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b406a07f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualize the signed distance transform using the function you wrote above.\n",
    "\n",
    "root_dir = \"tissuenet_data/train\"  # the directory with all the training samples\n",
    "samples = os.listdir(root_dir)\n",
    "idx = np.random.randint(len(samples) // 3)  # take a random sample.\n",
    "img = tifffile.imread(os.path.join(root_dir, f\"img_{idx}.tif\"))  # get the image\n",
    "label = tifffile.imread(\n",
    "    os.path.join(root_dir, f\"img_{idx}_cyto_masks.tif\")\n",
    ")  # get the image\n",
    "sdt = compute_sdt(label)\n",
    "plot_three(img, label, sdt, label=\"SDT\", label_cmap=label_cmap)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a6b1c56",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Task 1.2</b>: Explain the scale parameter in <code>compute_sdt</code>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e63453b4",
   "metadata": {
    "tas": [
     "task"
    ]
   },
   "source": [
    "<b>Questions</b>:\n",
    "1. _Why do we need to normalize the distances between -1 and 1?_\n",
    "\n",
    "2. _What is the effect of changing the scale value? What do you think is a good default value?_\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce4196da",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Task 1.3</b>: <br>\n",
    "    Modify the <code>SDTDataset</code> class below to produce the paired raw and SDT images.<br>\n",
    "  1. Fill in the <code>create_sdt_target</code> method to return an SDT output rather than a label mask.<br>\n",
    "      - Ensure that all final outputs are of torch tensor type, and are converted to float.<br>\n",
    "  2. Instantiate the dataset with a RandomCrop of size 128 and visualize the output to confirm that the SDT is correct.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a096b8c",
   "metadata": {
    "tags": [
     "task"
    ]
   },
   "outputs": [],
   "source": [
    "class SDTDataset(Dataset):\n",
    "    \"\"\"A PyTorch dataset to load cell images and nuclei masks.\"\"\"\n",
    "\n",
    "    def __init__(self, root_dir, transform=None, img_transform=None, return_mask=False):\n",
    "        self.root_dir = root_dir  # the directory with all the training samples\n",
    "        self.num_samples = len(os.listdir(self.root_dir)) // 3  # list the samples\n",
    "        self.return_mask = return_mask\n",
    "        self.transform = (\n",
    "            transform  # transformations to apply to both inputs and targets\n",
    "        )\n",
    "        self.img_transform = img_transform  # transformations to apply to raw image only\n",
    "        #  transformations to apply just to inputs\n",
    "        inp_transforms = v2.Compose(\n",
    "            [\n",
    "                v2.ToDtype(torch.float32, scale=True),\n",
    "                v2.Normalize([0.5], [0.5]),  # 0.5 = mean and 0.5 = variance\n",
    "            ]\n",
    "        )\n",
    "        self.from_np = v2.Lambda(lambda x: torch.from_numpy(x))\n",
    "\n",
    "        self.loaded_imgs = [None] * self.num_samples\n",
    "        self.loaded_masks = [None] * self.num_samples\n",
    "        for sample_ind in tqdm(range(self.num_samples)):\n",
    "            img_path = os.path.join(self.root_dir, f\"img_{sample_ind}.tif\")\n",
    "            image = self.from_np(tifffile.imread(img_path))\n",
    "            self.loaded_imgs[sample_ind] = inp_transforms(image)\n",
    "            mask_path = os.path.join(self.root_dir, f\"img_{sample_ind}_cyto_masks.tif\")\n",
    "            mask = self.from_np(tifffile.imread(mask_path))\n",
    "            self.loaded_masks[sample_ind] = mask\n",
    "\n",
    "    # get the total number of samples\n",
    "    def __len__(self):\n",
    "        return self.num_samples\n",
    "\n",
    "    # fetch the training sample given its index\n",
    "    def __getitem__(self, idx):\n",
    "        # We'll be using the Pillow library for reading files\n",
    "        # since many torchvision transforms operate on PIL images\n",
    "        image = self.loaded_imgs[idx]\n",
    "        mask = self.loaded_masks[idx]\n",
    "        if self.transform is not None:\n",
    "            # Note: using seeds to ensure the same random transform is applied to\n",
    "            # the image and mask\n",
    "            seed = torch.seed()\n",
    "            torch.manual_seed(seed)\n",
    "            image = self.transform(image)\n",
    "            torch.manual_seed(seed)\n",
    "            mask = self.transform(mask)\n",
    "\n",
    "        # use the compute_sdt function to get the sdt\n",
    "        sdt = self.create_sdt_target(mask)\n",
    "        assert isinstance(sdt, torch.Tensor)\n",
    "        assert sdt.dtype == torch.float32\n",
    "        assert sdt.shape == mask.shape\n",
    "        if self.img_transform is not None:\n",
    "            image = self.img_transform(image)\n",
    "        if self.return_mask is True:\n",
    "            return image, mask.unsqueeze(0), sdt.unsqueeze(0)\n",
    "        else:\n",
    "            return image, sdt.unsqueeze(0)\n",
    "\n",
    "    def create_sdt_target(self, mask):\n",
    "\n",
    "        ########## YOUR CODE HERE ##########\n",
    "\n",
    "        ...\n",
    "        return ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccc61d8a",
   "metadata": {
    "tags": [
     "task"
    ]
   },
   "outputs": [],
   "source": [
    "# Create a dataset using a RandomCrop of size 128 (see torchvision.transforms.v2 imported as v2)\n",
    "# documentation here: https://pytorch.org/vision/stable/transforms.html#v2-api-reference-recommended\n",
    "# Visualize the output to confirm your dataset is working.\n",
    "\n",
    "train_data = SDTDataset(\"tissuenet_data/train\", ...)\n",
    "img, sdt = train_data[10]  # get the image and the distance transform\n",
    "# We use the `plot_two` function (imported in the first cell) to verify that our\n",
    "# dataset solution is correct. The output should show 2 images: the raw image and\n",
    "# the corresponding SDT.\n",
    "plot_two(img, sdt[0], label=\"SDT\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8f65d87",
   "metadata": {
    "tags": [
     "task"
    ]
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Task 1.4</b>: Understanding the dataloader.\n",
    "Our dataloader has some features that are not straightforward to understand or justify, and this is a good point\n",
    "to discuss them.\n",
    "\n",
    "1. _What are we doing with the `seed` variable and why? Can you predict what will go wrong when you delete the `seed` code and rerun the previous cells visualization?_\n",
    "\n",
    "2. _What is the purpose of the `loaded_imgs` and `loaded_masks` lists?_\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cf40a3e",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "Next, we will create a training dataset and data loader.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f58a6402",
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: You don't have to add extra augmentations, training will work without.\n",
    "# But feel free to experiment here if you want to come back and try to get better results if you have time.\n",
    "train_data = SDTDataset(\"tissuenet_data/train\", v2.RandomCrop(128))\n",
    "train_loader = DataLoader(\n",
    "    train_data, batch_size=5, shuffle=True, num_workers=NUM_THREADS\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76fa4118",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Task 1.5</b>: Train the U-Net.\n",
    "\n",
    "In the cell below, fill in your code anywhere you see ...\n",
    "\n",
    "In this task, initialize the UNet, specify a loss function, learning rate, and optimizer, and train the model.<br>\n",
    "<br> For simplicity we will use a pre-made training function imported from `local.py`. <br>\n",
    "<u>Hints</u>:<br>\n",
    "  - Loss function - [torch losses](https://pytorch.org/docs/stable/nn.html#loss-functions)\n",
    "  - Optimizer - [torch optimizers](https://pytorch.org/docs/stable/optim.html)\n",
    "  - Final Activation - there are a few options (only one is the best)\n",
    "      - [sigmoid](https://pytorch.org/docs/stable/generated/torch.nn.Sigmoid.html)\n",
    "      - [tanh](https://pytorch.org/docs/stable/generated/torch.nn.Tanh.html#torch.nn.Tanh)\n",
    "      - [relu](https://pytorch.org/docs/stable/generated/torch.nn.ReLU.html#torch.nn.ReLU)\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9547623",
   "metadata": {
    "tags": [
     "task"
    ]
   },
   "outputs": [],
   "source": [
    "# If you manage to get a loss close to 0.1, you are doing pretty well and can probably move on\n",
    "unet = ...\n",
    "\n",
    "learning_rate = ...\n",
    "loss = ...\n",
    "optimizer = ...\n",
    "\n",
    "for epoch in range(NUM_EPOCHS):\n",
    "    train(\n",
    "        model=...,\n",
    "        loader=...,\n",
    "        optimizer=...,\n",
    "        loss_function=...,\n",
    "        epoch=...,\n",
    "        log_interval=2,\n",
    "        device=device,\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f37ed17f",
   "metadata": {},
   "source": [
    "Now, let's apply our trained model and visualize some random samples. <br>\n",
    "First, we create a validation dataset. <br> Next, we sample a random image from the dataset and input into the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71ec9e70",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [],
   "source": [
    "val_data = SDTDataset(\"tissuenet_data/test\")\n",
    "unet.eval()\n",
    "idx = np.random.randint(len(val_data))  # take a random sample.\n",
    "image, sdt = val_data[idx]  # get the image and the nuclei masks.\n",
    "image = image.to(device)\n",
    "pred = unet(torch.unsqueeze(image, dim=0))\n",
    "image = np.squeeze(image.cpu())\n",
    "sdt = np.squeeze(sdt.cpu().numpy())\n",
    "pred = np.squeeze(pred.cpu().detach().numpy())\n",
    "plot_three(image, sdt, pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d2923bc",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<h2> Checkpoint 1 </h2>\n",
    "\n",
    "At this point we have a model that does what we told it too, but do not yet have a segmentation. <br>\n",
    "In the next section, we will perform some post-processing and obtain segmentations from our predictions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8fce806",
   "metadata": {},
   "source": [
    "<hr style=\"height:2px;\">\n",
    "\n",
    "## Section 2: Post-Processing\n",
    "- See here for a nice overview: [open-cv-image watershed](https://docs.opencv.org/4.x/d3/db4/tutorial_py_watershed.html), although the specifics of our code will be slightly different\n",
    "- Given the distance transform (the output of our model), we first need to find the local maxima that will be used as seed points\n",
    "- The watershed algorithm then expands each seed out in a local \"basin\" until the segments touch or the boundary of the object is hit."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "541b8e4b",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Task 2.1</b>: write a function to find the local maxima of the distance transform\n",
    "\n",
    "<u>Hint</u>: Look at the imports. <br>\n",
    "<u>Hint</u>: It is possible to write this function by only adding 2 lines.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aaac8857",
   "metadata": {
    "tags": [
     "task"
    ]
   },
   "outputs": [],
   "source": [
    "from scipy.ndimage import label, maximum_filter\n",
    "\n",
    "\n",
    "def find_local_maxima(distance_transform, min_dist_between_points):\n",
    "    \"\"\"\n",
    "    Find the local maxima of the distance transform and generate seed points for our watershed.\n",
    "\n",
    "    inputs:\n",
    "        distance_transform: the distance transform of the image (2D numpy array)\n",
    "        min_dist_between_points: the minimum distance between points (scalar)\n",
    "\n",
    "    returns:\n",
    "        seeds: the seeds for the watershed (2D numpy array with uniquely labelled seed points)\n",
    "        number_of_seeds: the number of seeds (scalar)\n",
    "    \"\"\"\n",
    "\n",
    "    ...\n",
    "    seeds, number_of_seeds = ...\n",
    "\n",
    "    return seeds, number_of_seeds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9c77ac6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# test your function.\n",
    "from local import test_maximum\n",
    "\n",
    "test_maximum(find_local_maxima)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6d02e27",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "We now use this function to find the seeds for the watershed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba15b010",
   "metadata": {},
   "outputs": [],
   "source": [
    "from skimage.segmentation import watershed\n",
    "\n",
    "\n",
    "def watershed_from_boundary_distance(\n",
    "    boundary_distances: np.ndarray,\n",
    "    semantic_segmentation: np.ndarray,\n",
    "    id_offset: float = 0,\n",
    "    min_seed_distance: int = 10,\n",
    "):\n",
    "    \"\"\"Function to compute a watershed from boundary distances.\"\"\"\n",
    "\n",
    "    seeds, n = find_local_maxima(boundary_distances, min_seed_distance)\n",
    "\n",
    "    if n == 0:\n",
    "        return np.zeros(boundary_distances.shape, dtype=np.uint64), id_offset\n",
    "\n",
    "    seeds[seeds != 0] += id_offset\n",
    "\n",
    "    # calculate our segmentation\n",
    "    segmentation = watershed(\n",
    "        boundary_distances.max() - boundary_distances, seeds, mask=semantic_segmentation\n",
    "    )\n",
    "\n",
    "    return segmentation\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d54660ac",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Task 2.2</b>: <br> Use the model to generate a predicted SDT and then use the watershed function we defined above to post-process the model output into a segmentation\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0855add",
   "metadata": {
    "tags": [
     "task"
    ]
   },
   "outputs": [],
   "source": [
    "idx = np.random.randint(len(val_data))  # take a random sample\n",
    "image, mask = val_data[idx]  # get the image and the nuclei masks\n",
    "\n",
    "# get the model prediction\n",
    "# Hint: make sure set the model to evaluation\n",
    "# Hint: check the dims of the image, remember they should be [batch, channels, x, y]\n",
    "unet.eval()\n",
    "\n",
    "# remember to move the image to the device\n",
    "pred = ...\n",
    "\n",
    "# turn image, mask, and pred into plain numpy arrays\n",
    "# don't forget to remove the batch dimension.\n",
    "\n",
    "# Choose a threshold value to use to get the boundary mask.\n",
    "# Feel free to play around with the threshold.\n",
    "# hint: If you're struggling to find a good threshold, you can use the `threshold_otsu` function\n",
    "\n",
    "threshold = ...\n",
    "\n",
    "# Get a semantic segmentation by thresholding your distance transform\n",
    "semantic_segmentation = ...\n",
    "\n",
    "# Get the segmentation\n",
    "seg = watershed_from_boundary_distance(...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f8b9830",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualize the results\n",
    "\n",
    "plot_four(image, mask, pred, seg, label=\"Target\", cmap=label_cmap)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99cfe007",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Task 2.3</b>: <br> Min Seed Distance\n",
    "\n",
    "Questions:\n",
    "1. What is the effect of the `min_seed_distance` parameter in watershed?\n",
    "      - Experiment with different values.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "566968d0",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<h2> Checkpoint 2 </h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4db8fb04",
   "metadata": {},
   "source": [
    "<hr style=\"height:2px;\">\n",
    "\n",
    "## Section 3: Evaluation\n",
    "Many different evaluation metrics exist, and which one you should use is dependant on the specifics of the data.\n",
    "\n",
    "[This website](https://metrics-reloaded.dkfz.de/problem-category-selection) has a good summary of different options."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6978da65",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Task 3.1</b>: Take some time to explore metrics-reloaded. This is a very helpful resource for understanding evaluation metrics.\n",
    "\n",
    "Which of the following should we use for our dataset?:\n",
    "  1) [IoU](https://metrics-reloaded.dkfz.de/metric?id=intersection_over_union)\n",
    "  2) [Accuracy](https://metrics-reloaded.dkfz.de/metric?id=accuracy)\n",
    "  3) [Sensitivity](https://metrics-reloaded.dkfz.de/metric?id=sensitivity) and [Specificity](https://metrics-reloaded.dkfz.de/metric?id=specificity@target_value)\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56eaa998",
   "metadata": {},
   "source": [
    "We will use Accuracy, Specificity/Precision, and Sensitivity/Recall as our evaluation metrics. IoU is also a good metric to use, but it is more commonly used for semantic segmentation tasks."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8447acb",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Task 3.2</b>: <br> Evaluate metrics for the validation dataset. Fill in the blanks\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5770df39",
   "metadata": {
    "tags": [
     "task"
    ]
   },
   "outputs": [],
   "source": [
    "from local import evaluate\n",
    "\n",
    "# Need to re-initialize the dataloader to return masks in addition to SDTs.\n",
    "val_dataset = SDTDataset(\"tissuenet_data/test\", return_mask=True)\n",
    "val_dataloader = DataLoader(\n",
    "    val_dataset, batch_size=1, shuffle=False, num_workers=NUM_THREADS\n",
    ")\n",
    "unet.eval()\n",
    "\n",
    "(\n",
    "    precision_list,\n",
    "    recall_list,\n",
    "    accuracy_list,\n",
    ") = (\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    ")\n",
    "for idx, (image, mask, sdt) in enumerate(tqdm(val_dataloader)):\n",
    "    image = image.to(device)\n",
    "    pred = unet(image)\n",
    "\n",
    "    image = np.squeeze(image.cpu())\n",
    "    gt_labels = np.squeeze(mask.cpu().numpy())\n",
    "    pred = np.squeeze(pred.cpu().detach().numpy())\n",
    "\n",
    "    # feel free to try different thresholds\n",
    "    thresh = ...\n",
    "\n",
    "    # get boundary mask\n",
    "    semantic_segmentation = ...\n",
    "    pred_labels = ...\n",
    "    precision, recall, accuracy = evaluate(gt_labels, pred_labels)\n",
    "    precision_list.append(precision)\n",
    "    recall_list.append(recall)\n",
    "    accuracy_list.append(accuracy)\n",
    "\n",
    "print(f\"Mean Precision is {np.mean(precision_list):.3f}\")\n",
    "print(f\"Mean Recall is {np.mean(recall_list):.3f}\")\n",
    "print(f\"Mean Accuracy is {np.mean(accuracy_list):.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44f53870",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<h2> Checkpoint 3 </h2>\n",
    "If you reached an accuracy of about 0.4, that is good enough for this exercise. You could definitely get better results if you spend some time improving your training pipeline with any or all of: augmentations, a larger unet, more epochs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50022b97",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "<hr style=\"height:2px;\">\n",
    "\n",
    "## Section 4: Affinities"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78d0d678",
   "metadata": {},
   "source": [
    "<i>What are affinities? </i><br>\n",
    "Affinities are a generalization of the a topic that we briefly touched on while computing the signed distance transform.\n",
    "Remember how we created a binary mask defining the boundaries between objects?\n",
    "\n",
    "### 1D\n",
    "```\n",
    "a a a b b c c c\n",
    "  a a a b b c c c\n",
    "  1 1 0 1 0 1 1\n",
    "```\n",
    "and for visualization we can center the affinities:\n",
    "```\n",
    "a a a b b c c c\n",
    " 1 1 0 1 0 1 1\n",
    "```\n",
    "\n",
    "\n",
    "In this example we are shifting the labels by 1 pixel and comparing them to the original labels.\n",
    "We call this an affinity with offset 1. We can also compute affinities with different neighborhoods.\n",
    "For example: an offset of 2 might look like this:\n",
    "```\n",
    "a a a b b c c c\n",
    "    a a a b b c c c\n",
    "    1 0 0 0 0 1\n",
    "```\n",
    "And centering for visualization:\n",
    "```\n",
    "a a a b b c c c\n",
    "  1 0 0 0 0 1\n",
    "```\n",
    "Notice that we are just lengthening the boundary between the objects. Object b that is only 2 pixels wide no longer has any positive affinities :'(\n",
    "\n",
    "### 2D\n",
    "In 2D, we can compute affinities in the same way. We can compute affinities in the x and y directions, as well as diagonally.\n",
    "Consider the offset (1,1). I'll use \"-\" to represent some padding for easier visualization.\n",
    "```\n",
    "a a a b b -\n",
    "a a a b b -\n",
    "c c c b b -\n",
    "c c c b b -\n",
    "- - - - - -\n",
    "```\n",
    "```\n",
    "- - - - - -\n",
    "- a a a b b\n",
    "- a a a b b\n",
    "- c c c b b\n",
    "- c c c b b\n",
    "```\n",
    "```\n",
    "- - - - - -\n",
    "- 1 1 0 1 -\n",
    "- 0 0 0 1 -\n",
    "- 1 1 0 1 -\n",
    "- - - - - -\n",
    "```\n",
    "Now lets look at some real affinities. In the next image we have computed 2 different offsets for our affinities. The first set with offsets (0,1) and (1,0), and the second set with offsets (0,5) and (5,0).\n",
    "Note we call a collection of offsets our affinity \"neighborhood\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1ba25fb",
   "metadata": {},
   "source": [
    "![image](static/figure3/instance_affinity.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1bfb851",
   "metadata": {},
   "source": [
    "What do the colors mean in the affinities plots? We are displaying the affinities as RGB values. But we only have 2 offsets in our neighborhood, so those get assigned R and B. The G channel is faked by setting it to 0 only if both R and B are 0. This makes the background black, and pixels with both x and y affinity (inside our objects) show up white. The exceptions are at the boundaries where we now have either RG or BG (magenta and cyan) representing pixels that are on either the right or bottom boundaries of an object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d64f3af3",
   "metadata": {},
   "source": [
    "Note that the boundaries only show up the side of each object. This is because we usually don't bother centering the affinities. Half voxel shifts would add a lot of unnecessary complexity with unclear benefits to training."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e055346",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "source": [
    "The pros and cons of Affinities:\n",
    "- Pros:\n",
    "    - No limitations on shape or size. Blobby objects like nuclei, tiny objects only a pixel wide, and massive objects that could never fit in a field of view, all can be turned into affinities and back perfectly.\n",
    "    - Easy post-processing. We can do a simple watershed to get an initial segmentation. And then we can compute the average affinity between each pair of labels. This is very powerful for processing huge objects in small pieces.\n",
    "- Cons:\n",
    "    - Extreme class imbalance. The affinities are only 0 between objects and in background. This means networks can often learn to predict 1s everywhere and be mostly correct. Thus we always use some form of weighted loss when training affinities.\n",
    "    - Post processing can be sensitive to small errors. A naive agglomeration may merge fragments if a single high affinity edge is predicted between two separate objects, despite potentially thousands of low affinity edges contradicting this signal."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a09d6b75",
   "metadata": {},
   "source": [
    "Similar to the pipeline used for SDTs, we first need to modify the dataset to produce affinities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a1ca3be",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a new dataset for affinities\n",
    "from local import compute_affinities\n",
    "\n",
    "\n",
    "class AffinityDataset(Dataset):\n",
    "    \"\"\"A PyTorch dataset to load cell images and nuclei masks\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        root_dir,\n",
    "        transform=None,\n",
    "        img_transform=None,\n",
    "        return_mask=False,\n",
    "        weights: bool = False,\n",
    "        neighborhood=None,\n",
    "    ):\n",
    "        self.neighborhood = (\n",
    "            neighborhood\n",
    "            if neighborhood is not None\n",
    "            else [[0, 1], [1, 0], [0, 5], [5, 0]]\n",
    "        )\n",
    "        self.weights = weights\n",
    "        self.root_dir = root_dir  # the directory with all the training samples\n",
    "        self.num_samples = len(os.listdir(self.root_dir)) // 3  # list the samples\n",
    "        self.return_mask = return_mask\n",
    "        self.transform = (\n",
    "            transform  # transformations to apply to both inputs and targets\n",
    "        )\n",
    "        self.img_transform = img_transform  # transformations to apply to raw image only\n",
    "        #  transformations to apply just to inputs\n",
    "        inp_transforms = v2.Compose(\n",
    "            [\n",
    "                v2.Normalize([0.5], [0.5]),  # 0.5 = mean and 0.5 = variance\n",
    "            ]\n",
    "        )\n",
    "        self.from_np = v2.Lambda(lambda x: torch.from_numpy(x))\n",
    "\n",
    "        self.loaded_imgs = [None] * self.num_samples\n",
    "        self.loaded_masks = [None] * self.num_samples\n",
    "        for sample_ind in tqdm(range(self.num_samples)):\n",
    "            img_path = os.path.join(self.root_dir, f\"img_{sample_ind}.tif\")\n",
    "            image = self.from_np(tifffile.imread(img_path))\n",
    "            self.loaded_imgs[sample_ind] = inp_transforms(image)\n",
    "            mask_path = os.path.join(self.root_dir, f\"img_{sample_ind}_cyto_masks.tif\")\n",
    "            mask = self.from_np(tifffile.imread(mask_path))\n",
    "            self.loaded_masks[sample_ind] = mask\n",
    "\n",
    "    # get the total number of samples\n",
    "    def __len__(self):\n",
    "        return self.num_samples\n",
    "\n",
    "    # fetch the training sample given its index\n",
    "    def __getitem__(self, idx):\n",
    "        # We'll be using the Pillow library for reading files\n",
    "        # since many torchvision transforms operate on PIL images\n",
    "        image = self.loaded_imgs[idx]\n",
    "        mask = self.loaded_masks[idx]\n",
    "        if self.transform is not None:\n",
    "            # Note: using seeds to ensure the same random transform is applied to\n",
    "            # the image and mask\n",
    "            seed = torch.seed()\n",
    "            torch.manual_seed(seed)\n",
    "            image = self.transform(image)\n",
    "            torch.manual_seed(seed)\n",
    "            mask = self.transform(mask)\n",
    "        aff_mask = self.create_aff_target(mask)\n",
    "        if self.img_transform is not None:\n",
    "            image = self.img_transform(image)\n",
    "\n",
    "        if self.weights:\n",
    "            weight = torch.zeros_like(aff_mask)\n",
    "            for channel in range(weight.shape[0]):\n",
    "                weight[channel][aff_mask[channel] == 0] = np.clip(\n",
    "                    weight[channel].numel()\n",
    "                    / 2\n",
    "                    / (weight[channel].numel() - weight[channel].sum()),\n",
    "                    0.1,\n",
    "                    10.0,\n",
    "                )\n",
    "                weight[channel][aff_mask[channel] == 1] = np.clip(\n",
    "                    weight[channel].numel() / 2 / weight[channel].sum(), 0.1, 10.0\n",
    "                )\n",
    "\n",
    "            if self.return_mask is True:\n",
    "                return image, mask, aff_mask, weight\n",
    "            else:\n",
    "                return image, aff_mask, weight\n",
    "        else:\n",
    "            if self.return_mask is True:\n",
    "                return image, mask, aff_mask\n",
    "            else:\n",
    "                return image, aff_mask\n",
    "\n",
    "    def create_aff_target(self, mask):\n",
    "        aff_target_array = compute_affinities(\n",
    "            np.asarray(mask), self.neighborhood\n",
    "        )\n",
    "        aff_target = torch.from_numpy(aff_target_array)\n",
    "        return aff_target.float()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c116e4c6",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "Next we initialize the datasets and data loaders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87610b6f",
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [],
   "source": [
    "# Initialize the datasets\n",
    "\n",
    "# TODO: feel free to play around with the neighborhood parameter\n",
    "# The visualization code will break if you change the number of affinities, but feel free to change the magnitudes.\n",
    "# Training will break if you change the number of affinities. It is a simple fix, you will just need to change the number\n",
    "# of output channels the unet produces.\n",
    "\n",
    "neighborhood = [[0, 1], [1, 0], [0, 5], [5, 0]]\n",
    "train_data = AffinityDataset(\n",
    "    \"tissuenet_data/train\",\n",
    "    v2.RandomCrop(128),\n",
    "    weights=True,\n",
    "    neighborhood=neighborhood,\n",
    ")\n",
    "train_loader = DataLoader(\n",
    "    train_data, batch_size=5, shuffle=True, num_workers=NUM_THREADS\n",
    ")\n",
    "idx = np.random.randint(len(train_data))  # take a random sample\n",
    "img, affinity, weight = train_data[idx]  # get the image and the nuclei masks\n",
    "plot_two(img, affinity, label=\"Affinities\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "223b7900",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Task 4.1</b>: Train a model with affinities as targets.\n",
    "\n",
    "Repurpose the training loop which you used for the SDTs. <br>\n",
    "Think carefully about your final activation and number of out channels. <br>\n",
    "(The best for SDT is not necessarily the best for affinities.)\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bfcb023",
   "metadata": {
    "tags": [
     "task"
    ]
   },
   "outputs": [],
   "source": [
    "\n",
    "unet = ...\n",
    "learning_rate = ...\n",
    "# Note you will need to use `reduce=False` for whatever loss function you choose. The easiest choices will be `BCELoss` or `MSELoss`.\n",
    "# Normally for e.g. MSE loss you compute the squared error of each pixel, then reduce with the mean, and backpropogate.\n",
    "# However we want to weight each pixel separately, so we compute the loss per pixel, then multiply by that pixels weight, then reduce with the mean.\n",
    "# This provides a larger gradient for pixels that have a larger weight since they will contribute more the the final loss.\n",
    "loss = ...\n",
    "optimizer = ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7acd99e",
   "metadata": {
    "lines_to_next_cell": 0,
    "tags": [
     "task"
    ]
   },
   "outputs": [],
   "source": [
    "for epoch in range(NUM_EPOCHS):\n",
    "    train(\n",
    "        ...,\n",
    "        ...,\n",
    "        ...,\n",
    "        ...,\n",
    "        ...,\n",
    "        log_interval=2,\n",
    "        device=device,\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c82e6ac",
   "metadata": {},
   "source": [
    "Let's next look at a prediction on a random image.\n",
    "We will be using mutex watershed (see this paper by [Wolf et al.](https://arxiv.org/abs/1904.12654)) for post processing. I won't dive too much into the details, but it is similar to watershed except that it allows edges to have negative weights and for splits, removing the need for finding seed points.\n",
    "However this does mean we now need a bias term since if we give it all positive edges (our affinities are in range (0, 1)) everything will join into a single object. Thus our bias should be in range (-1, 0), such that we have some positive and some negative affinities.\n",
    "\n",
    "It can also be useful to bias long range affinities more negatively than the short range affinities. The intuition here being that boundaries are often blurry in biology. This means it may not be easy to tell if the neighboring pixel has crossed a boundary, but it is reasonably easy to tell if there is a boundary accross a 5 pixel gap. Similarly, identifying if two pixels belong to the same object is easier, the closer they are to each other. Providing a more negative bias to long range affinities means we bias towards splitting on low long range affinities, and merging on high short range affinities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9373d53e",
   "metadata": {},
   "outputs": [],
   "source": [
    "val_data = AffinityDataset(\"tissuenet_data/test\", v2.RandomCrop(128), return_mask=True)\n",
    "val_loader = DataLoader(val_data, batch_size=1, shuffle=False, num_workers=8)\n",
    "\n",
    "unet.eval()\n",
    "idx = np.random.randint(len(val_data))  # take a random sample\n",
    "image, gt, affs = val_data[idx]  # get the image and the nuclei masks\n",
    "image = image.to(device)\n",
    "pred = torch.squeeze(unet(torch.unsqueeze(image, dim=0)))\n",
    "image = image.cpu()\n",
    "affs = affs.cpu().numpy()\n",
    "pred = pred.cpu().detach().numpy()\n",
    "gt_labels = gt.cpu().numpy()\n",
    "\n",
    "bias_short = -0.9\n",
    "bias_long = -0.95\n",
    "\n",
    "pred_labels = mws.agglom(\n",
    "    np.array(\n",
    "        [\n",
    "            pred[0] + bias_short,\n",
    "            pred[1] + bias_short,\n",
    "            pred[2] + bias_long,\n",
    "            pred[3] + bias_long,\n",
    "        ]\n",
    "    ).astype(np.float64),\n",
    "    neighborhood,\n",
    ")\n",
    "\n",
    "# Mutex watershed often leads to many tiny fragments due to the fuzziness of our models predictions.\n",
    "# We can add a simple small object filter to get significantly higher accuracy.\n",
    "precision, recall, accuracy = evaluate(gt_labels, pred_labels)\n",
    "print(f\"Before filter: Precision: {precision:.3f}, Recall: {recall:.3f}, Accuracy: {accuracy:.3f}\")\n",
    "plot_four(image, affs, pred, pred_labels, label=\"Affinity\", cmap=label_cmap)\n",
    "pred_labels = remove_small_objects(\n",
    "    pred_labels.astype(np.int64), min_size=64, connectivity=1\n",
    ")\n",
    "precision, recall, accuracy = evaluate(gt_labels, pred_labels)\n",
    "print(f\"After filter: Precision: {precision:.3f}, Recall: {recall:.3f}, Accuracy: {accuracy:.3f}\")\n",
    "plot_four(image, affs, pred, pred_labels, label=\"Affinity\", cmap=label_cmap)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bf0ec01",
   "metadata": {},
   "source": [
    "Let's also evaluate the model performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74e22261",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "val_dataset = AffinityDataset(\"tissuenet_data/test\", return_mask=True)\n",
    "val_loader = DataLoader(\n",
    "    val_dataset, batch_size=1, shuffle=False, num_workers=NUM_THREADS\n",
    ")\n",
    "unet.eval()\n",
    "\n",
    "(\n",
    "    precision_list,\n",
    "    recall_list,\n",
    "    accuracy_list,\n",
    ") = (\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    ")\n",
    "for idx, (image, mask, _) in enumerate(tqdm(val_dataloader)):\n",
    "    image = image.to(device)\n",
    "\n",
    "    pred = unet(image)\n",
    "\n",
    "    image = np.squeeze(image.cpu())\n",
    "\n",
    "    gt_labels = np.squeeze(mask.cpu().numpy())\n",
    "\n",
    "    pred = np.squeeze(pred.cpu().detach().numpy())\n",
    "\n",
    "    pred_labels = mws.agglom(\n",
    "        np.array(\n",
    "            [\n",
    "                pred[0] + bias_short,\n",
    "                pred[1] + bias_short,\n",
    "                pred[2] + bias_long,\n",
    "                pred[3] + bias_long,\n",
    "            ]\n",
    "        ).astype(np.float64),\n",
    "        neighborhood,\n",
    "    )\n",
    "    pred_labels = remove_small_objects(\n",
    "        pred_labels.astype(np.int64), min_size=64, connectivity=1\n",
    "    )\n",
    "\n",
    "    precision, recall, accuracy = evaluate(gt_labels, pred_labels)\n",
    "    precision_list.append(precision)\n",
    "    recall_list.append(recall)\n",
    "    accuracy_list.append(accuracy)\n",
    "\n",
    "print(f\"Mean Precision is {np.mean(precision_list):.3f}\")\n",
    "print(f\"Mean Recall is {np.mean(recall_list):.3f}\")\n",
    "print(f\"Mean Accuracy is {np.mean(accuracy_list):.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ad1901f",
   "metadata": {},
   "source": [
    "<hr style=\"height:2px;\">\n",
    "\n",
    "## Bonus: Further reading on Affinities\n",
    "[Here](https://localshapedescriptors.github.io/) is a blog post describing the Local Shape Descriptor method of instance segmentation.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5118b6c7",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<h2> Checkpoint 4 </h2>\n",
    "You have now completed the exercise! If you achieved an accuracy of around 0.5, that is pretty decent. If you have time to spare you can try ot push the accuracy higher. I would recommend exploring augmentations (rotations work very nicely for this task), a larger unet, and more epochs, and potentially adjusting the learning rate."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c861567",
   "metadata": {
    "lines_to_next_cell": 0
   },
   "source": [
    "<hr style=\"height:2px;\">\n",
    "\n",
    "## Bonus: Pre-Trained Models\n",
    "Cellpose has an excellent pre-trained model for instance segmentation of cells and nuclei.\n",
    "<br> take a look at the full built-in models and try to apply one to the dataset used in this exercise.\n",
    "<br> -[cellpose github](https://github.com/MouseLand/cellpose)\n",
    "<br> -[cellpose documentation](https://cellpose.readthedocs.io/en/latest/)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f78a0cbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install cellpose.\n",
    "!pip install cellpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5313138",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "all",
   "main_language": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}