From 32a2dc6988fc05312f9b7a4e958c4ef0cf59839e Mon Sep 17 00:00:00 2001 From: Wenqi Li Date: Sun, 5 Jun 2022 22:35:57 +0100 Subject: [PATCH 1/5] adds 2d/3d example Signed-off-by: Wenqi Li --- modules/training_with_2d_slices.py | 208 +++++++++++++++++++++++++++++ 1 file changed, 208 insertions(+) create mode 100644 modules/training_with_2d_slices.py diff --git a/modules/training_with_2d_slices.py b/modules/training_with_2d_slices.py new file mode 100644 index 0000000000..70ed010ee0 --- /dev/null +++ b/modules/training_with_2d_slices.py @@ -0,0 +1,208 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import logging +import os +import sys +import tempfile +from glob import glob + +import matplotlib.pyplot as plt +import monai +import nibabel as nib +import numpy as np +import torch +from monai.data import DataLoader, PatchDataset, create_test_image_3d, list_data_collate +from monai.inferers import SliceInferer +from monai.transforms import ( + AsChannelFirstd, + Compose, + EnsureTyped, + LoadImaged, + RandCropByPosNegLabeld, + RandRotate90d, + Resized, + ResizeWithPadOrCropd, + ScaleIntensityd, + SqueezeDimd, +) +from monai.visualize import matshow3d + + +def main(tempdir): + monai.config.print_config() + logging.basicConfig(stream=sys.stdout, level=logging.INFO) + + # ----- + # make demo data + # ----- + # create a temporary directory and 40 random image, mask pairs + print(f"generating synthetic data to {tempdir} (this may take a while)") + for i in range(40): + # make the input volumes different spatial shapes for demo purposes + H, W, D = 30 + i, 40 + i, 50 + i + im, seg = create_test_image_3d( + H, W, D, num_seg_classes=1, channel_dim=-1, rad_max=10 + ) + + n = nib.Nifti1Image(im, np.eye(4)) + nib.save(n, os.path.join(tempdir, f"img{i:d}.nii.gz")) + + n = nib.Nifti1Image(seg, np.eye(4)) + nib.save(n, os.path.join(tempdir, f"seg{i:d}.nii.gz")) + + images = sorted(glob(os.path.join(tempdir, "img*.nii.gz"))) + segs = sorted(glob(os.path.join(tempdir, "seg*.nii.gz"))) + train_files = [{"img": img, "seg": seg} for img, seg in zip(images[:35], segs[:35])] + + # ----- + # volume-level preprocessing + # ----- + # volume-level transforms for both image and segmentation + train_transforms = Compose( + [ + LoadImaged(keys=["img", "seg"]), + AsChannelFirstd(keys=["img", "seg"], channel_dim=-1), + ScaleIntensityd(keys="img"), + RandRotate90d(keys=["img", "seg"], prob=0.5, spatial_axes=[0, 2]), + EnsureTyped(keys=["img", "seg"]), + ] + ) + # 3D dataset with preprocessing transforms + volume_ds = monai.data.Dataset(data=train_files, transform=train_transforms) + # use batch_size=1 to check the volumes because the input volumes have different shapes + check_loader = DataLoader(volume_ds, batch_size=1, collate_fn=list_data_collate) + check_data = monai.utils.misc.first(check_loader) + print("first volume's shape: ", check_data["img"].shape, check_data["seg"].shape) + + # ----- + # volume to patch sampling + # ----- + # define the sampling transforms, could also be other spatial cropping transforms + # https://docs.monai.io/en/stable/transforms.html#crop-and-pad-dict + num_samples = 4 + patch_func = RandCropByPosNegLabeld( + keys=["img", "seg"], + label_key="seg", + spatial_size=[-1, -1, 1], # dynamic spatial_size for the first two dimensions + pos=1, + neg=1, + num_samples=num_samples, + ) + + # ----- + # patch-level preprocessing + # ----- + # resize the sampled slices to a consistent size so that we can batch + # the last spatial dim is always 1, so we squeeze dim. + patch_transform = Compose( + [ + SqueezeDimd(keys=["img", "seg"], dim=-1), # squeeze the last dim + Resized(keys=["img", "seg"], spatial_size=[48, 48]), + # ResizeWithPadOrCropd(keys=["img", "seg"], spatial_size=[48, 48], mode="replicate"), + ] + ) + patch_ds = PatchDataset( + volume_ds, + transform=patch_transform, + patch_func=patch_func, + samples_per_image=num_samples, + ) + train_loader = DataLoader( + patch_ds, + batch_size=3, + shuffle=True, # this shuffles slices from different volumes + num_workers=2, + pin_memory=torch.cuda.is_available(), + ) + check_data = monai.utils.misc.first(train_loader) + print("first patch's shape: ", check_data["img"].shape, check_data["seg"].shape) + + # ----- + # network defined for 2d inputs + # ----- + # create UNet, DiceLoss and Adam optimizer + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + model = monai.networks.nets.UNet( + spatial_dims=2, + in_channels=1, + out_channels=1, + channels=(16, 32, 64, 128), + strides=(2, 2, 2), + num_res_units=2, + ).to(device) + loss_function = monai.losses.DiceLoss(sigmoid=True) + optimizer = torch.optim.Adam(model.parameters(), 5e-3) + + # ----- + # training + # ----- + epoch_loss_values = [] + num_epochs = 5 + for epoch in range(num_epochs): + print("-" * 10) + print(f"epoch {epoch + 1}/{num_epochs}") + model.train() + epoch_loss, step = 0, 0 + for batch_data in train_loader: + step += 1 + inputs, labels = batch_data["img"].to(device), batch_data["seg"].to(device) + optimizer.zero_grad() + outputs = model(inputs) + loss = loss_function(outputs, labels) + loss.backward() + optimizer.step() + epoch_loss += loss.item() + epoch_len = len(patch_ds) // train_loader.batch_size + if step % 25 == 0: + print(f"{step}/{epoch_len}, train_loss: {loss.item():.4f}") + epoch_loss /= step + epoch_loss_values.append(epoch_loss) + print(f"epoch {epoch + 1} average loss: {epoch_loss:.4f}") + print("train completed") + + # ----- + # inference with a SliceInferer + # ----- + model.eval() + val_transform = Compose( + [ + LoadImaged(keys=["img", "seg"]), + AsChannelFirstd(keys=["img", "seg"], channel_dim=-1), + ScaleIntensityd(keys="img"), + EnsureTyped(keys=["img", "seg"]), + ] + ) + val_files = [{"img": img, "seg": seg} for img, seg in zip(images[-3:], segs[-3:])] + val_ds = monai.data.Dataset(data=val_files, transform=val_transform) + data_loader = DataLoader(val_ds, pin_memory=torch.cuda.is_available()) + + with torch.no_grad(): + for val_data in data_loader: + val_images = val_data["img"].to(device) + roi_size = (48, 48) + sw_batch_size = 3 + slice_inferer = SliceInferer( + roi_size=roi_size, + sw_batch_size=sw_batch_size, + spatial_dim=2, # Spatial dim to slice along is defined here + device=torch.device("cpu"), + padding_mode="replicate", + ) + val_output = slice_inferer(val_images, model) + matshow3d(val_output[0] > 0.5) + matshow3d(val_images[0]) + plt.show() + + +if __name__ == "__main__": + with tempfile.TemporaryDirectory() as tempdir: + main(tempdir) From f4b8c86940412d467b93a59264ebf824f5b2eeca Mon Sep 17 00:00:00 2001 From: Wenqi Li Date: Sun, 5 Jun 2022 23:13:33 +0100 Subject: [PATCH 2/5] adds eval Signed-off-by: Wenqi Li --- modules/training_with_2d_slices.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/modules/training_with_2d_slices.py b/modules/training_with_2d_slices.py index 70ed010ee0..1e9a09de3b 100644 --- a/modules/training_with_2d_slices.py +++ b/modules/training_with_2d_slices.py @@ -22,6 +22,7 @@ import torch from monai.data import DataLoader, PatchDataset, create_test_image_3d, list_data_collate from monai.inferers import SliceInferer +from monai.metrics import DiceMetric from monai.transforms import ( AsChannelFirstd, Compose, @@ -39,6 +40,7 @@ def main(tempdir): monai.config.print_config() + monai.utils.set_determinism(0) logging.basicConfig(stream=sys.stdout, level=logging.INFO) # ----- @@ -55,7 +57,6 @@ def main(tempdir): n = nib.Nifti1Image(im, np.eye(4)) nib.save(n, os.path.join(tempdir, f"img{i:d}.nii.gz")) - n = nib.Nifti1Image(seg, np.eye(4)) nib.save(n, os.path.join(tempdir, f"seg{i:d}.nii.gz")) @@ -79,7 +80,7 @@ def main(tempdir): # 3D dataset with preprocessing transforms volume_ds = monai.data.Dataset(data=train_files, transform=train_transforms) # use batch_size=1 to check the volumes because the input volumes have different shapes - check_loader = DataLoader(volume_ds, batch_size=1, collate_fn=list_data_collate) + check_loader = DataLoader(volume_ds, batch_size=1) check_data = monai.utils.misc.first(check_loader) print("first volume's shape: ", check_data["img"].shape, check_data["seg"].shape) @@ -172,7 +173,6 @@ def main(tempdir): # ----- # inference with a SliceInferer # ----- - model.eval() val_transform = Compose( [ LoadImaged(keys=["img", "seg"]), @@ -183,8 +183,9 @@ def main(tempdir): ) val_files = [{"img": img, "seg": seg} for img, seg in zip(images[-3:], segs[-3:])] val_ds = monai.data.Dataset(data=val_files, transform=val_transform) - data_loader = DataLoader(val_ds, pin_memory=torch.cuda.is_available()) - + data_loader = DataLoader(val_ds, num_workers=1, pin_memory=torch.cuda.is_available()) + dice_metric = DiceMetric(include_background=True, reduction="mean", get_not_nans=False) + model.eval() with torch.no_grad(): for val_data in data_loader: val_images = val_data["img"].to(device) @@ -193,14 +194,17 @@ def main(tempdir): slice_inferer = SliceInferer( roi_size=roi_size, sw_batch_size=sw_batch_size, - spatial_dim=2, # Spatial dim to slice along is defined here + spatial_dim=1, # Spatial dim to slice along is defined here device=torch.device("cpu"), padding_mode="replicate", ) val_output = slice_inferer(val_images, model) + dice_metric(y_pred=val_output > 0.5, y=val_data["seg"]) + print("Dice: ", dice_metric.get_buffer()[-1][0]) matshow3d(val_output[0] > 0.5) matshow3d(val_images[0]) plt.show() + print(f"Avg Dice: {dice_metric.aggregate().item()}") if __name__ == "__main__": From 78fbc315a0526601e4d938cb3d754e8b5bcf0f7f Mon Sep 17 00:00:00 2001 From: Wenqi Li Date: Mon, 6 Jun 2022 12:02:10 +0100 Subject: [PATCH 3/5] update to use EnsureChannelFirstd Signed-off-by: Wenqi Li --- modules/training_with_2d_slices.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/modules/training_with_2d_slices.py b/modules/training_with_2d_slices.py index 1e9a09de3b..c1e0399a40 100644 --- a/modules/training_with_2d_slices.py +++ b/modules/training_with_2d_slices.py @@ -24,8 +24,8 @@ from monai.inferers import SliceInferer from monai.metrics import DiceMetric from monai.transforms import ( - AsChannelFirstd, Compose, + EnsureChannelFirstd, EnsureTyped, LoadImaged, RandCropByPosNegLabeld, @@ -71,7 +71,7 @@ def main(tempdir): train_transforms = Compose( [ LoadImaged(keys=["img", "seg"]), - AsChannelFirstd(keys=["img", "seg"], channel_dim=-1), + EnsureChannelFirstd(keys=["img", "seg"]), ScaleIntensityd(keys="img"), RandRotate90d(keys=["img", "seg"], prob=0.5, spatial_axes=[0, 2]), EnsureTyped(keys=["img", "seg"]), @@ -176,7 +176,7 @@ def main(tempdir): val_transform = Compose( [ LoadImaged(keys=["img", "seg"]), - AsChannelFirstd(keys=["img", "seg"], channel_dim=-1), + EnsureChannelFirstd(keys=["img", "seg"]), ScaleIntensityd(keys="img"), EnsureTyped(keys=["img", "seg"]), ] From 1dfa20ca373a582f404856b3ff509958655b183f Mon Sep 17 00:00:00 2001 From: Wenqi Li Date: Fri, 10 Jun 2022 15:31:49 +0100 Subject: [PATCH 4/5] update to use notebooks Signed-off-by: Wenqi Li --- modules/2d_slices_from_3d_sampling.ipynb | 533 +++++++++++++++++++++++ modules/2d_slices_from_3d_training.ipynb | 510 ++++++++++++++++++++++ modules/training_with_2d_slices.py | 212 --------- 3 files changed, 1043 insertions(+), 212 deletions(-) create mode 100644 modules/2d_slices_from_3d_sampling.ipynb create mode 100644 modules/2d_slices_from_3d_training.ipynb delete mode 100644 modules/training_with_2d_slices.py diff --git a/modules/2d_slices_from_3d_sampling.ipynb b/modules/2d_slices_from_3d_sampling.ipynb new file mode 100644 index 0000000000..ccd3f9fac5 --- /dev/null +++ b/modules/2d_slices_from_3d_sampling.ipynb @@ -0,0 +1,533 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training with 2D samples from volumes\n", + "\n", + "This tutorial shows how to train a network with 2D samples from 3D inputs.\n", + "\n", + "It mainly demonstrates sampling of 2d slice dataset using `monai.transforms.RandSpatialCropSamplesd` and `monai.data.PatchDataset`.\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Project-MONAI/tutorials/blob/main/modules/2d_slices_from_3d.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup environment" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "!python -c \"import monai\" || pip install -q \"monai-weekly[tqdm, nibabel]\"\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Copyright (c) MONAI Consortium\n", + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "# http://www.apache.org/licenses/LICENSE-2.0\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License.\n", + "\n", + "import os\n", + "import tempfile\n", + "from glob import glob\n", + "import shutil\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import monai\n", + "import nibabel as nib\n", + "import numpy as np\n", + "import torch\n", + "from monai.data import DataLoader, PatchDataset, create_test_image_3d\n", + "from monai.inferers import SliceInferer\n", + "from monai.metrics import DiceMetric\n", + "from monai.transforms import (\n", + " Compose,\n", + " EnsureChannelFirstd,\n", + " EnsureTyped,\n", + " LoadImaged,\n", + " RandRotate90d,\n", + " Resized,\n", + " ScaleIntensityd,\n", + " SqueezeDimd,\n", + ")\n", + "from monai.visualize import matshow3d\n", + "\n", + "monai.config.print_config()\n", + "monai.utils.set_determinism(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup data directory\n", + "\n", + "You can specify a directory with the `MONAI_DATA_DIRECTORY` environment variable. \n", + "This allows you to save results and reuse downloads. \n", + "If not specified a temporary directory will be used." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n", + "root_dir = tempfile.mkdtemp() if directory is None else directory\n", + "print(root_dir)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create a dataset\n", + "\n", + "The example volumes are created with different spatial shapes for demo purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generating synthetic data to /Users/wenqili/Documents/monai_data (this may take a while)\n" + ] + } + ], + "source": [ + "print(f\"generating synthetic data to {root_dir} (this may take a while)\")\n", + "for i in range(40):\n", + " # make the input volumes different spatial shapes for demo purposes\n", + " H, W, D = 30 + i, 40 + i, 50 + i\n", + " im, seg = create_test_image_3d(\n", + " H, W, D, num_seg_classes=1, channel_dim=-1, rad_max=10\n", + " )\n", + "\n", + " n = nib.Nifti1Image(im, np.eye(4))\n", + " nib.save(n, os.path.join(root_dir, f\"img{i:d}.nii.gz\"))\n", + " n = nib.Nifti1Image(seg, np.eye(4))\n", + " nib.save(n, os.path.join(root_dir, f\"seg{i:d}.nii.gz\"))\n", + "\n", + "images = sorted(glob(os.path.join(root_dir, \"img*.nii.gz\")))\n", + "segs = sorted(glob(os.path.join(root_dir, \"seg*.nii.gz\")))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "train_files = [{\"img\": img, \"seg\": seg} for img, seg in zip(images[:35], segs[:35])]\n", + "val_files = [{\"img\": img, \"seg\": seg} for img, seg in zip(images[-3:], segs[-3:])]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Volume-level preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 35/35 [00:00<00:00, 61.25it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first volume's shape: torch.Size([1, 1, 50, 30, 40]) torch.Size([1, 1, 50, 30, 40])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# volume-level transforms for both image and segmentation\n", + "train_transforms = Compose(\n", + " [\n", + " LoadImaged(keys=[\"img\", \"seg\"]),\n", + " EnsureChannelFirstd(keys=[\"img\", \"seg\"]),\n", + " ScaleIntensityd(keys=\"img\"),\n", + " RandRotate90d(keys=[\"img\", \"seg\"], prob=0.5, spatial_axes=[0, 2]),\n", + " EnsureTyped(keys=[\"img\", \"seg\"]),\n", + " ]\n", + ")\n", + "# 3D dataset with preprocessing transforms\n", + "volume_ds = monai.data.CacheDataset(data=train_files, transform=train_transforms)\n", + "# use batch_size=1 to check the volumes because the input volumes have different shapes\n", + "check_loader = DataLoader(volume_ds, batch_size=1)\n", + "check_data = monai.utils.misc.first(check_loader)\n", + "print(\"first volume's shape: \", check_data[\"img\"].shape, check_data[\"seg\"].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## volume to patch processing\n", + "\n", + "- define the 2d sampling transforms, could also be other spatial cropping transforms\n", + "https://docs.monai.io/en/stable/transforms.html#crop-and-pad-dict\n", + "\n", + "- patch-level preprocessing, resize the sampled slices to a consistent size so that we can batch\n", + "the last spatial dim is always 1, so we squeeze dim." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first patch's shape: torch.Size([3, 1, 48, 48]) torch.Size([3, 1, 48, 48])\n" + ] + } + ], + "source": [ + "num_samples = 4\n", + "patch_func = monai.transforms.RandSpatialCropSamplesd(\n", + " keys=[\"img\", \"seg\"],\n", + " roi_size=[-1, -1, 1], # dynamic spatial_size for the first two dimensions\n", + " num_samples=num_samples,\n", + " random_size=False,\n", + ")\n", + "# this can also be balanced samples:\n", + "# patch_func = RandCropByPosNegLabeld(\n", + "# keys=[\"img\", \"seg\"],\n", + "# label_key=\"seg\",\n", + "# spatial_size=[-1, -1, 1], # dynamic spatial_size for the first two dimensions\n", + "# pos=1,\n", + "# neg=1,\n", + "# num_samples=num_samples,\n", + "# )\n", + "patch_transform = Compose(\n", + " [\n", + " SqueezeDimd(keys=[\"img\", \"seg\"], dim=-1), # squeeze the last dim\n", + " Resized(keys=[\"img\", \"seg\"], spatial_size=[48, 48]),\n", + " # to use crop/pad instead of reszie:\n", + " # ResizeWithPadOrCropd(keys=[\"img\", \"seg\"], spatial_size=[48, 48], mode=\"replicate\"),\n", + " ]\n", + ")\n", + "patch_ds = PatchDataset(\n", + " volume_ds,\n", + " transform=patch_transform,\n", + " patch_func=patch_func,\n", + " samples_per_image=num_samples,\n", + ")\n", + "train_loader = DataLoader(\n", + " patch_ds,\n", + " batch_size=3,\n", + " shuffle=True, # this shuffles slices from different volumes\n", + " num_workers=2,\n", + " pin_memory=torch.cuda.is_available(),\n", + ")\n", + "check_data = monai.utils.misc.first(train_loader)\n", + "print(\"first patch's shape: \", check_data[\"img\"].shape, check_data[\"seg\"].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define 2D network and losses" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "model = monai.networks.nets.UNet(\n", + " spatial_dims=2,\n", + " in_channels=1,\n", + " out_channels=1,\n", + " channels=(16, 32, 64, 128),\n", + " strides=(2, 2, 2),\n", + " num_res_units=2,\n", + ").to(device)\n", + "loss_function = monai.losses.DiceLoss(sigmoid=True)\n", + "optimizer = torch.optim.Adam(model.parameters(), 5e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The training loop" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------\n", + "epoch 1/5\n", + "25/46, train_loss: 0.5968\n", + "epoch 1 average loss: 0.7530\n", + "----------\n", + "epoch 2/5\n", + "25/46, train_loss: 0.7140\n", + "epoch 2 average loss: 0.6856\n", + "----------\n", + "epoch 3/5\n", + "25/46, train_loss: 0.2901\n", + "epoch 3 average loss: 0.5425\n", + "----------\n", + "epoch 4/5\n", + "25/46, train_loss: 0.4971\n", + "epoch 4 average loss: 0.4795\n", + "----------\n", + "epoch 5/5\n", + "25/46, train_loss: 0.3957\n", + "epoch 5 average loss: 0.3271\n", + "train completed\n" + ] + } + ], + "source": [ + "epoch_loss_values = []\n", + "num_epochs = 5\n", + "for epoch in range(num_epochs):\n", + " print(\"-\" * 10)\n", + " print(f\"epoch {epoch + 1}/{num_epochs}\")\n", + " model.train()\n", + " epoch_loss, step = 0, 0\n", + " for batch_data in train_loader:\n", + " step += 1\n", + " inputs, labels = batch_data[\"img\"].to(device), batch_data[\"seg\"].to(device)\n", + " optimizer.zero_grad()\n", + " outputs = model(inputs)\n", + " loss = loss_function(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + " epoch_loss += loss.item()\n", + " epoch_len = len(patch_ds) // train_loader.batch_size\n", + " if step % 25 == 0:\n", + " print(f\"{step}/{epoch_len}, train_loss: {loss.item():.4f}\")\n", + " epoch_loss /= step\n", + " epoch_loss_values.append(epoch_loss)\n", + " print(f\"epoch {epoch + 1} average loss: {epoch_loss:.4f}\")\n", + "print(\"train completed\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## SliceInferer" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dice: tensor(0.9784)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dice: tensor(0.9706)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dice: tensor(0.9727)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAC4CAYAAADnsTZ9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAACkUElEQVR4nOz9WcxtyXUmiH0rYu8z/vP97715M/PmyKQ4lUSRIlOVVdXVXSVS7Wp3uWGXugWhYQJ+tLvKRsMPfrFFpgAD9oMfVA3YgF8sNFAmmkJ1Gd1VriSlcg0qSskhM0VJpMRkZpI53My88z+cce+I5YcVETt2nH3O+e/88+b+gP8/5+wh4osVcc5ae60VEcTMaNGiRYsWLVq0eJihHjSBFi1atGjRokWLe43W4GnRokWLFi1aPPRoDZ4WLVq0aNGixUOP1uBp0aJFixYtWjz0aA2eFi1atGjRosVDj9bgadGiRYsWLVo89MjWXfClF35H5q1bBrkZ7EzupCLAykGKZ7czA0T1z4Ac8+fia6Kp8awIZJP7SwtkCt98+f9Eng8ZlvuYwVrV6/ewFlCqenXXLxwjks+AHHP1hdeIH5Vyne1ofOtPHB/LgCI5xwxYVKakbysgxz38eX+tXXPMtZk1VceVAs2KUM9Lr75Y8QFAha2XE8vAAtAEGK6bvdRwrAFkpA7WVG+nayMxg3MtffarLzIxRJ4qujaVfzwe4v6P0XSuqT1JWVQYcKbwze9+lb70wu9wGD9EYHLjN/28BOvO1+Db5drLJP1Cbry99OqL9OXnX+TaWI3HzEkQX59+x9JL/Rjy10LGNGsZvy+9+uISwf/84kvqN07N2hvfst+gls9ynDY+wOnj1PJZjW/Zbyz9DWs9PC1atGjRokWLhx6twdOiRYsWLVq0eOjRGjwtWrRo0aJFi4cea3N4aGbqeRfkcmwAwPiLGvIG0pyC+Fj8PskzIJscI6qZZWpaym1RHofPh6guQpUv48/F1ywc49o5Ygb71zIp29fpm1cYyYvw+RCcyAZLQpum4f26Y8yAJanDADDxScentJLHoiO5hdwgW88jMg25RWg6liA1k210nz9vEPqRjF3ox8AHWD0+mrDsXHw8zkNiBquqcjJcq5uA2jgN4zvcUB/ftOLcwn0WgPK5TRZErv/SHDeLalA15XytQig/eh8fA5b3WZq/1aJFixYPKdYbPMxgS6gUWvQjue5HFmuOqaZk3qQsjboyiHh5pMaG8HXcnYLxr/76VecCJ2/gcWXQLCg3CzGS7rWyWJYEniQ2g1n4mrqMANTaeUfwxoyrv1F2MXXDIdFdZHnnFKqyor52xqDv/5gHMSOYKhwbCEjGLtcNZhVdH8Ymqtemc6jKrNUbj/kYUZ/FfBcuaxi3cTtXtt1GQreR7MIDRmvstGjR4uHGWoNnQZkTAWXqzanP0Knfv+IYNzwV+2PulaFA1oKdJqHC1Lw7AECJARZ/JlV/DedPcI4MA5rr13pF4RWttaDCyOdVs2vSc00GVNNsm/R+xZVHy89uMlV5VAqfRgPsbhk8MW9NYcYWaNGABJwXLOEBAFBY8I4t9O2KY7GnxL+PXzmqR/quLiP2XqfYiEHyPv6cHj/hObL1soO8fHtKK5652GvZZKT7c8lrrayGY+F4GNPOUI2PMS/watGiRYuHCes9PP7pPH4SBpKnZF6vEJqOrfP+WIAgIRryF1pbhSA8ODIe/Oc0LLDqWHwuPmYtCKp+jQ9p+Km9hgFTV1YVrwZjpmlK/kmOKQKMBWWQ+uLp3DEMA6Vp5ENayb13Az78wzqUGRSx4xo4lPXQGynvhXBt8u2zSbjIH4uWP6iVkVyfHqOkHPbD3VqgNO56b6xHYyCNFDaFF09yzrUPOlrawB+rlSF9RrXr6u0OMrsTeHnzIh+CXuinFi1atHiYsN7D4xT8QrgA9RBSLaTQFGaIFbBFraxaeGpJPeESt+ZNoydlXQ7IqmNN91qWUFp8ja1fT8yL98aGS1O56bGTXBMML64ZOWQsWCV90sSHndxi71DqVQqFrDmX8ozLBKIwiUNaZ4hvxUYG12UXH0tjYLEBWuOTrGOT8AnjzPOr5R6t8W6k3E4CH/Li2CjmBSOVvAxjw465yrEC5H3T+kNpW5v4+vfL+Pj6U+O5RYsWLR4inMjgAdzTsvduJMqQlrwuO+bLXQi7+GPROQ5KTFd8TL1++TGPnpxXKfGmY0sTTu1iiMm3x1SKiZIn9rB44l0Eu3qYCOSfxB1Hiqu3Vs43KGcG6vee1Lvkj/v7os8LfNgtBGkskDvPTywff96615jrSfik/RFdxzrpi4QPaxcWjZX7qjEQgSzXDMsTwZLUi0rurKjiGHH314U2R/X6++4YCR9fJlmWY3fL+9eiRYsWpxAnyOHh2myXxtfbRXq/ryuqk7xXRTfcU/MirDi3jOu6dsTnmzwb/jVeJRh1Y+hugVyIrWaE+Sf1GJYXOcYenmV9uM7L5D+ncmgwHsgfj6+J2+I5ewNynZyXHUvOhXpDRQmfyAil1DheY/DIPbfWn6ydsc4q8Ar96OtO5EC2WfZ3I7+GfcjM9U1tnNqG8GiLFi1aPERYb/B4NCkD/+PsXfHp67Jz/t74fVpmuAb1cMRJDZe74OGRp/p6PeGJO+a4ymA6gSI9MZqUYep5iY8l19EqrietX0XvU15eKuSM1CXK22OBT83gpfqxtC6VXB/X6+vUqgpL2kRmJzHwYqQerxNgwbBraoP/nPbPSfvppN5MJPJOtvK447HRokWLFqccJ5qlJRsAJcZBnGBplrye9BxQ/7ElivIsbO3cQjjA3+7CJO7TYrmpQRDnLzSFR1zbKc03afKM+HyIJm/E3YIPXxlbT0r2a/H4dWasrbw+TeGfO01MTcNnmQbKsqo/OleNjyjJ2hhAa/mcJYmy6d5n/pi/Pr5OaykrrjfuH1+/tQAy4RjOcd0zFtfny4kRxg43yzTt9/g7Ytwsx3jchjWAonuMXRyrcVnWlQdUMvOh3FsJn5am4pPW04a0WrRo8RDjxDk8tff+B3jVj/+yczHSY+l1657CU0WzyvvTVH5Tue618Yk3bT/gDAzTrKhjJdp0Ln4Fll/vYQzAWf1cGjZiFuXe1AdKVQbSrfRZei6VRTAsUF0Tfy7LSIRRHljMJ0ZqfBizyMMfi+/3RlAwEmzFLzWGPKd4w05/ny/TG1q+rixbOl4ax5RtqNvXH7czcI2M6zhUqHVlkJQleDqrRN3tAHnezCHtN2PrXNI+bD08LVq0eIjxYLeWuFs/sPfyh5oiJRS/X5ZEert5EKlxs4rLSa5NwLcro5OEcdJriG6do5dv+reOxyp+StX7rAlN/aVU3Tj1MM3J4CdGfG/MbV3fEIl3pyzBwbCVV449V3fK6U7a1qJFixanHCfTSqt+CG/1RzI1HNLXVUrvpBzSH/G0rFU/8qv4nQSxIkuPLzu26twypO1adb1SEsZQDXLwfP1reixuU3wsbaM3Epp4nFSO/t7UsIjLbDL6lrUpPp/yWsU3LZNZDIv0XFrvqnam/JrONR1LrvWzF6nXW825iZeiRbmk17Ro0aLFQ4r1Ia1lT9qKULOXVhkJyxRB0w9tXL7FomJxCiCe+s3uh9xPO3YFyf/oGrJYmN7rpxvH047DlGmuT6EOyZ01nkpCHYoA6w2ENQpkmZJdl/Qd6tPN98d80nCGV7RaV8d82KNJeafGWHrOl+3ri6GTe3TFl7yREfLAsvq1ynkzPD/WdcMkbVPcTq0AEx3XSvpEJ22Jy1NU3ePLiGXvuFPWwHMdvJGplKzYHd8flxH6JpIrKSDP6uG2Tg7MC0ArcFFU/JrGQ1P4uDZmk2tjji1atGjxEGK9waNUpcDjnBkipPtbLUV837JjaY6IK5+JQFqFhQs5Uqa1GVSpgmdv6CC6flEJ+GNxWazcOS2KwH8GM5gSnjoyQKK6worUMa/4cxPf+L6kLNYKRAac6eZtGjy0U5QNWLi3Ken2pHD3cKarGXRRHxGZytDIs8a65DpaKLNmiOWJgRW3u+mYUvUytDN2/ThOZMSKQJrrayfpqH153Xj0G6HGRvKCseyP+fV/nNzDNamh78ZQtU5Q1C5ncLEiINMgrSVvx8srPh+LwnLjQwEZ6TP4hT2JahxbtGjR4mHFCQyehqd/oLa3z4mwym3fcCyUryA/ziq5J73Xe4T8e0RekqbzwZMSfY7P+adt/8Tvy/QKLwkHLC4MR0vex5+brmmSauSh8Z4sp5AXrl7KBw1esNtHUPLO6EmNYfZeGqDykiXGAZSqrW/cZDiENp3U4Gky4ojEUFWxsVyNa2/Esm6SPWpjjSNvCuvofm8Qx8d8+1J5JGWG8957uexBQimpvyjFSMkbPHneUEvb5NsavY/7B1rdfp5XixYtWvwcYK3Bw1pHkav6k2n4fWzyWiA513Ssdo4WzjHD/cijUlYN3ouwlYX31kSfaztMR+fDObXknCb3VK7CNULPySBzyilz3oK7sRLuKhCBM6e0o6dzJpMoZAV08+pYGgJKF70LN67w8jR5Z+KQFidGlKuHnYzQyasNHFIvYTQ24lFyy6rXh2X8DLaGWWVe+XOmQJwHw/VEG6rehheMiWTjWyUb4Ib6kkRp4ZOBtV693pSvv9u5NfkEI2iRjz/PSrUenhYtWjzUWO/hyapwUoBCfT2W9PNJ0XRfekyT5FhEyipVPMGoSYriJa9rzzkFUHsqDuciHnAGYRfNyrBpavdJDI1l13ulHhsYIRfFXZJr58FQC4o8KPfbCWE1tQ1YXk9k8HAnWzjfhNrO4Fw3Vv359Nyy69P92yg2eLyMSDyHbHH7Y3gVFADjvj+sqt3Zy2T8Rn3GkRzuNpgIsFJP4AMEIwjLPFwtWrRo8RDgBB6eRc8LgCrXxJ9L82NOgmX3RTkzUl8anlj8YW5ScrcNr5h4sS6K80s819TDsZDrFL1vqmvZsdhz440IqsJY0mazcC2CIl80VNnSnRs7EH9cMBhALjQYXcBVPUHRA4vXxbdEPgb/ftUxjkKd/n14TT2GBotjyI8zleRPpV7Jk3gwl5xjQsXHG9AqMWqcsVNry92GlznX5RSOacLCJq0tWrRo8RBhvcGTu5wFy2HVYXmhWu4LxT+WqxKSmxJT47CGT7SMDYUItieUKeyk7WdUNYRB0gX+vHcjPRaHepQCSjnH1kroKlZONRmIfCS5mUClX93XK5OkfalXzB9TqBsCTcd8pbGyali4L/CBPLnXylEKYfd3C+c943od1HCsCcZ5TbxhoakqNy4LAOfSPyJXVDJJ5R+H4daF14DF/dW8cRzVXY23aiVjCVdWdbOiKv/eGSmUKv+asYR6vv4qg9YbUyGshGrhxfh+FY1LTVgwnlYhHmOrDLAar5hv9V1q0aJFi4cV1CYqtmjRokWLFi0edqz18Hz581+ViR3+CdzntyBxy5/kCXPZsTiJM004tRaw4rn45ve/Sl/+4tcYpr6ZaEiOTXIwViZoJjuc13JSjJEEUn9/lPdChQFrAmvH5/kXOeZPJgmrKXdMUzgXQm8Ki8ewmKviy4nbR67dNC+DN+ylV75GX/rVFzlsi2FRK8+X0Zj7Erc1wtKcmTgJN/KchDqtlT77zm/Tl7/wVU7rXdqmFbk5y3jV+npJWJOMAXcy4fP8iyxhrqhMzyX2VMVerlv1iLn7fd/HZVNRbX/x0mu/E/jUpsav8tDcRmgtnIu9bO4cFQaca9C8xEuvvvjQxbW+pH7j1DzVfct+g1o+y3Ha+ACnj1PLZzW+Zb+x9Dfs7sxRbtGiRYsWLVq0OMVoDZ4WLVq0aNGixUOP1uBp0aJFixYtWjz0aA2eFi1atGjRosVDj7VJy3GycjgWrwabJkmuWil21bF4GnFctp9K7esubb0cqifKplODw7o56bGFhrqE0jWL8vmtA4KpWNpaAm+tfOZq/nqUQOxfm9ZbSbmFBF7bkMDb0A4ytpY4ndZHTf3o239CLF3QcNn1ZrFN7PotbVMTv6aya+1qSlJOE6RrywPYxUUG/eeYa3qNP1c73nQsuT8u2ycMpwnzhuvT1VfNnlz1PTrp9y5NtF4z7lu0aNHi5x3rDZ7SRjOMFmf8NKx+06iE1q+ci8Vz8ewnrzVKm5TPIK9EDNcXMrSQzwurOXOdezxbSLEoaM1OIZsFxSxrqcgNZG2olzyHuExXF8Xr4fgZPI4j+S2eIt616wEpmzm8ioyqfvFtIcMiowbfXbg3mYGU8qjdk7zWZAsG6TqfoDjjviiTDvBtd9c11du4QOGSRQsDf99Xadt8PRTJKNneYe26NeuwbHaUqcsIVtZrqn0/DIOMQVjA8l4tFRFmPUZGuJu5RcBiP7Vo0aLFQ4T1W0uUBsQKMBbkFhokrcRzkSqNCE3Pik3KU5QVV2X7Pan8ez8V3q0yR8bUrwOcouD6jzlQLQKYeqLiY4D88MfnjAVBV+V5hU4U5OD5gJ2yspTUkdTPqr4wn1c23guUKjl/zF/fNO3YKbCarK2tlGfqifHT8X39KW5F3wUuCR856RZ2dIeTxRHjvcAW+iwuPz3edCw+x6penufo6gkLYltbTQ2/l/Dt87w8l9KE8Q6I0Uxlxe9ebi2RLj8QjpUN/dSiRYsWDxHWGzzWVquweoXoFUlDuOu2ECsymxxzq8+SV06lqa4LBgvLqs9losRiA4Fo+TF/HKjOlVhsX6SgPR/xqJhqT6s0vBdzbAohpXxSHh5ajM7wGvOJQIblvF/PJSqPmKt7m3Arayf5YykfIPQFeZmUDdtf+HvTPrtdsPMoNYQ1g2Ho14/yfRZft24c307Ix/dPhnp9qZHn+JD2xjLXVjFfQNM5f2zFfaScwa65MrZ8X2W66qcWLVq0eAixPqRlrGzdYCw43RGc+c6NHQBkWfYXshzq8MdqBpfjA0Cuq3kWFj0atbyGVediZccsdTcdcwvDiUMpKbsphyKto6n+9Lqm84AYFcyLhlNTu9Idw8N10fYaTcr7pPkfcXsbc7jceFnWvmVG4B2MpVqfpeWoBj5NhmlTm5pyy2oVNxir6TnfTndd+E6FbVm4us7XYVbIoumcP5aea/Jk2sgwNFzn2KJFixYPKU7k4SH/6sMXSonyX/Z0vs570qBcfNkUhUjIb0BprexK7niEcx4kO5ov5XOrYAaVWFBy5MJ4ZKniY2xNmVL8dL3Mm3QLPPx9rJyizFw7gUYPj4TYhA8lT/pBRv7eJXWdmBtcSCSRO3ujy/dVWqcPU2b3qM/Sttg6Hxhb1bvKYEnbu4znsnN+7KYyKs3CKuVhDEXH0/4Ll8crMifH1p7zYyh6cKDSCMdV3r8WLVq0+DnHeoPHK6/4qdjaavPFJiXhXetNZcWvoXxudslHOTwL9ybhIUrPxcrVcY6vXwgvxZ/95qUh3yXi48NKcV1xHk2sPBcUr5X7iaSMZfU3yMwbW7V8kKYQlXtSJ+8R8jAWhKxqk8sl4dFYNiDVGjToA5le9A6t4FXj45vD1BxWS/lYWxsrPBqDsgzodYXDZAq2FtTvrecT15WOP2rgE3PyssozYF4EQ4inM2B3C8X5LRRbGfTEovunb4F6PZFTkzxieGPeWAkX+T5vMFJrY8h937iTy72TKdDtgEcT0LCPm194FPMt2XV95ydz9H74HqjXlSpN1K70YSL+zsYPDsaClF3k1aJFi4cCX3/n2+H9b1584QEyEcR8gPvH6QQeHnYzi7gyQOKQhIfPx2CulMGyHIQUzJG7HZFhBak7Vt5pnQAwm1c7h3c7Fcd5AZ5OAQDU6QCdvN6eisAinzTE4PnECjJwZ4Sp88yimDo5eDoFDQZBNnw8ArIM2N0CrlwHtAJtDJeHS1JYCa2FNjTdEytzI0qM5wX40X2UWz3kP34PlOfCczoFzu6huLAFVoTOn78DzGagfr/ZYE24AFjkY7kyCBv6jKczUK+L4smzOL7Yw8Y7U+Q/vSyy2tpE8cgOjp7qw+aEfGyx/b33gelM5LbKExT3mQ8JeaNQq0VlbhlwydU8L3D8N57GeF/DZsD5PzkAvfkuaDjAzV/ax3xDwXYAssAOP4XuX14CTPQ9WObR9PlN3oD0xm6aZxT2PnPjal6geOo8rn52AADoHDL2XnodOLuH0TM7mG2LsUMM3Hy2g3Mf7oA+vAYa9pvHQfSgIsaN5xUZ5vF4b9HilOKlS6/h1x/97MJxr0DvpzJ/6dJr4X3M6UEp85Py+fo7374vnGI+MaeUz/3EyZKWQyIxiZKcF2I8MIty1Ao8mojSIgIzgzq5GBlKLZYXQzUoo/gckxgy/ke7LKtzRQEuClCnA94YgOYF+OgYlOdyvNsVgwKQJ3Z3Dlm2aCh4DjEfY+qfvVGV5PegLAHWQFmCZ3PQ7jbGz+3D5gobP7wM++EVUK+L8lNPouxr2Xz0Y3vIxgadV34C2tpcnivi61JK6vHK2ydtpzNrmEPyKY9GACkUn34SB8/2oUqGfeZZnH3pTZgbN2G++CkcPdkFk1Ogj38Mgyslev/uh1C7O/UyU3iZeD6cyCTtM2ZwWQJa4+D5xzDfUAAD1z/ZR/b0E9h75TpufmYP86EP4QFmW6H4W49h/1+/Az46Ag2Hy8cKs/RBuhFt3JfBY2fB8zlgGTwaYf6rn8R4XwMEqBK4/ovbUJ/cAjEw3ySQAagUA+PgqS6yC09h7//302psm4awXMwn07Vr2Ie0Yu/jvJBQ8WiE6a98DEdPdKReBso+4cp/+nHJHVPCMcw4Y+Da53cx/HAT/Vd/Jp4eb5Cn4Tovj/AXjaGm8GiLjzS8wlqlPIH7o9Bj5RkbPU3K/H5wSpW559Qkn/thYDTxAYAbZtx4/b3mlPLxx1bxAe59v61faTlSEjBGfpgBULcrnoPZXDwsANTONmh7C2pvB8gyCQnE5TT9oPqn2sBoDaXoyZUL4YJOjnJvCO51QHkOe3AIlCXKi/uYfuwcph87h/EnzoM2hrCjZoEv1LEGFHs4HCcuS9D2JspzWzA9BdMlzJ7cg9rdAQ0GGF/oYvxIjvH5HONzGY6e6IJ2t6UdaZgvfZ9yWpVPYivPDjo5pue6oiBJdPD0049DPfMExo90YDMxdlgBNgPGZzOovV3p1xPKYoFTg/Jn5+GgLEMxULA+IsSAzQiHn9zFfIPAWpQ8WfljBUw++Qhoe0sMprStt8oRkVfKGtCgD9NVIANnAHhZEIoBLTj/iAHTIcw/dkHkm/JJw7zLwr5N/WctqN9HOdTSfm/LUuVArB4+ELjZDBidz4CtjcqL5OuOX1dhnUevxT1Hk5L4+jvfrv09CC5NvB40TiOnVf3zILway4wLj/vNaR2f+4GTbS0Rnua1eHYA8GwG6nZAva4oItswpdWYygOhVLMxo9Tij7+/zoem0vv8lPDchahmc2TXR6BZAZ5MJOej2w0zvpggSnfQA3U7lZdomdGQTleOuUdJxAu3ZRn44AjZ5UPoqYWeM7qvfwh7/QaKx88gzrMGi+KdP7Vfl1Pc7pjLsqTYVGbx6U4OzAv0Ls9AVurUc0b3/SOUOwMUg/qKh8SiPOdPna3683amYi/hA63AZYl8bKF88QyoksXrpYVjTU4EFEMNdjkqjXU1cYzr9/JsmK7OxyPomZW6CTUjwi/v5HkwAVZX4wlsF/sqrSf+7MfRivw2Ho2RjUzw5shBBIPV80D6B5eInNa9TD7LuLZ4YGgK1TwoxFzWhSIehDJf5k3xeJBhkxanF+tDWt4gca5x6nbBWoOIJF9GKYRlgVX1A0tu5lQwGPxT5jIDJ3a7M4txReTyDKIfZj87igjIMqlnMpEw1vEINByC54XwI5KtIPz1RMK1yYjSus5H1w2c2vtIUbAikHaJvpkGjAUfjdC9PARZC3vjJqjbBRSBFcFqCkqLWY6BIkUYO8Hi+hRFMomUpk6SZ4nCMer1wEWB/PIRevsdmI7C4MMZ8OFV0NbjgFPgcrHrIkK1fYZWVQJ3ihq3iE+cwxP1GVkLOO9b/8ocJu/CdAiqBAaXS7AiTHcywBsezvjwkSFoJX2attfDj50mY0PV+1v6TAFajPfu+4fA0/swXYIuGGSBbMYhMZhR8QEQbQ8RjaWm2V6xkayrZHBSqt4ON5aFTBf54Rz5OMd0h8TTA5EBuwiv93xFO66ArWuXz7Nr7CcS8kpJIUA1rpRqc3ha1HDaDLDT6NU5LWjlczKsN3gynfyIa1CeVfkARKBhH3zzwJ1XYK2A6VRmvfS6iy7+WDmsOuYVSWygpLNjtBKvjVKgrQ358Z4XYGORXR9hvr0DVoRsYkDXD8DWAN3+ots/Rlp3nE/jV1SOn9r9zCZAEkeJoG8cyfmzZ8CjCbIPD5Dtd2AzhWIoeSFqxui8c0M8MZ3ctXOJ0gkGnKpm8zR5LTwfIiDTktMxL7D5vfekP9wU5OzyIfTTA5TbsXIEVAF0f3YN6PWcIdNMJ3gkMl3no7jiqKM+s2IUqb0ddH56FXs/MXJ8NgdPpyg+8zRYZeCMauEaAOheL0HXD6qE9GV8ls0u833p+SgF5DmgCJQPgeMJzv/Lnwmf0kioan8HH/6tfdgOBQ8LMQArnrn82kjGXaajhJoERADL94GiMVLj4uXkzlOeIfvwJnbfvwHuyiwtvnET888+i2uf6oWQX21VBguogsXD2c0lZJeO3bR/WNeModq4anFq8JsXXzg13oplXO5XUm5qgK2Szb3mtCpx+kHhVjndSxmdRvkAJzF4tA4LD3qwf2L2q8XqDDh7BpjMZBYOEXh/T649AYnaon7xlG//o20jBRE9GXPkUQKRexJWMgvKWuDKdQyMlem9H1wBNjeAzWF9AbrU8CG/VomuT/8O50Q5VHxUkBHScr0S7uSgoxE2X7kEu7uBg0/uYOsnR9Af3pQwz6BXtWNZvoVTnlCqviFmuqWFVsI9NQy8kaoVSCvwaIzd713GwWfPYralYHqE7bcKDN64ARQluNdZPT098mJwntTlvXsq6jOdhAE9nzwD9Xvo/OR97Awu4ujxHNM9uY4Y2HzboPtnbwO9LtiFUxc8KbGsm1Za9snmKuqzPKv4xEZ0noGUAn9wFTs/2cKVz3bBLrxFJaBnwPZbYoDx5rDOJ5WP56V15e303s94nCsF9vLwOT/uXs40aHcHnR+9i8G5Z3D8qILpVJ45VQD9K4y9HxwGo2mZ/SXjRZKo62PIH2tXWj6NOA3TiD08l/s102cdmoyeB8XrQRpgPw9YZ7zfDxmtzeFhrYLXhjOn2LUWpeFzEohEgfS7oOEAvLVRHVdq7V9cR61MH1qKQhWsKy61cnR0v3ZGxtYm6GgEde0maGMoSiUOQSzjkyXta+AalKeKuKScPBci8OYQPJ1BXTvE1o+PoN69AhgjuSlpm5v+dPKavnd82L9fxkUpcLcDGg5Ax2Ns/fgQww8NNi4ZDP/sfdDxGNzvnrz/vPHnvRY6qsf3WaYb+quSMTvvVu/dQ2y8VyCTlQSQHzO2/+IGaNCrDDB/7yoZLfxR3VCM+0zrhTJ50ANtbaD3xmXkI9mc1XQA0wW23ikx/OEHYuys4qN11QdJn6VjiOOxnrn7Iq8P9zqgLMPWjw/Rv2JhuoDtArYDmB6w+6Nj6PevioziPmj6i71dOuHW5vC0OCFOkwKPuTxoXk31P0hOy+p+kEbhrRy/21jv4enkYbd0D79bOsVKBJDF0YCFXc/j+9KNEeMd1Jt2UoeCU45OeXY7tY0PAQSzLeXDgx7gvSe3AGJJohVFBtR2S3ebLwY+mQIhq3KFvCPM3Vd7PX9GPAWFAZ/fk6f+9Jplx4jcDuRwCkqOLey8nSkw8npZnk8UGuRuBmz0AMMY/PQQxAy7u9EskJhHfAwQOaSeFufFQObq8p6ZGJ6PaxOf2QEU0Hv/GI+8X5XPmQJvD5vlErWNTNJn8fW+Hs8n97lQzc0N8gFw7o9vSP87DxETwXo+J4Efu5kfpBTGaRjHua76dYlHjfe3AWbs/vkBdv+UQbO5GNI9MRbt+b31XLw3J83xKa3waw2eFj+neNCGTozTxAVo+cRYa/Bw7tzfVIV3OHg3lvw4L3nf9BmATFkmCq/+WNjVmRgcK6vUaPLGhuKa8l9lSMXH/HHAGVHWiiHjlahbcJCJAAPn6XE8lQJyqspXVTnk+WjUFbSPoDQdi95T3B4V/cXGBlBTVKwJhMjw04nxmCr5MD28Lo/GayKEdsaGXlw2UeizoOyBeh0K1QhMVyxoyk3WS14VpO99X6UGDwCCrcZQVhmsjWgILXIjoRMgNVqjVw5hSAKrhhWum0JlAJAD3Fv/rLIAIqCkxXHjjNPW3GnRosXDjBXPuIKlSnDhwmi9kfg1XZtk2bF4PR73Sv644ZqSr3FKPEgLnNwrub+mY9TIp3r154lZPF3xYoyZM34iYyKEcrwnLG5P9LruWCNsck2yzouE+9TKng1tTsuJzjVdEx8LdVrxrlD0ubZaNsQoavL41a5fUk96rJF72ldRmU18qtwwLF7rjZ3UAPPn0uNNx/z1KUegPtaTXLX6dHxa7nFpOp4YUyuvb/qexcdbtGjR4iEEcfsj16JFixYtWrR4yLHWL/7lz3+VoaP8kSUhg5U5KKvyWoB6flBDiIQKA841vvndr9Kvf+63k1hDFWJLw1UUz7KKZmOxUtW5qBwpxOU5uPBCCKv594WRnBPH58vPv8go7UJbGkNrLv+nFmJLjtXqijgu5D+xhPloZiREQYSXXvkaffmLX+Pak3qUf7TAJwrjxTyCPIjq52KZRedDmZpqng3OFL75nd8OnMgk4cRobKScls18qnH0h5dxjPqBjAF3MnzzO79NX/rVF5mMXeiruA1pntjC2DpBmDQu07fdc5E3hJdefVHGkG+T/y7475zPkYq9SEu+Ryc5VgvTurL894sKg5de+52HLrL1JfUbp+ap7lv2G9TyWY7Txgc4fZxaPqvxLfuNpb9ha0NaLVq0aNGiRYsWP+9oDZ4WLVq0aNGixUOP1uBp0aJFixYtWjz0aA2eFi1atGjRosVDj1tbzKNpATqPpuTl9HXJsWUJn7WF45Jrw2e1SKi2bH786t5TlBDLyef0voXp4gkff5wRTUVfhoZz7BYRZCtJvAyqtuyIkoKhAJgGvimfOME1mSa/UHdcBlONB/wrkXC0FZ+F+uHuW4YkOTgkLDdwCVP5zeLCkkCVbBuPg9BHrh0LU+B9e3wpNllDyHPw5avF9qT8mq5dSMhG/dwClzgB3H+O17ZS0bl0mDd9twBZiLKTgeZlNX4sQvLzwjpI8fT3ky5B0aJFixY/h1hr8FBh5Ac6zCJB/Yc6PuexbEueeMZUMpMICmIy2EQJWJmtQm5raDUvw21Msn9WbYbUmh/thRlLK65pnInjZwM5zUuFqWTk2+I5RTNkKH1tuKaRb7hOZEZRHeTWwGFb3UyljWbUUTXrJ1aMnoeHccds9BmoGQnwa+0ks+iIG8YCuT7znIpoQATDOOnnGJ6Pv7aI5OFmOJHflT2eKQZpe9y2MKYMB2OCSiurC6dyidq11LiP1oOiwgDzAjRzBLUCD/uh3WE2lKba7KtqdeyIT7pv263A1UHzEjSdg3sd2EEH6ngGNZ2BNwa12WecuQUO3XeZSlkXKJ4t2aJFixYPG9aGtMKie27xPzIsP97ek+AXBTzJ35J7/IJ+5Ms1VX1+wb+mhQvJ2mgxwOra8OfPxwvWxef8+fh9Uld631I+cVt8e6LXWjt5xTFvvMXcTV0m8f01jp6zXxgxqau2SKDvy4j3Qn9BlDFFRmbaZ7X2c3Of1frCcG0MUToWojamixqStUBRgiYz0HRWHwfWClff9rh9S2RU45PKpuGcGIVyHwyDpnPQZAa7uyH7WM3mgBVjhkmmopNbZDDU79ud8om/U3FfLfl+1Xj5cViUYK1gBx0c/MImzHYf0FrkVZjF+nyfxf3XokWLFqcAb/yTz971MteHtEoDYgUYC3K7SxORhEBu9ak09gDUPDwM+LK9x8DXxwooTeW5KSNvQeypUQSYhrV1mlaZjetPubjPpLkqL77WWkAxyG81YFhkpL1HihfrwhJPUspRkbTf11dW67WQIsByeF1oszcKjPCuVviNriV3vf8c8/JlxyhiBWllp/Wad49lbITPVL3GfRH3WVyvuy6tl2I+bmwQIJ6UojK+aDKTbT78/Vr6pBaG9PXEY8j12cL48bKqS6HyVMXXOE8TD/viIenk4L1t0PUD5wlzG3/2u3K/q6+xz0orYyh4Cd33YQkff67Ga2ZApcHsqX2UfY3uTYPZfg9mkKPz7g1ZV2o2B40mgNvlnYjES1aUoEyHsdGiRYsWDwqxoePfP/tbr92VstcbPD5cEm+n4OP+6UJ0MZIF6hZeY/gnzPg+a10eCQPGgLRbXNApT46VpDPAqDS142S5ft0JQZbBTsn7+31Z/lxQ3NZKvbHHx3EiY2Vn7CaDMJUPEPJkGmXmt7RgFfUJBY4+L0W24jByXczHQpSeX/QuPh/qSfonCpUFY8naKgfGK0l/nefq6vF9Fup0nMO1RHLOHQt96+9Lw4TW1sdcaQAYUOmMoCwTT4uvLhiSSsrOZbiTTTj7OhIjmKZzoCzFeOl2Kl6eqx8HJupLt9s6MudZORqJUWSsyIsJ5DwxAcw1OSyEiknGNuaFGFBTaS+79vhxAGOhCguVEcjfWloUj+1gvpVDzyy6H46gbh5X9/vxC0gZLVq0aHHK8MTL1YbNbz8/uu1y1hs87BVtg9JOlXzTuabrGjwq6bViYMCFH3jBoIjzdbzulmvrHILLv8kAa6o/5uHL8+8hxgYxgTXXrot5uxNRGXXDi1JPlMvlCNfUjJCEm/e2+BwQa4VX7NWwDEaD9y1S8kFhA5VRFss4rAos5UgOiK0rxWhF6prc3HW8IJN6X0EpOccSquJCcmFIKaDXjfo3MVrdzuX+fajHGFBRBk8P4OSe7l2VyjCRL4oSPJsDGwMxXgDgxiFo0HMbx0ruEKYzaeegJ22ezMSo8mV0O8BkKp4prSrZ+fqTPvVGkB/7ZN13z3mH5s+cRznMwAoY/OwQdP1ADLHMtVcRsusjYHcA08ugJyXUtMTsXB+qYNicMD8zQO9gJF4doqr/Yvm0aNGixT3A2W/vhPdXXrjZeM2zv/Vazcvz7G+9BkQGzxMvD2/b6FmftOx+iCl2wxPVjrELl5Cx4G4OGk/lh7QpvLTg6Ul+aP05ZjEsgLqnock44srjxHlWKXNjwZsD2F4H+vKN8ITfaIzFYK7CTbER0LDBKSw3KrDgJTBOYc3ncq01wNamKO14dkxqrClVkw1rVTMCl/KykREUy9YZLVQa8PEIyHPwxkD67WgELgrQ1mbUBhu8MKwoeF8QGUrEGpxT1XbXjmBA2Yijk0ktMdYy+GgkXpKdLUyfvABWhGxUIv/R2yKTzY0qzEkEZBqgTPp2Lh4Y6vfB0ynYGOm3LkUGm+OTyqjJqCQCHx4Bu9soL+5j9HgPZU+2sugcn8Hmax+IkdPtyH15LrI+PAbP5uBODurkQFeShvW1I6DTkbLj8WFs8BA2jiE39lEa8GQC2tzAwecewXzDZfYzMDmzB1XuYu9P3heDKtMS5jocIZ/MkDODOzmK81sgwyg2NfTUwnRdmG0aGWe+btt6eE4rvv7Ot/GbF1940DRarMFJFPr9QszF41Y43YlhcRI+/nMTpziEFXt37hQn8vCEH8N5AXtuF4cf38JsR6F3w2LrRzdBB8e48TcvYrbtnsgJIAb0DDj7h+9InoArqzH01WR0RLkbcO56+PcxvekMxScex+jRLoiBnX//NkCE8WcexeGT0jxWAJktkAWGHxoM//gN0HBQz7dJ2hzqWuYNio0nr8DIKamigHn6EajxHPT2+zA3DzD/9V/BwdM5iJ2Xg0VGOz+Zo/vn74DyXOQUGwlxjokPJ6U5TansbCSrOPRjLajbgXnvA6idbfDGAJf/g/PgTPrLJ4QMLlts//ufAt1OVXccaomNBP+XhLSIWerseAPDVnkp3jNjrST5KgINB5g+to2jx3OYDkCcgT/zccDJp/e9n4D6/YqTV9JEYKXB06kc11r+knEW+EQGRZBhlCeEogT1epg+uYdiQ8NmBNMBoAjzTY3x/mM49+1rwJUbYvRoBUC5EJ58P9DrgsZT6PFUPC9HzkDy48m3Pd4a3XtxQiiPZcbXfA7a2sT0qTMwHYIqGSDA5IRyAJAhjD51Dv1/+5egQR/U6wofZwxSaZBfUbCPbaNzWII1QY9L0HgKZhZvmFIStuvkH6kcnpcuvRbe//qjnwUgRkUT7oehcRI+8ecHYfwskw/wYPgAD7bPUpz99g7+8cV/UR1458HxiY2LlNNJudxLYweoeP3Db/+9lYbY28+P7prRs37hQW/sEIEnExx8chvTPQUywOSMwujpbcyeO4/5kEAGMlWaATKAzYHZx84B0Ywa8UBEf8bWX/0fc/1J3MN/VgR78wCkFQ6e7aEYEMZnFYqnzmH23HmMz2ViVFjh4nMaxvsa2NupK7+mP5t8Nqb+mvJxsuKJJIUePTXA0XPboM1NZI+cx+iRHMpUfJQBwMD4XA5sbYRwTlWfrf68UZF6kWI+sccnNkSsKD9zYQ/l/ib0+bOgQQ+zJ3bBmePjOInnQIHP7IgxAlR9k5bvUOUORbzTEEloA1fhnvE0GGR20EM51LAZajIiBkYXOqDtLfBoXJVvucoBUonB7I3GhbHUIDtfnu+7eQEoBdNTMB0CK4C1b6e8Hz2zA5zdlX6OxghpJUbKdCZVaCUhLs8p5E65PmsaR76/Q44Ww5zZRDnQAAkHq0n6zQAgYHQug9raFK9d8n3h2Qx0PEY2lrGlJwb5tdGScbQkbP0QIjYu/OdVynzVuXuBdXzuJ49UVg8aMZ8mJfqgcJq4rMP9HlurjJ30/Ulwb3N4whRnA9rbrQwbI3ePLmiQcbNjQnKpe2Xg6GIXnXcGwMGx5EAsCSEtPbagPL3hQVBbm5g99whsDlAp4Yvrn+qDXA5rMHSoMnhYA5Nn9tD/7hugTkeecGNl6D+HGVnR+diQiPl5ZVaWoK1NjD6+j/lQQkj2hcdhM6c4Y8cLSz52MSCMnzuDwY8ZGE3qPDzKyNMU1x0fcyDLtXAZT2egzSGmZ/sgyyi2HkGxmWG2pYKRQ3Ayckr05l/bxe7LUzFUMxf28OvWWCvHAPFKKBUZO7FRG4dwnHy0Dh4w6uTC78wOiv0BJnu6Gj+OEzFgesDxL17A8Cc98JXr4ulhFgMxMhooz4VXk5ciysOq9ZmXnxYvEc8LkFYyrVwTyj65HC43fhgYndcoNvaw+28OJdzU7YLLEphMgU4O6kvOD40m0s5ut+7VAsS7En2WhOP6rDGUBtTJYXO3OzwDZY/COAq51h1g9EuPYfCTvshnOJD8I7bAzhbM7gZsV0OPS2Rvvi9eqK0NkKm8rimfFvcXt2NU3OsQV8zppUuv4YYZP1A+MafTwifFKsX9oEKSyzj9PPEp/+AJvHkk77Nfe/uO6j/Z1hLLfgip7pkH6uERAFWSKpAk6i7BSa5p4pXU2zgP3J/yXgmviBpWa67x8eeDV6Hheqc44JTTwumUnz+mnEfD58goVf15xO9T+aySF7MoPuaqbiVKkxUqmSX508WA6uU2hc3i2VKeB0X3LZOpn5nlE48VwJqCJ0WuQTW2GCiGCvPzm5E3xkgYJqZdFJLTk/I4KYyE/ZjZJVJHXPxbBqAgxqyb2i3hqFJyjYaDygDtdcXYST05gCQLJ+OIU4OsLIFMQxUWVDKyGUPPXZ5X3G8MzLY1igtbIacJ1oA2higu7KAc5oAFbE+jfPYCaGvjIxW6atHitOA0eO0eBL79+jPhbxWa5FP+wRMrP98q1hs8qYJvUJLsUhkWlKgCrAZ40K0Ub1yuf00VVHysSZEmSpXJ/5G8qsqY8IYGe34A5psa1OtJCCNIQi0mWi8zOmL+0eegyGIZRH9eTl42XqmzBnjYR8iPSfNz1BL5pNxTEAGkqinQJDkcquQgt5psVPV5YUq6A3tDJ+6/dBbVwueEH6lwnzqeonNFXJTx+Fl4D1SeoqifqBPlGi0zcrz8ms5HxynPQFmGfFQiH9vK4xTJyGovp+a6uNeV2VnAYh+tMMRqRpD3znVy2E5lCepCvHCei5eRzQg2nuae1FMOM1nZuel7FI/bVYZ/i/uGdd6LFqcPDzpB+ecFn/9X/9UDrX/9L5xWkqCb58BkirPfO0D3gGFzYOOSwZm/mAAsisBm0V8ur1AATeZVQqlWMqMkfl31p1TYQkAYq6osInT+4h3s/dUU+ZgxvGxw/o+uQZmqfptHf+5zNraS39DrCofYq6Jd+f64bjiXGl2+Xd0OMC8wfOVt7P3FGOdePsDun1zC8P3C1U+wmSSdmpzCMSZyU5rzqq1e7pmuPtd4OPllWc2gYK3cMbmHNgagWYHhq++g/8Y16D/5c6gZS7KyhuPh/qK+40xXcohkFJKrXd+xT0RO+yyVkara5ad3YzYHX70OGs+CLIJsMpGPyQmmQ7AdJYm1rm7KczHmSgMoDcrcGHXtrsnI91HMJ8vkzyc55x3Q5qa0sbBVX3Vc/Y4PK4KaoxoLWvqAS9m7iopSPEWZlrBb3D+BU1Yd933my/LTxJ3smQA9F8vLalQGjpeRJvSvleh+cCThNO1kMS+gClmXSk8NQEB2Yyy5WX6M+XHlx+9HxODxScHLPt9vpPWfhtlYv/7oZ2t/pwGnjc9pxjpvymnEScb9nYa01ufwaC3TkpUoYHU4xvYrE/lxnxfg0Rj9cx/D4ZNawgDuaZgMAAVsvFmCjkbAcOCU42KVtXVa3JTmsHaNUuJM8k+wkbcCkKfyztvXsfueO37jAL2bOzh6LIPNfQUI3FQBDH5yDbS5Ac60hJLS33kiOReefKOcmeQpvKZUAfeaI7tyKOVMpui+cxP8yfOOD7k1VgBYWSBu+FdXJSl3cyj5HM6DEC8o6PuAtar2alLR0zlHYbpMh2nsAJzBKrk4+rELGLxxHaa/j8MndBU6AkBGEmK3fmaAm4fgnS3pB29kuFCILKDnQj9Kcl5qs7eI6n3m14nxMmSWkedkzDcOsP3WGVz7pPOMKNdfbkPTwc9K9N6S/JQg5y6BtKm8Pm49mnjNo/A+5eP7LJ4FZ2WmHecZ8g8OkL93HeXfeAzj887bQtJ3+TGjd9OADo6Bfk/qzDR4MpXE4Z0tWVhwOhPDo5PLNbU+S/J13HerlojtvI+cC+fe5Rlm+x3MtzRM3xcGZGNG/90jWZNnOJBlGYoSMBbZBzehBz1MLm7JNWOZzcadXMZ95KUL4/0jgtOmNG+Vz/02in7z4gunapbWOj6nEfdTRs995RVcAWozxU4zlsnGGzjlHzxxx8YOcAIPD7snP9bVX/zETlkGPbOwHcB2AeP+bEe8BapgeQLW1T21J/4lZYf3OlroDajdu3AfACgtHoKOJLyaHlD2HB/nhUInD8olLqNW1opz7J/UgeY2ROEByjIxDAkwHSefjvvrAXrGkuzqvA21ciAK0ht+vuxlPKX9VL/OfWZnlHEnB67fxPDtUeUB68hrORD5bPx0JMnBqt4ezrNqdV8/NuL+TPo09mDU/jIt5TjvCG0M0f+zd6FKx0c7OfUBKoHBj68B12+C3WrHrIUL8kwWKHSGR9hmIh1DcTuW9VmWhS0w7KAH7nWx9ycfgEo3bnKAM6B3w2Lw7kgWPHRGCucZqN8D9fuydcO8AOU5uN8NBlfT+I77LBzz/Du57NVVyErapqex+YPLOPODsXhUM0DPgeFlC3XDrZzsxjV7T5hbnbn/05ti7JRG5KVcH0TjIsioRYufE6wyIB6El+y08VlV74Pi89xXXrmtuu+GsQOcxMOTZ7I7eJLTwUTylDzsY/Djqxj8rIM3/4s9mB5gM8bujwhnv3sAmhXgrWG4rxFNuT3OU8Aux4DdLt3czRfv90/G1gL7O9h+9TK2/+0Il//+s7j5iSoB9bn/102oqzdg93cBX47zVtTo+J24Y6+FXxtFWffqlHmmpKxoxWH29xkb2v7YP/0p3v/7T+LwGYBz4bTzl4Tz//Qn4PNngK1hFWKI5RIr6ZhP3A86qjt33gRvADbJ9vw+1GiGi//8Ct78zbMwfQZrxv4rwN6r12Xa+Ea/kmvivYnL9HJId5gnVfUZOnm9LQ5WKdBsLlw3Bnj0X7yH8vw2Ln9+AzYDOoeMc//mfTEsHjm7UD/HXhrmqg+axlDEJ/RZJFfOZYYXFc4jCcnHeeyfX4Id9GC2e1CzEvrKgRh+e9u1fgqGoOcX8ah9f3yfRXlOnOuarMPK0dM5Ou9el5Wc3VpK2bVjPP4/HNUWuuTNwWK/dPJq/SNAttzod6V8rYWP5+e/yx/hWVr+Rzj1GjxoRXVa+Pi6m7wqp43Tg+YDPPg1k2I86Pqf+8orC8ceFKe1Bg93XMJjNN2KI4XCRKBcQhZP/9OD2nkmAvc6QQnG8Bs8eiWZlh2fhyVRUo6Pr3shkdc6pdHJgGEPZ79zE2e/E1WqCfb8ntyuVzQ9Vp7xMe/N0FQZPLGySq+Nld7ZHZz/4wOc/+M6d35033kAaEFR164jqpSUl41SIF2vm3XFJ5atKFlUSwY4GT/1zw7CeyYS+XYiL05sxDTIIx0L4VVHfZY3hLSCsdYNx3lrADUt8ci/vxkut1uD5f0Uc7S2MiySsebb7nlwruvGUTz+enldxn0Js+mRrEtkdzdxUsSy898fJlrss1xLvynUdqDnzqC6riMeLTFOFGzDw8Oy71l8LOYTvmuaxAiK9zz7iOJBK4cULZ/1aDm1OCnWGzxeebmcHNmE0p2zTpGAasfDe/fKfqXe9Ji/Pv6dTcqW80tmdwGiGLyXweWTBAUdGwjJ9QuKMV3bxh9WqjIalBKlwFxxU6qa4QSEPb7CrBigxoddThKn54AFA6VmYKRt9xwKADo6FxljXo7Vzumo1Vl7nxqQDZ6SJi9NDXFfR+3n3OX8mHpbZexEHqJI1o11pdecADUDwPPRMhAp7KMacciUrHMTG4qRnNLXpnNNcoFJuMTtUwp+oSiZOSffORiWV2bARsZ+/D1s+D6uPOa+x7XvpIleW7Ro0eIhRRu0b9GiRYsWLVo89CC+haflFi1atGjRokWLn0esDWl9+Ytf43h69C1hVSgkDZn43BK9eD0VBqwUvvn9r9Kvf+63GUjCA2koDdHnW4XLo2BN4TWUowAqrUtS1fjmd79KX/7i15hKW4U3ko00V74uk9EyuTWF5opqWv1Lr/0Offn5F7mWfGqX53HUwmc+3JaElJbmx/htN+L743CQCw9987tfpS9/4asMoAppcSLXiNfSkGPc5pgjqqTg2mtUlu8XzjW++Z3fDjKq8VmS+7IyfLYi7BbKaeATcmWI8NKrL9KXfvVF9knInlPMIcgGiyG2Js41eaL+XfH9VKvHmJDI/NKrL66IWf584kvqN07NU9237Deo5bMcp40PcPo4tXxW41v2G0t/w9qQVosWLVq0aNHioUdr8LRo0aJFixYtHnq0Bk+LFi1atGjR4qFHa/C0aNGiRYsWLR56rF9p2bCs3OsTi72JlKxX0wgLAAxiBh2PQdM55s+eQ3ZjAnU8XVhUjuMy43Vx/KJ5EeoLEwovYq7WF1kCv9aKeucyAODd//JjKHvAU/+PvwRtbsDsbwGolx3qiteYieQDZizUukw2TevMlBbq4Bizj53Dpf/NHJ86/wH+9I+fw3P/1x8DZ3bD4ne1MnxCrUr4RMm4QJVEXVvnJ+Hr2xfaqQnq7St45yvPwf71A/xPn/kR/vTGY3jnpSfx5NffkcX3LGTtGF9mIqta0nlZZSenclpIrG1aNFAT1GiGcm+I3v/5Azy3cRldVeLr//YFfOy/myK7fCirOecyfmIOjWvjWFtxWpPkmyLI0CVB/+w/2cbf+5/9CQwUvv3B09j9nT70tWOELR5Us0xq9Rq7kKyccmr6nCZvU2lx/PEdvPd3gf/4+T/FN//NZ3Hh3zO2vvsuykf3kF05BPc6YNUJ969qa4ufD7zxTz4LAHj2t157oDw8PB/gwXOKuXicNk4tn0XcqzG01uChwsgKxn7xv5MaPNEidzSewm72cfPz53H8mIIq+9h6u8TGH70BULV7NndycDehRORmRqmKj4NfxM7z8ov+LYXjrj84wPiXnwwbjKoSeO+//ASGH1rsvHoVdqsPdTwFHY1h92RlXV/2ggIyRvg1zaZaNTsrupZGE5hHdvHh53vAaz38yG6ha4F3/5e/gPyYQQbIx4zNt6fIPjyQXdmDkWFrq0JTad3MrWoxvQA38yxFPBMLCtAHExz9jadhOwC/to3/4VVZNZT7wBv/q4tgLWV0rxMe/5dXQQfH4J3NaoPMYBRQvc9qhhnVZpAR0GiokALUwRRmbwPvvzCA+dYzeF09A2JADxlv/md9kO2HYgfvEx77f/8EfHavKi9pd5AREUBcGWyeQ2TEpauAB57MeO/X9qAK4P/7z35Vdp7vMa79Fwwqh1KuIXRuEnZfN9j+7iXYzaHcn6yYHffZqllhy2aNMRFoNkd5bgvXP6HRex/41//sc8CuxXt/B7j0ty+CCSAzhCoI+3/K2Pv374E3ZCXnYBQ3jI0WdZwm5ZByOQ2GTxOn/+jZ18Pnt58fPTAuAITLy8PasQfJqYkPcP84nZQP8GA43W0+6w0ea8GIfoj9irGKa9N6G8EMlAbcyVFu92EzIB+JAi/6Cvz4edCsgO3moPEMNJ2FjRRDEQRR6n5L72jad6yo2NKipyWd6s3OQOjkKAei3PNjgEqZJj3dJdz87L5sqplt4MyfHkDdPAb3ZcNFsrZuvABi2Blb7YHFLPsXKWp+9XCbSqIowYMe5rtdZFNAz8Rxwko20JxvC//pWcLxYwM89ocF9MFI9kZilrqBqmzvwfFyio0IU5efn8ZNbs8l8gK3smFlNkJwyZieawbDbYgpxw4+vYutHynQvAi7onuDAKTrHGLDwtutvs/8vk/MICLA7wTPTtaGkY0BNRdOZR/IJgSwk5fYLrAZcPzXn8Lmn34o/cYMggpyiWUEZpAzFik6TkRAaaDG02rqe78L8jualwZ22IOeirHMSjZeBRP0OPJUsZwf7ytsbQxkF/NMS59Fe2mFemOO8TkANJmJoZtp8VBePZD3vS5IEag0mO12kI8AsIydbKSAkZO1kuNkgdk2ZH+uqzdA+7uyh5g3nlssRZMCPW1IFcSpMDAiPPHy8L5yWsXF40FxWsYHeDCcVvG5X7jX37EThLSse1r3Hh7nVbHyw09heXwKCqsezjCya3QmSjI/9mETYPTUBuYbCqZD6F830BOL/is/A3a33M2y6SNKI4rJ8akKj+pRJOec0vWbLSLPatxRlGCtYLUYF6pg2cm8ywABkzOVZ+Tq57Zx9o8L0I1DeRrWOlKKsvmkGAt2MRTnFbXOALag8QyYzWVH9EHPhYREUTGRMzCEgxg7hGzi7DwSRQUANz+1ib3XSvGqOIUeK3MyYmTWNg/1faKVGDbTGXg6A+1tg6ZzYDKV9vlrtYYqGJ0jBhgoB9J3miHRvkh5lj2FK8/v4ty/u1wpcishnzA2ygYPjzdqZgVQlIBWGH/iPIoNhY2fjqDfvy57R3VycJ7BDHPkI+krm7v7p45PcC2JQTQ6p7Ex6IFGEydr68ZqXpcRRWMWALQSPpMpeHOIwy8+jtF5BbLA1s9K9F/9GbC9KYaLJuRjlr7qOD5j+Gho4KRnjGwC3PzMLnb/6G3pMx+G9ZeGPou4ePncPAKUwuSTF3DjE11YLYadmu9g+KHF5rffAg0HwLwAAORHDNYSluzeqOTi+wwAsjFw+W/uY+utLfT/wnl63Pe5xcnxoJ/OUzQprNbAWM3F425x+vyr8sX+/i8vpsc+CIPZ8/Fo4nVS3KmMUi4eyzidpM+AW/u+ncDgMaKBvRveIihFHByBBn2MP34W4/PeAGBs/2SM7N1rlRdiNkd23EH3IEPZ86EDYLal5cncArNNjY4iYHdLnmYzLXsesRKjwBsy1oIsi5chBivQZAa7vYHrv7wL1hDlYAEQsP/KAdTBCKzFG9E5FIVnNWAzAvv9LZmDsiILjJ7dxfANgKbzkGNElsGRB4VKI+VGHhzONOh4jPnHL2B8roPZtjdApO3bb83QfetqCEvlRwWyXS2izsldiEWFboD5uSG6o4nUbRJPjrWOD4f+ACC7zBclyDKu/u3HYTriDfHt1DNg/0+uiOyZoScGeqbEAJuLp8Jz8PvIEgO6YJFfvwN1NJF+8jLxYTVTecZCvxGBCjEWx5++gMMnM1i3m/l4fxOq3MTGeyWGP3gPyDTyayPoiz3YXPpKTzhw4GgoqFLkNTu/gd4b46DEa2MokpvnQ9Z5I0djjL7wFEbnNdjvU0vAwVMZio2nsfWvfwL0elCjGbLphvRXRsjGzV5OVYiM5psEHvRAx2PwsF/b7Tzus9BfikDjAtAa86fP4eDZDqhkaFMZv+NzCr2PP4b8L98FdXJ0jgrMtxRsRrAzDtf5PiNv1xUM2yHYjpJx7Dyx9BE2eM5+e2fh2JUXbt53Hh63yudeeguauKzjdK8NDM/pif71cOztyd4D67Oz396pcfHKPeb07G+9Foyek3hT7kRGy4yLz79qGw2Me+3dWcbHn7sTQ+xWsLYW8mEG/2rE4KDxFNjexOypMxg9kjvDATAdwsHHBrJL+mjiFFsJdThBNjaiXAtnsDCgjPww2wwo+pFbvRaK4mY+0TEaTYA8w+GndmDzKAImdhhufHorcEFpxMAYW5DLIyGL8Bee0hmVd8srTlvng0Q+cAmtNJsD/R4On+xhvileAtbCx3SAo8e7GH/iPDCdgYoS2c0JVOmNFPdnXDjCuj8Wb0DZ1+A8qxs7MSfHh6IwF01moOMxJh/bh3Ey8QrQh4gmT++KBwKAnlko42TBqMlHGdTOgYBiry/G8RI+VajN/RkLPhph8vFzGJ3PXNlcGw/Hj2XCxzJYa6jSy7mZT+g/AKavwD7X6QR8wCwGYa+L8VldebFMVf50W4GGA/BsDpQGes5VPzW9LoynhrBa0mdh/Lj3vDXEfDtfaLP/PN3vAFa8mdm1SXXO1PnU5OOdSBb1MOuqnLyHGKsUeoz7lRuT8vkHZ7/XePxB4B+c/V74A+qc7rd8YgPDc7sTGT2xJFfkpHya4OXU4mS412NovYfHPw2zy9nRClSU4G6Oo0/v15S5f/I3OeHgl89heGmG/O2rQKZB0xl6f/k+ei7v4PAzZ0RpSiVQTO5HOfrRZ5fnYuxCjkrIzQCAeQHeGGB6cRvFgEJehdWQXJMOwESYfGwfvbeug5RC/rMryN+yMI+fxfRsD+OzIorQFhJjLIQeIjmEfJOYT5yIygyezjD+3JNgJV4HmzmFw3AJrsDokQz9tzZAowno4Bg735ti9KlzmG9ql0gsHKyuPFCxUg/GYay0bDMfaI3ppx/H6JEcylQGofLpURo4uphhunsWe//uHXR+8j709Cwm5/uwua4rSW9MZs7YNGK8hlCWl1PkdQqy8pzmBUbPP43JvnZ5WhLRqdUD4NoLj+DMn1wGXbmO7dkcNz9/DioDqGgYqrHTz3sivSERjyEbycfzm82BbgfXX3hM6jeVYy32kBx84VH0r8zR+atL2HrVoHh0FwfP9KsZT4njMRgqfmzDebxqHp6oz5yBzZkGZnOMnn0M0x0dPGw+V8nXM9tS2NzfAw6PoY5G2PneDLMn9zC6kFd8outlXEd82FaGc8zpI4JlxgUA/P63fwVA3YtR+0G+TQV5O3z86+9/+1dqHgPg3oZKYj7/4Oz38J3jZ/DFjTdrnP7v+Fi4JvZiAMCbR2fC+2c2r91VPk34B2e/F2S0isvd4rTM+PL4zvEzOPvtnUYvTxOfu8epmU91HgsyelB8UnhOy/jcCaf1fiRr5cm9lD+aFc7A6Et4KvLSeHAGFAOF2W4HfDyqFB0AzAvQaILhexN0Di30nKEKoHfDYOOdKTCWUA2M5F3AuFwcrzQdDxjHqyjBRYH5o1uYb2fuyZarp/NC/sgC8y2Ncn9T8h3yDNAa+t0r6F6dondgkE0ZumDJu5jJa/faVLxZRJUcvEIHQjgg8C2NtHE4wHxLQ88YquDwxK1Kx6cEwMD80S0pVyvw8RjDH13Bxs8myMc2yFWVLNxmDGKgd+mo4lQm8rF2kY9TZDYjdI4tsgmL3MuKU/AmESQU2cmh3rqEjT+9hMGVUuRSOA+M4cBJGSAfW3TfuiI5MJ6PfwWivvTHGVAK2dige2DRPbLQLmymSkAXlXcCLOEoUgp0PMbOD65j4925eHtM/U+V0q5syhj87AB0NHLGRYOMvNHh+QCAUsjHFtmsLhv/55PtbabAzODxBPl719E9NME4VSUHbp6PnjPysRh5oc/KsrnPjPCkyQy0MYDpUjQOqvETODEwe3wb6HUlL8t47xBqfUURN1UIp9DuoqzL5yOKW30af/PoTPi7G1hlfK267tnfeq3G5W7ziuGNnZPyiREfu5Nw1rdffwbffv2ZE1377G+9Fvg0IT5+O5w8l6//4Fcaz39x482FflzFJ+Z0uzI6qWxuhc+djKWT8EnH0JPnVhtIt8tnvcHjf4QjTwZbi/leHyAXDord505JsYbMhNIq3M/zAuj3YM7voBzkMF0xgrKZRTY2kuc7m4e8luBJiX+IY49KFF4yXQ2bEfKxGFGinOthAFYE7qhguPBsDt4YYHa2B9NRtdwdMqJMsqtH4MlEFJRTRguhiThx2RhpazeHMox8bNE5slX4IwpHiCLjysBThOL8NmZnupLDEV1beQoYNJlXxleQk23mA5GpObMpG3YyglEQymT3F0IgVoy2Xg/mkV3MN3SdQ8JHGUhOlx8rxi72WSy3sgRvDVEOxG3lvWlVX1XvVek8ZtaC53MUZ4eY72TwuVAUh3rYhZ8KCU9V42jVGLLgyQTlU+cx+sS5ICNfvg9rxnzISD8TEbjbQdlTVaiIUe8zd3/n0Mg4AiJPTtRn3igrS/BMZmQd/dJ5dz6ROddlpUobjKjikR0x/Bn1/q31nzPqR85tZMxin30EkP7I/v6VutL6xxf/xdJ7yz94ovb5bhoXXkGkfG4Xd8O4uBUlmsrmbuH13/tcjccyI+NW+dwLwzBG2o/3Uj6v/97n7knZt4vb4XOv5AOcMKRVAxEoz6EKKzOcFCGbWpiOjq5xOTkDAnW7QFEAWQYogjmziXIjx2y3qpqJkI0LWUCu2wn1AKim76YGBhCML2wOwdopRxKPAxNhuueSouFCXJnUxWUJIgJlGsX+JoqBCuG42P3fvV4Ckymo11sqHkrDEUTgjQEmT+7IjKKMoEgMH5tXSdpBQVqAjQWhBCmF+W5HDEWft5wkaHevzUHHYyDPK8XdsLaPlxFbC/vUIzh+YiDTtrXzDhjx1tjMyzdS5u4+bA5RbHZqCa8p9NSi/86hGBhxP8WIZVMUmH/yccz2JJGIlQuxsONCgFUSwgteHkAMjM0NzLdy2IyqZGVfXSSC4SXJV0KWiSJvWpvJr19kLbC7jdHjfVgt3pRsxuA5oxj4Xc4RHg0qPhbY6mN+YWulfLxsh391Bej3nYenbL7OGDAzsLuN6cVdlF0FXQgfwxIqhgv/ETiEPQGE2XG2p8V4X8LHh8N2vnMJfDwC9fvL+TzkSJX49//OfwMA+DfTc/jbPVmY9B9f/Bf4TbxQu27ZD/KbR2eQ/drbd4WPfx97B/527zJ+v+G+VQrizaMzyHB7Bk+qrP7rb//n+L+98N/Vjt2OUXY7nJYpztTjdLtG4q0ahU18vv6DX8Fv/uL3GnndKu6k3zwXAIGPxxc33sTbk73asZMaGHcio1g2C+UmfE6Ke7IOz8KCepCQR7HpniLd03g+sZj0K8OBrHgSeHsDuHIDBPlRtbmSpFtNlRJUQDnIoRWBtK7WtLFOmStV8fCfgWC4FGe3ZPaOzyHqyIypfGQx3RVOZIBsysivj+seGiUzh3z+hzeO4F/9tZmu58r49X/8ejFKCZ9+D3Z3A8VQOLMGjBJ59G4Y2Iww265mdOlJAVgj5Qz6YF21Q6aoU6VQGbAdXTd0InnUuHk+nQ7m2x2Rt5X1howCiElCUqWFyQmmGylPkjaZ7YEk/ypIToxzfqCykWA7CsXeAJ2DYycjV0YTJ2NA/R6KzSxMrza5FOZDY2Qk8d1mUa5KMH4Vyp6TjzN4wgS2KEfF9DTymiwSGfnyjAEbC3NmIxiVVhPg8q18WBEMzDdUWB+JNVUJ2rQolxjs+jDAc/EGVyqjokB5TsKzQCQfF47yOThll1zSE9xsNwZ1OzAdVRs/vp/iHB4mmTEGHxYNcvpo7zTz+X/1X+H7f+e/CcbO/cQyhf5ff/s/D4aYx/2YibSKDyDG4T985+/dcx7r4PkAwAvPLRoZJ1Xm5R88cUfGqoc3NL74wpt3zUN3Eizrr9gL9sJzi8bO/eSTeuSa+uteY/0vnFeqXsEP+7C7G3LO6X+buVyeAvLjr0UTyY+9qsoJZQJgdkqcw1oztbq8okrqX1Dy3Q6K7U5YIt8bCKzJeSw8J0BPLGhaAEqHskLdDkzVX00GQJ1PTYoqGAmcaZheVhlNrl1++rL3GIhhQ9BXDwGlw5o1rBIOXqFG72vy8cZgqrjIG2Ik/dEAVlRTxsGwmkwjWbi+VBUHVs4YJP8a8VC0KCet5by7JtxT4yLGhjd0Qj8SJIGXVODLVK/fvw+fteOjVfMYivoMiqJtLSpZ+/4yOVWep4wkv2dmgG63xifcF91f46k9H1WXl++z2JCv9XXFxbox49vsjePs2ggoCrCxYabfQv2q3oc0nYtstHL90zCuH2KcNtf/zxtiY+dBTt8/rYgNsRbrcb/G0HoPj45+mEs4BYGgROOnXtuRp3MoIB8B3QMLdeMQGPYBJbO7shtjyEqwPbkWQH5s0X3/qFqtN15pWRGIdaQ8KwOKykqBBkXHzrCwDAWCzQGbE1TBGLx9CDo8Bnpd+YGfzaFnMr14PlSuPVVuSzYqJSySZ6FO/1QdeCglnP3sI6JgzMRP1WACawbDzbiywMalAnx0DNreEsNvNEY2Mih7Ksgm3u+ImJEfSH4HZ7qadu7rbuKjVFCSYQ0djiMecs7khM33CvTevCbyKQ2y92+gqxWmuwPAK8sIpIDOYYnOu9fB3by2VEDd4In6U6vIixV5s3zE0ntackCVhL3vXJZE6M0hMJmhc2gkVBl7wiJoy+heOhYZKQohQfKcYhlZBSrLUFZsuPhcHJ9LxUrWbNr886syhoZ9wFiouZX7kcjHN33uxlNRyqKTfjzHoUilQsgXSgNa6qoZzZFoLWSMmQ6wcckA1w+AQQ8YjeV7mFUPIU1rOTG52ZbeyFLO6PkIGTx3guzX3m70HNwND8E6PAzGxb2WUyyjZX2V4l5yup0+O218HhasNXjYL6cPyCyc6RzaMtReD4XLNcmmFtmRwfhcB6oANt432PzxTZnqm2dhPRS/r1Y+nYM7eygGUn3vgzHocCSLDfocHq4MC9lA0j39+sXj/L5DRMiPShQb3ZCj4xfDKwYEPQN2X5+i++MP5Id90K/KyDPoD26g18tgOl2UXQJDEp+7Bwb5O1fBw349hBQbFo5fUGREoHkBPS3BquMWEAR84mvZE3kNPygxePkN0MYQvLvtvCiSG9V75wCq3MLhk11ZQ8hpUVUC/asG+tqR9Ak7pQUxIsLU4oQPrIWeW5g8g1ISCvHhMcDl7ebVQojccdOZ3cKJ+Qc3kT/Wq0KDFiEPSRVA54MjKSTTlSeJCLBVn0HH+V1ihIhRisiw8wNOFH3vhsXG6weSp+WMbioU+u+PwNkGRo9oWXbAF+uSc/MRQ0WrUHtvTzyGkGmn4C1gFTgXAzM2MDyfKomacfb7N2SBwC3xcNJogvzDQ+jHuphtRV4iVDLSMzEK4foJRGFBwwBdGamUaZiulrBeTjUjKiQia2BwuUT3yhj66iF4ZxPMDBoO0HvnADbfwdHjWa0tIXfMAPnIytISm0NHOZMx5cN0HwE895VXGr08//CdvxeSlX/z4gsL5z1SRXovFdQ/fOfvrVRSq5T6g1CcJzUy7iZ8eKSJ0zo+91tGD0I+Hh91Pus9PEqFhEhoLVPTpzOouUX3pvdoAL13DvDoDw7BZ3Zg+7ksie+NHSWPzqw7spIvgPzKCDnLgnLkpolzntX3pAIW3f9RiIwzDSoN8utj0PkOxFcvSpQM48z3b0DdPBJl4sv37QGkrlmB7MYE+U6ObCJFqDmj+4HLSdEKfm2UeD8sjvgERea8WOp4DlX2UfarcIcqCP1rBoN3jmSbiTO7cl+8OnOvAzoeo/MhQV9wBhNJOK573WLw1oEYaz6fyBk9UKpyABBVx5SsKk2WZTFGJR4vrzhVCWxcmqP7/pHU7xb5C7LuySKEnZslJmc6VYIzAbBA/7qb7eauq8ZMva+CgallNWxVMEwuhpft1JWxKoH9798AzUoXcqmsGu51QLMC2djAal0ZlEAIXeYjK6tK+z2rfD+jCq96gw46B/IMncsjmGe6YohE3hA/+3B4zWD4w8uy03gefWW6HTHgRxaTM1kVWgNCrk02tchvTqPvwSJYqcqLOOyj++EI5WATx4/o2j5hvo0b75UY/OWHYpxGsmetQYcjDH6qcPjEXjCY4jLUnNH9cCw7ueeS1M2+z5pcZh8hPPeVV3AFWEhSXoa7qSiXGWCe00m4pEriTvgt43NSTvfbC3bavBYn7be7Wd+6MO2dyOhW++1O+dwrI3W9h6ebVUmWgFO2Fr03r8DubMD2MmTv3wD3urD7u4ACqDCw+9sNhTE4HwCAWyvHbXLpjBF5Ck/jJgSUNhznTl4VN+iCmKEOx9h8/RBmo4vrn+hj98dT5JePAOaw2/nS9rnzwx9dCUvr81CSh+3GQOpllmRchSopN/PKXIGQVzlEnRxqNMHmmxpXP7uF8aMEKoGdnxhs/MWH0k7vxQJAKgpZZRp2Q3b+3vujd2F3N8C5hv7wpiR/k2zhAAsgLEQou5z7DVw51+L1cbLkQRfdH72HYf8JHDydY3zBJbpa4MyfWfTevAoe9CoDLvKa+L7vvXOA/l8cwzxyBpef38K5lw+hLl0B9nfBgy7gd9n28lEQQ8X3ZWQk8LCP4Z9eQu/sDt770jamZyTkowzQ/4Bw7pUxaFY64zQqD+59ptB9/wgXfniI6//hUzh8SqHYZjz79QOoD66Bz+wIJ4vIC+eM5sx7eBQYuYQLuxrqxiH613dw8LTG5BzDr7KsCuDcKxbDH10RGSVjk/MM2Oxj488+QP/dTRx8YhOXv+iqnBGe/foBaDSVPvMeMCJQmUz/dnyg5Huhrh1ikGtc/uUtlEPrku5JtqmYEs7+8ZHsT5frejkW4DNboGmBR/7tdfz0f34G07MGnDHUXOHcd4Dd714GOnk1BnMNKi04U1U/fkTw3FdeedAUavB8Xv+9z90Wt7ttTDQprVvhdT8MQn/uVrjcjQTluK/uhM/98hKu49TE50453Y0+u9tG8wlCWj4fxCl0b28M3U7UhYE5ux3yRU66PH3tqtig8LkfkYdHwja+/uhHXgEMgtkeAgpQc4P9Vw4BAHajWy9nHZ/tQfUhNm78q0ZQSIAYOuGVqsRXshZ2awDONfZfOQT/mYKaleBOBrPjQiERJ8n9kGTmmKnZ33ZrHDHs/nZ1DVHNSIIRGfl94gMvosDdPnIGnYMCj/zRMdTNY8wvngGIoMdz2O1qtdhaHVHuEPod2MEZEDPOvSzy5Qv71fkMCwYhKa64+D5jFm/G2R1AEx77wwOwVih2ulCFRX5lLEZav1O1IQ5bKQlRcTcHHjmD7b88ws6POIwN89i+Ww2cEG/OCQUQceDBmkBQQfb27A6GPz3G8G1gem6AS1+ZYfhHG3j0n78Hu9mH2R7W5eHhuJldMZq3//II239ZyYE1AUMxlMJebbHRRFGf+f5SDN7fBpUWT/2zA4ye3sCZ/+1P8YOfPoZf+D9cAm9twG50wVbXDfCIDw/lzRP/40Gdr4IY1Kkh6TjQyrn1Le4XTpMh9jByuduG2J3gNHEB7o3RfCe423xONC09LILXcK72PjUu4ryXVFk0HfOGRbzsf1gkrkrcBZwyDFOg3Wtp6/PObueJVblEYVB4XeDNXGWoUpJR6ouZlmIQzv3UYdMsD3Y1rDlGfpsEV7737IjiqicLN83KUuMCrBTM3hay43kwagBn6EQyj+vimG9UP6wNO9izpYpPdH9YxsAnuPuZ3Mxyyko7OlfcgnyZGMyez0Ir3DgIBqN/tVSNkfgab2BZ1PhICNAG4zXASj7ZM/8XgPgmzM6GGJ3uvthQDfU3jGv2g9DXG/PB4kOBJDJHRnDUD8O3jjH93+3jF3gKe34vjHtiBtt63alRVvuuoJK39wiG+/0DxwkfDlq0aNHi5xHE7Y9cixYtWrRo0eIhx1oPz5e/+DWxiPzTsM9pSZG4yGvelzRElF5vK68AZ+6JPKrH5xh887tfpcAHaH7CbsJJPE2Jh0UWyuOKh3/qLm3wHHzz+8In5ED4J+UYafubzp0ELpxWC6uoig+I8NKrL1Z8Em+ND7vFnxvl0PS5SUbeIxRdE3KJfF9qLTL6wlc5eCV8uCwNO0VcWamaxwmovFBxvlLwICkFMkaSdv01fqXpiFNtDDGH8Ff8GuqKPE1Lx8cyD4/3oKScHQcqTJDdS698jb78/ItcrR7e4JlBXXZL+2xFf8Yh11rOF1FNdi+9+uIJvlA/X/iS+o1T81T3LfsNavksx2njA5w+Ti2f1fiW/cbS37CP9rSMFi1atGjRosVHAq3B06JFixYtWrR46NEaPC1atGjRokWLhx6twdOiRYsWLVq0eOixflq6X19HJTlJ6TT01HTyCyIbBqyFzXPM97vo3Jghu3wgC/ANe/U1X8LqxaiXvSyZdhWf9Fx8v1vAzrp1YvSkABVG1kvJ3Y7fGS22OS4vXsMkSSQOSKfNpwnb6Xl3zifc1qaY++nvafI3Uf3V84nLj9YJij/TMhkD1aavCgDcVOioreT6K5STLlGQtLdp2nWatM1uzaVGzgoypdutvSTluroVwrIFy+RRa51LWK7xIb8qcTKmmcL9HJetZJr9whIAVs6xf/Wcbb1tjWNSobq3QT61c0C1PlVyTXUWixMGmBrqoOpcixYtWjykWGvw0MwA2jYbIGumtPtZRTSdgTe6+PCLHZhuDrIbmO0b0EYpi8mVCjxT2PhJjov/z78AP3GhXpAFyP2SU+EXc2lQsJ7PMuPHKRbONdSNY5hHtnHtM30oA4zPE6aPGPDAgDILLhX2/iTH+f/PG8D2ZlgMz89WC3xKK+v/2ESBBe5LuPhti5zxBWbQZI7inCxip6cl3v9bWzh6yoK3CqgbObZ+onDhX1+V2T6dLJkVVq33Q6WtKcJgkMQLAy4yqqCcQWPcStjMsrt2afDu/+IJHH6qgDrWeOp/LND76TXZckHJvl41Q9eBClPNMorqCDPhYkMQADmeFCvqdK0dItB4BioN3v/1R8GasPNGgcGPPoDdHFaGi64UP3E1087PZCN2HEL5Uf22zoNqhqlbl4grww8KUNM57LCLcqeD/NoYNJlXY8dxiGfReT4La0gBMkYig2VhLazGYw2G7cyA3L528l3RbhM1kU9Y+fkjttLy7eCNf/LZ8P4/evb1xmvefn50n9gIPKfTwifGEy8PF449SD5AndOD5uLhOZ0WPg8r1hs8xkC2km6YzmwsaF7Abg9x8AtbsLls3rj1xz8Fb28CikClQXl2C4fP9NG5CdgOoewD3asadDlze00xyMguz9f/k09i75tvALtbtV2/2StD/+O8ZDouHY4w+msXcPxYhtkOgQyw80aJzdfel41AiUCjKaZP7WH0aAcgYLIve0x1r+pq8TxLmJ4Brv36szjz/eugaQHOM5EHUeADaysZeUSGF12/CXtmB+/+T/ZgugAI2HrT4sy/fRe86VZ3nlugNCjPbGB6tov5psLRRXJ7aCnwQQdkCLM94P2/s48L/+oq6NJV8KP7IFPWDTzDst9Z2AmTAcsg7ab7zwvwoIvrv7SLo6ekDiqBp/77a0BpROaFTMWm6RzczVHuDPDBC2dhupB90y7lAAOX/mYXg49dQO8mY/vfvAk+uxe2DIGJFjI0RjjEe0l5xVyUoMkMV37tCRw9WZ1/+vevga4cgPe2gdKNOytyoqKEObOJ9/7+IzBdwGYi1/fP5eh9/CLOfXeE/IOb0l8crfIclkYWryMB0diuptvT0RTc6+Kd//Sc9JkC9n5osP3yu+Ct6Afce91YNiy1Z3fw3n98FmXPVal72P2xxfCdCfL3b4AHPamnNIkskjEUG+5WjGmazHDw+Ucw31CwGtj70RjZ5cPKiAnfB66Mr5vHMPtbuP65XakmAzrHjO3Xrki5nTzwgZue/lHG51+trMfv//JitP8kxg4gyutOFVfMZRmn+8mniVOTjGJeyzjdbz5xvauO3e0+W8enidPdNnzuBqd7xeckXJZxul0+62s0Vn4cjQ0bVgbD5/oBQISrv7yNoycVRhcUbj6rMfrcE6DDYzGISoNiWzae1DOWsIEBsjFBT4BsAugJQU+BbApM9xRwbk82GWWO6nZ8fP3WVn/uMx2PYfa3cePjOaZ7osxZATeey2D2t4B5IWVYi3Koq12/DZCNAT11XDyfMTDbJhx+cgc0nYm3w3Kdj0VdLp4vEejmEUafu4jLL+yKYWEANQdGjyqM/tqFqo1OiZebOcgywCILPYs4Tf17xuSJbeDsLmhaRHyi1YA5Mjo8N0AUW7eDS393D6NHxRjUrp73vnRGdki/eSR9Oy9kCwcXViMr3FUBqJnck00AYsDkAOW5M2xsqD94WYyt84k5MeP4lx/D+LzsFSX7RQEf/K09HP/KE6DDUegzlEZ2K59MMbkwlOjMvJJTNpb+np7vgo+OQUUZ9UuyYnLgYut9V5Qw53Zw9a+fFaPB9dnN5zTMhT3QeCpyjMYgTeew+9s4fE68c6qU+/QMmO4Qpue7QabVfVxtburHUDye3bgAADoa4/jT591eX4TZGcKHXxji6BfPyXcw5u/kTuMZ7M4GJo8OMd8kTPYJpguYDlCe2RDZ+Haw8+R5Ph9BpIoh/XxS4+K0okmJnRSff9U2GmBNx9YZO3eDz7K6m47dLyzjs4rTKhncqXyWcVqHZfXeCz7r5HM36/ZYb/A4RQPj/opSnsqv3cT8Mxdx9W9eQLERKeQZcPhkhuknHxM3urXQM4NsyqLMZkDnCMiPq7/OEZCPgGzMIAaOP7YN5BloVsiPsDFVXktpHB/3A10KJ7pxCO52cOWLW1ClKL9sDOi5GA9XPr8FdHLQ4QhkGXrGyKbOuBhJ/TGfbARkU+EzekTLZoveYIr4iKIwFRcnKxpNwMM+Di9msDlJ2aOK19HjGY4/fR50NA7t0uMSpkMwHZHFgnwmQDZjHD+aYfz0thiVjg/807kVIxOlMz6MGAk0mgAHRxg9vQ0qq/ZmrlxVAqOnt8ULVhqQsaDJDDSZYfxoD3rCyCZAflT1X+b6rOwTiov7oOOJjA9n6PrF9MgZKkGhG8fv2k0cf+YsDi9mIpdR1Rc2JxxezMQr4uROxoohk2UYn9Mij2klU5ERYz5UwLkzgYsfQ9Xifo5f3G/O04Q8w4df3KzGtDPK8yPgwy9ugvvdYMx7o4mPRjj45DYm+wpq7o14eQUBs00Nu9mXsOC8ACV8xABLxpCTF03nGH/6Ag6fyJy8RUZkgeNHNcaffxJ08yiEHGMD+urnd3B4UZy4qpR8n9m2wvETfdn49NqNYESGPvuIYdWP7p0o0Ds1MG7l+IM0wJo4nZTP7cpoVb8sO3c3leZJ63yQuJ0x/aBkdDucbpfrWoOHvPKLfhCpKMHbmxg90kHZA/SMq785gwwwejSXTSrnBbo/vYbhu1PoQowMPWOoeXWPmjNUwaBScj9UIU+rrKhSTv7pPObizlFRgs/sYPzcnjRqLjx8+VTKveMnt8H9LgCg/+Z1bLw7RT6Wa1VRcfL3ez5UcrWyMHONjyTAVgqMjJUk7+ms4lMk7fV8zmrhwwzuddB54wMoI14TVSC0Qc0jTgawuSTQsvcwOJkACJ6CICfLYK3A4ylwZgej81ram8hfzxjjcxqTZ/ZAh8fgTIMPxNsz36BmPgVDGQmVTM91wZOJ8AjeNyejlKdS4mHY38V4X4O43l/KjRNVMsbP7oKOx6LQmUEbQ0x/4QKY0NgOVQBlnzC5uAXudUDzohpDgU8lo+AVcZ6j0cd2ZQymZRfCZ/SxXfCW85BYC5rNwefPoOhXMvJ9pdwYUoYxubgJaCVGPCIj0MnHcyHvDQNAx2NMn9nH6JHMyVrGoiorTpP9DLwxAMayHxlN56DDY8yeOQvWgCrlutCGgsEKmD2xB+xui3xij2mLGvyP8bO/9Vrj+TePztyT+k5yfhmnu4lbVeb3g9M63K4Bcq8UfhOfk9R1LwzCk5xfhnvFZxle/93n7+h8E9bP0gJqSbfkXfGZRtknwIWFGKKo/avpEMphhtwZJPmHh6AneoALIcmMGDdphEVpEkvYx3QVzP4W9Ic3JUfBhSRqfIiESwM8j/A5/EMwpOjwGJm14Gf6UIVLn1i4SdpGFuJxms6rXIlYeTaKzIdP5E8O1l7cNBv3SSnwfC4nWZ7Iw8UEWC2v5M5LP1QhiQYCje+JEYUHkzZzcp9W9ftcqMa6UGFIUGYEI66x/vSY32YhJJu7NjWJMj5WGnA3h+mqkMir3L2cVWk4rOHCcCzGVRxyTPjUxpALJ4Y+i76nXu5BRsxivJQlZh87W+2G7lOXKLoPwPhshqHWwHxajelkppbnQpbdeHR8bF1GgQslcmcGihK8OcT0TF4lWnM9xQwAxudzAHvo/eg9oNddPo5aBDz7W6+FH/3Y0PHvn9m8Vrv+buWqrOOEl4dLDa+U0/1EyulBcvGIOZ0GPsDy8XM/8frvPo8n8OcPrP7bxeu/+zye+0cvn/j69QaPsYCiKu8iA2AMbC+DKhB+hGMDBnBGkCJJliVJutz7kw9w/flHRCHF09EBaON/6AnZ2EBfOXD12ioHBKhyHNJpveyefj0nl08Kijk5b0xRAt0O6HiM4YcFxucy8Sa5672SFe+Im5LtnswBSOigEynvdGdva0FEgY+fSZPKSLk2oyhFCeY58pFB2SfJpXVGHStCVrIzhCTBGwAoy+q5IF4+vs8coiaJcRcb3FxdRM67xN7j4aYlZROngF1B2lb3qZJBpZsRpkXrUwj32GoMeSgS/i6nRs9RKfUIYUzZer+TZWRTg2yinUzd1PSoe1gR1NwLnav8oXgMpfkq7pyK+qxplnaYfRYZB7qw0DPPuzrOiqo8sdLxUKri42EW+YQZZVY8Or4s3wdBPlEUquZptIAuEOoHwY2p6rM3CCsvZevhWYe3nx+h/IMnGs+liut+zbhZ5WV68+jMfVeky/g8SMXexOlB8vnDlz+Dpz/1/ko+f/jyZ/AcTq7M7xQfBaN5fQ5PWUoORVmG/IDy4lmML8qTjvfKKONeS/kjC8x2NNDtgMdjcK+DG194pFKslt19zlVvWXJvXN6MTFn2OQ1lpWDiHAdAnmiHfRz9wi6me5lTLlXiqH+vC6AcahSP7oKLAiBC8ewFTPblHvI8Yj4uqTebcQivhXyZ2FsR58y4fJnyqfPCxzgvUeDCES+WXIqyBMYT8JkdTM6IDeplI0nVHDxNZIB8wtBTb0w4+dhIwXuF7v/mBWhjgNkjm1XZZV3+qmTXJwzMZsB0BtoYYPrUGfEkmHo/x3xUCeTjUqayxzlfoc/KiqNXymUJzrXkUxVRf8VyKp1iLwrx7szmKB7ZxnQvDxykz1D7U4UzMHyejLG1MUT+c+Dqw4EG2XEh9Zo6H11ICC8/LivjoCiALMN8Kw9jJngEWcaULqoQFHckCbyWEwc4HmXIJQrjngidy8foHNkgD89F+gvoHBnQ0Ug8ikUJaA0e9mAzcmM4/n5x1ZaZM+bzTO4rIz4fAbz+e5/D67/3ubXXvT3Zq31eZuzEuN0w10n4AMDZb++cKj63Cs/nD1/+zC3fezuc1snoTvjcDso/eGLB2Gnicz9xEj63K59bmY3l8frvPt/I6c2jM3ckn1tjYgyKi/uYnu+Lt8Fw5RVZBf+UvuI67/rPpozem9fAo0mlMJumoHtDgwjTx7fcjzlXT8Fp2bG33hhwJ4fp6aVrrfl7dMHoXTPAkXtaW+IZCGE3a4FuB7MzXeiCax6m6h4x+PKxrcI7zCh2+3V3TBzm8aJgRjZhZMcuvOaf0j3veOaRv7UsUTy6C9tRYgjEfHxIiAiDKyW679wE8o5w6ndhumpxrZcEunB5Tst27vbwRplLQuZcQ88WwyhkxfOnDKP/48ugPK+3sSn8RdWfeGlcLlXDQoQLfPxYUhrZzanIMO6HCPn7N8EHhyHcx9NZ8Pp4TqG/I2+nMqjyZdYhCnPSjUN0brq8HxfiApz3lIFsbMDGircPAM/moNHUXVTx8Z5U5XPkCFCl83YqVfMIPuy4V4o8xq16dzynr//gV1aXmxhg9xrr+KQ4iQF2uzhpv92Ogr1dnITT/eRzkvruN5/bwbow1e0aX+tbHk9zHvQxudBD2Vdhmrko7fqPPLEYH/nEKRTl1glJDY+0KgV0b5TAzUNQt7Ocj08g7uQonjyL6a7MhCIW7wcrl2dC1R8xQ08ssuujqF2olH9imLALAXQODQZv3gB1Ij4qEVuU0Gx3tzD+xHkUQy2KrvAeq3pd0l4J9bGb7WO7ugodUcLJ30OE4TsjZO/fkNwLj1Sh+/WLZnOUH3sU4wtdmB5BF14+VNUF12dzWynyssTswibm2zqEQqqy61WpgpFdOZJ1XVZBKTE2tzYw//gFjB/th3BPXAcrQj6xGF6aA9MZ/Ho01Oti/GgPZZdWLgosU8kjL+AqPkAw7uxTj2Dy5KZ4GUPoquK09/1rwI0DMcAsS7/tbKIcrPgacfXHWtX7KR1HAMKaOtblyV08C7KM7k33XSLhomeMzbdn6Lz2hnxXYuOuky/k7PjwcchV89/D2Dhu4vOQ4+s/+JWlSv1+GRep0lzH58oLN2+5jts1wNaWe5sy+sOXP3NLuRcxn1VG2O145ADxHNwKn5jTrRqFJ+VzO/Cey2WcbtfYuROvyio+wP01wNbn8GgdfhRZudwS96Npc/fUWHJIXLWaYJxCysZWnoa7TjE7IwKQH21xYbjPPl9Fk9SplfNeJE/o0Q+7JLCKQraZLFzIhOA18MnRpkuwmpBNjCQe57n83vsnX8VVDg9im4yr0IhP4PUKKfYcaB3uMNtiELICyq4YYVS4UAcDYEYxIGRzRveGm0HUycFlWT2Jx1taxEYZi/z09WMJp+RZJRN/iSKQrhZshCLMt3JYt+KwzUgUupWyyLqE8RLoXDqQKdedHDwvKoMxTujm5DNBjN6DI2DQl7GiFWThIarzcwZPub+B2W4OkxNsJnL3oUwmMTKzqUHn8rF4L7zx6/JYYkNtAQzkUwt9+WZlqCvXR37cKAIpVXk2jEV5bgvz7Q6KofSlLsR7ko0N1Nygc+kmMJsDvV5oD2kFVirIKR7LXjY+B6n/4VTywDIthlg0ZsIY8mPeycpuD1FuduS7NDHo3pgjuzkRHjcPAVKgjY16crlW4NKIVy5z3ytEOUCWAAL6l2fIrkpfh0Ui13noHmKkP8gvPPfmA2IieJB8TmKA3SmfWzUuUiyTz+0Yg7eDdTK6G3xu1wBr4vTCc2/eN9ksg+fz3FdeuWtl3qqM1hs8/sfYGHCvK54BAoiqp2xiJE/oQP+qQe+9I1C/D3bTbcVYonCNaISqKo7d6n4rhPSHWFE1e4bqXoqgdKLP3tuTTRndt6+DD49AG0OARNmK8nZtAhLPAQmnmEPq+vfnHC/PIX4l11T210M8WZ0Pj8FlCep1ZdE+Re66SmGmBg9IppmT1vJqVvBhcnteVVwWPUYylbp7vQy5IJRpkDHQMwtlgDKL+okT45AknEVZJnx8QnlqFBKJYi7qIZbK2wVZkHJqkU0MOu/eEOM0c4YAETCdIZsyTIfqYyUGA9mxy8uJZ0PFs7GIKmMn5hobdwRwJlt8ZAdTCcNZC2RZZWAUkGnpyo+TiIaTuXjSnAfMrxy+kKEdcYgfdpR4Um2uXMjWgjMFdVgAeV4ZSfH3wx0LMnavweNDYotmlw9l3aFOXoVF18UuP4J40EoiRcvn5wd3Ipu3fngBz+HtU8HF406N1LuN2+Gz3uCJlAbNi+BNAdi9Rr+TzuvTPbTY+P7b8iPa74EmU/HG5G71Y2+UJMpclZXXCIAkYPqnca9ktBYPiOPE2nsJxDvEhGrPIy0Jx91Di60fXBFPze62VFsa6LkFa3noRaTovDLXc/eEnmeSNJvpysAIfFRNkXEmSkpWefYbUlZP+tmEcea1A6iDkZS5OZSncCJ0Pxzh+NGdynikOidiILvu1mrxWwrEngJAZB74uP4xHAzM0GcujDH4oED3gxHoynVg0BcDCQB6XeQfHCDfOIPZphsm3iKM+Ywt+j+9KYqTCOzqplhG7hhrBep2kN+YwAwyTPeywAeQ2U7ZyKD7s2vVNhdxmCzLkB+XmG11JGSpIxk5OXUPGb13DmpbLrBW0q7Y0+Q5KZnlld0YoxxuwWoET5PVBH04k0Ub80zW9XH9yIpAbjp359BgfD6r95uT1/CqQf/Diazbo5TcF22ZEo8h1irMypPFI90SCoad8R59N/o9ORfx8V1EhyN0jnZk9qE3dn1XTBkbrx/I2lVuDSjydXMylj7iOG3K/DTxWcYl+7W372kezzLcKZ/s127NuHjuK6+sDPvdaV/djjJfxulueFRuVT73GrdrfK01eNiHTYhAszmyKcveUyXBuD2D/KyUjUsWwzdvysyprY2oliFoVmD/e9fxwX+wB5tT7UmarIRU+tcNhq+8Az6zI/kRgIQxosTcwMflv/Q+UDi6uONCafLD75OpiYG9P70JdTgGD3qijAHJv4BB980r6O49iqPHde3JmowoiN67Bv2/uATeGIB7ElbhWGm6V86zEI7oXD6G6W7h6GJeD70wyYq9xyXUwSgsgOg9D9ztQN08RudoC6PzWtaV0ajlW6gS6H0wFuXW66G+lo3P+tayIKGf/pxn6H04xvjcNpABZT+0EtkY6NycyYrYWxvSNu8RYQbN5hi8cR3Hj58Tr4oOTQEA5MeM/vsj0PFY9pgK4RgSymmfEYF7XdB4iu4HhMn+DkynGgf9axadmzK/mwd+Q6ooGTrT6L51Ffn1Ia58cQdlT8ZRSHgfMzZ+OhJl3smrexVJ23z/exk5rxNrDZrM0L08Rtnf8OKBnjLI5RCxM6Bim4C1BhRh+Ofvw/Qew2RPwXYq42PjksHGn38gizjGYTlV96Sw1mKgaVVFDrUGFSV6H4xRbR5qQfNSxqKXbWKjsDMQh3/xAUCPoBgo54ElDN+ZILtyKO3od0PImJXkC9V2p/8I47mvvIIrS86dRIHebeV52vjcKW5Hea7itE6hr5PR7Srz2zUwfH3LON2JcXG7fbdKRndq7NyuwdXE6U65rM8W8h4MLTkPPsG07BOKDfc3JJQDt65O5nIjtKp5P7ibgw6O0TlkmB5QbADFJlAM5X3/usXG6wfgzWG9XlcW60rpeTc+d3PQeAY9B0wPKIeEcgAUQ8J8i2SriskcnGei8JQoN+854F4XG28ew3YqHv7VdIHNHx/IKraOB/sQQsRHco6iNpcG/XePAALKgcimGBLKIaF3U85xnrmQimujaxMP+9j60Q1svG+ExwDSng0xCjffLSV/JyjPSM4+2VhTJSOnaNXBCJ2Rhc2EUzkglD1JDFYH48pjFPe14wNm7P5oEmQz3wTKIWD6wN4Px6DjCXh7o+ozLwulKgUatzHPwJmGOp6ic2jdApWSV9S5WUAdTUVpx+MnaiP3u1BHE2y+U8LmgO2KEZcfMwZXDbL3rokyV1Tnoys+sYx8n3InB42m6F2do+yLLHvvy9YdnGcLPOLvBA962PyrG9j98RSdI0Z+zBh+aLDxltuXzMtWUdVn/n5AdnSP5Aaq+KnRVDbMzRTU0UQ8X768VD7BayV9N3j9OrZ+fIjBe1NsvjVC/uGBeJC6nSrE6GUTe1Fb3DYexJPwqjrvRJnfzrk7qfNeYhmnu831buan3A0Ot8In+7W3F+TxoPvSc2ridlvlrbuAu3m1uBuA4Rs3sfHqCH/5v7+I//BX/xwWhIN5D5P/9RnZOX3YA/qq9rRIuTw9UjfH7l8cYueHBDWeYfyxXfTfG8lTaycDNMn9Ccja4FmxHe/hAaiQ5M8z3/4AP/3NC+h+4Tou7tzEm9fOgP54G3v/4q9gn30MVFoJd/k2xYVb4LF/dQCaGam/n0Mdz8E9MUrsRldyhtxTtt9dm8MTdqVkoAAqNThTOPdHV/Gz/+wsJo8aQAGPf4ux8dol2O0NYNgL8okXqvPYeOsIw3cU1Hgu3rJ+R9asMQyzs1FbsDHsMebb5kNcPqTFDLO3gY0fH2ADwOSJTbAm6IlB/42rsNtDWCIpJw6zeOQa2dEMj/9BISsbzwoxar3xsNFfvAcANAUu3Mmqa4hgN/qAAgZvH2L4lgtPutW7uZfXc1JqjXNhzE6G7odjPPaB8445/qwU7P62a4eq5ODuTfsMEI8do/LwqWmB7R/NQpXW7WjvZR42Z/WyIgJyaWd2NMPun02rsolgtwZgpcJ9rJTka0Vt5EwByCrvIbCQv8aaUO5vVqtGR93eNIYYCnDfFT2Rae1me1h9l5x8mGSXdDH8PhoeHq8E0ifhkyqH+Ie3/IMn7soP8Z2GI+6FYko53aryvBd87gSnjdO9NCZOK68HjfUGT+Z+GI0YP9AE9HM8998e4b3/9snqwhzgrlNwoOoHWQFsqfYKAHbQlfCMdp6aMDUWbtXeSPl6gwOo/Shz7oyNXoYn/uUh8C8zzLGPxwEAh7DPPibXaaorqBjKKdGuyz0pbdWOkEjq7tMA0i0UNLnMX6qUqgVsr4OL//Kgao8CzP52UreTSRMMw3ZzoLs41TsYk8EIi9qlRdkHgwgIHgImQv/SKFxvt/3ikUlCL5Iy2U3TZhbjBaim4vt7vDJv2KKAM5FJbDQwxCCKQzLBKIgNsKjN4f7o2rj+9Nr0fTyGxPBgMVKN8PFT0X07ajyYcVJzoFZnCgXAz5YP/ajA/pvo5ATjQ4duxmHBi+U2jecl59pw1SJOW27DafAOpDiNnFq0uF20PuwWLVq0aNGixUMP4mVPoi1atGjRokWLFg8J1oa0vvyFr8ryMaYKEQCowilAPaeEuTGkkG4W2piHQtToeidjwJ0M3/zOb9OXv/g1KdhEhpr3U8WhjTgMFufgpD6tpnPuPbl1T+IQGxXGTb9W+OZ3v0pffv5FruV0pPkdwGLooSkU0XRfCheCqdqthI9r80uvvkhf/uLXOPBOcj3iPmtE0/kl98T92yRbz+Gb3/0q/frnfpvTNvp8lYXQzyo5NMkRQFiZWKnqNQ13MYO1xje/L31GhcSVWLswpg/HoZ4TVMttSvKBGsNu1jaHxOL7ChNCs77PYLgaY4Zr9aXfoQUZxW1tkpXPfWoItcU5PMSMl1752kMX+/qS+o1T81T3LfsNavksx2njA5w+Ti2f1fiW/cbS37A2pNWiRYsWLVq0eOjRGjwtWrRo0aJFi4cercHTokWLFi1atHjo0Ro8LVq0aNGiRYuHHmuTlmUfn2gRQZ9sHK2r4o/H1yyUw7x8LZDkeC0h1p93x6i0i4nPPmHWJPXahvdNSbvJOWKW9XF82YjKjhaDE5Is5zSq5NH0NX3f9HnZfR5xnb69y5JV/aut9wVbWt0Pq2TjaTTdn8o2NaMb5BDKOUmS8rJzTe8bxszCvdZGye2L/ek/Na5P1HQuObZ0XSMPlZwzLMnOTc8fTev/RG306xLVbnHHQpJywn3lOkEtWrRo8ZBivcEzl00PF37E3YJtSI0PJMZPXJZ79T+4NC/qSolkY8UwgwdYrKcwzT/mfgG5hEM6OyxwaZhNBk2ifKJyCUnbwqwdx7G0QGlFccYyWqb8Twpv1JBfxVmUYjC8DMJCibV2lVaOWUI6i47cbKo7mYZDXgF7GcVyjWZrUWR8+hlR8oFq997RLC1/OMyOQm2W1ML1ujKaAydV9XfjPbeK+P5k1haYpT5jqr3YILMQqbSywCUSgyktL5VXwyzIsDBjen30nQnH3Sy11Dhu0aJFi4cN63dLLw1Ic21jSLIs++7MC6iixPEvXsDNZzKoAugcMXZeHyF756psAKkSja/IbU+gMf74GRQD2V18660x9MEEdDgChn3ZdwgQxW2iqb1FKT/YrjhyZcIAsBymuJdnN3H4TB9bb06Q3ZxAHY+rDSldW0iRvNcKajyVU1sDMMm0ZnXtUPZlIgK5zUEXFL21osBYYcEzwyzH5wXIWJgzm0Bpoa8eVBtANu1fxCznpiVgLVS8I7bblTzUZRIXjGHps5iPZddWqh8ryrBictgAdR28DBxHynT12ZfPSvZ88jIqmw0e0qri7/tilcGx5Bz5ncLZtZ1s/XpXNkHXZAQgjG2K6/d97Xn5dq/j48uIeRlbfX+YhZt1xo33CPk+01XfNNVBSfkA6t+DSBa1NvlzTt6x3Ml9vyjD4lj6COHzr9bb/v1fPtmTyhMvD8P7t58f3VVOgPA6KZcWLVqsxnqDh6sfawD1PXxGE9gzOzh+VPYish1geoYwPu5j6z0FmszCBpRyA4HGU2A2x/GvPonjCxo2kx9o0x2if62HjVdGgDFVqMGtsRKePpvWIbEIiokmM4x+8VFM9jNMdwngPjrHXWy+MgbNClHswVhwincyAw96GD+5haOLIpLOEcueX1cPwiacIgtbf0K2qCsKtwN1eJ3NQbMCxcUzOHqyj3xisTEvxbDLtBg+sXL1980LcLeDycVNjC5k2HivQO+9Y9m92+3SHeQRIXgSfL+FPoTzwDBgjOwo3uuC8wxqNAHN5tWmkk1jQCvZ12vQxeTxTWQTg+5bV8E2iwxAz8Uu9llcVvze96Gxsmu731PLbxyb8qg1lpzx4AwZ7zH098V9ZG3lleNoPPu+81t0MNf6k2alFJVFe2DE4y+G8R4k49b9cXuOWTdu4vvTz2l/NbU5Dqsu80bFYV3fprgO9uPTVt8d32b70TV4UpzE0IiNnfjz3TB8YgPMvz+J4fP67z6Pv/v8nwMA/vDlz+C5f/TyHXNp4nUrRtjrv/t8eH+3+dwuPKfTwqfF/cEJcngsmFm8Oh7MwHSG6acew+GTsnO3njDIXTI6r5D/wnn0f3IFNJ7KXln+R19rTD/9OEbnRIGoUtzwpgNMzmiozzyK/vffAg0HYpwQgUoj7+GUCVDPjfALtI3GOP7iUzi+oMEK0HPGfJMw39RQn7mA4Q/eA02m4GFfdggnAooS0+fO4/jxDmyGoLPnG4Qbn97C4MM++m9cFWXsF7YjCgqQbKQogsIEkGfBkJo8tYejix2YLjDf0jD5DrZ+rKCuH4Gm88oIs07eeYbDXzoLkxNYAaoAxudyTM7uoHfdYPDGDdmlfNCr5OHh+aTGBhGgtBhMlmH3NjG+uAnWQDYaShtHEzE2OnndSC0NJk/sY76dyd5nStox2b+AwQdz5NfH0s95FgwLMhbs5EKphwfOW+X4krHAdAbe2qjacOMA1O1WO8P7oecN2+kck088gmIrg81I9p0iYPjeDJ23LsuO4oAYHX4ce0PI2sCJtZIdxH25xoZjmM0BY2T8Z5mU6Rc1jAwN1krCs8Zi/tRZ2K4WPorQe+8oGL1+N/PaPmSAGHulkf20vNfHcfLjlL1nNTZ04uOJfHxbYC24161kby1oOq+1HczgDItj6SOA1LOTnlum2F//3efxBP586bk7UaTLOK3jAyAYO/79H94lxZ5yOolBGBs66bG7ZWjEvE4Dn1tFEyfgwRpiKaeHyShcb6Z7hWTrf2wtZrsZWANkAFXKK5UAMVBuaPHulKXcb+THdPTJs5juZSCu7lElAwQwAbOdDOXHH5dwSWmqupueVP1xY8CjMSjLMNnTIAsox0kZ+ZucFWXFk4mUCQBFCbu9IYpcAWDhTkb+WBOKzQzTp/erJ2Bfb/Q0HnMk6z4bC8zmmD66idluBpAYLmQA0yXMzg9h9zaByTSUQcaCuzlmj2+L4iLhwxpQhkEWsDlh/ugWeHMgRljg4z0Vrn5fpv8MCKd5Abu9gXKnB7IMVTBsV8EO+6IQnczJurbMC8wf28VsL3cyYlHmTlbz7Ryjp7fBeQaaF5Vh2+TBiLh6JU2zQmSQibFERSnc8xw8nUoIM7qXSgOaFZj+wiOY7eUweZxwDEzOdTB/9pxcX5ShLfX8qmrs+L7z7Q3HihJclmA3dtkZNGk7wCIj7nUx/fgjGD/aw+Rsjul+julehtEz2yge25F6SyP3mGgcRfKJ5R54+Hbbep2+rPR46LeiBHdyFI/tYfzsLg5+aR+Tp3Ywv7gLu9kHprMg69p3vMVaLFNSt3rN3UZs7KTH7oTPKgNsGdL6Um53Qz6r6l/H51bP3wusqvNB8FlW7+u/+/wD4xPXH//dLtYbPLGy8rAMIgJZiFfCQhSgkfdk5X3tfue58CEs+Hvje1zUwXZ0/V6buPvTvzhPwfPxf+zrifnboDDKnV51H4vBpgInlnSUgZan+yj/JZVRrKhCHXBlspNPTVYR50ixcTeHzf2Tt1yr59V7MXqU7KQeK+A0tLVMXsHLAZiekuSP+FZrF2RLXJVH7I1IdkZP1G6vuC3X+yXlEB8DQoiGhz2U57YqAy2Sby0ExQzTUYEPmCs5A7Au/AZjmutOy132Zxk06IF6PcCaupGdXGe3+rAd5/1hBKMQ7PhoVTdwjMVCrs66P29Ip4bXsu+E80KaroTWbEdVyftaR4bX4veoxc8PHqQyOin+8OXPPGgK9w23YoidJvw8jKM7xXqDJ/6RLU31lKo18mODfMxQRd2bomdANpLrOPxQV3s+kQU6I0Y2Y2h3r57BfeZq5pF1T7JlWVd4nof/izwCg8uFcPGGi/P0bFyag+dz8SR4V39ZgjMFVkA+tsgmDGUAsNyTTUWR2pzqCif2YAT5GPmLn7yVQvfdA+THdoFP99Ih1OUbLn/FBCNsvtdHMVRgEs+X8hE8ls9kGfMtjWK3BxRFJQ8TKdPSVHycR8HnlQCQ8AuA/NhAFbJ3ExkDLooqbFca8XJ0c0z3Oy5kRE6J1xVj2Vcoz21JDk3qxYj7LBlHIYTikrfpeILs8qELv6kqNyfpax72wVmVx+INMnLGmekq8PaGKPWykm3NGI35xGPK1LnzaAyeTFw7jMuB8uOAKwNskMk4QWUUEgOcyfjhTl6NjwWvnK3zTLmZiH8wfkzztZEXttgfYLbXlbBoyTAdQrGpYTZ7VXv8Pb7+FifGm0dnwt9pwB++/JkFw+JuGBrLQkXrwmvrcNoU7N3i0yaZ3z0s65Pb7asTzNIqRXH4H0PvISBC/ydXAexjfC6TR1oGQEA+sui+cwN0NKoUqHPRsybYjCRfBhDjonCGT8FgjcWkzNoTvqkfB4RfJweVOfpvXMN8+zxMjjB1JZsyOu/ckNlS3U5VhuXgaTEdCk/l2ZyDl8rmJNfU1m5JwjXWukd695mpesK+eYj+mwzwbrhFzyzoxiG4LMV7EBkroriFu9V+Krx4hIhRX4OI3RRxv2Gmf89cT171hoEzJOjwGJ3JTLxWPp9kOpMyXAJxjY/zeAUXCqSJC+nNyzw4piE3RCmEWV1KSb7M8UicTZaBLKvPAPMIHg0EOdU5JFzipOGYWzyeU/n5ZREyDZ/ozHHfxxuUBoMV8GE+jl1m3vPk+yuu2yGEpUyUiN/kjYpnB6aJ2eF91A7rPXBuzMB7GFNvkK1yiz5i+P4vq6VP5KsU19Ofer/2+c2jM3jrhxfuKad1itRzuptc1nF6kGgNixa3ipONmNhtHlziCnz9Bvo/uQo9R6RogN61Arh5VHkMIrCCGDUxCLBOt0iyp7+YG3/4eZkSzDLg5iEGl6boHlrhct2g/+EcuHkoU7q1q9xPV0ZUL5whoZyeIyzWEyvOtP6Io5cV5Tno8Bi9948BImRTg+5Pr4qxk2X1ewCouXhdKj5x24WfnjGosGLApFyissL7uP8AQGvxdrlZTTyegEsjskln/cwL6KkJYTmP+DNZQB9Nq/tPwimVVZZVHh3tprt7oyIxML2HyssEDdXRrJC8m2VoGlupwo/XylGqMo6WtKtaeBDh1c+Qb1wcckk5NQ9QXF/kJW3kG7dLKahZCT2tZsuRZeiZhSpOl+J60LhVxZkaO+uOPwjcCy6xnB5GY+NhSs5t0Yz1Hh4fXvBPtT7fopOD9nbBirDz3ferH3RrwccjmWGDvCojy5yCdc6geNG/aKaJLhg0t1V5/qk2XnzNH/fw+QjOG5W/fgm5MRgC7sdfC5/46ZwIpBTyayPwo12XNC2crCYQMTQLn/zQhQ7SadIeXi4xZ6BaPyjPoW4cY3D9qBJrvy9vYiOSCNm1EWxXoxx0giEmuU1Vsk1+VCK/NhKZxvU3yauJX6bFoPBcet2Kq1eo/npmZOMSxZYkmlt/W2Tg6qkFjWc179+CNyL1qKRgBnVyqWBh7aZq3PkwVeeowLTTCbOzAJGVYkbnsJCE5XhdoVhGcR+l9aTctF68Job7fuQfHgLYgul0KoPeeS+zUSkz4OJ+aConfm0aaymX9HN8PzP0zbFLeu+iHCjkh0YM6vFcDO48r7johnWkPkI4bQr8Vvg8949eRvkHTywcf/pT798TT89J+MQhh2U8WgPjdCHtt9OAZZxud+ysN3i0dgmXKlr7RX607UYP3MmgDsYy1dUZHDQc1BMgFYWwSeegBOscRR9gUC1plhXQuVYif/uKhIPitVjiZMv4s4oUa0mivKczMQbyvL4YXKyE/XTl6wfoHG1jcsZNY3bGl0+g7tww6L593eWUUGX4xIop0zVFE68fVDciVP1zfL0ri8ZTdH9WYrZ7PoSvWKFKyrVA59KBrGfk80JiEEnbYj6+Kh2tmJ2GDdN7IgWcv3cdtnMW8+0MROSmpkt+UX5YyLT0oqwSu4lkVeNYRrFC97J0K0gjmkodxlmaQBuvUUSEzhuXwXQe822XCE8in96VOfKfXpY+yfOqXfEWEkTVOIrHtsu7qtW1LJE3vgYAjafovDUFmX3YbmWIdD44kplogPNiJYaN7xf/PQtyaKg3ltMquP6k2Rz6gxl6NzuVx9HPzOp06vX5vvgI4vXf+xye+8ord7XM+63M3/rhhQWvTmxk3G8+saI6DcbOOmX+IIyvVZwelDHYxOlBG6Z3s/4TGDxOYSjU8xaIQNNCFmbzSsL/aCsFSSBIftzzHN3LIwBDlI92xFtACNPAdcHoXDoQxekVslfG/sdeJwYQIl5KhZWYAyci2TICWFDkIoEMg9evYb51rlr3xk2tz8YuF2k6r5S5fxpODa44p8Kvj+L5RXXGa6ss5GUAsmbRrMDGG4c4+OR28GD4EFLvg7FMR+/kC2WH19gjktbjeNbWdUnlmXqItEb37evQ+5uYPNqHdUZq56Z4mujGIXhjIOURufVdbNVnKnLDRHXUDLBQF9Vf03ORl6r79nXkGz0UewOwIqi5QX7pRiSDqN2pB86HNP3Y9uMkjLkVPFKuvj5m5O9cC6tzw1rJY+t1pb+axp9/H743/lhTnC66JzVc49f4emIZv7Hx3e1Uxo03qpv64iOCWzV2sl97u9Gj4hX7g1KeMacHaezE9d7Np/M7xWnjE9d9mhZnfND130usNXg4NT6854IZyGUhOknqZVk1GHDXR4aJvzfTUIdj9MYzAHswfVkgcPDeGPrakcwK6nXCIoMARAnEew+5J/N4gbWQZArUFEFYHTdVCLGycOvH7LxyRcJ0zOI9cVxAJArMgZQsTBcML6WErze6woVuD6w0RARUC+A1gQg80KDxDLsvvx9CcOwTePNMVkT2ZS6EYNy1DR4eqGhaMhDW1VlQlqnidJ/1zTE2rh/X20ME3t6UMKdvllaSZ5X0mdRZNzo4Q2NdCwo9kk9NXJM5OpeKSk5aAVm3Xpb38Pg+y3R9YcJldTaNmZhHk7GYRTlHROCNQT1URgQyVNXr5AWtwyKJgXtaV9L2xmNNyKNy3AzLmI/IRjelQrVYgtToyX7tbTyHtx8gI+Hg8aC5eJw25Xna+HicVl4PG9Z7ePzeTbXVYWWDT5oXIOet543+iX58/Sq+vXcOaiEV7uRAr2FrA/ckzu5pOhhVabmZCkpsQXn7cpYoLc6zyhBgBve7shpzbEz4a5V1RoUK9RJn8tnNiqnx8l4Ad27ZTuWLm5lm4D5q7fCbo1JkuASO/r5MgZDVN6z0XJSqrj+Jogw3xkq/njcS6omPkdut2/dZN8cCvCGyzKtwEg9GnUhlWPhrjK28cczB0ORMAd3EQ9bU1mV1r+KTenF8zlhsBLkxFPpMa6CLupewqY51hld6rMlYDMejBxLP8aQhsxYA6gZGixYtTj/We3iUci7/JEEyU2BEisxFsWqfPdIcVSIgU9V6O0SVIZA6P4hkum4IxTR4R7ye8OEJEMLeUY37tcfc5B4y7HJTVLiXoRI+BPJcY29NxiGEwnEdsdLRVD+XwJ9buN8rLKXALkwYriECl6ksZF2hUB9zJQsiaVMks5OBkldUfapJKCbGACPKv2ros9BX9uRKdt2u96wJhMgY9H3l6/HGZ5SvwjoaK2uM0lvm6L837jVwjMc74EJpKjKOaXl5qbz8Mf/986K2DfJVyXE3Jqh0cki/4y1atGjxEGG9hydTIWy18COdRU+kQE1x1LDkd5S1DsYGEBssqP14E2zlUcl1/RrgFpX3Ei6xEyJuR1w2EeCMNI5yPFg1JC2fNNxwUhABJdXzRtxr7GEJiiuWkZe/itpzuzJL+7ipHCIQJX0G1GQSjBJV92z5c01eI0TKP3jC/HnvwVFc99YF48fWvHK1uvw9urqHlrz6utNjVYH1Ywtla4IsrFRdw0oBeWycRYZOWkf0XQo84jqa6vXwhn183H+FlVr6PW3RokWLhwHrPTxR0mbtB957DpLjIezClRGzSmnEOzoTAI6fSL1SjZWf52MSNz5Qd+HXnnbRbMCsOUfWVh4fn9AaQiaLhsfK8EystFaFQpYZSr7s+LUhbCUGkAWTWs7HtztFk7HadCwK3XGTd8FzOqE8asYNc5WLlV7DiY8sCXv5Rf0oyp0KZUXjtSZfBaDkBcMx7g9fBi075w9H/RcbLLX7LMnYjY0LTWCDMMaa2loLeTZxaxhjKV//3aoZl7Yatx/VpOUWLVp8NEDc/si1aNGiRYsWLR5yrPXwfPkLX2Ug8tw4D0fIfUD0ZHiSBM+mZFTvNUmeUH2+DhkD7mT45nd+m778ha9KKkucBBqFAmp8VmFlAiwvJuP6Y8ZInbkWPs+/yKFNhkOeRq2NaW5TU1ho1TGPNNckU6DChHpeevVF4RP2aELF5yR1Rhx9TlN8rlZW8jltN5Wyjcg3v/tV+vVf/D8yXH5U8FT4mXervF23gngsOQ4h30sBVBiw1vjm979Kv/653+baNO2m17uJeNxHOVkA8NIrX6Mvf/6rrOZlLdRWy71q8kzeLg//WpuEUJ1/6ZWv3eXGP3h8Sf3GqXmq+5b9BrV8luO08QFOH6eWz2p8y35j6W/Y3fgZbdGiRYsWLVq0ONVoDZ4WLVq0aNGixUOP1uBp0aJFixYtWjz0aA2eFi1atGjRosVDj/Xr8PhF+OKF9hIzieNkSLjp5UuONZ6LF/KLrg9Ikyv9ooDR59q5EyxmV+PRcC4upzbltyG5us6rYZp6alY2rYWz6lgDYhl6uS4gloVbZA7LNhBIkpdrsnHnli7IF9cTr/vjkamQWB6msbOqLeBYwwmThmvLHMCvqbNEaNEaT/Eie/FmqrX1c+7C7MXagohm8VyAJnCmFhPldZ333QIT1b5zjZxatGjR4iHDWoOHCrM4o8crT8PNP8YWoIb1bkgtP+cVcTjnrwv1uPOzRHOggU/KdcnaMsuMBNkbbHFmE8ULt3lFW9r6jJemWWjJOjkrZ6w1HUtlFdYakjaTpmpdotKGmWSBj19rJd7iwB/zr7FY03PRWi219wCIG+phqYf84Cit9KWvwzj56xVj6IQI0onGVzgXrzpsGOQ25JT+rWayLVyf4iSzpBrWffLciGP5+WORwA0LP38yntl3D3Ywp+Q7VTveokWLFg8p1hs8xgQFVlNoSBZzi+GV37Jj6T2xQWATBeqn0Lopz2QaDJ74ulXKOr5+2RO8O0dI2uzPGQtS0VO3tWL0pAbPraBp0cImQwmolgbwx6yt+gcyXX+BjyuLVX06/9rlA4ICbFh2wJXBhPpieADYWlm00Y0uMqbqV3+/H0fLxtCtIjK0AmzllSRrwf6UtWF175qMmRbbGMo6AQebvA99FskorsuBvLwiq6raI+3uGyFMrvyk7HtQVYsWLVqcGpwgpMUArHv1P9hOoRrbvOGgjZ7abT3kI+dSr0VyTVqGsZUHw8SP5FS/x9hFJd0YwuFEoTecC7walL1Fpdwsqk0qmevt8+/TNqef0/tWHCMvd0Dq9O9txDPm448hUbrpa9OxJuMtlo1yoZGkjLDSsZeR55PeT7w4hppkdpJjtXHq4Koka109kZsm3WV+mQzuFLE8VpXJvLjS871AvFpzeure1NiiRYsWpwLrDZ7YwxO8AZFHJXbXN3lqYsRGQqQoyViw8mWiKst5bqg01U7o1oIsy/VxXfGic3cLwWsiPFmRcNUKlLkcEOtCWrESSduQeryaPGDxfel1PhzlX72Xy1rhE9UdwjVxn3hZZwBKd++ykFt8bh04kbu/T3FlnHk5pgZmCCnZxXbb5PWkx/xYjD1yVHH0XhORUYPSXyWT20For63qSxYeFN5cGYD+vDfe/UPC3YCK2hcbob58vS5u16JFixY/vzhBSMuC3WussFgrMUS8217H7vjYG+RvkB9ab6hQUYIzDeSZhBymM2BeAL1uTeGw9qElp6ycwiav5KL6A5/UAEuSpGM+FWl3X2mkLqVEAUQhH2KnOJnBuSNgbE0OC2Gik2BJDg87BUWWZad0z8NEBoa11X5R0fkg50hZygrHDcbHLSAYpl55K7VQJns+7FfKtrW+98cCn7sBZhkDsSETjw1jwVk0LlLjeFVIb5m80vG17LwPj6YenNhA9p9jTx3z3Y0zxatse09gPObuVl+0aNGixSnEeg+PV7CxhydWeA4L1yxR9lS6H36tUZ7fhumJp6T7wTFoPAWPJ6B+r6obkB/iWBEk/EAkis6HRxaeiP1TNTXeCyB4PrjXqbgejwGtqzYrSsJmqMvhJCGhRqGkOTNyjIwNBpiffcTdPFKUDXJxypyaFGVkON6yB8N5SsgyYE0wdjgeC97L5MpnXedGhutjxxseTYZobEysMkJSucVle87GNhs4cfOsz3Gqv8bnFkQSPH9rZOf41I3PSF6xsdPUL3fibVpl5EfcFq5tcSK8/rvPh/fP/aOXHyCTFi1arMMJQlrO9R3n1AB1AwOoXPTrlL37YbfbPdiOCrZIudVD5sMOtTyd5GnccsMPd6T84llMvj5/rWn4wY+VVaarEI1SYuzEZZlYUcfHk5yZmOuJ4A0y3+bI2xQbN4jkHrcv5pMqzaj9tEyhngQNhk0tYTrOr+EGDrXmRgZA07mYd5NBuaTMUJ6Xh6qfj41DWtE3/lx8zUmuT1HzaDUZpgn/2rk7MXLScgOJJd+Rpmtb3DJe/93nW6OnRYtTjBMkLUf5KdHME2T+nH/KTtzj6Q+tf3XHzbALJoLNCXpuwZmC3ehB3zxqMDRMZfQURb2skLhMVW5L0w/3sqdXX1eeSfgs04AhUFECmQaPJpKc6z0s1tYTda0FyhJgXXks4unfy+Cv8YZi/D72YhgDdDvAbA42VnKHyrK61hip2yM1GGOsy+FZOksLzR42dgm5PqTlx0KGuuGVesV8OT6XJM2ZWZVXtCrMlIZmLABwZbCHPms2omjVLK2T5DwlHP1MME4NNyTGpzPAal6fFd4jn8O2kMt2C1jmtWpxcsTenfhYa/S0aHE6sf4nr5ZcGhk/XrnHiqMsnQJe8tQevc8Op1CFhZ5JErKellAH40VjpwE+SZdrXE7wVLzKU1CUoKIETeeg2VyOzeYgrbBqfZKguLxRlsplGY9UrgsFR/lS05m01efPrEMsl9Qrk7a7SRbrPA3++ElDICmHk3iAmspI7226blnocxmndfU21b/u3Lr2nQSpceReU++TPxb/naRMPulYarEUTYZNa+y0aHF6cWvPePHMEiL5HHtvlKpfkyJ6CqbjMVRhwlRcdTgBzebg2bwqNy47+nH2BsiCIZJeH/+l55vu8yEkx5F9MnLUtqYVamuyWVZHfJ0vz39OZeYVkw+rASClxJtCJMea2trUpmVYxbNJ7rEXaJmc42O34nm4XcXb5G1Jy1zGY1W719W57FiSg7Xy/Lr6YoPXtYEVnejvlri3uGtojZ0WLU431oe0YiUbY5VBsbI8n09jkX14AM4zMYDGU3BZgnpdl3jsrtcKsGqxjjQklF63LFyTtiFuJwDMC+GRZaBOvtimOIkZooTIGyDeO/X/b+/sliNHYSgsCZx9/+edSWsvQCBk+SdJb82O63xVqe6AAQEuo5ZkyFxCcdx8XfY9yihMJKUpOrboFSH+RcfjHuclyhOV1lg+GxuPMBHL3p34ojm3mYK5vPLM05U10vu1R3sX+bwljeb1zOvO2uLGIbNoXM3PEWeK9lF+SIuKicaxo5P79itk9+Kd7+AWUHIA+Hu4VnhqmcqFe6BrEWIt+UMyi7WID92uHPCv363urRJvde43w+racQvdx+YWPv8Glcyg4yN5zmJVLK84OfwbTbE/PljbxuiOq+c7C1gJyk11/X7x6gYsYRy8xaqW924uZ/ND1Pbe8e34gPYaLFKqa1mPhM8s7+h6q9sHf1NXEn/TlKfIso3CQecu8o+uzy07OoLaT5RUu4e6zEveT4jlheceRWfXAQDAg7hl4RkLU7QUyAyeXLhhzm/l+j/BemT7qYw4g+g6K/v6h2KUceZyyPKi+8b/b4qfL+ddcFeBtbF93+bJgjPG2VlpVPphrH4se/5uH55gjYtBrzEQ9iqPmMf8WPvtep4LvB8j9u4Wnvs6jfJJG0HOO/KyC4fyVpNFnm+M/485US7GYZ7esnlmmXyHDJki9c0AaAAA+Bu4VHh0q+0Xsbi3aborYpygHk/Hvsko5x/oY0Fe21Fb5D+2WWZROnge6hnrO3qrJsOUmlr2bxA5hcfkoVqa8yHd/+eNCLd22J3qLdzmpQipKQhV2q7U5gLzMrk5I+GWF67TcpDn0kadYxNCWa4flh6bs63OuerjpN0ypvKa7Safd9MWud2YDXk+3T0kc6fsQeYuexfLoa3OEjfy+/8izbIZZX83Z643AAB4KNcKz8fWH8hugTD3gcjqZnjRjKEQl+bLxReShOYJ5BTK9XaYmaiuCg9rKMP85dPSU0ye0l1FS0yIk9Xk2cp0OWVK1J1f6HeUMq9sVufu8H0mIi2F6B9arUyjb27hzdx5WVt3ZLd2hkspxFdttY2nx+Ym3kPfJZtr79oSmZbBKvOV7GFlpB/dM2nesq9St96UkEd9zl7U5LPxfu2v26XfkTHcv0OeT97XDYUHAPBgrl1apf0yZr/PTrcyMIfFcDxQfUBrT7MF0edZFoeF3dWhzERF54Jpioa3ulB3C9ihplEOoXVBNjl8e05G5WaBYNFZT79WexsmjxYm4qkYLYrYEGOfFvlKOXPdaXF9NhlLt7j0clYHqw5Zl7TsupAX5fGuw1ieiJpiqNMSpVV2cz7mxt8PWbzXUaxVTCu0joNd02Vk/ZwWHuZ5oGe0TpbwmeVlnOVZXwpN+X3wuNBUmsc4vdayWTt3ZbQ0X5foEjOUtgUAAA/i8re1VhkWlGUBlLZwLGlne5RkafFzpwjtYy608G4h1q7UqEhaZvl+lJ/9H9vOyprlIIzNWMSEduO2fPbv1oc0TdZymvXFyaXloK7OGC/Xpvo+XgQOL/Me2hnWNl9P36F6aePIGnaU5j+ztNE5nYG/JmfoB6vuj9g422fnv+ZF88gVv4eP7Yjsd/h+x5/xJ/oKAAB/CFY89AAAAADwcN4RPQEAAAAA8L8GCg8AAAAAHg8UHgAAAAA8Hig8AAAAAHg8UHgAAAAA8Hig8AAAAADg8UDhAQAAAMDj+RfAgUqVuwv9AAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Avg Dice: 0.9738895297050476\n" + ] + } + ], + "source": [ + "val_transform = Compose(\n", + " [\n", + " LoadImaged(keys=[\"img\", \"seg\"]),\n", + " EnsureChannelFirstd(keys=[\"img\", \"seg\"]),\n", + " ScaleIntensityd(keys=\"img\"),\n", + " EnsureTyped(keys=[\"img\", \"seg\"]),\n", + " ]\n", + ")\n", + "val_files = [{\"img\": img, \"seg\": seg} for img, seg in zip(images[-3:], segs[-3:])]\n", + "val_ds = monai.data.Dataset(data=val_files, transform=val_transform)\n", + "data_loader = DataLoader(val_ds, num_workers=1, pin_memory=torch.cuda.is_available())\n", + "dice_metric = DiceMetric(include_background=True, reduction=\"mean\", get_not_nans=False)\n", + "model.eval()\n", + "with torch.no_grad():\n", + " for val_data in data_loader:\n", + " val_images = val_data[\"img\"].to(device)\n", + " roi_size = (48, 48)\n", + " sw_batch_size = 3\n", + " slice_inferer = SliceInferer(\n", + " roi_size=roi_size,\n", + " sw_batch_size=sw_batch_size,\n", + " spatial_dim=1, # Spatial dim to slice along is defined here\n", + " device=torch.device(\"cpu\"),\n", + " padding_mode=\"replicate\",\n", + " )\n", + " val_output = slice_inferer(val_images, model)\n", + " dice_metric(y_pred=val_output > 0.5, y=val_data[\"seg\"])\n", + " print(\"Dice: \", dice_metric.get_buffer()[-1][0])\n", + " fig = plt.figure(figsize=(10, 4))\n", + " plt.subplot(1, 2, 1)\n", + " matshow3d(val_output[0], fig=plt.gca())\n", + " plt.subplot(1, 2, 2)\n", + " matshow3d(val_images[0], fig=plt.gca())\n", + " plt.show()\n", + " print(f\"Avg Dice: {dice_metric.aggregate().item()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cleanup data directory\n", + "\n", + "Remove directory if a temporary was used." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "if directory is None:\n", + " shutil.rmtree(root_dir)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/modules/2d_slices_from_3d_training.ipynb b/modules/2d_slices_from_3d_training.ipynb new file mode 100644 index 0000000000..2e92ea9a84 --- /dev/null +++ b/modules/2d_slices_from_3d_training.ipynb @@ -0,0 +1,510 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training with 2D slices from volumes\n", + "\n", + "This tutorial shows how to train a network with 2D samples from 3D inputs.\n", + "\n", + "It mainly demonstrates 2d slice dataset using `monai.data.PatchIterd` and `monai.data.GridPatchDataset`.\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Project-MONAI/tutorials/blob/main/modules/2d_slices_from_3d.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup environment" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "!python -c \"import monai\" || pip install -q \"monai-weekly[tqdm, nibabel]\"\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Copyright (c) MONAI Consortium\n", + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "# http://www.apache.org/licenses/LICENSE-2.0\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License.\n", + "\n", + "import os\n", + "import tempfile\n", + "from glob import glob\n", + "import shutil\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import monai\n", + "import nibabel as nib\n", + "import numpy as np\n", + "import torch\n", + "from monai.data import DataLoader, create_test_image_3d\n", + "from monai.inferers import SliceInferer\n", + "from monai.metrics import DiceMetric\n", + "from monai.transforms import (\n", + " Compose,\n", + " EnsureChannelFirstd,\n", + " EnsureTyped,\n", + " LoadImaged,\n", + " RandRotate90d,\n", + " Resized,\n", + " ScaleIntensityd,\n", + " SqueezeDimd,\n", + ")\n", + "from monai.visualize import matshow3d\n", + "\n", + "monai.config.print_config()\n", + "monai.utils.set_determinism(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup data directory\n", + "\n", + "You can specify a directory with the `MONAI_DATA_DIRECTORY` environment variable. \n", + "This allows you to save results and reuse downloads. \n", + "If not specified a temporary directory will be used." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n", + "root_dir = tempfile.mkdtemp() if directory is None else directory\n", + "print(root_dir)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create a dataset\n", + "\n", + "The example volumes are created with different spatial shapes for demo purposes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generating synthetic data to /Users/wenqili/Documents/monai_data (this may take a while)\n" + ] + } + ], + "source": [ + "print(f\"generating synthetic data to {root_dir} (this may take a while)\")\n", + "for i in range(40):\n", + " # make the input volumes different spatial shapes for demo purposes\n", + " H, W, D = 30 + i, 40 + i, 50 + i\n", + " im, seg = create_test_image_3d(\n", + " H, W, D, num_seg_classes=1, channel_dim=-1, rad_max=10\n", + " )\n", + "\n", + " n = nib.Nifti1Image(im, np.eye(4))\n", + " nib.save(n, os.path.join(root_dir, f\"img{i:d}.nii.gz\"))\n", + " n = nib.Nifti1Image(seg, np.eye(4))\n", + " nib.save(n, os.path.join(root_dir, f\"seg{i:d}.nii.gz\"))\n", + "\n", + "images = sorted(glob(os.path.join(root_dir, \"img*.nii.gz\")))\n", + "segs = sorted(glob(os.path.join(root_dir, \"seg*.nii.gz\")))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "train_files = [{\"img\": img, \"seg\": seg} for img, seg in zip(images[:35], segs[:35])]\n", + "val_files = [{\"img\": img, \"seg\": seg} for img, seg in zip(images[-3:], segs[-3:])]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Volume-level preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading dataset: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 35/35 [00:00<00:00, 109.45it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first volume's shape: torch.Size([1, 1, 50, 30, 40]) torch.Size([1, 1, 50, 30, 40])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# volume-level transforms for both image and segmentation\n", + "train_transforms = Compose(\n", + " [\n", + " LoadImaged(keys=[\"img\", \"seg\"]),\n", + " EnsureChannelFirstd(keys=[\"img\", \"seg\"]),\n", + " ScaleIntensityd(keys=\"img\"),\n", + " RandRotate90d(keys=[\"img\", \"seg\"], prob=0.5, spatial_axes=[0, 2]),\n", + " EnsureTyped(keys=[\"img\", \"seg\"]),\n", + " ]\n", + ")\n", + "# 3D dataset with preprocessing transforms\n", + "volume_ds = monai.data.CacheDataset(data=train_files, transform=train_transforms)\n", + "# use batch_size=1 to check the volumes because the input volumes have different shapes\n", + "check_loader = DataLoader(volume_ds, batch_size=1)\n", + "check_data = monai.utils.misc.first(check_loader)\n", + "print(\"first volume's shape: \", check_data[\"img\"].shape, check_data[\"seg\"].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## volume to patch processing\n", + "\n", + "- define the 2d slice dataset using `monai.data.PatchIterd` and `monai.data.GridPatchDataset`\n", + "- patch-level preprocessing, resize the sampled slices to a consistent size so that we can batch\n", + "the last spatial dim is always 1, so we squeeze dim." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "patch_func = monai.data.PatchIterd(\n", + " keys=[\"img\", \"seg\"],\n", + " patch_size=(None, None, 1), # dynamic first two dimensions\n", + " start_pos=(0, 0, 0)\n", + ")\n", + "patch_transform = Compose(\n", + " [\n", + " SqueezeDimd(keys=[\"img\", \"seg\"], dim=-1), # squeeze the last dim\n", + " Resized(keys=[\"img\", \"seg\"], spatial_size=[48, 48]),\n", + " # to use crop/pad instead of reszie:\n", + " # ResizeWithPadOrCropd(keys=[\"img\", \"seg\"], spatial_size=[48, 48], mode=\"replicate\"),\n", + " ]\n", + ")\n", + "patch_ds = monai.data.GridPatchDataset(\n", + " data=volume_ds, patch_iter=patch_func, transform=patch_transform, with_coordinates=False)\n", + "train_loader = DataLoader(\n", + " patch_ds,\n", + " batch_size=5,\n", + " num_workers=2,\n", + " pin_memory=torch.cuda.is_available(),\n", + ")\n", + "check_data = monai.utils.misc.first(train_loader)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define 2D network and losses" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "model = monai.networks.nets.UNet(\n", + " spatial_dims=2,\n", + " in_channels=1,\n", + " out_channels=1,\n", + " channels=(16, 32, 64, 128),\n", + " strides=(2, 2, 2),\n", + " num_res_units=2,\n", + ").to(device)\n", + "loss_function = monai.losses.DiceLoss(sigmoid=True)\n", + "optimizer = torch.optim.Adam(model.parameters(), 5e-3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The training loop" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "----------\n", + "epoch 1/5\n", + "200, train_loss: 1.0000\n", + "400, train_loss: 0.0747\n", + "epoch 1 average loss: 0.4299\n", + "----------\n", + "epoch 2/5\n", + "200, train_loss: 0.0490\n", + "400, train_loss: 1.0000\n", + "epoch 2 average loss: 0.2845\n", + "----------\n", + "epoch 3/5\n", + "200, train_loss: 0.9365\n", + "400, train_loss: 0.4271\n", + "epoch 3 average loss: 0.2817\n", + "----------\n", + "epoch 4/5\n", + "200, train_loss: 0.0836\n", + "400, train_loss: 0.1104\n", + "epoch 4 average loss: 0.2690\n", + "----------\n", + "epoch 5/5\n", + "200, train_loss: 0.0659\n", + "400, train_loss: 0.1202\n", + "epoch 5 average loss: 0.2769\n", + "train completed\n" + ] + } + ], + "source": [ + "epoch_loss_values = []\n", + "num_epochs = 5\n", + "for epoch in range(num_epochs):\n", + " print(\"-\" * 10)\n", + " print(f\"epoch {epoch + 1}/{num_epochs}\")\n", + " model.train()\n", + " epoch_loss, step = 0, 0\n", + " for batch_data in train_loader:\n", + " step += 1\n", + " inputs, labels = batch_data[\"img\"].to(device), batch_data[\"seg\"].to(device)\n", + " optimizer.zero_grad()\n", + " outputs = model(inputs)\n", + " loss = loss_function(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + " epoch_loss += loss.item()\n", + " if step % 200 == 0:\n", + " print(f\"{step}, train_loss: {loss.item():.4f}\")\n", + " epoch_loss /= step\n", + " epoch_loss_values.append(epoch_loss)\n", + " print(f\"epoch {epoch + 1} average loss: {epoch_loss:.4f}\")\n", + "print(\"train completed\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## SliceInferer" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dice: tensor(0.9861)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dice: tensor(0.9780)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dice: tensor(0.9807)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Avg Dice: 0.9816081523895264\n" + ] + } + ], + "source": [ + "val_transform = Compose(\n", + " [\n", + " LoadImaged(keys=[\"img\", \"seg\"]),\n", + " EnsureChannelFirstd(keys=[\"img\", \"seg\"]),\n", + " ScaleIntensityd(keys=\"img\"),\n", + " EnsureTyped(keys=[\"img\", \"seg\"]),\n", + " ]\n", + ")\n", + "val_files = [{\"img\": img, \"seg\": seg} for img, seg in zip(images[-3:], segs[-3:])]\n", + "val_ds = monai.data.Dataset(data=val_files, transform=val_transform)\n", + "data_loader = DataLoader(val_ds, num_workers=1, pin_memory=torch.cuda.is_available())\n", + "dice_metric = DiceMetric(include_background=True, reduction=\"mean\", get_not_nans=False)\n", + "model.eval()\n", + "with torch.no_grad():\n", + " for val_data in data_loader:\n", + " val_images = val_data[\"img\"].to(device)\n", + " roi_size = (48, 48)\n", + " sw_batch_size = 3\n", + " slice_inferer = SliceInferer(\n", + " roi_size=roi_size,\n", + " sw_batch_size=sw_batch_size,\n", + " spatial_dim=1, # Spatial dim to slice along is defined here\n", + " device=torch.device(\"cpu\"),\n", + " padding_mode=\"replicate\",\n", + " )\n", + " val_output = slice_inferer(val_images, model)\n", + " dice_metric(y_pred=val_output > 0.5, y=val_data[\"seg\"])\n", + " print(\"Dice: \", dice_metric.get_buffer()[-1][0])\n", + " fig = plt.figure(figsize=(10, 4))\n", + " plt.subplot(1, 2, 1)\n", + " matshow3d(val_output[0], fig=plt.gca())\n", + " plt.subplot(1, 2, 2)\n", + " matshow3d(val_images[0], fig=plt.gca())\n", + " plt.show()\n", + " print(f\"Avg Dice: {dice_metric.aggregate().item()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cleanup data directory\n", + "\n", + "Remove directory if a temporary was used." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "if directory is None:\n", + " shutil.rmtree(root_dir)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/modules/training_with_2d_slices.py b/modules/training_with_2d_slices.py deleted file mode 100644 index c1e0399a40..0000000000 --- a/modules/training_with_2d_slices.py +++ /dev/null @@ -1,212 +0,0 @@ -# Copyright (c) MONAI Consortium -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# http://www.apache.org/licenses/LICENSE-2.0 -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import logging -import os -import sys -import tempfile -from glob import glob - -import matplotlib.pyplot as plt -import monai -import nibabel as nib -import numpy as np -import torch -from monai.data import DataLoader, PatchDataset, create_test_image_3d, list_data_collate -from monai.inferers import SliceInferer -from monai.metrics import DiceMetric -from monai.transforms import ( - Compose, - EnsureChannelFirstd, - EnsureTyped, - LoadImaged, - RandCropByPosNegLabeld, - RandRotate90d, - Resized, - ResizeWithPadOrCropd, - ScaleIntensityd, - SqueezeDimd, -) -from monai.visualize import matshow3d - - -def main(tempdir): - monai.config.print_config() - monai.utils.set_determinism(0) - logging.basicConfig(stream=sys.stdout, level=logging.INFO) - - # ----- - # make demo data - # ----- - # create a temporary directory and 40 random image, mask pairs - print(f"generating synthetic data to {tempdir} (this may take a while)") - for i in range(40): - # make the input volumes different spatial shapes for demo purposes - H, W, D = 30 + i, 40 + i, 50 + i - im, seg = create_test_image_3d( - H, W, D, num_seg_classes=1, channel_dim=-1, rad_max=10 - ) - - n = nib.Nifti1Image(im, np.eye(4)) - nib.save(n, os.path.join(tempdir, f"img{i:d}.nii.gz")) - n = nib.Nifti1Image(seg, np.eye(4)) - nib.save(n, os.path.join(tempdir, f"seg{i:d}.nii.gz")) - - images = sorted(glob(os.path.join(tempdir, "img*.nii.gz"))) - segs = sorted(glob(os.path.join(tempdir, "seg*.nii.gz"))) - train_files = [{"img": img, "seg": seg} for img, seg in zip(images[:35], segs[:35])] - - # ----- - # volume-level preprocessing - # ----- - # volume-level transforms for both image and segmentation - train_transforms = Compose( - [ - LoadImaged(keys=["img", "seg"]), - EnsureChannelFirstd(keys=["img", "seg"]), - ScaleIntensityd(keys="img"), - RandRotate90d(keys=["img", "seg"], prob=0.5, spatial_axes=[0, 2]), - EnsureTyped(keys=["img", "seg"]), - ] - ) - # 3D dataset with preprocessing transforms - volume_ds = monai.data.Dataset(data=train_files, transform=train_transforms) - # use batch_size=1 to check the volumes because the input volumes have different shapes - check_loader = DataLoader(volume_ds, batch_size=1) - check_data = monai.utils.misc.first(check_loader) - print("first volume's shape: ", check_data["img"].shape, check_data["seg"].shape) - - # ----- - # volume to patch sampling - # ----- - # define the sampling transforms, could also be other spatial cropping transforms - # https://docs.monai.io/en/stable/transforms.html#crop-and-pad-dict - num_samples = 4 - patch_func = RandCropByPosNegLabeld( - keys=["img", "seg"], - label_key="seg", - spatial_size=[-1, -1, 1], # dynamic spatial_size for the first two dimensions - pos=1, - neg=1, - num_samples=num_samples, - ) - - # ----- - # patch-level preprocessing - # ----- - # resize the sampled slices to a consistent size so that we can batch - # the last spatial dim is always 1, so we squeeze dim. - patch_transform = Compose( - [ - SqueezeDimd(keys=["img", "seg"], dim=-1), # squeeze the last dim - Resized(keys=["img", "seg"], spatial_size=[48, 48]), - # ResizeWithPadOrCropd(keys=["img", "seg"], spatial_size=[48, 48], mode="replicate"), - ] - ) - patch_ds = PatchDataset( - volume_ds, - transform=patch_transform, - patch_func=patch_func, - samples_per_image=num_samples, - ) - train_loader = DataLoader( - patch_ds, - batch_size=3, - shuffle=True, # this shuffles slices from different volumes - num_workers=2, - pin_memory=torch.cuda.is_available(), - ) - check_data = monai.utils.misc.first(train_loader) - print("first patch's shape: ", check_data["img"].shape, check_data["seg"].shape) - - # ----- - # network defined for 2d inputs - # ----- - # create UNet, DiceLoss and Adam optimizer - device = torch.device("cuda" if torch.cuda.is_available() else "cpu") - model = monai.networks.nets.UNet( - spatial_dims=2, - in_channels=1, - out_channels=1, - channels=(16, 32, 64, 128), - strides=(2, 2, 2), - num_res_units=2, - ).to(device) - loss_function = monai.losses.DiceLoss(sigmoid=True) - optimizer = torch.optim.Adam(model.parameters(), 5e-3) - - # ----- - # training - # ----- - epoch_loss_values = [] - num_epochs = 5 - for epoch in range(num_epochs): - print("-" * 10) - print(f"epoch {epoch + 1}/{num_epochs}") - model.train() - epoch_loss, step = 0, 0 - for batch_data in train_loader: - step += 1 - inputs, labels = batch_data["img"].to(device), batch_data["seg"].to(device) - optimizer.zero_grad() - outputs = model(inputs) - loss = loss_function(outputs, labels) - loss.backward() - optimizer.step() - epoch_loss += loss.item() - epoch_len = len(patch_ds) // train_loader.batch_size - if step % 25 == 0: - print(f"{step}/{epoch_len}, train_loss: {loss.item():.4f}") - epoch_loss /= step - epoch_loss_values.append(epoch_loss) - print(f"epoch {epoch + 1} average loss: {epoch_loss:.4f}") - print("train completed") - - # ----- - # inference with a SliceInferer - # ----- - val_transform = Compose( - [ - LoadImaged(keys=["img", "seg"]), - EnsureChannelFirstd(keys=["img", "seg"]), - ScaleIntensityd(keys="img"), - EnsureTyped(keys=["img", "seg"]), - ] - ) - val_files = [{"img": img, "seg": seg} for img, seg in zip(images[-3:], segs[-3:])] - val_ds = monai.data.Dataset(data=val_files, transform=val_transform) - data_loader = DataLoader(val_ds, num_workers=1, pin_memory=torch.cuda.is_available()) - dice_metric = DiceMetric(include_background=True, reduction="mean", get_not_nans=False) - model.eval() - with torch.no_grad(): - for val_data in data_loader: - val_images = val_data["img"].to(device) - roi_size = (48, 48) - sw_batch_size = 3 - slice_inferer = SliceInferer( - roi_size=roi_size, - sw_batch_size=sw_batch_size, - spatial_dim=1, # Spatial dim to slice along is defined here - device=torch.device("cpu"), - padding_mode="replicate", - ) - val_output = slice_inferer(val_images, model) - dice_metric(y_pred=val_output > 0.5, y=val_data["seg"]) - print("Dice: ", dice_metric.get_buffer()[-1][0]) - matshow3d(val_output[0] > 0.5) - matshow3d(val_images[0]) - plt.show() - print(f"Avg Dice: {dice_metric.aggregate().item()}") - - -if __name__ == "__main__": - with tempfile.TemporaryDirectory() as tempdir: - main(tempdir) From db53f050375cf136b8ada7e2715dd0526214045f Mon Sep 17 00:00:00 2001 From: Wenqi Li Date: Sun, 12 Jun 2022 11:03:39 +0100 Subject: [PATCH 5/5] update to use the weekly build Signed-off-by: Wenqi Li --- modules/2d_slices_from_3d_sampling.ipynb | 52 +++++++++-- modules/2d_slices_from_3d_training.ipynb | 107 ++++++++++++++++------- 2 files changed, 124 insertions(+), 35 deletions(-) diff --git a/modules/2d_slices_from_3d_sampling.ipynb b/modules/2d_slices_from_3d_sampling.ipynb index ccd3f9fac5..eddc8dd406 100644 --- a/modules/2d_slices_from_3d_sampling.ipynb +++ b/modules/2d_slices_from_3d_sampling.ipynb @@ -39,11 +39,45 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MONAI version: 0.9.dev2224\n", + "Numpy version: 1.22.4\n", + "Pytorch version: 1.11.0\n", + "MONAI flags: HAS_EXT = False, USE_COMPILED = False\n", + "MONAI rev id: cb6ecb1a22042d4a559b864e74c64d99352dcf7c\n", + "MONAI __file__: /usr/local/anaconda3/envs/py38/lib/python3.8/site-packages/monai/__init__.py\n", + "\n", + "Optional dependencies:\n", + "Pytorch Ignite version: 0.4.8\n", + "Nibabel version: 3.2.2\n", + "scikit-image version: 0.19.2\n", + "Pillow version: 9.1.1\n", + "Tensorboard version: 2.9.0\n", + "gdown version: 4.4.0\n", + "TorchVision version: 0.12.0\n", + "tqdm version: 4.64.0\n", + "lmdb version: 1.3.0\n", + "psutil version: 5.9.1\n", + "pandas version: 1.4.2\n", + "einops version: 0.4.1\n", + "transformers version: 4.19.2\n", + "mlflow version: 1.26.1\n", + "pynrrd version: 0.4.3\n", + "\n", + "For details about installing the optional dependencies, please visit:\n", + " https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies\n", + "\n" + ] + } + ], "source": [ "# Copyright (c) MONAI Consortium\n", "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", @@ -98,11 +132,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/wenqili/Documents/monai_data\n" + ] + } + ], "source": [ "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n", "root_dir = tempfile.mkdtemp() if directory is None else directory\n", @@ -177,7 +219,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 35/35 [00:00<00:00, 61.25it/s]" + "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 35/35 [00:00<00:00, 121.13it/s]" ] }, { diff --git a/modules/2d_slices_from_3d_training.ipynb b/modules/2d_slices_from_3d_training.ipynb index 2e92ea9a84..bc4d968f29 100644 --- a/modules/2d_slices_from_3d_training.ipynb +++ b/modules/2d_slices_from_3d_training.ipynb @@ -39,11 +39,45 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MONAI version: 0.9.dev2224\n", + "Numpy version: 1.22.4\n", + "Pytorch version: 1.11.0\n", + "MONAI flags: HAS_EXT = False, USE_COMPILED = False\n", + "MONAI rev id: cb6ecb1a22042d4a559b864e74c64d99352dcf7c\n", + "MONAI __file__: /usr/local/anaconda3/envs/py38/lib/python3.8/site-packages/monai/__init__.py\n", + "\n", + "Optional dependencies:\n", + "Pytorch Ignite version: 0.4.8\n", + "Nibabel version: 3.2.2\n", + "scikit-image version: 0.19.2\n", + "Pillow version: 9.1.1\n", + "Tensorboard version: 2.9.0\n", + "gdown version: 4.4.0\n", + "TorchVision version: 0.12.0\n", + "tqdm version: 4.64.0\n", + "lmdb version: 1.3.0\n", + "psutil version: 5.9.1\n", + "pandas version: 1.4.2\n", + "einops version: 0.4.1\n", + "transformers version: 4.19.2\n", + "mlflow version: 1.26.1\n", + "pynrrd version: 0.4.3\n", + "\n", + "For details about installing the optional dependencies, please visit:\n", + " https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies\n", + "\n" + ] + } + ], "source": [ "# Copyright (c) MONAI Consortium\n", "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", @@ -98,11 +132,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/wenqili/Documents/monai_data\n" + ] + } + ], "source": [ "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n", "root_dir = tempfile.mkdtemp() if directory is None else directory\n", @@ -177,7 +219,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Loading dataset: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 35/35 [00:00<00:00, 109.45it/s]" + "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 35/35 [00:00<00:00, 107.81it/s]" ] }, { @@ -229,7 +271,15 @@ "cell_type": "code", "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first patch's shape: torch.Size([5, 1, 48, 48]) torch.Size([5, 1, 48, 48])\n" + ] + } + ], "source": [ "patch_func = monai.data.PatchIterd(\n", " keys=[\"img\", \"seg\"],\n", @@ -246,13 +296,15 @@ ")\n", "patch_ds = monai.data.GridPatchDataset(\n", " data=volume_ds, patch_iter=patch_func, transform=patch_transform, with_coordinates=False)\n", + "shuffle_ds = monai.data.ShuffleBuffer(patch_ds, buffer_size=30, seed=0)\n", "train_loader = DataLoader(\n", - " patch_ds,\n", + " shuffle_ds,\n", " batch_size=5,\n", " num_workers=2,\n", " pin_memory=torch.cuda.is_available(),\n", ")\n", - "check_data = monai.utils.misc.first(train_loader)" + "check_data = monai.utils.misc.first(train_loader)\n", + "print(\"first patch's shape: \", check_data[\"img\"].shape, check_data[\"seg\"].shape)" ] }, { @@ -299,29 +351,24 @@ "text": [ "----------\n", "epoch 1/5\n", - "200, train_loss: 1.0000\n", - "400, train_loss: 0.0747\n", - "epoch 1 average loss: 0.4299\n", + "200, train_loss: 0.6586\n", + "epoch 1 average loss: 0.5654\n", "----------\n", "epoch 2/5\n", - "200, train_loss: 0.0490\n", - "400, train_loss: 1.0000\n", - "epoch 2 average loss: 0.2845\n", + "200, train_loss: 0.4702\n", + "epoch 2 average loss: 0.2818\n", "----------\n", "epoch 3/5\n", - "200, train_loss: 0.9365\n", - "400, train_loss: 0.4271\n", - "epoch 3 average loss: 0.2817\n", + "200, train_loss: 0.4618\n", + "epoch 3 average loss: 0.2705\n", "----------\n", "epoch 4/5\n", - "200, train_loss: 0.0836\n", - "400, train_loss: 0.1104\n", - "epoch 4 average loss: 0.2690\n", + "200, train_loss: 0.4595\n", + "epoch 4 average loss: 0.2643\n", "----------\n", "epoch 5/5\n", - "200, train_loss: 0.0659\n", - "400, train_loss: 0.1202\n", - "epoch 5 average loss: 0.2769\n", + "200, train_loss: 0.4590\n", + "epoch 5 average loss: 0.2640\n", "train completed\n" ] } @@ -367,12 +414,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Dice: tensor(0.9861)\n" + "Dice: tensor(0.9846)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -386,12 +433,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Dice: tensor(0.9780)\n" + "Dice: tensor(0.9769)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -405,12 +452,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Dice: tensor(0.9807)\n" + "Dice: tensor(0.9803)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -424,7 +471,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Avg Dice: 0.9816081523895264\n" + "Avg Dice: 0.9806270599365234\n" ] } ],