From 21d4846cf9ebaf95fa95f9958c192bb5addc0d13 Mon Sep 17 00:00:00 2001 From: mirjagranfors Date: Wed, 22 Apr 2026 10:59:47 +0200 Subject: [PATCH] Add example on phase mask optimization --- .../DTEx252_phase_mask_optimization.ipynb | 1596 +++++++++++++++++ 1 file changed, 1596 insertions(+) create mode 100644 tutorials/2-examples/DTEx252_phase_mask_optimization.ipynb diff --git a/tutorials/2-examples/DTEx252_phase_mask_optimization.ipynb b/tutorials/2-examples/DTEx252_phase_mask_optimization.ipynb new file mode 100644 index 000000000..165c05735 --- /dev/null +++ b/tutorials/2-examples/DTEx252_phase_mask_optimization.ipynb @@ -0,0 +1,1596 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5e65db32", + "metadata": {}, + "source": [ + "# Particle Localization and Phase Mask Optimization" + ] + }, + { + "cell_type": "markdown", + "id": "d4aa8b6b", + "metadata": {}, + "source": [ + "This tutorial demonstrates how to jointly optimize an optical phase mask and a neural network to improve the localization of closely spaced particles in microscopy images.\n", + "\n", + "The phase mask, inserted in the optical pupil plane, shapes the microscope’s point spread function (PSF). Simultaneously, a convolutional neural network (CNN) is trained to reconstruct the 3D particle positions from simulated images. Through backpropagation, gradients flow not only through the network but also through the optical model. As a result, the optical system learns to produce images that are easier for the CNN to interpret, leading to improved localization accuracy." + ] + }, + { + "cell_type": "markdown", + "id": "82dfa30b", + "metadata": {}, + "source": [ + "# 1. Create a simulation pipeline\n", + "The first step is to define a simulation pipeline that generates synthetic data consisting of fluorescent particles imaged through a fluorescence microscope. For each simulated image, the pipeline also provides the true 3D positions of the particles, which serve as the ground truth during training." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "89d98126", + "metadata": {}, + "outputs": [], + "source": [ + "import deeptrack as dt" + ] + }, + { + "cell_type": "markdown", + "id": "8a7638e5", + "metadata": {}, + "source": [ + "## 1.1 Set the backend\n", + "DeepTrack supports both NumPy and PyTorch backends. In this tutorial, the PyTorch backend is selected to enable backpropagation through the optical setup. Enabling CUDA (optional) allows the computations to run on the GPU, which accelerates both simulation and training." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1c8abc46", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch cuda\n" + ] + } + ], + "source": [ + "from deeptrack.backend import config\n", + "\n", + "config.set_backend(\"torch\")\n", + "config.set_device(\"cuda\")\n", + "\n", + "device = config.get_device()\n", + "\n", + "print(config.get_backend(), config.get_device())" + ] + }, + { + "cell_type": "markdown", + "id": "568fe6fb", + "metadata": {}, + "source": [ + "## 1.2 Define the trainable phase mask\n", + "A phase mask modifies the wavefront of light in the microscope pupil plane, shaping the resulting point spread function (PSF). By making the phase mask trainable, we allow the optical system itself to learn — optimizing its design through gradient descent to improve particle localization performance.\n", + "\n", + "The LearnablePhaseMask class inherits from both `nn.Module` and `dt.Aberration`. `nn.Module` makes the phase mask compatible with PyTorch’s autograd and optimizer system, allowing the phase mask parameters to be learned, while `dt.Aberration` ensures the class integrates seamlessly into DeepTrack’s feature graph, making it compatible with the rest of the optical pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3470f1bf", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "\n", + "\n", + "class LearnablePhaseMask(nn.Module, dt.Aberration):\n", + " \"\"\"Applies a learnable phase mask to the pupil function.\"\"\"\n", + "\n", + " def __init__(self, shape=(144, 144), **kwargs):\n", + " dt.Aberration.__init__(self, **kwargs)\n", + " super().__init__(**kwargs)\n", + "\n", + " # Trainable phase mask parameter\n", + " self.phase = nn.Parameter(torch.zeros(shape, dtype=torch.float32))\n", + "\n", + " def forward(self, pupil: torch.Tensor, **kwargs) -> torch.Tensor:\n", + " \"\"\"PyTorch forward pass for use in training\"\"\"\n", + " return self.apply_phase(pupil)\n", + "\n", + " def get(self, pupil: torch.Tensor, **kwargs) -> torch.Tensor:\n", + " \"\"\"DeepTrack Feature graph call\"\"\"\n", + " return self.apply_phase(pupil)\n", + "\n", + " def apply_phase(self, pupil: torch.Tensor) -> torch.Tensor:\n", + " \"\"\"Shared implementation of phase modulation\"\"\"\n", + " phase = self.phase.to(device)\n", + " phase_mask = torch.cos(phase) + 1j * torch.sin(phase)\n", + " return pupil * phase_mask" + ] + }, + { + "cell_type": "markdown", + "id": "e8a1553c", + "metadata": {}, + "source": [ + "## 1.3 Define the optical setup\n", + "The optical setup is simulated using `dt.Fluorescence`, incorporating the trainable phase mask as the pupil function." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6d1f7321", + "metadata": {}, + "outputs": [], + "source": [ + "image_size = 121\n", + "depth = 30 # Number of axial slices (z-planes)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "44058db9", + "metadata": {}, + "outputs": [], + "source": [ + "phase_mask = LearnablePhaseMask()\n", + "\n", + "optics = dt.Fluorescence(\n", + " NA=1.45,\n", + " refractive_index_medium=1.33,\n", + " output_region=(0, 0, image_size, image_size),\n", + " pupil=phase_mask,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8fe88c92", + "metadata": {}, + "source": [ + "## 1.4 Simulate particles\n", + "A simulation pipeline is defined to generate images of randomly positioned 3D particles, together with their corresponding ground-truth localization targets.\n", + "\n", + "A custom DeepTrack feature, `Positions`, creates a binary 3D mask containing randomly placed particles. Each voxel corresponding to a particle is assigned a value of 1, while background voxels remain 0. The true particle coordinates are stored in self.points for later retrieval." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9eecebff", + "metadata": {}, + "outputs": [], + "source": [ + "class Positions(dt.Feature):\n", + " def get(self, image, num_points, **kwargs):\n", + " mask = torch.zeros(\n", + " (image.shape[0], image.shape[1], image.shape[2]), dtype=float\n", + " )\n", + "\n", + " points = torch.rand(size=(num_points, 3)) * torch.tensor(image.shape)\n", + "\n", + " for i in range(len(points)):\n", + " mask[\n", + " torch.round(points[i, 0]).long().clamp(0, image.shape[0] - 1),\n", + " torch.round(points[i, 1]).long().clamp(0, image.shape[1] - 1),\n", + " torch.round(points[i, 2]).long().clamp(0, image.shape[2] - 1),\n", + " ] = 1\n", + "\n", + " self.points = points\n", + "\n", + " return mask + image" + ] + }, + { + "cell_type": "markdown", + "id": "38c4a606", + "metadata": {}, + "source": [ + "The number of points for each sample is randomized between 25 and 50 to provide diverse training examples." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "544624c6", + "metadata": {}, + "outputs": [], + "source": [ + "num_points = lambda: int(torch.randint(low=25, high=50, size=(1,)))\n", + "xyz = Positions(num_points=num_points)" + ] + }, + { + "cell_type": "markdown", + "id": "446fee06", + "metadata": {}, + "source": [ + "To make the training data physically plausible, a combination of Poisson noise and Gaussian noise is added.\n", + "\n", + "Since true Poisson noise is not differentiable, a Gaussian approximation that preserves differentiability during backpropagation is used." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7d339aaf", + "metadata": {}, + "outputs": [], + "source": [ + "class poisson_noise_approx(dt.Noise):\n", + " def __init__(self, **kwargs):\n", + " super().__init__(**kwargs)\n", + "\n", + " def get(self, image, noise_scale=1e-2, **kwargs):\n", + "\n", + " image = torch.clamp(image, min=0.0)\n", + "\n", + " # Gaussian approximation of Poisson noise\n", + " noise = torch.sqrt(image) * torch.randn_like(image, device=self.device)\n", + " noisy_image = image + noise * noise_scale\n", + "\n", + " return noisy_image" + ] + }, + { + "cell_type": "markdown", + "id": "9ac539dc", + "metadata": {}, + "source": [ + "Next, the components, including the particle positions, the optics, and the noise, are combined to form the simulation pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3cb3b33f", + "metadata": {}, + "outputs": [], + "source": [ + "i = -1\n", + "\n", + "\n", + "def next_position():\n", + " global i\n", + " gt_pip.resolve()\n", + " i = (i + 1) % len(xyz.points)\n", + " return xyz.points[i]\n", + "\n", + "\n", + "particle = dt.PointParticle(position=next_position, intensity=100)\n", + "\n", + "gt_pip = (\n", + " dt.Value(torch.zeros((image_size, image_size, depth), dtype=float)) >> xyz\n", + ")\n", + "\n", + "noise_gaussian = dt.Gaussian(\n", + " mu=0, sigma=lambda: torch.rand(size=(1,), device=device) * 1e-4\n", + ")\n", + "noise_poisson = poisson_noise_approx(\n", + " noise_scale=lambda: torch.rand(size=(1,), device=device) * 1e-2\n", + ")\n", + "\n", + "im_pip = optics(particle ^ num_points) >> noise_poisson >> noise_gaussian\n", + "\n", + "pip = (im_pip & gt_pip) >> dt.MoveAxis(2, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2f78ddd7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqQAAAFJCAYAAABNdD9oAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZJRJREFUeJztvQuYX0V9///Z+252s5v7DRKIiAUUEbkZQcGSGpQfhYIXKP2LSKUqqBBUzPMULNYaS1v0wSK0PhZsy0WgBIQqlAYIIiFAuMktgAYSEpKQ225ue/vu9//MgdnODjNzZs6Zc3+/nufsd7/nMmfO5TvzPp/5fD6noV6v1wkAAAAAAICMaMxqxwAAAAAAADAgSAEAAAAAQKZAkAIAAAAAgEyBIAUAAAAAAJkCQQoAAAAAADIFghQAAAAAAGQKBCkAAAAAAMgUCFIAAAAAAJApEKQAAAAAACBTIEgBAAAAAEA1BelVV11F++67L7W3t9NRRx1Fjz76aFZVAQCAwoK2FABQBhqyeJf9L37xC/rc5z5H11xzTSBGf/SjH9Ett9xCq1atomnTpoVuPzIyQuvXr6fx48dTQ0NDKnUGAFQL1jTu2LGDZs2aRY2N+RxMitOWoh0FAOSqHa1nwJFHHlk/77zzRr/XarX6rFmz6osXL7bafu3atUxEY8I5wD2AeyDxe4C1N3klTluKdhTtB9oP3AOUo3a0mVJmcHCQVq5cSYsWLRqdx1Tz/Pnzafny5cptBgYGgoljY9QVLafsf5Ullc9n++fL5fXk+Xzfch3Ydz6PWR7E77r1bI8FgLiE3d+6+1G+7+VlLS0twe+HfTY3Nwf3/vDwcPDJfuu67cT9sUlVP91vQ/cblOeFHZsOvh07BgYbickjrm2prh09hj5JzdSSUq0BAGrq1NxWp+aWOtWGG2hooIGoXvwR4GEaoofoV1btaOqCdPPmzVSr1Wj69Olj5rPvL774onKbxYsX02WXXaZcFtbBmjpiLkZlMzJfJopVsWPmE++w2CdbLgtNnSjV1ddmfd1x8u1NZYNyY3JfMT2URS2T/3aamppGJ7Y+/12wZfz/sDJ19ZPh4lUUsfKyKMeiWofXP69uQa5tqa4dZWK0uQGCFIAsaW4ZoY+etJ0OPXonvfBEJy39r4k0sCefrkJOvC09bNrRQhwtswD09vaOTmvXrrXaThSWqmWiZVReX+5o5Yl3xmL54qdu37p5YdvJiILXZEmCEAVh91Gc5fI9a3sP6+5d23s/bJ7Lg534+yvz7yVqOwoASJ7GJqIDP7ibPv7ZrXTwh3ZSS+s7H+bLTuoW0ilTpgSCbuPGjWPms+8zZsxQbtPW1hZMaSFaflQWUgazTPDvpiHEKJ0px6WDNK1X5k4WRCPMmiivq0O0hvLv7LfB3VZkZPEn3uMmq7+NJdc0XB+GbiQlz7i2pWm3owAAe0ZqRM891hkM2a96chwNDRbCXuiV1I+4tbWVDjvsMFq6dOnoPNZ5se/z5s1LpQ4mKwybzxp55g/HJu4bp/ouDlOqyvdhcSlSBwnyjfzgFPfe5G4rTIAyf0bmn8g+mQ8pF6Uipt+c7YiAiar9VvLQlgIA/DA81EAP/aqH/uVvZr09XF+t9iwTCylj4cKFdNZZZ9Hhhx9ORx55ZJCqZNeuXXT22WfHKjfMr1I3VM4tNbbDjuKwPu90df6aOlHqIlZt1w0LQNEtA9XBdP1N95lO7IniVgzmi+MLbVpPtqq6HIOp/q71yQtJtaUAgLRpoOFBNlX3zGciSD/72c/Sm2++SZdeeilt2LCBPvCBD9Ddd9/9Duf8NIclGaLvKLOAmiw3fIiSW1RZZ8w7ZNE6qurwokTZl92/DWSLyY/S9BuSA/t8WV51+1cN9cv4CuYrwu8trbYUAABKmRg/Ln19fdTT06PsrGRUy1XR9VyIsmXMzypMkMrDlaIg5cvZxH1N+Tzxf1PqqDAKeNlAwkSJMJdHAlwCjcJSOonfdVHxqn2E/Q5cH+ji/FbYb5oFAHV3d1PZ4O3ocXRyKlH2jY11au1gDy5Eg/2NQWqb2GU21am13W+ZAAB/DNeH6AG6w6odzcRCmmeiBEP49BkFIG1sA4fiYBKjuvpEXVa0YfeqMG3vQfrEn2+lzp4aLb11Ir2wsjN2mTPmDNIJZ2yhjs4R+t9bJ9KqJ+OXCQDIhuqFcVlgE2TB17NBZ/GxSQkFQNg9GOe+UVkbXfw6df7WsrXTNU2ZaTvd6IKqnLD6m8DDpV96Jg3TvBN66WOnbAuEpA8mTB6moz/RS8edvN1bmQCAbCiNhdSlQxY7NlXHyYfi5Tylchl8mF5+M5OqI1X51/kKzADVxdZP2rSeapnO19lHqqg46H4/UX4z+I2ly/YtLfTgnROoc3yN1q9u9VLmtjebadkdE6m9s0ZvvIqUVgAUmdIIUlfEwAhRLHIxqvM9FbfnqW24IOUBHqKwFeclEVkPgOs9b7tMdQ+aslb4IMyCaiIspynIlk3rWujmq6YF/p5Dg36uz4a1rXTTP/stEwCQDaUQpHGGK3XBGmI6J5WYtLGOqsoVP8PqHze9ja9oY5BvXKLio4jSpOsVdehc5ZeqC2zE/Z899ZEGGuxvyH2ZAIBsKIUg9YUYGc8+2ZC9bHHh39k6LAE4F68qH7aowRkiPnMuAmBzP8r+oC73mMt9bVpm+7AVlmXD9GAIAAAgP1RWkKqG9kRLqGghldcRRahsIY1TF47N0GmUclVA1AJ+r8Qd5jbdb2ECUvUbiCJKbdxycM8DAED+qKwgZYgBR7IYNXVysn+obj1GFEuTD3EQBnzsqovN0Ly4js2Qui7tmfhA5zNzhSqzgKvri2oexCoAAGRDaQSpjb+aKBJFAaoSpQx5KJ6XIQcvycvjRv+qQEcJbO9vGxFqCv5RWRbDfk9JpKRy8Tk1zVMJ8LDAKVVWDAAAAMlRCkHq0hGrtjMNF8odk0mMiturylMJYACi4BqA5BLIpFpua7WXh+RFQRvVnzPs92tzHGJZNr8//DYBACBdSiFIwwizBokikSOKRzmKXvzUYfIDFYOlTJYaDKsD2/sry8h91Xo6y2iYZVK1P7Es1W9SVYZJrPP/+e8Q4hMAALKnEoKUI1tGVEN6quF2lSCV/7fZtwqTpUYnkuXtfdYHFAOd/2PYMr5c9T3MUhq2D9d664bRRStmFOGNBzngg6bmevC60/E9Ndr6ZjNtfqOFqI4UUwAkRaUEqcnyKIpOZjmR1xWH6mXCLK/yunwylQlAUrgKNvlBLuyhSH7QU/li2+xPV76qDuJ6pvVN6wAg0tFZoz89ezN98CM76H9+MYlu/9lUqg3jHAGQFJUTpCp0QUiyRVLVGer860yWVNmvTtfZ+7T0IEij2oQFIPF1bCLqTfNsg4fClrnWwTXCXrWNzTkC1YHZJbonDtOUmUPU2c3e3sfuD9wbACRFJQWpTaCTuJ5uyJ4v4xZVvlznl6brSG0jfgHIS7BU2L3p4tpiGkUwLXdxdTGlaIsTcAXKy57djXT3jZPpiQfH02ur2qlWQzsMQJJUUpDaoApiMvme2gZcqDryrCPus94/8IPK71J3H6qsgzo/atV+VNvp6hRWZxmV76iqTiofb1OqJ5v6iuvgd5EX5HskHWE4NNBIv1velcq+AAAVF6QuFkiXTljVsXI/urAOMyvQ+RYfl/vJ9v5zuU+jBiDZiFbZv1te7rI/1b7z+rsERBOnDtMhR++ktvYR+t2KLlq/ug2nBYAS8s7WvSLIAlM3LK/6btpetuQ0NTUFE+tI0dGBImIj+FTBQraIQ/RRAq5slsllh6WnAvmBRbp/5rxN9LlvbqB3v29P1tUBACRE6S2kpoAG1TCgHGSkKyssUl/13bWOAOiIM0wed4TAdlvbwD7ZTztqgJWN72sYiL7PHwN7GmndH9qod0sz7eqrrA0FACUNjXWattcQTZg8RL3bmmnT6600EtHfua1jhGbMGaDWtjptWtca/ObSpPSCVIfK/1NE5Rsqb88/VdZPkzjVWWUgTEFRhvtV8+SsEab7me+Pjx4wl5ZarWZdH5X1M+z3jCDBYrL+1Tb6t8UzqampTls3tWRdHQByRUtrneZ/aisde/J2euSebrrxyum0Z1dTpLKmzhqkz31jYzAqcfNV0+g3d/WkmlmitII0CXGnirCXA0FsU0XZ1NfnUKLt0CYoJ0mm/VKJUZc68f/l9Ge2ftquxwQ/0WIx2N9Ib7wKv1EAVLBWkqUlmzx9iLp6WHoyivUyiJ7JwzRp+lBgLU2b0grSpFEFKJk6UJMItbEkAZAUPiyHsih12Y5NrsnzVQ9+KkGM/LsAgDIzNNRAy345gV55toM2vNZGgwPR2/EtG1oCy2hHV41efmZc6nl3Ky1ITZ2ni++nznctzMfNdj+29QDlx9bNRCaKFTGsTL5e3Ah1nRgNK0+2qKq20R03rKQAgDIwUmugVU92BlNcdvY206NLuykrKu8hHjVljIhs4VF15jofU52vnW3HDjFaTdK67kkF5fHfDJ90v4W4x6kbuVDNx2gEAABkR6UtpByVVUXVWemsOCZriyka3zbwA4AkcbGCupZrslCKn7Z1cqmLToiqPnXb4YEPAADSAYJUQxRfONsO1TYdVNg+QPXI6h4wWS59J9gPW9+UTsqmTrZuD3ggBACA9IAgNRAlF6LO986mE+UgJRTIMzZpn1Truzy0yevwNzRFDQRU1S3OwyEAAAC/VEqQmnw1dctcOitd6ifT/nX1sV0/KhiWrCam6x73fpOj3H2MMLgGHrpmupDrDgAAIBsqJUhVhHV4tr6k8nZRQIcIssBVjEXNNRr14S5OOabyYR0FAID8UIko+zgCMk4EvAuuUfXoTIHp/gi7f8Lmi28/0v0GVMtV96XqTUouRA2ocikHD4MAAJAtlbCQxu1sTJZSH4m3Xa1TAJjuD9+ZG8K2Mfk8u0TE24hlmyAk8VNVD1UZJt9XAAAAyVMJQeoDnShVrWcDhCUoK1EFsa2AFNdXDenbCGidFRcAAEA2VEqQmqyZNhadsHyjthbTOH5xsNoA3b2TRBJ71/ROqu3jjAC41tc2BRVcXpKlsalOM2YPBu/F3vZmM218vZXqIxD8AICK+5D6xNSRib5yuomlr4E1BhSRKGI2Ts5dcarVasEkvtlJVaewl07Y+ItDsManrWOEPnHmFlp4xVo6/rRt1NIC9wcAQIUtpKq8g7Z5ReO+vcbn8J9Pq6gPn1dQnGFxm/VEIRZ2f0RNjxQlgb1qO7mOLimh4i4D9rDL0tldo4lTh2hc1wgRjKMAgCoLUhufzzhEybdoKgeArEkiH6dv4ajK9xuWA9h2n8APg/0NdO/Nk+iZ5V20bnUbDQ9BkQIAUh6yX7x4MR1xxBE0fvx4mjZtGp1yyim0atWqMev09/fTeeedR5MnT6auri467bTTaOPGjZQGLr6aYcONqiG+KJO8T933MEyuAGKKHnTI5UcUaK4C05TqLOz+MpWpu7/Dfhcu9Q37vRYlmCnv7WgYw0ON9MLKTnrg9on08tPjaKSWv3MMACi5IF22bFnQSD7yyCN077330tDQEH384x+nXbt2ja5z4YUX0p133km33HJLsP769evp1FNPpTTw2fn47sjy2jmC4pGE1d4kRouAyqfbtCzL48p7OwoAAL5pqCdsLnvzzTeDJ3zWYH70ox+l3t5emjp1Kt1www30qU99KljnxRdfpAMPPJCWL19OH/rQh95RxsDAQDBx+vr6aPbs2W8dgEd/Nh1ZdUxR62kSE7COlh/bdGRRM0KY9mdzf0W9F02pnVwT4dvA6seEIGuzuru7KUuSbEePo5OpuaEl1eMBAFSD4foQPUB3WLWjiUfZs0owJk2aFHyuXLkyaOTnz58/us4BBxxAc+bMCRpS3fBVT0/P6MTFqCvykJ2tJSTqUGJU4kYmg2riatXzdb/Ivw3XQCWbHKOm/1XiVLWO7fnJg4U0z+0oAAAkQaKClKVnueCCC+joo4+m973vfcG8DRs2UGtrK02YMGHMutOnTw+WqVi0aFHQIPNp7dq1SVYbABARnRDUrWuzjmpdnUXUpUzXZVmBdhQAUAUSjbJnPlDPPvssPfTQQ7HKaWtrCybfRLUO2abcSWLfpv2oAjaibBenDr7KBulFy7tex7DgpajD52Hr2AjMsLrZ1iVP5L0dBQCAXFtIzz//fLrrrrvo/vvvp7333nt0/owZM2hwcJC2b98+Zn0WHcqWAQDik5XoirrfMMtn1H3rovvzFsSkA+0oAKAqeBekrLFnjeiSJUvovvvuo7lz545Zfthhh1FLSwstXbp0dB5LZ7JmzRqaN28eJYnN8GFcXFM9+dyPr841zx00iHdvmNbPC1HuY3k90zGFRdfngTy3owAAUIgheza8xCI/77jjjiCHHvcLZU70HR0dwec555xDCxcuDBz0WdTVV7/61aARVUWGAgCqnTyf4fIgGZayysZfNWuBjnYUAFA1vKd90jX21157LX3+858fTeh80UUX0Y033hikIVmwYAH95Cc/sR6yZ+lKmLA17c9EWdMiRRUJJt/TuP6yRT6fRSNu2i/X+8c0vG7jz+xapm79sPtVjrq33Tcra8+ePZmkfUqzHUXaJwBAHtI+JZ6HNAlsBKlLYm/d+kUDgrTa2AhSkaii0bS+yboYtXyTSBXFpu5NTPJ6tvtiZe3evTsXeUiTAIIUAJAnQVrqd9kDANInjSFvmwAo1+F8WbyW4SEVAACKQmkEqU3nEdcilBZJDK/K2Ha2qg7dZd9lt0rnCdvUTKZ15Otrut6q/el+Y7bX2ub+skk7ZXvf5bUNAACAqlEKQQphkx7owPNP3AwLUcrSCUkbgRi2P1lAqkSzvJ5cFksurypLLEPeHu0KAACkRykEqQoby4yNhSfqflX7sh0GtLGMuvjI2lo1dcObKhEQB51IgQDwgykBvHgdw6yfrtfbJPZcxafr7yhs9EMWnLp9i+twEQsAACB5SitI80aWPmlRhaRNqhyf9YHfnl9UotL2mvpyCbEZOvd93W39Rpuamt6xnmhtxQMSAACkR+kFKUQOANnhIkx9oLOMyvVobGwMJnkd3y+wAAAAUHFB6pqL0Vfnk0QnZpsXNGqZaZThGkRV1lyxeRSEadbD9SEyzIprM8Sv2o5NsiBlQ/RJ/NYAAKBqTJw6RDPmDNIQS/u0suKCFABQTFwi7VUjIPKDi+w7yq2jbMhe3r5Wq40Rp/AjBQAAV+p08LyddPpXN9HQyBBd8/GKCFIXK0YSAUtJBUHZ7sN1KNRH8vM0zl0S57rK5MVSmkUqK9VybiUVg+vE/KNw9QEAADsam+rU0TkSfPbvbqShgQZqaa3T+J4aDYzULEspgSAFAFQDUSjK/+uG8E0R/txCytfl1lHG8PBwSkcFAADFZuqsQTrp81uCYfr/+cUkevq34+m5Rzvp6kv3CobsiV62KgeC1AEbC12YhcZ3rkNfr2mUt03SGimnfQpLzQVrld9zz5AtgWlbTuV92vpuymmrTGXq8pPy/cm+pOyzaBZkAMy8fe+z23r0Z4B7HPilq6dGh35kB83aZ5CeebiLniaiDWvagom9OtQWCNIUSWvIOe2ApSTLNvkKguiI4i0LEZZkyimxHPmBhn8yayizgjIRahKuABSZ9s4R+uBHdtL02YP04hPjggm3OfDN9s3NdN9/TaTuSTV6dVV75HIgSEEuousBiIrpYUVexv9nwUpckPJ8pGIAEx6AQBno7BqhP/nMVjrs2B30i3+eRqueGkd1e5c+AKzYurGF7vi3KYHxfWQ4ukEBgtQzeUr7FPamHpv1XZaHbWPjXgABW018uZ6EvX2Kw8Qnm2Sx6hpEBUCeGR5qoHV/aAuGVDe/0QLrKEiEer0huNfiAkFaMeKKSl/7hvAEafqniu+ylxPfcx9S3JugbOzobaLbfjqV2jtGaMf2Jqrjbbggx0CQFgDXpPIu5M0KZJMYnwNRm14qKJfAJ5/D3VEDrsJeS6rKNZq33wIAcRmpNQTDqQAUAQjSCpPEEL3rvm19/0C2uIjRpFG9ClSVxF5cpgpeEtNHqeqP+w8AANIDgrRE6N5Yk7RwSCqJPURp8ZLm27zsIOqLHnT7Md1/ciYBVRoxCE8AAMgeCFIQ+403uuU26XQgOoFvVMP8Ng9NKvEKAAAgHSBIwRhsX88ov3YxzH8PohQkje5+M70aVGUdhi8pAACkDwRpwUnT5830HnCxDvLwqLxcV7YukAl+pumQdMojm/tTVYew+0gWk2FvcFK9YlT+X/UdAABAckCQFhxdFLLvzpQHhtgM1cv/q1LtuO4borR62PqJylHyovVT50saZt0HAACQLhCkBSfp4CR5vuvQpu7d6br9RF2m2y/wT9RUTHH3aRoVUFk35cClKEn2AQAApAMEaUUxpbuRMfmLyuuorKAqqyosnsUlb0PZpvtN9yYmm7c5QZACAEB6QJBWMCDJtcywICbVMrnjlwUwOvv8kTehafJN1lnNwyylYnk2+wQAAJAOEKQgMsynlPuVNjU1jSYnFyd06sAXpocakzB1TePE95NngQ4AAGUDghSEouqceZBTS0tL8Nnc3Bx8Dg8PBxMTo0NDQ07R0ACEYfIFDXvdrEqYqoQshCgAAKQPBGnBsXnne1RshuiZZVQUpHKdZOGZlhBFoJM7ttcla8FmK0ptXtpguh/xwATSpLllhPbeb4DGT6jRm+tbaMPaVqI6rPSgOrylIAAwoLOOMjHKLKStra3U3t5OHR0d1NbWFnznAjWNLACgepjEIlsW5joiW051owAApEVn9widfM5mWvhPa+mYT/bS28/3AFQGWEhBLMTO3CZPaVhZYdYvXSCLjTXLVCdYw4pHWCqnsMC6sLJxT4A0aWioU2vbCLV3jlBzK7tXcf5BtYAgrSiunbMcTMKnWq0WfDIxyv1G2Tw+35UwcZn024RA+USpuA7uGZBXdu1oojuvm0IP/fcEWre6jUZqWdcIgHSBIC04UTtY26T2JmslHxplcAEqD5FGtTKprFtJAp/T8PORBmFpnHTbhK0X9lIGm7oAkCRDA4304hOdOMmgskCQAiOisJTFIROhzCLK0z3xKHs2X+e7F9bJ64ZKVcFRoPzI912YOwcAAIBiAkEKQlF19uJwPVvGhCgXpmHvrY/jnwfRUV1sraCm5QAAAPIJBGnBUVkNfVqLZAupLoUTE6Liq0N1b8dJKk2V7dBunFeqVknQmI41q/fY+xq+d90vAACA5Ek8scQPfvCDoIO44IILRuf19/fTeeedR5MnT6auri467bTTaOPGjUlXpTJE6ZBNna9o9VRtx5Yza6k4XO/DOpqFNVQnRkFxCLPQFxG0owCAspOoIH3sscfoX/7lX+j973//mPkXXngh3XnnnXTLLbfQsmXLaP369XTqqacmWRXwNnE6anlb3feoYlS0hKlcBLJGl68S+D/HvhDvyaIKVbSjAIAqkJgg3blzJ5155pn005/+lCZOnDg6v7e3l372s5/RFVdcQX/8x39Mhx12GF177bX08MMP0yOPPJJUdYCEztqpgltBxc8wxM7f9F57iDuQFGHuI0UA7SgAoCokJkjZkPyJJ55I8+fPHzN/5cqVQWS2OP+AAw6gOXPm0PLly5VlDQwMUF9f35ipqohWOnlyLSeOP6mtpVQnCnR1LopQiHPu83bfuE5JIN8rvvdr8mk2TVmDdhQAUBUSCWq66aab6IknngiGmmQ2bNgQvFpywoQJY+ZPnz49WKZi8eLFdNlllyVRVeCALoVTWOCPTU5SU+CKL2HgmocSgCxBOwoAqBLeLaRr166lr3/963T99dcH7zf3waJFi4Khfj6xfYBksMkTKr8nXH5nuLyOT2tTXItZEayZAKAdBQBUDe8WUjYkv2nTJvrgBz84Oo9FXj/44IP0z//8z3TPPffQ4OAgbd++fYyVlEXZz5gxQ1lmW1tbMAF/6XjiJhlXJcqPio3l1CfcUlpWi2nUV8L6Xt8nUfdd1AcQtKMAgKrhXZAef/zx9Lvf/W7MvLPPPjvwE7344otp9uzZ1NLSQkuXLg3SPTFWrVpFa9asoXnz5vmuDkhYlIqEra8a2o8T8R+HogoVn6Thd+yLKolRBtpRAEDV8C5Ix48fT+973/vGzOvs7AxyjvL555xzDi1cuJAmTZpE3d3d9NWvfjUQox/60Id8VwfEQCVKoyaKj+obKu8vihCNsh9X0k6gX2SxVYXjiQvaUQBA1cjkTU0//OEPg/eeMwspi6BfsGAB/eQnP8miKiAEk6XUdbjX9D2qoEtiGLmsQ/mgXKAdBQCUiYZ6AXtelvapp6eHqoxJwCUxFKtaJ6oQDKuvaAn1YXl0tZDG3Z/N9q7+t7r1YVlMDn6uWSAlG8kpG7wdPY5OpuaGlqyrAwAoIcP1IXqA7rBqRxN/dShIlrSeJ1TD5a5D6Lp8pHHK9EUBn8sKXW8AAAAg8yF7UFx8CqC8WfeyjCIHAAAAqgwEaUXRpT7yIciiCrukrH0qK6xNHeKmtYp7LtMOlEoCiHwAkmH8hGGas38/sWZizcvt1LcN3TkoNhiyrzBJvRXJJQ9mnl7TCPwDizMAyTDnPf30l5e8Qed+Zz3NPWgPTjMoPHikKji+AoviRNb7toIlbRl0FeK+XgBgW5ckt3MFFk4A3GhorFPn+Bq1tNapf3cj7dnF7D7+f6+NjUQtLXVqbK5TIzyNQAmAIAWxhQisYOUF1xYAN8Z1jdD/O2sLHXDobnroVz10320TaaTm/yyyYfqffX9mMGS/+kU/r+kGIEsgSAuILk+mb/GgEqW6eUnsP01srKZZ+nQW+dwCUCVaWkdo//fvpiOP76PXXmqnxsY6jdT8/357tzTTk78Z771cALICgrRgpClMwl4rmoQowxAxAKDIsGH6h/57Aq15qZ2eXdGZiBgFoIxAkAIlru+xD1ue1PB/3HoCAIBvQbrsjgnU0Eg0MkJUH8H5BcAGCNKCUZT3pIsW1DjlhW3rEtFvWiYGLkWpbx5SNJks1xjyByAtGgIhShCiADgBQQq84PPVojb7crW4jgQ9RLj11qVcnfBMyp3Bpk4AAABAEUEe0pIjCiNbkSTnBw3LE+oihOLmHY2TJolv6yI6TZZPvjxPLwGIsj/VPZKVlTfq+bTB1s0Ebh4AAJA+EKQlJ4r1T0fcjlq3fVi5ovAzCRYbocu2bWxsTCR/a56tmab9qe6RMlpbbd0/ynjsAACQdzBkXyJ8WTHTxkYsuQQvmYbS5f+jCEwbP9Oshu35vqNY/cTXyWYFrJMAAFBNYCEFubXW+rZYlSnYJynhVtTzAQAAoNjAQgpSJWpaJ9+v79Ql9y8KEI4AAADKBARpRUgrL6iuDBvBZ5MmSizHZHF1GaIOq2OcQCrRrzXsRQOmZS7XL4uAKQhkAAAAccCQPUiUqHlCVcFLLqLWtFwWtUmLqbB9RF2WF4pQRwAAAPkGFlJgxCW5vek99zb7UBE1pVIeEtXnEVfLKsQmAACANIAgBd7wNbxvCmaK8uYmG5eBLKPiAQAAgKoDQVoRVJbLvFi/0njLU1JvVjIFW5ksjrr1damXXF9tGtWi7Ys83V95rhMA+aJODW878tWDl9vh9wLSA4K0ovjqmH2UYyMUbIOUTOuGCU/fVlLX8mzSXMUVo+K5TlKc5VH45bFOAOSJWfsO0lF/0hf8/8i93fTGq21ZVwlUCAhSULqhfobviPmo5M0VAKIMAKBj1twBOvWLbxJrsda81AZBClIFgrRiVH3YUhekZZP2yTTMbkMW590lXVSV7wsAAFHf1mZ67rFOYs1G3zbIA5AuuOMqhm/RkReBm4fXdMZZBwAAsubVF9vpX787K/h/x/amrKsDKgYEaYlwET55EZJFEK1JDP+rts2zqPbp65sn63Ce6gtA1gwONNLWjUhPDrIBd15FSUKMmjp3247fZfhb5TcqJ76PUrZuX0Un7jH4OgcQgQAAAGRgIS0YaQijOMLNZZnL++nl13zqlkWtY1lFki59lA/ipsrKkrJebwAAKCqwkBYMnQWQz/PZ0dqWlcQ+TZZOeVnc/SctTlyOJSlMVl7TvZNU/eR9qqzbLvefzXYQoQAAkF9gIS0YOlGRRG7JrKLHbf1bsxDfUY45y8h2l6CrNF5QoNtnnH3bWoHzYJkFAACgBoI0h+R5WF6F+IYhVfm6IfUoItCHCFX5naqWmbbLQ1Car7JckF0n0rQ6mt58VbS3kwEAABgLBCmIjS56OYlgIBe/U9P2USiKoEnasm3y583z0HgRrh0AAFQVCNKMsenQ04qIz+r95ybrqmqeaxCUDlv/SJfXlrpulxVJuXaorOVpkudzDgAAQA8EKcjU+hbF91VledUJbJO7QJnEiy+fVhUu54mf77y9MhUAAEC+gSDNiKhDz2Jnn5chyKjDt3EDsVxFryqC37doch3OdrX8qrZzKct0znydC4hSAAAArkCQFowkounTIGrks61rQZhFLg0xalOXMMHqsw5h8+OmzvLlOgEAAAAkkod03bp19Bd/8Rc0efJk6ujooIMPPpgef/zx0eWsg7r00ktp5syZwfL58+fTyy+/jKsRgSJ39q5R5VHfxORLjIbV1/UtU2lik4c0KmHuD0mnjioraEcBAFXCuyDdtm0bHX300dTS0kK//vWv6fnnn6d/+qd/ookTJ46uc/nll9OVV15J11xzDa1YsYI6OztpwYIF1N/fT1XBxYdRFmOyMNOJNd36cQQSXzfOMLtpe3G5al1Tyibd+QhLnG5bp7xje719+c+q/Hh1+/Zx/nT3hGkdef2w+ysvoB0FAFSNhrpnE9u3v/1t+u1vf0u/+c1vlMvZ7mbNmkUXXXQRfeMb3wjm9fb20vTp0+m6666j008//R3bDAwMBBOnr6+PZs+e7bPalfFPDfM9tC2b45rD08bKqFrXxrIpDw/rhJcvP07V/uOUkYS1O43ofxfraF4t+qZ6sfapu7s71fqk2Y4eRydTc0NLgkcDAKgqw/UheoDusGpHvVtIf/nLX9Lhhx9On/70p2natGl06KGH0k9/+tPR5atXr6YNGzYEw/Scnp4eOuqoo2j58uXKMhcvXhyswyeI0eiYIs6TFguylUq13HZSYVt/V4uYzf6TtgDaWD5t6hRmJQ+zTrseu6ul1NZi6Uv0i/68ebKaoh0FAFQN74L0D3/4A1199dW0//770z333ENf/vKX6Wtf+xr9/Oc/D5YzMcpgT/Ii7DtfJrNo0aJAXfNp7dq1vqtdGWysmGntk3f8jY2N1NTUNDo1NzcHLh+qTz6x9dh2cVwHTHXzRVYix1WMhpUVJkxdRakP1w8f22UtPHWgHQUAVA3vUfYjIyOBhfT73/9+8J1ZSJ999tnAX/Sss86KVGZbW1swFY24Q7i2+4ia4kc3nOqzk9YNv6t8+rjAlIWmeB75pDu3tu4KUdJmuQ71uw5X+0y75FK26rhkVwzbiHpdmfI1F9fJqyjMErSjAICq4d1CyiLnDzrooDHzDjzwQFqzZk3w/4wZM4LPjRs3jlmHfefLQDimQI0iWV6Z+OQWUv6/yaLK1xEn8dhdA5ZU+0jifOoEa9R6uaznKnS5eEz6foIQ1YN2FABQNbwLUhZhv2rVqjHzXnrpJdpnn32C/+fOnRsIz6VLl45xrmfR9vPmzfNdndJhEgkuQioJK2iU7URhGTYML1pSZTGqqksW7gkqbIPL4pIH30cdea1XXkE7CgCoGt6H7C+88EL68Ic/HAzZf+Yzn6FHH32U/vVf/zWYeMd0wQUX0Pe+973Az5QJ1EsuuSSIGD3llFOo6JiGLcOGeF3Ktungdeu4DB2HDTvLdbJJCM+/6wS0KV2RPOwrfrJhTtV+dWXqLKph9VDVy2V+nHVdhF0cFwDZpcF22F5c37bssO3zGpmfJFVvRwEA1cO7ID3iiCNoyZIlQSDSd7/73aCh/NGPfkRnnnnm6Drf+ta3aNeuXXTuuefS9u3b6ZhjjqG7776b2tvbfVen8CRlSfPdydtYI/l+ZSHqEpwkb+8zQ0Bcn9Ko2ybhO5p0Cqm45Ufx4a0SaEcBAFXDex7SNGBD/Cz9U9nRBQRFKcNXHknXOnLBKcNFKI+YV9XHVCaHWUVrtdrop2qdsCTxum3C1k96ON8lZZJtAJUpmE0uL8zKadqPaRvX+zqrJorvN4s8pGm2o8hDWl4am+o0fkKNWttGaPeOJtq1g7XFeBAE+cxDinfZ5xS5s45qTbIdHk0rKTufHxaIxGBClQ/Fy3k45bLFslyGg1X7d0m+HwcX0ejLmmhzbmz8kEWRHzVoSt5vAZ+NAcg1XT01OuUv36T3HLKb7l8ykZb+10Sqv9OzCYDyvsu+ivgMKBEtSKK1LE4y8Kjbh20XVmacgCeTn6luH1H252Mo2jaYzKU+qjKTCFyydaHQXQ/TukUkjZdEAJAGLa11eteB/XTIvJ00Y/YgFfQnCSoCLKQ5I+lOPKq11XU7nSBxCRQSLXAqkRBXfKrqlGdLnUl4qyzqUYKQZKu17Osq14GJ16iW0jxShmMAgLN7ZyPdv2QCvfjkOHp2RSesoyDXQJBWkCSGTG0Eq4sYlQOWVBH6ttj4QtqS9HB9FFTnQ5d03pQFQS5HPvcqy71N2ap9AQCSZ8/ORlr2ywmB22jw88TzFsgxEKQ5wlY8JL3/uPu1OQ5RdOrEDfMdFYWpDpMVz4Rs2RMFV5JC1SQKXa+PixuDq+VU9TDA/le9ScvVdzcOiNAHwBb224QQBcUAghR4EQI6UambzwWnHGHPl4ufqv2ohvPFeWF+oVkNM/vYn0vAk044qizO4nw5a4Gq7rIfaVwLuy2wsAIAQPmAIM0JSXeyrkPcNgLBpswwa5Yuat6mXHH7sEh5H+4IWfoXulp945QXVobJwqvz8zU9FPjAh38xAHmDpWsaP3E4CEbq29ZMg/2IQy4iTc116p44TM2tddrZ2xS4UiD91juBIM0Beew8kxZgfDieWeG44OP5SnVR2yKyZdSUQsn1OH0GTyV5DlUWYdUQe9z7i1tCxTdh6XxUTWWkKegxrA/KwJz9++m0L70ZCJrb/nUqvfhEZ9ZVAhGYNG2IPv3lTTRz30H69fWT6eG7y5fX2Ad43IqJLi2PzzRAUesUtw5x6m6TOkccujetr6uHi2+pCZ2YU61nO4XV3QVTAJHOdUF2YbBB5fYgD8uHbR+FJH4jeXzIAyBKHtEDP7ibDjp8N3VPHOtCA4pDW8cI7XfwHjr4qF00ecZQ1tXJLbCQlpA8WYfCLGncUspRWUplCyDfzia4J8thdpV10NVyqougt7WChgWPqfYn11klbH3dXxCjAOh5Y00r3fbTKdTYRPT6H9pwqgpK79ZmuvuGyTRx6hCtenJc1tXJLRCkGVP1Dlm26Mli1CaISSW48iBERVSBRAwbi6xMlAwAJlFqmhdWvzioAq6qdO8DEMbGta1053VTgv9z1qQBB3Zsa6L/vWXi/6XfwutblUCQesIUEZ4ELimAskAWGLYWOlFsmqyDOqudi6hxDdyyifo3LVOVZTMMHiZKXYSrWF6YEBUj7+XtVNclS+T6ZB2EBoDXtE2g4CD9lg0QpAVHFhf8UwxASQOVcFKJUnm5XEacCG+bOtqskydhL6M6Ryq/VZtzKZcrlsEt1eI+VYI0K9FnelCQ3Q7y7M4BAADgLSBIC4pOIKh8AJPar80yVT1UvqFyOVHqFWVdVX19DDmHDUe7CDqbYXPVA4mr9VW22qp8X22toypXC5fjNNXdlzVUd10gVKtIncaNHwmCiIYGG6hvazPVhvP7YApAGYEgLTg8CEiVYF4O/IlafhxLW9R1+Hq6OpmWm9aVt4lqEdUNk0epo2l73TKx3uL155bN4eHh0f3bHLPOvSLMHYBb4k3HaePOEia6bV0cxPrLGQNsgSitJocdu4MWnLGV1r7cRrdeM422bGjJukoAVAoI0hJgEkc+OldXf9AwwSMLKld/RJ1vpKreNuXptrGxnoZZe8POv60lUBbUKssofzhhsE9VSi0X67TNg4W8jaocH7gOu6tEeFj5cfyRQcFpIJo6a4gOPmontbSOUGt7ui5PIE/Ug6wGrMlhz9v14FaAtTwNIEgLDhcbss+oy1Bp2uiivtMODDNhEp+69W18ZONgshirBCkftrfdr6uIS+sBy9dwvM02UfcHCk6d6LnHxtF/XjGDtmxoDqKiQTVh+V6PObGXpswcpJUPjKfnHsPLCNICgrTAcEHHxajYoea9U00zeChMnNjUJU5d44orm3JFUSpOUfFVT5eHDJ3FHIDkaaBVT42jl556K0dkzptPkCBdE2r0x6duo/d8YDft2N4MQZoiEKQFR7Q2uli44lgjfQgGG2tUFCuXbZBKFEGsKks1FC5vo/seNWOAbGHmFnJRiPrwH5b3qapnmBXYFOwVVrbsJmIqw2aZCZs6gJJTb2CGUlBx+nc3BiJ0++Zm2vBaa9bVqRQQpCXAJqI6K0zC1yTOVEP6UfdtG8hkstyphJcoRvl3eV4S/r3yeWPXnwUxidZy9smnrDFdS9V1z+u9DAAoP0yI3nL1VGpurtOeXXDdSBMIUk9k3YmaOnyfQ7dpHKdKqMoi1ibwSSf4bIKVTMt0ljtd4FccK7Dt9dMJZNN+4xDFuqzbzhRBH9dCbrO+zooL6ygoIyxgq2fS8OgrLQf7/y/nMCAaqTXQzu2QRlmAs15yshbKOgul6hWhYeJLDNoRrZ+2rgo+hIa4P9dsAFGuha0YrdVqY/ZpGuJOW4yatjMN+6chCJN4iAMgz+x7QD996q82Bf//179MpVVPIWgH5AMI0pj4tO74qourGHPpfH121q5CSRd9HWZltLVUmpbpLKH8u2572VIqByLp/FtVy8PWZ8hD9GFD4Lb3qI2Lg+29ZVMfk5iPagV13QaAMjK+Z5j+6NDdb/0/4a0HWZB36sRsMQ2NbwXcjQSXrXwPzRCkGVNka4wPdwBXMWyaH1dsq7aVhZBskdVFtJsErCxKdXVXLVeJUhdfVJ2wS0KA2UbNm8S8z3oAAIjWrX4r8T/j9dVtOCUFoKmZ6Mjj++jAw3bRK8920CP39NDgQPnaNQjSnFCkiN6wYB2XMqKKUlkYRh1Gd9mvzi9TJ7zCrJ9xRKWrKPVhJTVhEtSm8xLnPAAA3NmwppXu+vnkt3+LOINFoLm5Th/86A76f2dtoftum0ArH+imwQEqHRCkOSGNTtjWghhWF1u/Rpt1XIWULDxtz1tSFkDu16qKfDcFF9kIcdfzorK8iv+rrLFRrKQ21z8su4DsQywK/ijD83H9g/PgcgNAOrB2Cee6SNRGiFa/0EHL7+mmV54ZR2+/Gbp0QJBWaNheF00s18UnpmF2V8uobeS6rg5Rjs3k08iFKHuPPP+fTTwNkxhsJJfpKzDI5MMsztf530bBVH9xf3IAmji/paVlTBnsPA0NDWmPBeIQAFBVhoca6P7bJ9DDdzPLaCMN7ilnZgQI0oqI0jDhUhQ/PFfrretQvmxN1A2Py9/lSVwWJ9perpfJEhqXqL6o8nddnZgQbW5uDgT8uHHjgv95Av/BwcFRy7LuNbg2ddE9dPl6MAIAJEk9eFNS5/gaDexppL6trI3A75PqDbRnZ1MwlRkI0hxRtM6xaPV1RbYu6lwexImJLlsLogu2olZnXQzzfzUFTYXtU15HJ1aZCJ00aVLwuc8++1BHR0dgFWXW5C1bttDrr79OAwMDtGPHjtFE/7rjV9VJ9TAhbxvn4QAAkCyNTUQfObGXjjt5Gz3/eGeQlmpnL2RKVcCVzokFUiwnjU7S1xCo7XGHuQqYtjNFYUcNiBLr4mp11O03qtiU62S7vslK6Vq+KERN5ajOk431kX2yYfrOzk7q7u6m6dOn0/jx4wMByq2jTJQydu3aNea6yL7Grufe1s2j7A9YAOQd9vObvvcgHXTE7kCINrfA2bVKQJDmkKQ6xqQ62yjWPht/Vnl9eZ5uma4M8dNUf9sMAHyImfk/ioFMfNg5zCoZlSjiVfW/Sz1cxK+8bz5MP3HiRHr3u99NU6dOpWOPPZamTJkSiM89e/bQSy+9RP39/dTb20u7d+8ec15VolSsg61vbNh6EKMAZAvz1lm5bDzt6mui9a+24tWdFQOCNEVcfPRk61Jci2bana2NmFNZwWzKk8+Fqyh1qb/J+sfhwonBtzENk/P14tbXpmyTEHe1iJrmmerHfUeZZZQN1c+ePZuOPvpo2muvvQIBykRpe3s7/eEPfwisqOvXrw/EKRf1fJ9hYtQGnbgFAGRPfYTod4900rMrOin4deInWikgSFPGdviQr2PyXQzbzpUo25msTqqhcZ/1VdVBV77pHNoIMtO14NZRvr5pfyofS19EFVqm9XXW6SgPBzp/T/GcmNwzTOWJ64StCzEKQPq0dYzQuw/eTT2TarTm5TZ6/fcsKb/8e+ftCq5QGOO6arT/+3dTR9cIvfpie5Bftuhvb4IgzTlxRaKuzCjbxSUJIWAjYGyHccP2oxJ8svh0EWNhdYtClPLC7geTy4SuvDj+tGH1U4l61UMAApgAyA/jJwzTn31xMx102C66+SfTaN0f2iA8YzBp+hB99qubaO/9Bug//nHG24K02ECQekYlTkyWm7hl+qwnn5+kMA0TkDa+ilECmeKUIW5j41ogri8L0bgBT0Xxc1SJQxZRz/xF2RD9tm3bqK2tLYioZz6j7JMN07MAJ3Go3kZUmq4xhuUByAf1egMN7mmgPbsaaXiwGO1YnqmPNASpsfrZ+Rzyez4bGurUPbFGHV21wI+3b2tTcP2Sxnt2VeZPd8kll9DcuXODtC777bcf/e3f/u07rEqXXnopzZw5M1hn/vz59PLLL/uuSinx0cH6sBgmgTj0HQdTQFFcog67+zqvaQksn/cBS+HEhObmzZvp+eefp8cff5xuv/12uummm+jWW2+lJUuW0LJly+j3v/89rVu3LhCtrB2Jei8wn1X5ZQUyeRf2aEdB2ejb1kS3XDONfvTN2bRiaTesozHZvKGFrv/hdLry4r3p6Ye7yCctbXX6k89spYt+uJY+/tmt1NpWL6aF9O///u/p6quvpp///Of03ve+N+h8zj77bOrp6aGvfe1rwTqXX345XXnllcE6TLgyAbtgwYKgs2LBDSCeKPFlRVXt02Xo1rVsXr7ORzFqNH2YgDTtQ+eP6OKv6Tp8betu4FKW7XHZ1MnGJUS2ujOBxSygW7duDSylq1evpq6urmAe+75x40bq6+sLxCgTsKKV1AWVhb2IFlS0o0lQJ/bysMYm9rDaQMFL1FKw+oC3GBpopNXPd+B0eGJgTyO98rtxiZzPxsY6zdxnkA48bFfg68t+M4UUpA8//DCdfPLJdOKJJwbf9913X7rxxhvp0UcfDb6zDuBHP/oR/fVf/3WwHuPf//3fg7yEzGpy+umn+64SKBCioHS1YkVxjTDtRyXmTKmGbKPATSI3KdIWXqJg5/8zscmspGx4nolQNmTPxCebdu7cSdu3bw/mq163qitfNV/1WTTQjibDQUfsoiP+eAe9ub6FHvzlBOrbBq81AGSGhhqD15S+saaVXn2hnYZScrHwPmT/4Q9/mJYuXRrkFWQ8/fTT9NBDD9EnPvGJ4DuzjGzYsCEYpucw6+lRRx1Fy5cvV5bJkmcz64k4lY28DyGmiSgmXCZx2yj7C1suDteLEx8a1n3aDvPbWp+TEllJBlix/9nvmPmObtq0KXDRYSMiL774YvA/e0sT+10zf1IxjVbU/XL3j6RcN5IG7WgyvOeQPXTqF9+k407eTl094Q8+AFSR2tBb+WBvvWYqPf7AeO8+qjq8Px5++9vfDjqWAw44IPDjYp3L3/3d39GZZ54ZLGdilMEsoiLsO18ms3jxYrrsssuoaMgWtrSG2m1S7yQdvOSCrXXQlG4oDVxTGpnKiXs+khiGtrUU25Yv10W0mHIfUVk86vYtfpfvYV29RNcKm6j8PIF2NBnWrW4NLD/rX22jPbu922MAKAkNb32k3ER6F6Q333wzXX/99XTDDTcEPqRPPfUUXXDBBTRr1iw666yzIpW5aNEiWrhw4eh3JnhZcm2gxkZo5kWMRhGlWRImSsNEmyjKxHny8igkcU1lK6fJiqtbJp8TOWBJ5zNrcoVQwSzS8jaydTrr+8cWtKPJ8NRvxtOLT3TS8DDRnh1NCe0FAJALQfrNb34zeLrnvqAHH3wwvfbaa4GVkwnSGTNmBPNZEAOLsuew7x/4wAeUZTJfMzYVFV1gSdLCImmB4nufPuprKiOKhU+FSpi5BiyJwjNqEJftuj7Fvo3Prak+NlZQcV6YII6bmiuvZN2OtrSO0IQpw9TUXKferc20Z2cZxFsDDfSzCZZRAPKI918m8wFjlgoRNnTPLSIsqp41pszPVLR4rlixgubNm+e7OiBlitDZJ32csoiSfRlVPqVRhpBtovddI/yTQOXTqQo+CvMHFkW7vK68njz58DVOk6zb0Wl7D9LnvrmBzv/+OnrvEbtilwcAAKlbSE866aTAZ3TOnDnBkP2TTz5JV1xxBX3hC18IlrPOgQ3hf+9736P9999/NO0TG9I/5ZRTqMyEWZB8+XWq/OzC1vOJi5UvihUzap1dLdVh69tY4lRDyCKypdT1/Kj2b+Pnqtre1i/VVszx86O7H21Fvc08m2uadxGap3a0fdwIzT2wn6btNUg9k4Y9HBEAAKQsSH/84x8HDeNXvvKVIJqWNZB/9Vd/FSTC53zrW98K3tZy7rnnBqlejjnmGLr77rsrn4M0iaF6G+tZkUkrOMt0TnUiU+UvmnT94rojRF3PtG1Y9oC418/W1SBMAOfp95B1O7plQwvd/rMpNG58LbFchwAAINJQL5LZQBiaYqmiikyeOr8kyZOF1GZ7ncWRp3ByKStsaFk1bG1bd5tgIld0w99Rywzz53T183Q5P+L6cc9Hb28vdXd3U9ng7ehxdDI1N7RIS98+Zw3832q0VwAAvwzXh+gBusOqHUVW4BKSJ2uPa13ChKgqQt11KN52/6p0QfJ+XIbzwwSSKvhIFoRxnh+jbGvzYKBbx8YX1JeY9rU9yDbtCwCgukCQlpC8iNEkBLKrldLH/kRhKn7q/ID5cn7c/H8x16aNKHXxdXWJyE8S1+H4LB6ebLMOAAAASA8I0hQIG5pMs0P2mY/RRXz4OM6ovodR9qsSnLIYlaOgZb9RXQBS2LmPUt8sBJYP14AwcSiex6j3rk3gFgAAgGyBIM2YvFkzk8S3+E5KzIv+onL5bBmfWBoecT3RCspffykmgE/ioSDP2Ea+pxl4V6XfGwAAFAkI0hTw6ePoqy552L+rEPEVna2qgylyXv5fFKXikD4Tn/zThxC1PVc26ZNM+/YpkKNad6McXxzLZ1UeCgAAoChAkIJc4yOPqm3uS47KX5QL0Obm5mDi/zP40D0fqmfWUTaPi1IuUEVxyIVrWEBQXPLwEJQUSbq7QLACAEC6QJCCXONrODdqfk4uHtnwPBehLS0to/+LvqZckLJ1GUxw8qF72crqmhQepEeZRTwAAOQVCNKcWEvykKop7Tq4pD+y2d40hBs1Ol8MYOJ+o1ycch9SlYVUXKbLRepyX/nMLeqrbNcykwh6i3sPqbYDAACQPhCkOSEPHWEe6uDiOxlneN9VjHIhKlpI2Se3nopD81yEMmHKrag8wAkph9TXWXXu44hLH2IU1woAANIDgtQzLrkj45aRNXGCinycJ1U9kvK9FIOXRKEqfvL9q9blk85y6BLoJNfN1RqZV2RfX90DhE+LbtRgMQCAP5qa6zRx6hC1ttepb1sT7dzOHvKL14aBeIxNpAhACvgSS6pcoUn4lMoiVLaY8kkczpe3k/cdVezYWnazxkcdshKEOhcLAEAydE8apk9/+U268B/X0pHH91EOmjCQAbCQSqSZEzHP/p5J5AxVwa2DSVpbXaP0bVNBqSylbJhe3F5XlmqfLv6ettkF4uJqfdVZOE3ruu5f3N63aIQIBSB9WlrrtPd+/bT/wbtpxVTz+85BeYEgLShJi+M0xLetWEsL0xAx9wHlExOePIKeiy8+T0yKbwpoStovsuw+kBCjAJQDNkT/6+sn06P3ddMLj3dSiZstYACCFBQa32JWHmKXXwcqBieJgpPBhKgoWrMUo8ANnF8AsmP3zkZ66Fc9wpx8GClAukCQehI2rsPOebEK5gGbN/G4bCdvbzvMzdcTRagcIc/FJreI8nn8O7eeipZUWbiG7duGpPOYxk0zZZPSKqlAJVsgQgHIC+gPAQSpNyAw8+fHGmV72aopik02j/uLcpEpWlTFPKTDw8Njhvb5W5tUIshVjJYFX7lHfeYvBQAAkA2VtpBCRCYfKCWLtrTrLKcS4phSJ4l+ofI88T31XKzy8lS+pqLAjWIFTfMeTUKkmaygqmOL+hABAACg2FRakIKxJCF+8hp8JQ/Ly8tkkSO+d54nv2dWUNlCyoUoW8atpeK2fB3dfspMUVJWAQAASB8IUpAKtv6eUco1pW6Ksi1fJpYjilHxO0N8dahsHdUFN9mK0TQEq0tOVpf5umVZ5heF4AUAgHwCQQpyTZhoTENgyEPt8tA9QxWJrxKdRbWK+gzYixusFhWIUQAAyC8QpKCwLyOIm1TftD9dxL0sQlU+kmURoVGIei3khPpVOV8AAAAqKEhhIckntqmBXJarynR5M5AcOa97a5M8DK/73zYfaZpCzGZfLuff9felEvNyui0AAADVoFKCFJQPHxZSVfS9LES5n6hN7kzRUqr6vyzYilFddgOT/y9EKQAAVIvSC9KyWkURoJHOfaESRjbWOxsLqW59n0TN2enLMqqzANskzufruRxD2UQ/AABUhdIL0rJSVqGdBlHzXIoPATaBObohfNO8ImDK4SoutxXgNuK3qOcKAABARQRpUsLMR7noRN3PQRw/RNtybBPk695pb0NUi2jSr9OM468btk7UYfawOmU1fA8hDAAA6VF4QZoEsD7mhzykfdLtO87yImIj8n1fE7k8n+c1q/RTAAAA3gkEqQTEaDlSQqVFVUSLq59okm/98nHO83DvAAAA+D8qLUhd0gDp1o+bOqcqgiYtTKLFdP1s3qvucq3CLLuq/SdxL4T5e0YpwxeqVE+29bFxebAtS6wLAACAbKi0IA0DnVT18JGbk68T95WcRcZGYLpE6ovBZEgJBQAA5QOCNKU30PguN+9i2SZ4Jk/HYMopKlvwVGIrTkqnrM+DazCTLsG/vI7LcenOZ9J5SrM+9wAAAN4CgtRA3KhjUB6iDn0XXfDIr0cVUaXB8uk/it8WAABUBwjSBCl72pioSdejbudStq2/r6sfcVoU4d7RifSk0lUlLVDjpPkCAAAQDwjShMmr4Mk7VX4TVVGP2yXYKCwyP+1k+fL+IEYBACBd3npBN8iUogqQvJyTopy/qBbkrInjAysO+fP/dW4AYW+20pXvk7ydewAAqAqVspCmLVzk4eO4Cd5d36eeNlHrE3Uo3WW/vgOLbF+fGXUfRbm2pnuXz29sbHxHlPzIyIixXJs0XFF+A7qAOpUYzts1AACAMuNsIX3wwQfppJNOolmzZgWN++233z5mOWvEL730Upo5cyZ1dHTQ/Pnz6eWXXx6zztatW+nMM8+k7u5umjBhAp1zzjm0c+dOqio6q5FsUZLXK4plMGuyEBY8ylycqvjiAiZGm5qaqLm5eczERarrPRznPObp94J2FAAAYgrSXbt20SGHHEJXXXWVcvnll19OV155JV1zzTW0YsUK6uzspAULFlB/f//oOkyMPvfcc3TvvffSXXfdFTTO5557LiWBaYgwShk2k7ytr/qqfOzy1Mm6Eve6mLAVgmmKxTKJVNfh9SQfqMJymIr/5+W8F60dBQDkg87xNdp7v36auc8Atba/NdJUFhrqMVpn1hEsWbKETjnllOA7K4pZTi+66CL6xje+Eczr7e2l6dOn03XXXUenn346vfDCC3TQQQfRY489Rocffniwzt13302f/OQn6fXXXw+2D6Ovr496enpG62Cqn+vx+EAlHH11grqhxqysgHEwnRsXf8ssRHnUNFBh5SSN67mOY8HkVlBmEWVWUl4eW2doaCgYtmdT2NvQTHUy3f+u5aq2ZxNrw9hoTlJk3Y4eRydTc0NLYscHAPDH4R/ro099+U3q3dxM1/9wOq15uT3Xp3e4PkQP0B1W7ajXoKbVq1fThg0bgmF6DmvwjjrqKFq+fHnwnX2yYXreiDLY+qzzYpYAFQMDA0HjKU5h2HZsNhZUF6uKLlLY5D+qs5rZWNRcrU0+rXRxLZyq/buWmaSgs7WCh61rc2/5eKBQiWSXsuPWJWy7LK35ebCKFrEdBQC4Uqem5npgvWxuYRZMv21PV0+N9nlPP+31rgFq6yiXhdSrIGWNKIM9yYuw73wZ+5w2bdqY5cyCMmnSpNF1ZBYvXhw0yHyaPXt2JhHPKutkHoYByzB8X3bSuja+9hPlftYJ4lqtRsPDw2Mm2TIadR9R65pnitSOAgDG0tRMNG9BL33xkvX0sT/bTm0dftunV37XQf9++Qy69Zqp9Ob6co1sFCLt06JFiwJzL5/Wrl2buhgV52UtQFVAlCZzPvNepo483J/8d8KH5pkw5VMUQYoHrny1owCAd9LYVKeDj9pFJ31+Mx127A5qbfNrxXz992306xsm0QO3T6Dtm8uVKMnr0cyYMSP43LhxYxBlz2HfP/CBD4yus2nTpjHbMYsJi7zn28u0tbUFU1IdlcrXzCaNT1g9bIM9fIkHXlYeUkL59p1Ni6h+xyZ3Ctt0XXKaMFeySgtm8uPldeBpnlRE+W2JZZftfs2qHQUAxGek1kAvPd1B9/3XRHphZScNDfo2RDRQWfFqIZ07d27QGC5dunR0HvNTYj5N8+bNC76zz+3bt9PKlStH17nvvvuCDov5SLniU4yK30X/PzFFjWu0vY1F1dbf0AZYkfJPEa6RTz9e0UqqCmSKUn6Zc4Vm0Y4CAPxQGyb6zX9PoKv+em/6n5snUf+eQgxEF9NCyvKFvvLKK2Mc8J966qnAd2nOnDl0wQUX0Pe+9z3af//9g4b1kksuCSI+eQTpgQceSCeccAJ98YtfDFKasGjb888/P4gctYkM9WVZUVmQogoFOXjJp8VTJq7VVWUJimuZK4NfX5RjD7vuYQ8hSVlKVfWLu74qst20nq8MDGmVkfb9mqd2FADgkwYa7GcTzmrigvTxxx+nj33sY6PfFy5cGHyeddZZQUqSb33rW0GOPZYPjz3BH3PMMUE6kvb2/0tNcP311weN5/HHHx9YH0877bQg555vdB1SUhYq0Y8zq3REYl2KJgrzinwdTfeVS37OIlyjpO7jIliJk6RI7SgAAOQ+D2lW8Px5qkCetDs63VB7mPVL/t+3lTFsSFPn86gTIDbCxEcuTpPVOqo4MpXpYmV3FaK2fqVh1uy4x+5q3bSdb3MP2aYqczm+tIbr08pDmhXIQwoAyFMe0sKHaCUlQF2H803DtUkN6ZuIup+0rcouZPWwEWU7/ukrsM2nO0XSuAz968R+1iMMAAAA0gXethK6ACSTYJCtXXlKEI5OPdvzbHv+07pOPizMUfdn6/oQtixunQAAAOSPwltIk8a2QxWHKlXW0rDOV2chQsfrFxtLnGmI3vSwYjukL68rbp/U9VZZI132pTtPthZg03cXogaKRd0nfn8AAJAOEKQGTKmYdP6rOv82nS+dWL5YVtQ32QA9putomm8bqCSLPlu/YvG+SUqU+rDAxhGlPoji/xq2DAAAQD4opSCNkzZHFphhAS0uwRy6fcn7sSknipUraWyDZ2zLyEq8qI7DNghJvna2/sOyKNXVWWVp9XUPhAXZ8XV8Wjyj1E3er8pNxnRe8vSbAb6pU/fEGk2cOkwD/Q20eUMLDQ/CMw2AIlBKQRpViLpY0FTriIKEpWGxibhmU1NT05jk+8w6yt66wjtadKD+iOI6obt+MuK6vBx+XV1FqQtpu3a4RsTHFazyb0C+Ti5uMvgtlZ8PHruD/vTszbTm5Xa6/orp9Ob61qyrBACoiiDV+eNF2d6XtcfkU6paV5y4iLFNG2Rbl6wzEdiWI5YVdVkUTFZBV3SWUhtfUtt62QrdJNAJPvk4XR7oxLJV/+vqYVPXKEC8FhNmIZ2zfz8N9jdSSyus4QAUhUILUpVFy1WQuAzLh6ETG1ws2A7/oiPMHtE6LYsrXXCQykrnEkxk82Al+yln6R9p2r9OaLv8XuOMDsBvtLr87pFO+tnfzaLeLc3BBAAoBoX+tao6RNEqaeP3qRuqt8FFYIj1U9XVVE4SpG1Ryzu2QUy6oCXbc8m3s/VDDSPPopRjI1pV5eL+BO400OoX2oMJAFAsCi1ITUOGUTtJm/LChnZ1FiyVgGX/M59ReXnUKHuXIX3fQiYNAZG0+BKt2SrLnuhSwf2E+bVin/xa2uxH9V3l5qF7sDFZT13qYGOlDxOPKveEMFRWYBshavsACEFbVZBVAYAiUmhBGhXbYXrZr1NcX2UdE0WkaVhVHsKv1WpjRKlueD+PFrI08XGctsPMuuXsPuBBaOxTvn42glS+d1S+oLKl1OUBKgshpvOTtam3/IAW50EMAABAMSm0IDVZZmwshS5D+jaWUiZSVNZNXfCNafjepu62YjQpgZK1Rcp1eNtUjuv68pC97C8swuso11fnXyqu5yKeZYuj6p4ylRX3+qmsqvL1SeIeCXONsd0OFlUA0qWjq0ZTZgwR+7lufqOF+ne/9ZAP9HR212jy9CEaHm4IzhkL3isLhRakNsPoum1MASTikKxKlMqIKZ5kwWEa+lRZU12wGdotEzprsw9c7x/xf5Po01lAxf9tLPayxd1FcGVpNY06jO9jvzrkc61zpfFVHwCAmv3eu4fO+PpGGh5soOt/OINeenocTlUIBx2+iz79lU20fXMz/ecVM2jNS+Xxly60INVZhMRlKmyG6W3FqMpSFlYPF4FgY8WNiq/h/qw6bd25zRrTvSILyrD7yyZgz9f5T9KSmbRriYtI14l/3WgLACAZOjpHaK+5gzQ00EBt4+z876tO5/ga7f2ugeDctbaV65wVWpDGGYJXLVNZRhkmK6SqE5SDXVTr6cpPkyp2umEWSNM5EQPQxGvGfUh1AlkWQbLg4T6puv1zS7vopypa31VCtyrYinnx/Nq0E1U7jwBkwWsvtdN//ON0GhlpoPWr23ARLHjpmXF07d/PpIHdjaV76UOpBGlc65VsFbWxTvFlYtm8LIYpWj7Jji+uZTavJGG9Ulm05e/i9ZcFofzd5SGI3yu6e0/cB9+/yjUkyWvr43y7uETID4AuxxV2DWz9Rqv4sAZA2mx6vYWWvj4RJ96B9atbg+ktytVOVU6QqgizisnWU9lnlFnI+HdXK2gaVlJ0ruHIAUYmn1COaC11jQ4X7ylmIWWTzjrP00lxSyybeABdnkWoazmqY4nqemPzQKDbH34vAKRFuQRVOjRQWYEgfRuddYp3WlyItra2UnNz86gwEHNQqob2TSInKatW0a2gSeIiOPj9IAe76Kyo4nbi9io/Yy5E2T3F7ic28f9FYcpEKJ+GhobekfNU5ZNaxOsfJaBP3l73QKg6/6qRiyhBWAAAAPxQekFqa0WRkcWlaB3l1ixZeMhDqbb7l9eLIiiSFiFJBhCpjt3GpzMtK2mY36mI6kFE3l51P7GJidG2trYx9xgToWwaHh4etcTLQquIAlQkbv1drai291jRz2teaWys0+QZQ9TVU6O+rc20dVMz1et4AACgqLS2j9CUmUPU0lqnLRuaaWdvNGlZekEqYvLjMwlCtoyJBSYSmGBoaWkZtVAxocAmVfCS2OExkSEmTUdnl09kUSq7Z5hQWUZ164lD9czqzu6rcePG0aRJk4J7raOjI1jW19dHO3fupD179gT7Z/caH75n2L4ZKq/4+h2Y3GVE32+dJdV3fYAeFk39yf9vCx3xsR304J0TaMlPp9DQIAQpAEVl2l6D9BcXbaSpMwfp1mum0fJ7eiKVUylBaoNu2E62asnrmIZv0xpONZWdZ9eAqOVEPZ+6IVmdy4XN9ZPvA3m+KvBNFKZMhDJhyoQo++zs7AzmM+HJraNy8JOq/LiEuSHolqUp5MKs5iafUdWDowoI0+RgzefkaUO09379NGHKEDWUJ683yBENDXVqaasHFvmhoUaqDQVzs65WKWltq9P0vQdpxpzBIC1VVCBIBVQ+ZWIHLfruyT6ktp2dbK0R54Vto0NnvauCL5yLGFJFptvuw3a5Sijqhuz5Aw6zuLe3t1NXVxdNmzYt+L+np2dUpHIR2tvbG5THA5p8D9nHOR9R7zNf9de5yYQNy5f995FHBvobaOltE+mFJzqDtD/DQ7gGwD/dk2r0J5/ZSjPnDNLDd3fTymXjcZoTgr0x6tZrptK4rhF68cnoLzeonCBVWTVVy8R5JjGqS/mjsrBGsZSaLGE2QrYKiCJfnhdVlOrKsxE2uvtLXM7FKHcHYaKUWUeZEGWfbOieidGBgQHq7+8PPnkQlK1rgKsVNM0HmLi/B1U5quUmX19YQbNheLCRnv5tFz3929GrkVFNQJkZ11WjD/1JHx3wwV30xppWWvngeCJ45CRC37Zm+u2vemL/nksnSMM6J75OWCCDvJzngRTT74hpeHSiVPV/XItpWJm2y8uEyWrnKrzE66GzvNnUQ76uquVs4lH0g4ODtHv37mAeE6NMpLLvTJCKEfZyXVV1iOK+4WpFjCte5XveVLco9bAJjNP9RiFYk6O5ZYQOOnw3zdxngNa83E6rnhpHIzWIUuCX3Tsb6dGl42ntK2306gvtEKOJE/83XDpBmgTcOspg/nwMLkhFUcrXtUUWo6oOGmSDTuiZMFnnVEKUP+Swe4qJUSY8WRATs4ayZcxyyobpd+3aFQQ1iW+EcvGHjEMR78MoDyAgPdo66nT8advooydtp19dP5l+/1wHDUKQAs+wDA53/NtUamyqB68mBfkHgtRgHdGJCCYM+P86C4uNhcpmHZU/nI2VzIUi+5pGrbvtA4Bstbbdl+39xO8jLkq58ORD+bKF1HTPhdXDBV1wlm49m5GJuHXi25rqpjo3YcP8IF3Ys/v2Lc20YU0r9W1ronqxE0WAnMJSiQ3sKWa/VlUgSC2HP7kQYKKB+fKJ8+Qhe/F/ucM2iQmTL6pqmS+KKkbTrLt4/cLEq4jKJ5lbRvmDDROcYgoxngqK+Ysygcomdt+xSbbKJ3lf6I5B5y9rO/wu+/Da1t/14UPlPmGqF0iHgT2N9Kv/mEwP3tlDvVuaEdQEAKiGIHUJXBHn6+apXhdpGj5VCdAwC5epY7fp9F07XJuOPqvOXN6fLhDNdAw2vqQ+LXymOqruJZ7aia3DLKJMiDLxyb6z4XsxMb48ZG97/eOIubDv8vmXv9ucL5v7Ko4lXP4/rNw0hH5VYf6iG19vDSYAACidIFV1NqphUpsIa75c/p8HNcnvEVf59XFsBK9p2F+sb9UtpKZ6Rj0G+T5I6lzIlm42cYHJ54vfeTQ9F6L81aFsPf4iBtsgJ5vjCju3unMkilBVeToxrtqHq8VUty9xP64PUhjOBwCAbCiNILWJmrbplFVD71yI8jLkNy75EKO6DhNWGn/oxIar9TAq8r0kBjVxgSneZwzRLUT0XVaJ0aiECXKdIHW1uMr3unw9TGLQZl82YtLFSgoAACA9SiFITZ2QySoqW1HE/+XOUydqVcP1uvV8HiOE6tjr5UuUqpbFESsqwSVbSmUruEqQcguqaBkNe5hxJUyMip82olRl7ZfPs+r3qCvLl2iUr4k8iVkzAAAApEMpBKktYb6kcudoa/nU+R+axKuJtCx2IN3zLl97MbhJHKpXbcOFKN/OVL6v4xBFGv8uz5frK9ZDVU/Z3UXen7i9LbbHq/sd8+PgE7seuvoDAABIhkoJUhv/NXFe2HaqclT/u4pRl32mRR7qo/ILjCK8TNdW9XARduwu1nD5XtOJVLks3afNcURFvp9lASd+ivvVjS4keQ+F/bZ126iOMYpLAgAAVJ2GxjpNmTFE4yfWaMe2Jtq8oYXI4dX2lRCkOgsmXyb79PFJ9iXVdWzcSqQaqpej8kV07gHADtWDhE+iWt5kZMEmC2p56D5sX6b7xefwvSzMRCsiS03F5vNPcf+if6vsGyuW76OupvMm1j9MlIoWX4xQAACAO61tdVpwxlb68IJeeuhXPXTrNdNoaI/99pUQpAxTJyMHWagsJLYdn678MPGQVzGax3qZfHVdCbOCpj2MH2U739cobJheFKIqQco/mbjjD2S6UQjfolTlmxplf0lbdAEAoIwW0gmTh2nmvoPBZ2OjWxv6TgewEB588EE66aSTaNasWUGjffvtt48uY2lpLr74Yjr44IOps7MzWOdzn/scrV+/fkwZW7dupTPPPJO6u7tpwoQJdM4559DOnTspacKCJrglRw4akX3M5EnnfxqWuDzM8grKi+yjbPJZVm2TBqLVkFtF2dujWNJ+PrW1tY2Z+Dz22dLSEkxsG9HfVBa3qn2aiHP8qrJ5BgOW7UDO+ZoURW5HAQBAxdBAI91/+wS65tJZtOyXE2losDFZQcreq33IIYfQVVdd9Y5lLKn3E088QZdccknwedttt9GqVavoT//0T8esxxrR5557ju6991666667gsb53HPPpTQIE6XykKMpGlfVsdoO89vUB8S7ni6EXde0xahpvurTFyprvyhMmSjlwpRPXHiKApRPbF0uaE3l22J7vDr3GPF4+Dz+EMpFqZjNICmK3o4CAJKgLkzFozbcQM892kX33DSZnnusM/juQkM9Ro/GGvQlS5bQKaecol3nscceoyOPPJJee+01mjNnDr3wwgt00EEHBfMPP/zwYJ27776bPvnJT9Lrr78eWAPC6Ovro56enkiCwSZgQR6mDFvf5NtnOr1JdXg+RUqeBXNRgk5c6qlzF0nyGumG5cXheSYoRcHJX23K/hcj7fkrUNknf9Up++TzVK/blesv+l3b1F33QCgem+lcyccv1ovVv7e3N7BCJkXW7ehxdDI1N7R4PSYAgBuNTXX6o0N30z7799P619ro+cfH0bCjhTGPDNeH6AG6w6odTfxoWSVYg8uGlBjLly8P/ueNKGP+/PlBp7ZixQplGez1iazxFKeo2FguRUspf0uO/P5w0aoiLjN1tPI+QHzKdh5lC6nqVaFpH7Nq6J5bSXXWUb4OF7O2D49RfXZ1D4EmS6m4jvibzuM9lbd2FADgl+aWOn3kxO30pcvW0/GnbaW29vy1Q0mTaFBTf39/4At1xhlnjCrjDRs20LRp08ZWormZJk2aFCxTsXjxYrrsssveMd9nxxEW3KLbr83QqapsWVjoOsoo9cxjh5oESQ1bx0UVRR+FqMPTvpEFm5g4nglOEf6QplrXxmdWFuS2yJZNl2PL+/2VdDs6TENFHSEEoDQ01EdoaGTo7WmYhmmQhuvFjzsP2hfLdjSxo2WO+Z/5zGeCSlx99dWxylq0aBEtXLhw9Pu6deuC4SpG0p19WuRFfID42Lps2GwfZx2f+8sradR9x44dwdB2FqTRjj5Ev/JQUwBALPqJ7v0uEbGphNi0o81JNqLM3+m+++4b4zcwY8YM2rRp05j1mX8Zixhly1TwCF5OV1cXPf/880Fjunbt2kT9u7KGDavNnj279MdZpWPFcRYDJgJZI2rjj5kEaEf9gt9ducD1LF872pxUI/ryyy/T/fffT5MnTx6zfN68ebR9+3ZauXIlHXbYYcE8JlrZsN5RRx1ltQ/mJ7XXXnsF/zPhUmbxwqnKcVbpWHGc+SdryyjaUf/gd1cucD3L0446C1KW5+6VV14Z/b569Wp66qmnAt+lmTNn0qc+9akgVQlLQ8J8ybg/E1vOInMPPPBAOuGEE+iLX/wiXXPNNUHDe/7559Ppp5+emSUCAADSBO0oAABI1B25//77xURZo9NZZ51VX716tXIZm9h2nC1bttTPOOOMeldXV727u7t+9tln13fs2OFUj97e3qBc9llmqnKcVTpWHCdAO4rfHdoXtKPoL8bibCE97rjjYkd4M2vpDTfcQHFgPqXf+c53xviWlpGqHGeVjhXHCdCO4neH9gXtKPoLj4nxAQAAAAAAiEvxXwMAAAAAAAAKDQQpAAAAAADIFAhSAAAAAACQKRCkAAAAAAAgUyBIAQAAAABAphRWkF511VW07777Unt7e/CGp0cffZSKzOLFi+mII46g8ePH07Rp0+iUU06hVatWvSNVTENDw5jpS1/6EhWJv/mbv3nHMRxwwAGjy/v7++m8884L3vDFXhF72mmn0caNG6losHtTPk42sWMr+rV88MEH6aSTTgpeZMHqffvtt49ZzhJ3XHrppcGLMjo6Omj+/PnBG4dE2KuCzzzzzOAtKxMmTKBzzjknSBYP0gXtaLF+exy0o2hHy9iOFlKQ/uIXv6CFCxcGOSvZW6EOOeQQWrBgAW3atImKyrJlywKx8sgjj9C9994bvMHq4x//OO3atWvMeuwNV2+88cbodPnll1PReO973zvmGB566KHRZRdeeCHdeeeddMsttwTnZP369XTqqadS0XjsscfGHCO7poxPf/rThb+W7J5kvzkmZlSw47jyyiuDN7GtWLGCOjs7g98ne9jgsEb0ueeeC84Le6sbE7nnnntuikcB0I4W77cngnb0LdCOPleedrReQI488sj6eeedN/q9VqvVZ82aVV+8eHG9LGzatCl4a9GyZctG5x177LH1r3/96/Ui853vfKd+yCGHKJdt37693tLSUr/llltG573wwgvBeVi+fHm9yLDrtt9++9VHRkZKcy0Z7NosWbJk9Ds7vhkzZtT/4R/+Ycx1bWtrq994443B9+effz7Y7rHHHhtd59e//nW9oaGhvm7dupSPoLqgHS0uaEfRjj5fwna0cBbSwcFBWrlyZTAMyGlsbAy+L1++nMpCb2/v6FutRK6//nqaMmUKve9976NFixbR7t27qWiw4Vs23Puud70rsJStWbMmmM+uK7MMi9eWDefPmTOn0NeW3bP/+Z//SV/4wheC4cEyXUuZ1atX04YNG8Zcw56ensCthl9D9smGlw4//PDRddj67HfMLKogedCOFv+3h3b0LdCOHl6adtT51aFZs3nzZqrVajR9+vQx89n3F198kcrAyMgIXXDBBXT00UcHDSbnz//8z2mfffYJxNwzzzxDF198ceBnetttt1FRYMLkuuuuoz/6oz8Khsouu+wy+shHPkLPPvtsIGRaW1sDsSJfW7asqDAfy+3bt9PnP//5Ul1LFfw6qX6ffBn7ZH7SIs3NzcHDV5Gvc5FAO1rs3x7a0bdAOzqtVO1o4QRpFWC+pEygib6VDNE35OCDDw6CRo4//nj6/e9/T/vttx8VgU984hOj/7///e8PGlYmzG6++eYgAKaM/OxnPwuOm3WAZbqWAOQZtKPlAu1o+SnckD0bZmlqanpH5DX7PmPGDCo6559/fuCcfP/999Pee+9tXJeJOcYrr7xCRYVZQ9/znvcEx8CuHxtKZNbEslzb1157jf73f/+X/vIv/7L015LBr5Pp98k+5QDE4eHhIGK0qNe5aKAdLddvD+1oea5lldvRwglSNqR72GGH0dKlS8cMcbPv8+bNo6LC4kOYGF2yZAndd999NHfu3NBtnnrqqeCTWdeKCktRwayC7BjYdW1paRlzbdlQGvMxLeq1vfbaa4Ph6RNPPLH015LB7lvWGIrXsK+vL/Bp4teQfbKHDuYzzGH3PPsd8w4FJAva0XL99tCOludaVrodrReQm266KYjave6664JIs3PPPbc+YcKE+oYNG+pF5ctf/nK9p6en/sADD9TfeOON0Wn37t3B8ldeeaX+3e9+t/7444/XV69eXb/jjjvq73rXu+of/ehH60XioosuCo6RHcNvf/vb+vz58+tTpkwJsgowvvSlL9XnzJlTv++++4JjnTdvXjAVEZb9gR3LxRdfPGZ+0a/ljh076k8++WQwsSbkiiuuCP5/7bXXguU/+MEPgt8jO65nnnmmfvLJJ9fnzp1b37Nnz2gZJ5xwQv3QQw+tr1ixov7QQw/V999///oZZ5yR4VFVD7SjxfvtcdCOoh0tYztaSEHK+PGPfxx09q2trUH6kkceeaReZFjHrpquvfbaYPmaNWuCRnPSpEmBGH/3u99d/+Y3v1nv7e2tF4nPfvaz9ZkzZwbXba+99gq+M4HGYaLlK1/5Sn3ixIn1cePG1f/sz/4sEOZF5J577gmu4apVq8bML/q1vP/++5X36llnnTWa+umSSy6pT58+PTi+448//h3nYMuWLUHD2dXVVe/u7q6fffbZgdAF6YJ2tFi/PQ7aUbSjZWxHG9ifrK20AAAAAACguhTOhxQAAAAAAJQLCFIAAAAAAJApEKQAAAAAACBTIEgBAAAAAECmQJACAAAAAIBMgSAFAAAAAACZAkEKAAAAAAAyBYIUAAAAAABkCgQpAAAAAADIFAhSAAAAAACQKRCkAAAAAACAsuT/B+z3c3xfxnFIAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "pip.update()\n", + "im, gt = pip.resolve()\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(8, 4))\n", + "\n", + "axs[0].imshow(im[0].cpu().detach().numpy(), cmap=\"gray\")\n", + "axs[1].imshow(gt.max(dim=0)[0]);" + ] + }, + { + "cell_type": "markdown", + "id": "96f0641d", + "metadata": {}, + "source": [ + "## 2. Defining the CNN\n", + "A convolutional neural network (CNN) is used to reconstruct a 3D probability volume of particle positions from a single 2D microscopy image. The network outputs one channel per axial plane, corresponding to the likelihood of a particle at each depth.\n", + "\n", + "### 2.1 Architecture\n", + "The custom class `CNNConcat` extends a standard convolutional neural network by allowing each intermediate layer receive both the original input and the features from the previous layer." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3efed9b4", + "metadata": {}, + "outputs": [], + "source": [ + "import deeplay as dl\n", + "\n", + "\n", + "class CNNConcat(dl.ConvolutionalNeuralNetwork):\n", + " def forward(self, input):\n", + " out = None\n", + "\n", + " for idx, block in enumerate(self.blocks):\n", + "\n", + " if idx == 0:\n", + " out = block(input)\n", + "\n", + " elif idx < len(self.blocks) - 1:\n", + " features = torch.cat((out, input), dim=1)\n", + " new_out = block(features)\n", + " out = new_out + out\n", + "\n", + " else:\n", + " out = block(out)\n", + "\n", + " return out" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "23a07b70", + "metadata": {}, + "outputs": [], + "source": [ + "hidden_dim = 64\n", + "factor = 10.0\n", + "\n", + "CNN = CNNConcat(\n", + " in_channels=1,\n", + " hidden_channels=[hidden_dim + 1] * 8 + [hidden_dim],\n", + " out_channels=depth,\n", + ")\n", + "\n", + "CNN[\"blocks\", \"0\"].prepend(\n", + " dl.Layer(torch.nn.BatchNorm2d, num_features=1),\n", + " name=\"initial_normalization\",\n", + ")\n", + "CNN[..., \"activation\"].all.configure(\n", + " nn.LeakyReLU, negative_slope=0.2, inplace=True\n", + ")\n", + "CNN[...].isinstance(dl.Conv2dBlock).all.normalized(torch.nn.BatchNorm2d)\n", + "CNN[..., \"normalization\"].all.configure(num_features=hidden_dim)\n", + "\n", + "CNN[..., \"layer#:-1\"].configure(out_channels=hidden_dim)\n", + "\n", + "CNN[\"blocks\", \"9\", \"layer\"].configure(kernel_size=1, padding=0)\n", + "CNN[\"blocks\", \"9\"].remove(\"normalization\", allow_missing=True)\n", + "CNN[..., \"activation#-1\"].configure(nn.Hardtanh, min_val=0.0, max_val=factor);" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "0231c5c3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CNNConcat(\n", + " (blocks): LayerList(\n", + " (0): Conv2dBlock(\n", + " (initial_normalization): BatchNorm2d(1, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (layer): Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (activation): LeakyReLU(negative_slope=0.2, inplace=True)\n", + " (normalization): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1-8): 8 x Conv2dBlock(\n", + " (layer): Conv2d(65, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (activation): LeakyReLU(negative_slope=0.2, inplace=True)\n", + " (normalization): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (9): Conv2dBlock(\n", + " (layer): Conv2d(64, 30, kernel_size=(1, 1), stride=(1, 1))\n", + " (activation): Hardtanh(min_val=0.0, max_val=10.0, inplace=True)\n", + " )\n", + " )\n", + ")\n" + ] + } + ], + "source": [ + "cnn = CNN.create()\n", + "\n", + "cnn.to(device)\n", + "print(cnn)" + ] + }, + { + "cell_type": "markdown", + "id": "20cce959", + "metadata": {}, + "source": [ + "Check that the outputs of the cnn and the targets have the same shape:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "4d3f53fc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Preds: torch.Size([2, 30, 121, 121])\n", + "Target: torch.Size([2, 30, 121, 121])\n" + ] + } + ], + "source": [ + "images, gt = [], []\n", + "for _ in range(2):\n", + " pip.update()\n", + " img, g = pip.resolve()\n", + " images.append(img)\n", + " gt.append(g)\n", + "\n", + "images = torch.stack(images).to(device, dtype=torch.float32)\n", + "gt = torch.stack(gt).to(device, dtype=torch.float32)\n", + "\n", + "cnn.eval()\n", + "preds = cnn(images)\n", + "print(\"Preds:\", preds.shape)\n", + "print(\"Target:\", gt.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "e8a87911", + "metadata": {}, + "source": [ + "### 2.2 Loss function\n", + "Training minimizes a combination of a 3D kernel density loss and a Dice loss, adapted from [DeepSTORM-3D](https://www.nature.com/articles/s41592-020-0853-5).\n", + "\n", + "The KDE term compares Gaussian-smoothed versions of prediction and ground truth, providing robustness to small spatial shifts. The Dice term measures voxel-wise overlap, encouraging sparsity and accurate localization." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5d49c805", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import torch.nn.functional as F\n", + "\n", + "\n", + "def dice_loss(pred, target):\n", + " \"\"\"\n", + " This definition generalize to real valued pred and target vector.\n", + " pred: tensor with first dimension as batch\n", + " target: tensor with first dimension as batch\n", + " \"\"\"\n", + "\n", + " smooth = 1.0\n", + "\n", + " # have to use contiguous since they may from a torch.view op\n", + " iflat = pred.contiguous().view(-1)\n", + " tflat = target.contiguous().view(-1)\n", + " intersection = (iflat * tflat).sum()\n", + "\n", + " A_sum = torch.sum(iflat * iflat)\n", + " B_sum = torch.sum(tflat * tflat)\n", + "\n", + " return 1 - ((2.0 * intersection + smooth) / (A_sum + B_sum + smooth))\n", + "\n", + "\n", + "# create a 3D gaussian kernel\n", + "def GaussianKernel(shape=(3, 3, 3), sigma=0.1, normfactor=1):\n", + " \"\"\"\n", + " 3D gaussian mask - should give the same result as MATLAB's\n", + " fspecial('gaussian',[shape],[sigma]) in 3D\n", + " \"\"\"\n", + " m, n, p = [(ss - 1.0) / 2.0 for ss in shape]\n", + " y, x, z = np.ogrid[-m : m + 1, -n : n + 1, -p : p + 1]\n", + " h = np.exp(-(x * x + y * y + z * z) / (2 * sigma**2))\n", + " h[h < np.finfo(h.dtype).eps * h.max()] = 0\n", + " \"\"\"\n", + " sumh = h.sum()\n", + " if sumh != 0:\n", + " h /= sumh\n", + " h = h * normfactor\n", + " \"\"\"\n", + " maxh = h.max()\n", + " if maxh != 0:\n", + " h /= maxh\n", + " h = h * normfactor\n", + " h = torch.from_numpy(h).type(torch.FloatTensor)\n", + " h = h.unsqueeze(0)\n", + " h = h.unsqueeze(1)\n", + " return h\n", + "\n", + "\n", + "# define the 3D extended loss function from DeepSTORM\n", + "class KDE_loss3D(nn.Module):\n", + " def __init__(self, factor, device):\n", + " super(KDE_loss3D, self).__init__()\n", + " self.kernel = GaussianKernel().to(device)\n", + " self.factor = factor\n", + "\n", + " def forward(self, pred_bol, target_bol):\n", + "\n", + " # extract kernel dimensions\n", + " N, C, D, H, W = self.kernel.size()\n", + "\n", + " # extend prediction and target to have a single channel\n", + " target_bol = target_bol.unsqueeze(1)\n", + " pred_bol = pred_bol.unsqueeze(1)\n", + "\n", + " # KDE for both input and ground truth spikes\n", + " Din = F.conv3d(\n", + " pred_bol, self.kernel, padding=(int(np.round((D - 1) / 2)), 0, 0)\n", + " )\n", + " Dtar = F.conv3d(\n", + " target_bol,\n", + " self.factor * self.kernel,\n", + " padding=(int(np.round((D - 1) / 2)), 0, 0),\n", + " )\n", + "\n", + " kde_loss = nn.MSELoss()(Din, Dtar)\n", + "\n", + " # final loss\n", + " final_loss = kde_loss + dice_loss(pred_bol / self.factor, target_bol)\n", + "\n", + " return final_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "41248a71", + "metadata": {}, + "outputs": [], + "source": [ + "loss_fn = KDE_loss3D(factor=factor, device=device)" + ] + }, + { + "cell_type": "markdown", + "id": "1863bbeb", + "metadata": {}, + "source": [ + "### 2.3 Joint optimization\n", + "The CNN and the learnable phase mask are optimized together using the Adam optimizer.\n", + "Gradients propagate through both the network and the optical model, allowing the phase mask to adapt so that the simulated images become more informative for localization." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "2b4ca296", + "metadata": {}, + "outputs": [], + "source": [ + "optimizer = torch.optim.Adam(\n", + " list(phase_mask.parameters()) + list(cnn.parameters()), lr=1e-3\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "85f1f354", + "metadata": {}, + "source": [ + "## 3. Training the CNN and the phase mask\n", + "### 3.1 Visualize the phase mask before training\n", + "Before starting the optimization, the initial phase mask can be inspected to verify its values and distribution. At this stage, all phase values are zero, corresponding to an untrained, flat wavefront." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "63aabfd0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Phase mask statistics — min: 0.0 max: 0.0 mean: 0.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "phase_mask_before = phase_mask.phase.cpu().detach().clone()\n", + "print(\n", + " \"Phase mask statistics — min:\", phase_mask.phase.min().item(),\n", + " \"max:\", phase_mask.phase.max().item(),\n", + " \"mean:\", phase_mask.phase.mean().item(),\n", + ")\n", + "\n", + "plt.imshow(phase_mask_before, cmap=\"coolwarm\")\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f70f4a2c", + "metadata": {}, + "source": [ + "### 3.2 Joint training of the CNN and the phase mask\n", + "\n", + "The CNN and the phase mask are trained jointly using a custom training loop.\n", + "\n", + "Because the simulated images depend on the current phase mask, the simulation pipeline must be updated each epoch. This ensures that new image batches reflect the latest state of the optical system. If the dataset were generated only once before training, all images would correspond to the untrained phase mask, and the phase mask would not receive meaningful gradient updates.\n", + "\n", + "For each epoch, a new batch of synthetic images and their ground-truth particle positions is generated. The loss is then computed and backpropagated, updating both the CNN and the phase mask parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "9b1f6b57", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0, Loss: 1.9364\n", + "Epoch 50, Loss: 0.8802\n", + "Epoch 100, Loss: 0.7680\n", + "Epoch 150, Loss: 0.7135\n", + "Epoch 200, Loss: 0.6818\n", + "Epoch 250, Loss: 0.5940\n", + "Epoch 300, Loss: 0.5573\n", + "Epoch 350, Loss: 0.4878\n", + "Epoch 400, Loss: 0.4936\n", + "Epoch 450, Loss: 0.5192\n", + "Epoch 500, Loss: 0.4708\n", + "Epoch 550, Loss: 0.4454\n", + "Epoch 600, Loss: 0.4676\n", + "Epoch 650, Loss: 0.4847\n", + "Epoch 700, Loss: 0.4641\n", + "Epoch 750, Loss: 0.4695\n", + "Epoch 800, Loss: 0.4584\n", + "Epoch 850, Loss: 0.4581\n", + "Epoch 900, Loss: 0.4682\n", + "Epoch 950, Loss: 0.4481\n" + ] + } + ], + "source": [ + "num_epochs = 1000\n", + "batch_size = 10\n", + "loss_history = []\n", + "\n", + "for epoch in range(num_epochs):\n", + " cnn.train()\n", + "\n", + " images, gt = [], []\n", + " for _ in range(batch_size):\n", + " pip.update()\n", + " img, g = pip.resolve()\n", + " images.append(img)\n", + " gt.append(g)\n", + "\n", + " images = torch.stack(images).to(device, dtype=torch.float32)\n", + " gt = torch.stack(gt).to(device, dtype=torch.float32)\n", + "\n", + " optimizer.zero_grad(set_to_none=True)\n", + " preds = cnn(images)\n", + " loss = loss_fn(preds, gt)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " loss_history.append(loss.detach().cpu().item())\n", + "\n", + " if (epoch % 50) == 0:\n", + " print(f\"Epoch {epoch}, Loss: {loss.detach().cpu().item():.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "a5d574c7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 5))\n", + "plt.plot(range(len(loss_history)), loss_history, label=\"Training Loss\")\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Epoch\")\n", + "plt.ylabel(\"Loss\")\n", + "plt.title(\"Training Loss over Time\")\n", + "plt.grid(True)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8ba5c7eb", + "metadata": {}, + "source": [ + "### 3.3 Visualize the phase mask after training\n", + "After training, the optimized phase mask can be visualized. Comparing the initial and final phase masks provides insight into how the learning process has adapted the optical system." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "8df31c19", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Phase mask stats — min: -0.620, max: 0.614, mean: -0.000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "phase_mask_after = phase_mask.phase.cpu().detach().clone()\n", + "print(\n", + " f\"Phase mask stats — min: {phase_mask.phase.min():.3f}, \"\n", + " f\"max: {phase_mask.phase.max():.3f}, \"\n", + " f\"mean: {phase_mask.phase.mean():.3f}\"\n", + ")\n", + "\n", + "plt.imshow(phase_mask_after, cmap=\"coolwarm\")\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5be6c7c1", + "metadata": {}, + "source": [ + "## 4. Post-processing\n", + "The post-processing module, adapted from [DeepSTORM3D](https://www.nature.com/articles/s41592-020-0853-5), converts the network’s 3D confidence volume into discrete particle coordinates. It identifies local intensity maxima above a confidence threshold and refines their positions to sub-voxel accuracy. The output consists of the estimated particle coordinates and their corresponding confidence values." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "e48f01f0", + "metadata": {}, + "outputs": [], + "source": [ + "from torch.nn import Module, MaxPool3d, ConstantPad3d, MaxPool2d\n", + "from torch.nn.functional import conv3d\n", + "\n", + "\n", + "# convert gpu tensors to numpy\n", + "def tensor_to_np(x):\n", + " return np.squeeze(x.detach().cpu().numpy())\n", + "\n", + "\n", + "# post-processing module: thresholding and local maxima finding\n", + "class Postprocess(Module):\n", + " def __init__(self, device, thresh=40, radius=4, keep_singlez=False):\n", + " \"\"\"\n", + " Parameters:\n", + " -----------\n", + " device : torch device\n", + " GPU/CPU device to run on\n", + " thresh : float\n", + " Minimum confidence threshold for candidate detections\n", + " radius : int\n", + " Neighborhood radius (defines local region size = 2r+1)\n", + " keep_singlez : bool\n", + " If True, keep only one z-maximum per (x, y) location\n", + " \"\"\"\n", + " super().__init__()\n", + " self.device = device\n", + " self.thresh = thresh\n", + " self.r = radius\n", + " self.keep_singlez = keep_singlez\n", + "\n", + " # Max pooling layers for local maxima detection\n", + " self.maxpool = MaxPool3d(\n", + " kernel_size=2 * self.r + 1, stride=1, padding=self.r\n", + " )\n", + " self.maxpool2 = MaxPool2d(\n", + " kernel_size=2 * self.r + 1, stride=1, padding=self.r\n", + " )\n", + "\n", + " self.pad = ConstantPad3d(self.r, 0.0)\n", + " self.zero = torch.FloatTensor([0.0]).to(self.device)\n", + "\n", + " # Construct local filters for sub-voxel refinement\n", + " filt_vec = np.arange(-self.r, self.r + 1)\n", + " yfilter, zfilter, xfilter = np.meshgrid(filt_vec, filt_vec, filt_vec)\n", + " xfilter = torch.FloatTensor(xfilter).unsqueeze(0).unsqueeze(0)\n", + " yfilter = torch.FloatTensor(yfilter).unsqueeze(0).unsqueeze(0)\n", + " zfilter = torch.FloatTensor(zfilter).unsqueeze(0).unsqueeze(0)\n", + " sfilter = torch.ones_like(xfilter)\n", + " self.local_filter = torch.cat(\n", + " (sfilter, xfilter, yfilter, zfilter), 0\n", + " ).to(self.device)\n", + "\n", + " def keep_maxz(self, conf_vol):\n", + " \"\"\"Keep only the strongest maximum along z for each (x, y).\"\"\"\n", + "\n", + " D, H, W = conf_vol.shape\n", + "\n", + " max_proj, _ = torch.max(conf_vol, dim=0, keepdim=True)\n", + "\n", + " # keep only local maxima in 2d\n", + " max_proj = self.maxpool2(max_proj.unsqueeze(0))\n", + " max_proj = max_proj.squeeze(0)\n", + "\n", + " # keep only maximum\n", + " conf_vol_out = torch.where(\n", + " conf_vol == max_proj.expand(D, H, W), conf_vol, self.zero\n", + " )\n", + "\n", + " return conf_vol_out\n", + "\n", + " def local_avg(self, xbool, ybool, zbool, pred_vol_pad, num_pts, device):\n", + " \"\"\"Compute sub-voxel position refinement using local weighted averages.\"\"\"\n", + "\n", + " # Collect local (2r+1)^3 cubes around each candidate\n", + " pred_vol_all = torch.zeros(\n", + " num_pts, 1, self.r * 2 + 1, self.r * 2 + 1, self.r * 2 + 1\n", + " ).to(device)\n", + " for pt in range(num_pts):\n", + "\n", + " # local 3D volume\n", + " xpt = [xbool[pt], xbool[pt] + 2 * self.r + 1]\n", + " ypt = [ybool[pt], ybool[pt] + 2 * self.r + 1]\n", + " zpt = [zbool[pt], zbool[pt] + 2 * self.r + 1]\n", + " pred_vol_all[pt, :] = pred_vol_pad[\n", + " :, :, zpt[0] : zpt[1], ypt[0] : ypt[1], xpt[0] : xpt[1]\n", + " ]\n", + "\n", + " # convolve it using conv3d\n", + " sums = conv3d(pred_vol_all, self.local_filter)\n", + "\n", + " # squeeze the sums and convert them to local perturbations\n", + " xloc = sums[:, 1] / sums[:, 0]\n", + " yloc = sums[:, 2] / sums[:, 0]\n", + " zloc = sums[:, 3] / sums[:, 0]\n", + "\n", + " return xloc, yloc, zloc\n", + "\n", + " def forward(self, pred_vol):\n", + " \"\"\"Main postprocessing pipeline:\n", + " Input: 3D confidence volume (output of network)\n", + " Output: xyz_rec (N×3 array of particle coordinates),\n", + " conf_rec (N array of confidences)\n", + " \"\"\"\n", + "\n", + " # Ensure 5D tensor shape: (B, C, D, H, W)\n", + " num_dims = len(pred_vol.size())\n", + " if np.not_equal(num_dims, 5):\n", + " if num_dims == 4:\n", + " pred_vol = pred_vol.unsqueeze(0)\n", + " else:\n", + " pred_vol = pred_vol.unsqueeze(0)\n", + " pred_vol = pred_vol.unsqueeze(0)\n", + "\n", + " # Thresholding\n", + " pred_thresh = torch.where(pred_vol > self.thresh, pred_vol, self.zero)\n", + "\n", + " # 3D local maxima detection\n", + " conf_vol = self.maxpool(pred_thresh)\n", + " conf_vol = torch.where(\n", + " (conf_vol > self.zero) & (conf_vol == pred_thresh),\n", + " conf_vol,\n", + " self.zero,\n", + " )\n", + "\n", + " # Optionally keep only a single z in each xy sub-pixel\n", + " if self.keep_singlez:\n", + " conf_vol = torch.squeeze(conf_vol)\n", + " conf_vol = self.keep_maxz(conf_vol)\n", + "\n", + " # Find locations of confs (bigger than 0)\n", + " conf_vol = torch.squeeze(conf_vol)\n", + " batch_indices = torch.nonzero(conf_vol)\n", + " zbool, ybool, xbool = (\n", + " batch_indices[:, 0],\n", + " batch_indices[:, 1],\n", + " batch_indices[:, 2],\n", + " )\n", + "\n", + " # If no detections, return None\n", + " if len(zbool) == 0:\n", + " xyz_rec = None\n", + " conf_rec = None\n", + "\n", + " else:\n", + " # Sub-voxel refinement\n", + " # pad the result with radius_px 0's for average calc.\n", + " pred_vol_pad = self.pad(pred_vol)\n", + "\n", + " # for each point calculate local weighted average\n", + " num_pts = len(zbool)\n", + " xloc, yloc, zloc = self.local_avg(\n", + " xbool, ybool, zbool, pred_vol_pad, num_pts, self.device\n", + " )\n", + "\n", + " # Convert lists and tensors to NumPy\n", + " xloc, yloc, zloc = (\n", + " tensor_to_np(xloc),\n", + " tensor_to_np(yloc),\n", + " tensor_to_np(zloc),\n", + " )\n", + " xbool, ybool, zbool = (\n", + " tensor_to_np(xbool),\n", + " tensor_to_np(ybool),\n", + " tensor_to_np(zbool),\n", + " )\n", + "\n", + " # Calculate the recovered positions assuming mid-voxel\n", + " xrec = xbool + xloc\n", + " yrec = ybool + yloc\n", + " zrec = zbool + zloc\n", + "\n", + " # rearrange the result into a Nx3 array\n", + " xyz_rec = np.column_stack((xrec, yrec, zrec))\n", + "\n", + " # Extract confidence values\n", + " conf_rec = conf_vol[zbool, ybool, xbool]\n", + " conf_rec = tensor_to_np(conf_rec)\n", + "\n", + " xyz_rec, conf_rec = self.remove_duplicates(xyz_rec, conf_rec)\n", + "\n", + " return xyz_rec, conf_rec\n", + "\n", + " def remove_duplicates(self, xyz_rec, conf_rec, tol=1e-4):\n", + " \"\"\"\n", + " Remove duplicate positions (within tolerance) while keeping\n", + " confidence values aligned.\n", + " \"\"\"\n", + " if xyz_rec is None or len(xyz_rec) == 0:\n", + " return xyz_rec, conf_rec\n", + "\n", + " rounded = np.round(xyz_rec / tol).astype(np.int64)\n", + " _, unique_idx = np.unique(rounded, axis=0, return_index=True)\n", + " unique_idx = np.sort(unique_idx)\n", + "\n", + " xyz_rec = xyz_rec[unique_idx]\n", + " if conf_rec is not None:\n", + " conf_rec = conf_rec[unique_idx]\n", + "\n", + " return xyz_rec, conf_rec" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "33995ae0", + "metadata": {}, + "outputs": [], + "source": [ + "radius = 2\n", + "threshold = 2\n", + "\n", + "postprocessing_module = Postprocess(\n", + " device, thresh=threshold, radius=radius, keep_singlez=True\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "0caad544", + "metadata": {}, + "source": [ + "## 5. Performance evaluation\n", + "### 5.1 Jaccard index\n", + "Model performance is quantified using the Jaccard index (intersection-over-union) between predicted and ground-truth particle positions within a given spatial tolerance." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "23a4fb4e", + "metadata": {}, + "outputs": [], + "source": [ + "def jaccard_coeff(pred, target, postprocessing, max_dist=2):\n", + " \"\"\"\n", + " jaccard index = TP / (TP + FP + FN)\n", + " pred: tensor with first dimension as batch\n", + " target: tensor with first dimension as batch\n", + " \"\"\"\n", + " xyz_rec, conf_rec = postprocessing(pred)\n", + " if xyz_rec is None or len(xyz_rec) == 0:\n", + " return torch.tensor(0.0)\n", + "\n", + " xyz_target = torch.nonzero(target)[:, [2, 1, 0]]\n", + "\n", + " D = torch.cdist(torch.tensor(xyz_rec), xyz_target.cpu().to(torch.float64))\n", + "\n", + " # Each prediction and ground truth can only be part of one TP\n", + " matched_pred = set()\n", + " matched_gt = set()\n", + " TP = 0\n", + " while True:\n", + " min_val, idx = torch.min(D.view(-1), dim=0)\n", + " if min_val > max_dist or not torch.isfinite(min_val):\n", + " break\n", + " i = idx // D.size(1)\n", + " j = idx % D.size(1)\n", + " TP += 1\n", + " matched_pred.add(i.item())\n", + " matched_gt.add(j.item())\n", + " D[i, :] = float(\"inf\")\n", + " D[:, j] = float(\"inf\")\n", + "\n", + " FP = len(xyz_rec) - TP\n", + " FN = len(xyz_target) - TP\n", + "\n", + " JI = TP / (TP + FP + FN + 1e-6)\n", + "\n", + " return JI" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "02c70efc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(0.7635)\n" + ] + } + ], + "source": [ + "num_tests = 100\n", + "jaccard_index = []\n", + "jaccard_index_coords = []\n", + "\n", + "cnn.eval()\n", + "\n", + "for j in range(num_tests):\n", + " pip.update()\n", + " img, g = pip.resolve()\n", + " g = g.to(device)\n", + "\n", + " pred = cnn(img.unsqueeze(0))\n", + "\n", + " jaccard_index.append(jaccard_coeff(pred, g, postprocessing_module))\n", + "\n", + "average_jaccard_index = torch.mean(torch.tensor(jaccard_index))\n", + "print(average_jaccard_index)" + ] + }, + { + "cell_type": "markdown", + "id": "f98f2249", + "metadata": {}, + "source": [ + "### 5.2 Visualization in 2D\n", + "The predictions and ground truth are compared as 2D maximum-intensity projections along the axial direction, providing an intuitive overview of localization accuracy in the image plane." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "4d20b8de", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_samples = 5\n", + "fig, ax = plt.subplots(num_samples, 4, figsize=(20, 5 * num_samples))\n", + "\n", + "images, gt, exact_pos = [], [], []\n", + "for _ in range(num_samples):\n", + " pip.update()\n", + " img, g = pip.resolve()\n", + " pos = xyz.points\n", + " images.append(img)\n", + " gt.append(g)\n", + " exact_pos.append(pos)\n", + "\n", + "images = torch.stack(images)\n", + "gt = torch.stack(gt)\n", + "\n", + "cnn.eval()\n", + "preds = cnn(images)\n", + "\n", + "for i in range(num_samples):\n", + "\n", + " xyz_rec, conf_rec = postprocessing_module(preds[i])\n", + " xyz_target = torch.nonzero(gt[i])[:, [2, 1, 0]]\n", + "\n", + " ax[i, 0].imshow(images[i, 0].cpu().detach().numpy(), cmap=\"gray\")\n", + " ax[i, 1].imshow(preds[i].max(dim=0)[0].cpu().detach().numpy())\n", + " ax[i, 2].imshow(gt[i].max(dim=0)[0].cpu().detach().numpy())\n", + " ax[i, 2].plot(xyz_rec[:, 0], xyz_rec[:, 1], c=\"red\", marker=\".\", ls=\" \")\n", + " ax[i, 3].imshow(gt[i].max(dim=0)[0].cpu().detach().numpy())\n", + "\n", + "ax[0, 0].set_title(\"Input image\")\n", + "ax[0, 1].set_title(\"Prediction\")\n", + "ax[0, 2].set_title(\"Ground truth + prediction in red\")\n", + "ax[0, 3].set_title(\"Ground truth\");" + ] + }, + { + "cell_type": "markdown", + "id": "a0152702", + "metadata": {}, + "source": [ + "### 5.3 Visualization in 3D\n", + "\n", + "Predicted and ground-truth particle coordinates are displayed in 3D to assess depth accuracy and separation in dense regions." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "5d4137ed", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sample = 4\n", + "\n", + "fig = plt.figure(figsize=(14, 7))\n", + "\n", + "ax1 = fig.add_subplot(121)\n", + "ax1.imshow(images[sample, 0].cpu().detach().numpy(), cmap=\"gray\")\n", + "ax1.set_xlabel(\"y\")\n", + "ax1.set_ylabel(\"x\")\n", + "ax1.set_title(\"Input image\")\n", + "\n", + "\n", + "xyz_rec, conf_rec = postprocessing_module(preds[sample])\n", + "xyz_target = torch.nonzero(gt[sample])[:, [2, 1, 0]]\n", + "\n", + "ax2 = fig.add_subplot(122, projection=\"3d\")\n", + "ax2.scatter(\n", + " exact_pos[sample][:, 1],\n", + " exact_pos[sample][:, 0],\n", + " exact_pos[sample][:, 2],\n", + " c=\"red\",\n", + " marker=\"o\",\n", + " s=100,\n", + " label=\"Ground truth\",\n", + " alpha=0.3,\n", + ")\n", + "ax2.scatter(\n", + " xyz_rec[:, 0],\n", + " xyz_rec[:, 1],\n", + " xyz_rec[:, 2],\n", + " c=\"blue\",\n", + " marker=\"o\",\n", + " s=30,\n", + " label=\"Prediction\",\n", + " alpha=1,\n", + ")\n", + "\n", + "ax2.set_xlabel(\"y\")\n", + "ax2.set_ylabel(\"x\")\n", + "ax2.set_zlabel(\"z\")\n", + "ax2.set_xlim(0, image_size)\n", + "ax2.set_ylim(0, image_size)\n", + "ax2.set_zlim(0, depth)\n", + "ax2.set_title(\"Predicted & Ground truth positions\")\n", + "ax2.legend();" + ] + }, + { + "cell_type": "markdown", + "id": "ef0268f1", + "metadata": {}, + "source": [ + "## 6. Comparison without a trainable phase mask\n", + "To understand the effect of the trainable phase mask, an identical training and evaluation protocol is repeated with the phase mask removed.\n", + "\n", + "### 6.1 Training without the phase mask\n", + "The optical model is instantiated without a pupil function, and a copy of the CNN is trained using the same optimizer, batch size, and number of epochs. The loss function remains unchanged. The post-processing threshold is slightly adjusted to achieve optimal performance in this configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "edd1bcd0", + "metadata": {}, + "outputs": [], + "source": [ + "optics_no_phase_mask = dt.Fluorescence(\n", + " NA=1.45,\n", + " refractive_index_medium=1.33,\n", + " output_region=(0, 0, image_size, image_size),\n", + ")\n", + "\n", + "im_pip_no_phase_mask = (\n", + " optics_no_phase_mask(particle ^ num_points)\n", + " >> noise_poisson\n", + " >> noise_gaussian\n", + ")\n", + "\n", + "pip_no_phase_mask = (im_pip_no_phase_mask & gt_pip) >> dt.MoveAxis(2, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "87b30e58", + "metadata": {}, + "outputs": [], + "source": [ + "cnn_no_phase_mask = CNN.create()\n", + "cnn_no_phase_mask.to(device)\n", + "\n", + "optimizer_no_phase_mask = torch.optim.Adam(\n", + " list(cnn_no_phase_mask.parameters()), lr=1e-3\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "640f4d39", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0, Loss: 1.7318\n", + "Epoch 50, Loss: 0.8356\n", + "Epoch 100, Loss: 0.7817\n", + "Epoch 150, Loss: 0.7220\n", + "Epoch 200, Loss: 0.7109\n", + "Epoch 250, Loss: 0.6354\n", + "Epoch 300, Loss: 0.6048\n", + "Epoch 350, Loss: 0.5981\n", + "Epoch 400, Loss: 0.5540\n", + "Epoch 450, Loss: 0.5273\n", + "Epoch 500, Loss: 0.5394\n", + "Epoch 550, Loss: 0.5351\n", + "Epoch 600, Loss: 0.5180\n", + "Epoch 650, Loss: 0.5537\n", + "Epoch 700, Loss: 0.4988\n", + "Epoch 750, Loss: 0.4955\n", + "Epoch 800, Loss: 0.5093\n", + "Epoch 850, Loss: 0.5022\n", + "Epoch 900, Loss: 0.4898\n", + "Epoch 950, Loss: 0.4687\n" + ] + } + ], + "source": [ + "loss_history = []\n", + "\n", + "for epoch in range(num_epochs):\n", + " cnn_no_phase_mask.train()\n", + "\n", + " images, gt = [], []\n", + " for _ in range(batch_size):\n", + " pip_no_phase_mask.update()\n", + " img, g = pip_no_phase_mask.resolve()\n", + " images.append(img)\n", + " gt.append(g)\n", + "\n", + " images = torch.stack(images)\n", + " gt = torch.stack(gt).to(device, dtype=torch.float32)\n", + "\n", + " optimizer_no_phase_mask.zero_grad(set_to_none=True)\n", + " preds = cnn_no_phase_mask(images)\n", + " loss = loss_fn(preds, gt)\n", + " loss.backward()\n", + " optimizer_no_phase_mask.step()\n", + "\n", + " loss_history.append(loss.detach().cpu().item())\n", + "\n", + " if (epoch % 50) == 0:\n", + " print(f\"Epoch {epoch}, Loss: {loss.detach().cpu().item():.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "e6621526", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 5))\n", + "plt.plot(range(len(loss_history)), loss_history, label=\"Training Loss\")\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Epoch\")\n", + "plt.ylabel(\"Loss\")\n", + "plt.title(\"Training Loss over Time\")\n", + "plt.grid(True)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "da9038bb", + "metadata": {}, + "outputs": [], + "source": [ + "threshold_no_phase_mask = 1\n", + "\n", + "postprocessing_module_no_phase_mask = Postprocess(\n", + " device, thresh=threshold_no_phase_mask, radius=radius, keep_singlez=True\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "37281e94", + "metadata": {}, + "source": [ + "### 6.2 Performance evaluation\n", + "Performance is evaluated in the same manner as with the trainable phase mask, combining the Jaccard index and 2D/3D visualizations." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "6bc12a53", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(0.5868)\n" + ] + } + ], + "source": [ + "jaccard_index = []\n", + "jaccard_index_coords = []\n", + "\n", + "for _ in range(num_tests):\n", + " pip_no_phase_mask.update()\n", + " img, g = pip_no_phase_mask.resolve()\n", + " g = g.to(device)\n", + "\n", + " pred = cnn_no_phase_mask(img.unsqueeze(0))\n", + "\n", + " jaccard_index.append(\n", + " jaccard_coeff(pred, g, postprocessing_module_no_phase_mask)\n", + " )\n", + "\n", + "average_jaccard_index = torch.mean(torch.tensor(jaccard_index))\n", + "print(average_jaccard_index)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "6c077de8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_samples = 5\n", + "fig, ax = plt.subplots(num_samples, 4, figsize=(20, 5 * num_samples))\n", + "\n", + "images, gt = [], []\n", + "for _ in range(num_samples):\n", + " pip_no_phase_mask.update()\n", + " img, g = pip_no_phase_mask.resolve()\n", + " images.append(img)\n", + " gt.append(g)\n", + "\n", + "images = torch.stack(images)\n", + "gt = torch.stack(gt)\n", + "\n", + "cnn_no_phase_mask.eval()\n", + "preds = cnn_no_phase_mask(images)\n", + "\n", + "for i in range(num_samples):\n", + "\n", + " xyz_rec, conf_rec = postprocessing_module_no_phase_mask(preds[i])\n", + "\n", + " xyz_target = torch.nonzero(gt[i])[:, [2, 1, 0]]\n", + "\n", + " ax[i, 0].imshow(images[i, 0].cpu().detach().numpy(), cmap=\"gray\")\n", + " ax[i, 1].imshow(preds[i].max(dim=0)[0].cpu().detach().numpy())\n", + " ax[i, 2].imshow(gt[i].max(dim=0)[0].cpu().detach().numpy())\n", + " ax[i, 2].plot(xyz_rec[:, 0], xyz_rec[:, 1], c=\"red\", marker=\".\", ls=\" \")\n", + " ax[i, 3].imshow(gt[i].max(dim=0)[0].cpu().detach().numpy())\n", + "\n", + "ax[0, 0].set_title(\"Input image\")\n", + "ax[0, 1].set_title(\"Prediction\")\n", + "ax[0, 2].set_title(\"Ground truth + prediction in red\")\n", + "ax[0, 3].set_title(\"Ground truth\");" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "7640bb1d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sample = 0\n", + "\n", + "fig = plt.figure(figsize=(14, 7))\n", + "\n", + "ax1 = fig.add_subplot(121)\n", + "ax1.imshow(images[sample, 0].cpu().detach().numpy(), cmap=\"gray\")\n", + "ax1.set_xlabel(\"y\")\n", + "ax1.set_ylabel(\"x\")\n", + "ax1.set_title(\"Input image\")\n", + "\n", + "\n", + "xyz_rec, conf_rec = postprocessing_module_no_phase_mask(preds[sample])\n", + "xyz_target = torch.nonzero(gt[sample])[:, [2, 1, 0]]\n", + "\n", + "ax2 = fig.add_subplot(122, projection=\"3d\")\n", + "ax2.scatter(\n", + " xyz_target[:, 0],\n", + " xyz_target[:, 1],\n", + " xyz_target[:, 2],\n", + " c=\"red\",\n", + " marker=\"o\",\n", + " s=100,\n", + " label=\"Ground truth\",\n", + " alpha=0.3,\n", + ")\n", + "ax2.scatter(\n", + " xyz_rec[:, 0],\n", + " xyz_rec[:, 1],\n", + " xyz_rec[:, 2],\n", + " c=\"blue\",\n", + " marker=\"o\",\n", + " s=30,\n", + " label=\"Prediction\",\n", + " alpha=1,\n", + ")\n", + "\n", + "ax2.set_xlabel(\"x\")\n", + "ax2.set_ylabel(\"y\")\n", + "ax2.set_zlabel(\"z\")\n", + "ax2.set_xlim(0, image_size)\n", + "ax2.set_ylim(0, image_size)\n", + "ax2.set_zlim(0, depth)\n", + "ax2.set_title(\"Predicted & Ground truth positions\")\n", + "ax2.legend();" + ] + } + ], + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}