From 8bfa34eb588518c7608bfb10208e4154d57673b5 Mon Sep 17 00:00:00 2001 From: Theo Barfoot Date: Wed, 2 Sep 2026 18:06:05 +0000 Subject: [PATCH 1/2] Add 3D segmentation calibration tutorial Signed-off-by: Theo Barfoot --- README.md | 7 + calibration/README.md | 25 + calibration/segmentation_calibration.ipynb | 1417 ++++++++++++++++++++ 3 files changed, 1449 insertions(+) create mode 100644 calibration/README.md create mode 100644 calibration/segmentation_calibration.ipynb diff --git a/README.md b/README.md index 4218a8a79..c137c5c5b 100644 --- a/README.md +++ b/README.md @@ -101,6 +101,13 @@ Each user is responsible for checking the content of datasets and the applicable You can read details about adding a tutorial in our [CONTRIBUTING GUIDELINES](CONTRIBUTING.md). ### 4. List of notebooks and examples +#### **Calibration** +##### [Training and evaluating calibrated segmentation models](./calibration/segmentation_calibration.ipynb) +This tutorial trains two models on complete 3D MRI volumes from the Medical Segmentation Decathlon +`Task04_Hippocampus` dataset to demonstrate calibration metrics, reliability diagrams, the Ignite calibration +handler, and L1-ACE auxiliary training. It compares a validation-selected hard L1-ACE configuration with a controlled +segmentation baseline on separate held-out test volumes. + #### **2D classification** ##### [mednist_tutorial](./2d_classification/mednist_tutorial.ipynb) This notebook shows how to easily integrate MONAI features into existing PyTorch programs. diff --git a/calibration/README.md b/calibration/README.md new file mode 100644 index 000000000..18607466f --- /dev/null +++ b/calibration/README.md @@ -0,0 +1,25 @@ +# Segmentation model calibration + +This folder contains a self-contained tutorial for evaluating and improving the marginal class-wise calibration of +semantic segmentation models. It trains on complete 3D volumes from the Medical Segmentation Decathlon +`Task04_Hippocampus` MRI dataset. The notebook downloads the approximately 28 MB archive automatically and reuses +the directory configured by `MONAI_DATA_DIRECTORY`. + +The notebook demonstrates MONAI's calibration metrics, low-level bin statistics, Ignite handler, and hard- and +soft-binned L1 Average Calibration Error losses. It uses complete-volume train/validation/test cohorts and compares +a segmentation baseline with one hard L1-ACE configuration chosen in validation-only preliminary experiments for +its calibration improvement with minimal Dice reduction. The focused comparison discusses the associated +publication's 1:1:1 objective, finite-bin estimates, and the limitations of auxiliary calibration training. + +For a one-epoch CI smoke test, run: + +```bash +export MONAI_DATA_DIRECTORY=/path/to/persistent/monai-data +./runner.sh -t calibration/segmentation_calibration.ipynb +``` + +`runner.sh` rewrites `max_epochs` and `val_interval` to one. To reproduce the saved full experiment, open the notebook +in Jupyter and run all cells without that rewrite. A CUDA GPU is strongly recommended for the two 3D training runs. + +The notebook requires a MONAI build containing `HardL1ACELoss` and `SoftL1ACELoss`. Until those APIs are available in +an official MONAI package, run it in an environment with the corresponding MONAI core contribution installed editable. diff --git a/calibration/segmentation_calibration.ipynb b/calibration/segmentation_calibration.ipynb new file mode 100644 index 000000000..d2d226b83 --- /dev/null +++ b/calibration/segmentation_calibration.ipynb @@ -0,0 +1,1417 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8f6c5529", + "metadata": {}, + "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", + "# Training and Evaluating Calibrated 3D Segmentation Models with MONAI\n", + "\n", + "This tutorial trains three-dimensional hippocampus segmentation models on complete MRI volumes from the\n", + "Medical Segmentation Decathlon. It demonstrates MONAI's calibration metrics, reliability diagrams, Ignite\n", + "handler, and hard-binned L1 Average Calibration Error (ACE) auxiliary training, while contrasting hard and soft\n", + "binning. Calibration is one reliability property; these examples do not make model probabilities clinically actionable.\n", + "\n", + "The losses demonstrated here were introduced by Barfoot et al. in *Average Calibration Losses for Reliable\n", + "Uncertainty in Medical Image Segmentation* (IEEE Transactions on Medical Imaging, 2026). The paper proposes\n", + "hard- and soft-binned differentiable marginal L1-ACE losses and dataset reliability histograms for studying\n", + "variation in calibration between images. Below, **the paper** refers specifically to this work:\n", + "[article](https://doi.org/10.1109/TMI.2026.3673118) and\n", + "[reference implementation](https://github.com/cai4cai/Average-Calibration-Losses).\n", + "\n", + "The paper evaluates ACDC, AMOS, KiTS, and BraTS. This notebook adapts the method to the smaller Decathlon\n", + "hippocampus task as a runnable MONAI example; it is not a reproduction of the paper's experiments.\n" + ] + }, + { + "cell_type": "markdown", + "id": "e14115bb", + "metadata": {}, + "source": [ + "## Setup environment" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2759898b", + "metadata": {}, + "outputs": [], + "source": [ + "!python3 -c \"import ignite; from monai.losses import HardL1ACELoss, SoftL1ACELoss\" || python3 -m pip install -q \"monai-weekly[ignite]\"\n", + "!python3 -c \"import matplotlib, nibabel\" || python3 -m pip install -q matplotlib nibabel" + ] + }, + { + "cell_type": "markdown", + "id": "24a8cbd7", + "metadata": {}, + "source": [ + "## Setup imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "24c563b7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MONAI version: 1.6.0rc1+67.g198bcad9\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Numpy version: 2.2.6\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pytorch version: 2.8.0+cu129\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MONAI flags: HAS_EXT = False, USE_COMPILED = False, USE_META_DICT = False\n", + "MONAI rev id: 198bcad9fd05b286cc525b64f814d7c1421c0eed\n", + "MONAI __file__: /workspaces/MONAI/monai/__init__.py\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Optional dependencies:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pytorch Ignite version: 0.5.5\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ITK version: 5.4.7\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nibabel version: 5.4.2\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "scikit-image version: 0.25.2\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "scipy version: 1.15.3\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pillow version: 12.2.0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tensorboard version: 2.21.0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "gdown version: 6.1.0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TorchVision version: 0.23.0+cu129\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tqdm version: 4.70.0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "lmdb version: 2.3.0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "psutil version: 7.2.2\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pandas version: 2.3.3\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "einops version: 0.8.2\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "transformers version: 5.16.1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mlflow version: 3.15.2\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pynrrd version: 1.1.3\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "clearml version: 2.1.12\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "For details about installing the optional dependencies, please visit:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " https://monai.readthedocs.io/en/latest/installation.html#installing-the-recommended-dependencies\n", + "\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "import copy\n", + "import os\n", + "import random\n", + "import re\n", + "import shutil\n", + "import tempfile\n", + "from pathlib import Path\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn.functional as F\n", + "from ignite.engine import Engine\n", + "\n", + "import monai\n", + "from monai.apps import download_and_extract\n", + "from monai.data import CacheDataset, DataLoader\n", + "from monai.handlers import CalibrationError, from_engine\n", + "from monai.losses import DiceCELoss, HardL1ACELoss, SoftL1ACELoss\n", + "from monai.metrics import (\n", + " CalibrationErrorMetric,\n", + " CalibrationReduction,\n", + " DiceMetric,\n", + " calibration_binning,\n", + ")\n", + "from monai.networks.nets import UNet\n", + "from monai.transforms import (\n", + " Compose,\n", + " EnsureChannelFirstd,\n", + " EnsureTyped,\n", + " LoadImaged,\n", + " NormalizeIntensityd,\n", + " Orientationd,\n", + " RandFlipd,\n", + " SpatialPadd,\n", + " Spacingd,\n", + ")\n", + "from monai.utils import set_determinism\n", + "\n", + "monai.config.print_config()" + ] + }, + { + "attachments": { + "calibration_reliability_diagram.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "2cd70449", + "metadata": {}, + "source": [ + "## What is calibration, and why do we care?\n", + "\n", + "### Confidence that has a frequency interpretation\n", + "\n", + "A segmentation network returns a probability for every voxel and class. In this tutorial, **confidence\n", + "calibration** means that those probabilities agree with observed frequencies. For class $c$, a calibrated\n", + "model satisfies\n", + "\n", + "$$\n", + "P(Y_c=1\\mid \\hat{p}_c=p)=p.\n", + "$$\n", + "\n", + "For example, among voxels assigned a probability of 0.8 for anterior hippocampus, approximately 80% should\n", + "belong to that class. If only 60% do, the model is **overconfident**; if 90% do, it is **underconfident**. We\n", + "use marginal one-versus-all calibration, applying this interpretation separately to every class rather than\n", + "only to the most probable class.\n", + "\n", + "Calibration and segmentation quality answer different questions. Dice measures spatial overlap after a hard\n", + "decision, whereas calibration measures whether the probabilities supporting those decisions are meaningful.\n", + "A model can achieve high Dice while being overconfident, and a poorly discriminating model can still be\n", + "calibrated. We therefore report calibration errors together with Dice rather than treating either as a\n", + "substitute for the other.\n", + "\n", + "### Why calibrated probabilities matter\n", + "\n", + "Incorrect high-confidence predictions are especially problematic when probabilities inform clinical review,\n", + "quality-control thresholds, or active-learning decisions. Better calibration can make confidence maps more\n", + "useful for identifying predictions that merit inspection. It does not, by itself, establish clinical safety,\n", + "detect every distribution shift, or capture all forms of aleatoric and epistemic uncertainty.\n", + "\n", + "Segmentation is unusually suitable for per-image calibration analysis because one 3D volume provides many\n", + "voxel-level probability–outcome pairs. This lets us estimate calibration for each volume and class instead of\n", + "requiring one prediction from each of many images, as in ordinary image classification.\n", + "\n", + "### How to read a reliability diagram\n", + "\n", + "A reliability diagram divides predicted probabilities into bins. For each occupied bin, it compares\n", + "\n", + "- the mean predicted probability, shown on the horizontal axis; and\n", + "- the empirical foreground frequency, shown on the vertical axis.\n", + "\n", + "Perfect calibration lies on the diagonal $y=x$. Points below the diagonal indicate overconfidence, points\n", + "above it indicate underconfidence, and the distance from the diagonal is the bin's calibration gap. A companion\n", + "count histogram is essential context: estimates from sparsely populated bins are less stable.\n", + "\n", + "![Illustrative reliability diagram with calibration gaps and voxel counts](attachment:calibration_reliability_diagram.png)\n", + "\n", + "*Illustrative synthetic example. Black marks show empirical frequency, red bars show the gap to the mean\n", + "predicted probability, and the lower panel shows how much evidence supports each bin.*\n", + "\n", + "Scalar calibration metrics summarize these gaps differently. Expected Calibration Error (ECE) weights each\n", + "bin by its voxel count, Average Calibration Error (ACE) weights occupied bins equally, and Maximum Calibration\n", + "Error (MCE) reports the largest occupied-bin gap. Consequently, ECE can be dominated by the very populous\n", + "near-zero and near-one bins in segmentation, while ACE gives intermediate confidence ranges equal influence.\n", + "\n", + "A conventional dataset-level curve can hide differences between volumes because their errors are averaged and\n", + "may cancel. The paper therefore introduces **dataset reliability histograms**, which aggregate per-volume\n", + "reliability diagrams into a heatmap. In the figure later in this tutorial, a narrow distribution along the\n", + "diagonal indicates consistent calibration across volumes; vertical spread reveals case-to-case variability." + ] + }, + { + "cell_type": "markdown", + "id": "05cd7d9e", + "metadata": {}, + "source": [ + "## Why use complete 3D volumes?\n", + "\n", + "MONAI's calibration components form a separate histogram for each image and class. They flatten the spatial\n", + "dimensions but do not pool different batch items. A $64^3$ volume therefore provides 262,144 probabilities\n", + "per class, giving substantially more stable 20-bin estimates than an individual 2D slice. Volume-level\n", + "training also preserves anatomical context and makes the unit used for training, validation, and metric\n", + "aggregation consistent.\n", + "\n", + "The losses use marginal one-versus-all class calibration rather than top-label confidence calibration. Training includes background to match the paper's configuration introduced above, while reported metrics\n", + "exclude it so that it cannot obscure the two small hippocampal structures." + ] + }, + { + "cell_type": "markdown", + "id": "f438be1d", + "metadata": {}, + "source": [ + "## Download the Medical Segmentation Decathlon hippocampus task\n", + "\n", + "`Task04_Hippocampus` contains 260 labeled T1-weighted MRI volumes with anterior and posterior hippocampus\n", + "labels. The compressed download is approximately 28 MB and is distributed under\n", + "[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/). Set `MONAI_DATA_DIRECTORY` to reuse the\n", + "download and cached transforms between runs; otherwise a temporary directory is used." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d58b80e7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset ready: /workspace/data/decathlon/Task04_Hippocampus\n" + ] + } + ], + "source": [ + "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n", + "root_dir = Path(tempfile.mkdtemp()) if directory is None else Path(directory)\n", + "root_dir.mkdir(parents=True, exist_ok=True)\n", + "resource = \"https://msd-for-monai.s3-us-west-2.amazonaws.com/Task04_Hippocampus.tar\"\n", + "md5 = \"9d24dba78a72977dbd1d2e110310f31b\"\n", + "compressed_file = root_dir / \"Task04_Hippocampus.tar\"\n", + "data_dir = root_dir / \"Task04_Hippocampus\"\n", + "\n", + "if not data_dir.exists():\n", + " download_and_extract(resource, compressed_file, root_dir, md5)\n", + "print(f\"Dataset ready: {data_dir}\")" + ] + }, + { + "cell_type": "markdown", + "id": "fda28bd9", + "metadata": {}, + "source": [ + "## Create volume-level training, validation, and test cohorts\n", + "\n", + "We split before constructing datasets, so no volume contributes to more than one cohort. Thirty-two volumes\n", + "are used for training, eight for validation and hyperparameter selection, and eight are held out until the\n", + "final comparison. The remaining labeled volumes are deliberately unused to keep this worked example\n", + "accessible." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "78056033", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 260 labeled volumes\n", + "Using 32 train, 8 validation, and 8 test volumes\n" + ] + } + ], + "source": [ + "seed = 2026\n", + "set_determinism(seed=seed)\n", + "\n", + "\n", + "def natural_key(path):\n", + " return int(re.search(r\"\\d+\", path.name).group())\n", + "\n", + "\n", + "image_paths = sorted(\n", + " (\n", + " path\n", + " for path in (data_dir / \"imagesTr\").glob(\"hippocampus_*.nii.gz\")\n", + " if not path.name.startswith(\"._\")\n", + " ),\n", + " key=natural_key,\n", + ")\n", + "split_rng = random.Random(seed)\n", + "split_rng.shuffle(image_paths)\n", + "train_paths = image_paths[:32]\n", + "val_paths = image_paths[32:40]\n", + "test_paths = image_paths[40:48]\n", + "\n", + "\n", + "def files(paths):\n", + " return [\n", + " {\"image\": str(path), \"label\": str(data_dir / \"labelsTr\" / path.name)}\n", + " for path in paths\n", + " ]\n", + "\n", + "\n", + "train_files, val_files, test_files = files(train_paths), files(val_paths), files(test_paths)\n", + "print(f\"Found {len(image_paths)} labeled volumes\")\n", + "print(f\"Using {len(train_files)} train, {len(val_files)} validation, and {len(test_files)} test volumes\")" + ] + }, + { + "cell_type": "markdown", + "id": "7cbde853", + "metadata": {}, + "source": [ + "## Define the 3D preprocessing pipeline\n", + "\n", + "The native hippocampus scans are small. After orientation and 1 mm isotropic resampling, padding every spatial\n", + "dimension to 64 gives identically shaped complete volumes without extracting slices or target-centered\n", + "patches. MRI intensities are normalized over nonzero voxels, and random flips provide lightweight training\n", + "augmentation." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "836a23aa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Complete validation image: (1, 64, 64, 64)\n", + "Complete validation label: (1, 64, 64, 64)\n" + ] + } + ], + "source": [ + "spatial_size = (64, 64, 64)\n", + "\n", + "\n", + "def make_transforms(training):\n", + " transforms = [\n", + " LoadImaged(keys=(\"image\", \"label\")),\n", + " EnsureChannelFirstd(keys=(\"image\", \"label\")),\n", + " Orientationd(keys=(\"image\", \"label\"), axcodes=\"RAS\", labels=None),\n", + " Spacingd(\n", + " keys=(\"image\", \"label\"),\n", + " pixdim=(1.0, 1.0, 1.0),\n", + " mode=(\"bilinear\", \"nearest\"),\n", + " ),\n", + " NormalizeIntensityd(keys=\"image\", nonzero=True, channel_wise=True),\n", + " SpatialPadd(keys=(\"image\", \"label\"), spatial_size=spatial_size),\n", + " EnsureTyped(\n", + " keys=(\"image\", \"label\"),\n", + " dtype=(torch.float32, torch.int64),\n", + " track_meta=False,\n", + " ),\n", + " ]\n", + " if training:\n", + " transforms.extend(\n", + " [\n", + " RandFlipd(keys=(\"image\", \"label\"), prob=0.5, spatial_axis=0),\n", + " RandFlipd(keys=(\"image\", \"label\"), prob=0.5, spatial_axis=1),\n", + " RandFlipd(keys=(\"image\", \"label\"), prob=0.5, spatial_axis=2),\n", + " ]\n", + " )\n", + " return Compose(transforms)\n", + "\n", + "\n", + "train_transforms = make_transforms(training=True)\n", + "eval_transforms = make_transforms(training=False)\n", + "train_ds = CacheDataset(train_files, train_transforms, cache_rate=1.0, num_workers=0, progress=False)\n", + "val_ds = CacheDataset(val_files, eval_transforms, cache_rate=1.0, num_workers=0, progress=False)\n", + "test_ds = CacheDataset(test_files, eval_transforms, cache_rate=1.0, num_workers=0, progress=False)\n", + "val_loader = DataLoader(val_ds, batch_size=1, shuffle=False, num_workers=0)\n", + "test_loader = DataLoader(test_ds, batch_size=1, shuffle=False, num_workers=0)\n", + "\n", + "example = val_ds[0]\n", + "print(\"Complete validation image:\", tuple(example[\"image\"].shape))\n", + "print(\"Complete validation label:\", tuple(example[\"label\"].shape))" + ] + }, + { + "cell_type": "markdown", + "id": "80713856", + "metadata": {}, + "source": [ + "The following view comes from a validation volume. It uses array orientation for model development and is\n", + "not intended for diagnostic interpretation." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "04fc6e76", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "example_image = example[\"image\"]\n", + "example_label = example[\"label\"]\n", + "slice_index = int((example_label[0] > 0).sum(dim=(0, 1)).argmax())\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(8, 4))\n", + "axes[0].imshow(example_image[0, :, :, slice_index], cmap=\"gray\")\n", + "axes[0].set_title(f\"Validation MRI, slice {slice_index}\")\n", + "axes[1].imshow(example_image[0, :, :, slice_index], cmap=\"gray\")\n", + "axes[1].contour(\n", + " example_label[0, :, :, slice_index],\n", + " levels=[0.5, 1.5],\n", + " colors=[\"lime\", \"cyan\"],\n", + " linewidths=1.5,\n", + ")\n", + "axes[1].set_title(\"Reference (anterior/posterior)\")\n", + "for axis in axes:\n", + " axis.axis(\"off\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "0f00bae9", + "metadata": {}, + "source": [ + "## Define the segmentation model and objectives\n", + "\n", + "Barfoot et al. use Dice plus cross-entropy with unit coefficients as the segmentation baseline. Their\n", + "calibrated configuration gives Dice, cross-entropy, and L1-ACE equal weight:\n", + "\n", + "$$\\mathcal{L}_{\\mathrm{paper}} =\n", + "0.33\\,\\mathcal{L}_{\\mathrm{Dice}} +\n", + "0.33\\,\\mathcal{L}_{\\mathrm{CE}} +\n", + "0.33\\,\\mathcal{L}_{\\mathrm{ACE}}.$$\n", + "\n", + "For this smaller Task04 cohort, a validation-only preliminary comparison found that hard L1-ACE with coefficient\n", + "0.10 gave the best calibration improvement for the least Dice reduction. The focused tutorial therefore uses\n", + "\n", + "$$\\mathcal{L}_{\\mathrm{calibrated}} =\n", + "0.33\\,\\mathcal{L}_{\\mathrm{Dice}} +\n", + "0.33\\,\\mathcal{L}_{\\mathrm{CE}} +\n", + "0.10\\,\\mathcal{L}_{\\mathrm{Hard\\ L1\\text{-}ACE}},$$\n", + "\n", + "a ratio of approximately $1:1:0.30$. The segmentation terms are identical for baseline and calibrated training, so\n", + "the auxiliary calibration term is the only difference. The test cohort was not used to select this setting.\n", + "Both models start from identical weights and see the same shuffled, augmented volumes. Empty target classes\n", + "contribute zero before the batch-and-class mean, matching the reference loss implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fe98f9c5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training on: cuda:0\n", + "NVIDIA GeForce RTX 5090\n" + ] + } + ], + "source": [ + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "print(f\"Training on: {device}\")\n", + "if device.type == \"cuda\":\n", + " print(torch.cuda.get_device_name(0))\n", + "\n", + "# Use deterministic kernels so the saved comparison is reproducible.\n", + "torch.use_deterministic_algorithms(True)\n", + "\n", + "\n", + "def make_model():\n", + " return UNet(\n", + " spatial_dims=3,\n", + " in_channels=1,\n", + " out_channels=3,\n", + " channels=(16, 32, 64, 128),\n", + " strides=(2, 2, 2),\n", + " num_res_units=2,\n", + " ).to(device)\n", + "\n", + "\n", + "initial_state = copy.deepcopy(make_model().state_dict())\n", + "segmentation_loss = DiceCELoss(\n", + " include_background=True,\n", + " to_onehot_y=False,\n", + " softmax=True,\n", + " squared_pred=True,\n", + " smooth_nr=0,\n", + " smooth_dr=1.0e-5,\n", + " lambda_dice=0.33,\n", + " lambda_ce=0.33,\n", + ")\n", + "hard_ace = HardL1ACELoss(\n", + " num_bins=20,\n", + " include_background=True,\n", + " to_onehot_y=False,\n", + " softmax=True,\n", + " ignore_empty_classes=True,\n", + ")\n", + "soft_ace = SoftL1ACELoss(\n", + " num_bins=20,\n", + " include_background=True,\n", + " to_onehot_y=False,\n", + " softmax=True,\n", + " empty_weight=0.01,\n", + " ignore_empty_classes=True,\n", + ")\n", + "calibration_weight = 0.10\n", + "max_epochs = 100\n", + "val_interval = 10" + ] + }, + { + "cell_type": "markdown", + "id": "6b8044db", + "metadata": {}, + "source": [ + "## Verify that hard and soft binning are distinct\n", + "\n", + "Hard L1-ACE assigns every probability to one bin. Soft L1-ACE interpolates between two neighboring bin\n", + "centers, so they are related estimators rather than numerically identical functions." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1b556f0a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Same 3D logits: hard L1-ACE=0.479469, soft L1-ACE=0.478980\n", + "Absolute difference: 0.000489\n" + ] + } + ], + "source": [ + "probe_model = make_model()\n", + "probe_model.load_state_dict(initial_state)\n", + "with torch.no_grad():\n", + " probe_logits = probe_model(example_image[None].to(device))\n", + " probe_target = (\n", + " F.one_hot(example_label[None, 0].long(), num_classes=3)\n", + " .movedim(-1, 1)\n", + " .float()\n", + " .to(device)\n", + " )\n", + " hard_value = hard_ace(probe_logits, probe_target).item()\n", + " soft_value = soft_ace(probe_logits, probe_target).item()\n", + "print(f\"Same 3D logits: hard L1-ACE={hard_value:.6f}, soft L1-ACE={soft_value:.6f}\")\n", + "print(f\"Absolute difference: {abs(hard_value - soft_value):.6f}\")\n", + "del probe_model, probe_logits, probe_target" + ] + }, + { + "cell_type": "markdown", + "id": "11ad30cd", + "metadata": {}, + "source": [ + "## Train baseline and calibrated models\n", + "\n", + "Each run selects its checkpoint by validation Dice. Explicit one-hot targets are shared by the segmentation and\n", + "calibration objectives, enabling deterministic CUDA training. The test cohort remains untouched until both\n", + "checkpoints have been fixed." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9dd7485c", + "metadata": {}, + "outputs": [], + "source": [ + "def evaluate(model, loader, store_predictions=False):\n", + " dice_metric = DiceMetric(include_background=False, reduction=\"mean\")\n", + " calibration_metrics = {\n", + " \"ECE\": CalibrationErrorMetric(\n", + " num_bins=20,\n", + " include_background=False,\n", + " calibration_reduction=CalibrationReduction.EXPECTED,\n", + " ),\n", + " \"ACE\": CalibrationErrorMetric(\n", + " num_bins=20,\n", + " include_background=False,\n", + " calibration_reduction=CalibrationReduction.AVERAGE,\n", + " ),\n", + " \"MCE\": CalibrationErrorMetric(\n", + " num_bins=20,\n", + " include_background=False,\n", + " calibration_reduction=CalibrationReduction.MAXIMUM,\n", + " ),\n", + " }\n", + " probabilities, targets = [], []\n", + " model.eval()\n", + " with torch.no_grad():\n", + " for batch in loader:\n", + " image = batch[\"image\"].to(device)\n", + " label = batch[\"label\"].to(device)\n", + " probability = torch.softmax(model(image), dim=1)\n", + " target = F.one_hot(label[:, 0], num_classes=3).movedim(-1, 1).float()\n", + " prediction = (\n", + " F.one_hot(probability.argmax(dim=1), num_classes=3)\n", + " .movedim(-1, 1)\n", + " .float()\n", + " )\n", + " dice_metric(y_pred=prediction, y=target)\n", + " for metric in calibration_metrics.values():\n", + " metric(y_pred=probability, y=target)\n", + " if store_predictions:\n", + " probabilities.append(probability.cpu())\n", + " targets.append(target.cpu())\n", + " scores = {\"Dice\": dice_metric.aggregate().item()}\n", + " scores.update(\n", + " {\n", + " name: metric.aggregate().item()\n", + " for name, metric in calibration_metrics.items()\n", + " }\n", + " )\n", + " if store_predictions:\n", + " return scores, torch.cat(probabilities), torch.cat(targets)\n", + " return scores\n", + "\n", + "\n", + "def train_variant(calibration_loss=None, calibration_weight=0.0):\n", + " set_determinism(seed=seed)\n", + " train_transforms.set_random_state(seed=seed)\n", + " generator = torch.Generator().manual_seed(seed)\n", + " train_loader = DataLoader(\n", + " train_ds,\n", + " batch_size=2,\n", + " shuffle=True,\n", + " generator=generator,\n", + " num_workers=0,\n", + " pin_memory=True,\n", + " )\n", + " model = make_model()\n", + " model.load_state_dict(initial_state)\n", + " optimizer = torch.optim.AdamW(model.parameters(), lr=2.0e-3, weight_decay=1.0e-5)\n", + " scaler = torch.amp.GradScaler(\"cuda\", enabled=device.type == \"cuda\")\n", + " best_state = None\n", + " best_epoch = 0\n", + " best_val_dice = float(\"-inf\")\n", + " for epoch in range(1, max_epochs + 1):\n", + " model.train()\n", + " running_loss = 0.0\n", + " for batch in train_loader:\n", + " image = batch[\"image\"].to(device, non_blocking=True)\n", + " label = batch[\"label\"].to(device, non_blocking=True)\n", + " target = F.one_hot(label[:, 0], num_classes=3).movedim(-1, 1).float()\n", + " optimizer.zero_grad(set_to_none=True)\n", + " with torch.amp.autocast(\"cuda\", enabled=device.type == \"cuda\"):\n", + " logits = model(image)\n", + " loss = segmentation_loss(logits, target)\n", + " if calibration_loss is not None:\n", + " loss = loss + calibration_weight * calibration_loss(logits, target)\n", + " scaler.scale(loss).backward()\n", + " scaler.step(optimizer)\n", + " scaler.update()\n", + " running_loss += loss.item()\n", + " mean_training_loss = running_loss / len(train_loader)\n", + " if epoch % val_interval == 0 or epoch == max_epochs:\n", + " val_scores = evaluate(model, val_loader)\n", + " if epoch % (2 * val_interval) == 0 or epoch == max_epochs:\n", + " print(\n", + " f\"epoch {epoch:03d}: loss={mean_training_loss:.4f}, \"\n", + " f\"validation Dice={val_scores['Dice']:.4f}, \"\n", + " f\"validation ACE={val_scores['ACE']:.4f}\"\n", + " )\n", + " if val_scores[\"Dice\"] > best_val_dice:\n", + " best_val_dice = val_scores[\"Dice\"]\n", + " best_epoch = epoch\n", + " best_state = {\n", + " key: value.detach().cpu().clone()\n", + " for key, value in model.state_dict().items()\n", + " }\n", + " model.load_state_dict(best_state)\n", + " val_scores = evaluate(model, val_loader)\n", + " print(\n", + " f\"selected epoch {best_epoch}: Dice={val_scores['Dice']:.4f}, \"\n", + " f\"ACE={val_scores['ACE']:.4f}\"\n", + " )\n", + " return best_state, val_scores" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a863ae3a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Training: segmentation only\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 020: loss=0.0509, validation Dice=0.7388, validation ACE=0.1009\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 040: loss=0.0323, validation Dice=0.8088, validation ACE=0.1050\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 060: loss=0.0290, validation Dice=0.8055, validation ACE=0.1117\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 080: loss=0.0250, validation Dice=0.7838, validation ACE=0.1168\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 100: loss=0.0207, validation Dice=0.8184, validation ACE=0.1065\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "selected epoch 100: Dice=0.8184, ACE=0.1065\n", + "\n", + "Training: hard L1-ACE\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 020: loss=0.0693, validation Dice=0.6879, validation ACE=0.1353\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 040: loss=0.0462, validation Dice=0.8017, validation ACE=0.0850\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 060: loss=0.0379, validation Dice=0.7918, validation ACE=0.0992\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 080: loss=0.0382, validation Dice=0.8154, validation ACE=0.1056\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 100: loss=0.0326, validation Dice=0.8119, validation ACE=0.0963\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "selected epoch 90: Dice=0.8167, ACE=0.0945\n" + ] + } + ], + "source": [ + "calibrated_name = \"hard L1-ACE\"\n", + "configurations = {\n", + " \"segmentation only\": None,\n", + " calibrated_name: hard_ace,\n", + "}\n", + "\n", + "states, validation_results = {}, {}\n", + "for name, calibration_loss in configurations.items():\n", + " print(f\"\\nTraining: {name}\")\n", + " states[name], validation_results[name] = train_variant(\n", + " calibration_loss,\n", + " calibration_weight if calibration_loss is not None else 0.0,\n", + " )\n", + "model_names = list(configurations)" + ] + }, + { + "cell_type": "markdown", + "id": "03c869b2", + "metadata": {}, + "source": [ + "## Compare validation performance\n", + "\n", + "The selected coefficient is fixed before test evaluation. This table verifies the two saved checkpoints on the\n", + "validation cohort; Dice is higher when better, while ECE, ACE, and MCE are lower when better." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "caf12cd9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "configuration Dice ECE ACE MCE\n", + "segmentation only 0.818400 0.000985 0.106519 0.259649\n", + "hard L1-ACE 0.816666 0.000965 0.094508 0.245661\n" + ] + } + ], + "source": [ + "print(f\"{'configuration':<20} {'Dice':>10} {'ECE':>10} {'ACE':>10} {'MCE':>10}\")\n", + "for name, scores in validation_results.items():\n", + " print(\n", + " f\"{name:<20} {scores['Dice']:10.6f} {scores['ECE']:10.6f} \"\n", + " f\"{scores['ACE']:10.6f} {scores['MCE']:10.6f}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "29035d28", + "metadata": {}, + "source": [ + "## Evaluate the untouched test cohort\n", + "\n", + "The two fixed checkpoints are now evaluated on the held-out test volumes. This is the first use of the test cohort.\n", + "Dice is higher when better; ECE, ACE, and MCE are lower when better." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "82966ff2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "configuration Dice ECE ACE MCE\n", + "segmentation only 0.799317 0.001060 0.117391 0.295517\n", + "hard L1-ACE 0.828645 0.001032 0.090355 0.208534\n", + "\n", + "Change from segmentation only (positive ACE change is an improvement):\n", + "hard L1-ACE Dice +0.029327, ACE +0.027036\n" + ] + } + ], + "source": [ + "test_results, stored_predictions = {}, {}\n", + "stored_targets = None\n", + "for name in model_names:\n", + " model = make_model()\n", + " model.load_state_dict(states[name])\n", + " scores, probabilities, targets = evaluate(model, test_loader, store_predictions=True)\n", + " test_results[name] = scores\n", + " stored_predictions[name] = probabilities\n", + " stored_targets = targets\n", + " del model\n", + "\n", + "print(f\"{'configuration':<20} {'Dice':>10} {'ECE':>10} {'ACE':>10} {'MCE':>10}\")\n", + "for name, scores in test_results.items():\n", + " print(\n", + " f\"{name:<20} {scores['Dice']:10.6f} {scores['ECE']:10.6f} \"\n", + " f\"{scores['ACE']:10.6f} {scores['MCE']:10.6f}\"\n", + " )\n", + "\n", + "baseline = test_results[\"segmentation only\"]\n", + "calibrated = test_results[calibrated_name]\n", + "dice_change = calibrated[\"Dice\"] - baseline[\"Dice\"]\n", + "ace_improvement = baseline[\"ACE\"] - calibrated[\"ACE\"]\n", + "print(\"\\nChange from segmentation only (positive ACE change is an improvement):\")\n", + "print(f\"{calibrated_name:<20} Dice {dice_change:+.6f}, ACE {ace_improvement:+.6f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "4d0d08f7", + "metadata": {}, + "source": [ + "In the saved run, the validation checkpoints differ by only 0.0017 Dice while hard L1-ACE lowers ACE from\n", + "0.1065 to 0.0945. On the untouched test cohort, it raises Dice from 0.7993 to 0.8286 and lowers ACE from 0.1174\n", + "to 0.0904, a 23% relative reduction. This small single-split result demonstrates the possible trade-off; it is\n", + "not a guarantee that every dataset or training run will improve both measures.\n", + "\n", + "The fixed zero-to-one probability maps below show the same held-out volume for both models.\n", + "\n", + "## Inspect held-out probability maps" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ef4cfa13", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABoQAAAFpCAYAAAC1XEoMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAl6lJREFUeJzs3Xd4FFXbBvB7tmfTe0iA0HtTeEFABQVBQBARBUGaihVRsL42AqgoKlhQxAZIUWn6wStSBQuiKIIiSu8lhYT0bLJlvj9iFmbPAXaXQLLJ/fPaS+bJmZkzM5udzDl7zqOoqqqCiIiIiIiIiIiIiIiIqixdRVeAiIiIiIiIiIiIiIiILi12CBEREREREREREREREVVx7BAiIiIiIiIiIiIiIiKq4tghREREREREREREREREVMWxQ4iIiIiIiIiIiIiIiKiKY4cQERERERERERERERFRFccOISIiIiIiIiIiIiIioiqOHUJERERERERERERERERVHDuEiIiIiIiIiIiIiIiIqjh2CBEREVGlsXfvXvTo0QPh4eFQFAVfffVVRVeJiIioyuvatSu6du1a0dUoFyNHjkSdOnUquhpEVI2lpKRAURScOnWqwuqwceNGKIqCjRs3VlgdiKhyYocQuSmK4tWrPG4mhYWFSElJ8XpbZTcyRVEwf/58aZnOnTtDURS0aNFCE69Tp46m/sHBwWjfvj0+/fTTc+5nyZIlPh8TEVF1M2fOHM3nq8FgQFJSEkaOHInjx4/7tc0RI0Zgx44deOmllzBv3jy0a9eunGtNREQUmF5++eWL+qLE33//jZSUFBw6dKjc6kRERIGt7Jnut99+O2+5mTNn4rbbbkPt2rWhKApGjhzp1/6ys7NhsVigKAr++eefc5ZzOp2YPXs2unbtiqioKJjNZtSpUwejRo3S1NXzmdTz9fPPP/tVT6KqzFDRFaDKY968eZrlTz/9FGvXrhXiTZs2veh9FRYWYuLEiQDg0zfRLBYLFi5ciDvvvFMTP3ToEH766SdYLBbpem3atMFjjz0GADh58iQ++ugjjBgxAsXFxRg9erR/B0FERACASZMmoW7durDZbPj5558xZ84c/Pjjj/jrr7/O+bksU1RUhM2bN+PZZ5/FmDFjLmGNiYiIAs/LL7+MgQMHon///n6t//fff2PixIno2rWrMIJmzZo1F19BIiKqsl599VXk5eWhffv2OHnypN/bWbx4MRRFQUJCAhYsWIAXX3xRKFNUVIQBAwZg1apVuPbaa/HMM88gKioKhw4dwqJFizB37lwcOXIENWvWdK9T9kzqqUGDBn7XlaiqYocQuXl2svz8889Yu3atEK9IvXv3xvLly3Hq1CnExMS44wsXLkR8fDwaNmyI06dPC+slJSVpjmPkyJGoV68epk+fzg4hIqKL1KtXL/dInnvuuQcxMTF49dVXsXz5ctx+++1ebycjIwMAEBERUW51s9lsMJlM0Ok4KJqIiOhcTCZTRVeBiIh8oKoqbDYbgoKCLsv+vvvuO/fooJCQEL+3M3/+fPTu3RvJyclYuHChtEPoiSeewKpVqzB9+nQ8+uijmp9NmDAB06dPF9Y5+5mUiM6PrSPkE5fLhTfffBPNmzeHxWJBfHw87rvvPqET5rfffkPPnj0RExODoKAg1K1bF3fddReA0tE8sbGxAICJEye6h3GmpKRccP8333wzzGYzFi9erIkvXLgQt99+O/R6vVfHERsbiyZNmmD//v1elSciIu9dc801AKD5jN21axcGDhyIqKgoWCwWtGvXDsuXL3f/PCUlBcnJyQBKHwAURdF8e/n48eO46667EB8fD7PZjObNm+OTTz7R7Lds2s/PP/8czz33HJKSkmC1WpGbmwsA+OWXX3DjjTciPDwcVqsVXbp0waZNmzTbKJvve9++fRg5ciQiIiIQHh6OUaNGobCwUDjW+fPno3379rBarYiMjMS1114rfMv6m2++wTXXXIPg4GCEhoaiT58+2Llzpx9nloio+snLy8Ojjz6KOnXqwGw2Iy4uDjfccAN+//13TTlvPuOB0ntFu3btYLFYUL9+fcyaNcv92X82RVEwZswYLF68GM2aNUNQUBA6duyIHTt2AABmzZqFBg0awGKxoGvXrtJp2MrzvqMoCgoKCjB37lz381PZdD2HDx/Ggw8+iMaNGyMoKAjR0dG47bbbNHWaM2cObrvtNgDAddddJ0wHLsshlJ6ejrvvvhvx8fGwWCxo3bo15s6dqylz6NAhKIqC119/HR988AHq168Ps9mM//znP/j111+FcyJz4MAB3HbbbYiKioLVasVVV12Fr7/+WlOm7B6/aNEivPTSS6hZsyYsFgu6deuGffv2nXPbqqqiTp06uPnmm4Wf2Ww2hIeH47777vOqnkREvsrOzr7gM8Xs2bNx/fXXIy4uDmazGc2aNcPMmTOFbdWpUwc33XQTVq9ejXbt2iEoKAizZs0CABw7dgz9+/dHcHAw4uLiMG7cOBQXF5frsSQnJwv3Sl8dOXIEP/zwAwYPHozBgwfj4MGD+OmnnzRljh07hlmzZuGGG24QOoMAQK/X4/HHH9eMDiIi33CEEPnkvvvuw5w5czBq1CiMHTsWBw8exIwZM7Bt2zZs2rQJRqMR6enp6NGjB2JjY/H0008jIiIChw4dwrJlywCUdsbMnDkTDzzwAG655RYMGDAAANCqVasL7t9qteLmm2/GZ599hgceeAAA8Mcff2Dnzp346KOP8Oeff3p1HA6HA8eOHUNkZKSfZ4KIiM6lrAGq7DN2586d6Ny5M5KSkvD0008jODgYixYtQv/+/bF06VL3vSAiIgLjxo3DHXfcgd69e7u/eZaWloarrrrK3TgXGxuLb775BnfffTdyc3OFB4XJkyfDZDLh8ccfR3FxMUwmE7799lv06tULbdu2xYQJE6DT6dwPXz/88APat2+v2cbtt9+OunXrYsqUKfj999/x0UcfIS4uDq+++qq7zMSJE5GSkoJOnTph0qRJMJlM+OWXX/Dtt9+iR48eAEqnYx0xYgR69uyJV199FYWFhZg5cyauvvpqbNu2jUmviYgu4P7778eSJUswZswYNGvWDJmZmfjxxx/xzz//4MorrwQArz/jt23bhhtvvBE1atTAxIkT4XQ6MWnSJPeX1Tz98MMPWL58OR566CEAwJQpU3DTTTfhySefxHvvvYcHH3wQp0+fxtSpU3HXXXfh22+/da9b3vedefPm4Z577kH79u1x7733AgDq168PAPj111/x008/YfDgwahZsyYOHTqEmTNnomvXrvj7779htVpx7bXXYuzYsXj77bfxzDPPuKcBP9d04EVFRejatSv27duHMWPGoG7duli8eDFGjhyJ7OxsPPLII5ryCxcuRF5eHu677z4oioKpU6diwIABOHDgAIxG4zmvb1paGjp16oTCwkKMHTsW0dHRmDt3Lvr164clS5bglltu0ZR/5ZVXoNPp8PjjjyMnJwdTp07F0KFD8csvv0i3rygK7rzzTkydOhVZWVmIiopy/2zFihXIzc2tVDNiEFHV4s0zxcyZM9G8eXP069cPBoMBK1aswIMPPgiXy+W+/5TZvXs37rjjDtx3330YPXo0GjdujKKiInTr1g1HjhzB2LFjkZiYiHnz5mnuSZXFZ599huDgYNx0000ICgpC/fr1sWDBAnTq1Mld5ptvvoHD4cCwYcN82nZOTg5OnTqliSmKgujo6HKpO1GVohKdw0MPPaSe/Rb54YcfVADqggULNOVWrVqliX/55ZcqAPXXX38957YzMjJUAOqECRO8qsuGDRtUAOrixYvV//3vf6qiKOqRI0dUVVXVJ554Qq1Xr56qqqrapUsXtXnz5pp1k5OT1R49eqgZGRlqRkaGumPHDnXYsGEqAPWhhx46536IiOj8Zs+erQJQ161bp2ZkZKhHjx5VlyxZosbGxqpms1k9evSoqqqq2q1bN7Vly5aqzWZzr+tyudROnTqpDRs2dMcOHjyoAlBfe+01zX7uvvtutUaNGuqpU6c08cGDB6vh4eFqYWGhqqpnPsPr1avnjpXtq2HDhmrPnj1Vl8vljhcWFqp169ZVb7jhBndswoQJKgD1rrvu0uzrlltuUaOjo93Le/fuVXU6nXrLLbeoTqdTU7ZsH3l5eWpERIQ6evRozc9TU1PV8PBwIU5ERKLw8HDhb/az+fIZ37dvX9VqtarHjx93x/bu3asaDAbV89EYgGo2m9WDBw+6Y7NmzVIBqAkJCWpubq47/t///lcF4C57Ke47qqqqwcHB6ogRI4RzcPY9r8zmzZtVAOqnn37qji1evFgFoG7YsEEo36VLF7VLly7u5TfffFMFoM6fP98dKykpUTt27KiGhIS4j7/s3h0dHa1mZWW5y/7f//2fCkBdsWKFsK+zPfrooyoA9YcffnDH8vLy1Lp166p16tRx32PL7vFNmzZVi4uL3WXfeustFYC6Y8cOd2zEiBFqcnKye3n37t0qAHXmzJmafffr10+tU6eO5hoREZUHXz7bZZ/hPXv2dLdzlUlOTlYBqKtWrdLEyz6vFy1a5I4VFBSoDRo0OOdn/tnKnunO14bn6Vz3owtp2bKlOnToUPfyM888o8bExKh2u90dGzdunApA3bZtm1fbLKu/7GU2m32uI1F1wCnjyGuLFy9GeHg4brjhBpw6dcr9atu2LUJCQrBhwwYAZ3I//O9//4Pdbi/3evTo0QNRUVH4/PPPoaoqPv/8c9xxxx3nXWfNmjWIjY1FbGwsWrZsiXnz5mHUqFF47bXXyr1+RETVTffu3REbG4tatWph4MCBCA4OxvLly1GzZk1kZWXh22+/xe233468vDz3vSMzMxM9e/bE3r17cfz48XNuW1VVLF26FH379oWqqpr7T8+ePZGTkyNMGzRixAjNXNrbt2/H3r17MWTIEGRmZrrXLygoQLdu3fD999/D5XJptnH//fdrlq+55hpkZma6p5/76quv4HK58MILLwj5icqmUli7di2ys7Nxxx13aOqt1+vRoUMH932TiIjOLSIiAr/88gtOnDgh/bm3n/FOpxPr1q1D//79kZiY6F6/QYMG6NWrl3Tb3bp104zk7NChAwDg1ltvRWhoqBA/cOCAT3U624XuO+dz9j3PbrcjMzMTDRo0QEREhHCP9NbKlSuRkJCgec4yGo0YO3Ys8vPz8d1332nKDxo0SDP7Qtn0sWXn5Hz7ad++Pa6++mp3LCQkBPfeey8OHTqEv//+W1N+1KhRmnxH3uynUaNG6NChAxYsWOCOZWVl4ZtvvsHQoUMvegokIqJz8eaz/ezP8LJRLl26dMGBAweQk5OjWb9u3bro2bOnJrZy5UrUqFEDAwcOdMesVqt7NGll8eeff2LHjh2a+0rZc9Lq1avdsbJzc/Z91hvvvvsu1q5dq3l988035VN5oiqGU8aR1/bu3YucnBzExcVJf56eng4A6NKlC2699VZMnDgR06dPR9euXdG/f38MGTIEZrP5outhNBpx2223YeHChWjfvj2OHj2KIUOGnHedDh064MUXX4TT6cRff/2FF198EadPn2byVCKicvDuu++iUaNGyMnJwSeffILvv//e/Xm/b98+qKqK559/Hs8//7x0/fT0dCQlJUl/lpGRgezsbHzwwQf44IMPzrn+2erWratZ3rt3L4DSjqJzycnJ0TRk1a5dW/Pzsp+dPn0aYWFh2L9/P3Q6HZo1a3bObZbt9/rrr5f+PCws7JzrEhFRqalTp2LEiBGoVasW2rZti969e2P48OGoV68eAO8/4202G4qKitCgQQPh57IYIN4LwsPDAQC1atWSxsvyql6K+875FBUVYcqUKZg9ezaOHz8OVVU1+/HH4cOH0bBhQ+FLD2VTzB0+fFgTP1/9L7Sfsg61c+2nRYsWF72f4cOHY8yYMTh8+DCSk5OxePFi2O12n6ckIiLyhTef7Zs2bcKECROwefNmIb9QTk6O+x4DiM85QOnnZIMGDYTO7caNG5fLMfiiqKhIuO8kJCQAKM29GhwcjHr16rlzv1ksFtSpUwcLFixAnz59AJx5RsrLy/Np3+3bt0e7du0u9hCIqgV2CJHXXC4X4uLiNN+sOlvZ3NuKomDJkiX4+eefsWLFCqxevRp33XUX3njjDfz888/unBAXY8iQIXj//feRkpKC1q1bn7dBDgBiYmLQvXt3AEDPnj3RpEkT3HTTTXjrrbcwfvz4i64PEVF1dvYf3/3798fVV1+NIUOGYPfu3e5vQD/++OPCt9nKnKshDoB7/TvvvPOcDWueOejO/pbd2dt47bXX0KZNG+k2PO9Ner1eWu7sRrYLKdvvvHnz3A9CZzMY+GcYEdGF3H777bjmmmvw5ZdfYs2aNXjttdfw6quvYtmyZejVq5fXn/E2m83nfZ/rXnChe8Tlvu88/PDDmD17Nh599FF07NgR4eHhUBQFgwcPFkYiXSrlcd+8lPsZPHgwxo0bhwULFuCZZ57B/Pnz0a5duwppMCWi6uNCn1n79+9Ht27d0KRJE0ybNg21atWCyWTCypUrMX36dOEz3PM5p7L54osvMGrUKE1MVVWoqorPPvsMBQUF0va79PR05OfnIyQkBE2aNAEA7Nix45z3UCK6OGyJIK/Vr18f69atQ+fOnb26CV111VW46qqr8NJLL2HhwoUYOnQoPv/8c9xzzz0XPSz/6quvRu3atbFx40ZNMj5v9enTB126dMHLL7+M++67D8HBwRdVHyIiKqXX6zFlyhRcd911mDFjBu666y4ApaM7yzrmfREbG4vQ0FA4nU6/1gfOJN0OCwvzexuybbpcLvz999/nfFAp229cXFy57ZeIqDqqUaMGHnzwQTz44INIT0/HlVdeiZdeegm9evXy+jM+Li4OFovF/a3ks8liF+NS3HcAnPMZasmSJRgxYgTeeOMNd8xmsyE7O9ur9WWSk5Px559/wuVyaUYJ7dq1y/3z8pCcnIzdu3cL8fLeT1RUFPr06YMFCxZg6NCh2LRpE958881y2TYRkb9WrFiB4uJiLF++XDOayJeppZOTk/HXX39BVVXN57zss/VS69mzJ9auXSvEv/vuOxw7dgyTJk1yjwAtc/r0adx777346quvcOedd6JXr17Q6/WYP38+R3ESXSLMIUReu/322+F0OjF58mThZw6Hw/3Acfr0aeEbWmWNZcXFxQBK5zMFIDykeEtRFLz99tuYMGGC3zeIp556CpmZmfjwww/9Wp+IiOS6du2K9u3b480330RYWBi6du2KWbNm4eTJk0LZjIyM825Lr9fj1ltvxdKlS/HXX3/5vD4AtG3bFvXr18frr7+O/Px8v7bhqX///tDpdJg0aZLwzb2ye2DPnj0RFhaGl19+WZpTz5/9EhFVJ06nU5h6Ji4uDomJie7nCm8/4/V6Pbp3746vvvpKk49o37595Z5j4FLcdwAgODhY+vyk1+uF56933nkHTqdTWB/w7hmsd+/eSE1NxRdffOGOORwOvPPOOwgJCUGXLl18P4Bz7GfLli3YvHmzO1ZQUIAPPvgAderUueBMEL4YNmwY/v77bzzxxBPQ6/UYPHhwuW2biMgfZSOIPKf6nD17ttfb6N27N06cOIElS5a4Y4WFheecbvtSqlGjBrp37655AWemi3viiScwcOBAzWv06NFo2LChezaiWrVqYfTo0VizZg3eeecdYR8ulwtvvPEGjh07dlmPjagq4Qgh8lqXLl1w3333YcqUKdi+fTt69OgBo9GIvXv3YvHixXjrrbcwcOBAzJ07F++99x5uueUW1K9fH3l5efjwww8RFhaG3r17Aygd5tqsWTN88cUXaNSoEaKiotCiRQvN/NAXcvPNN+Pmm2/2+3h69eqFFi1aYNq0aXjooYdgNBr93hYREWk98cQTuO222zBnzhy8++67uPrqq9GyZUuMHj0a9erVQ1paGjZv3oxjx47hjz/+OO+2XnnlFWzYsAEdOnTA6NGj0axZM2RlZeH333/HunXrkJWVdd71dTodPvroI/Tq1QvNmzfHqFGjkJSUhOPHj2PDhg0ICwvDihUrfDq+Bg0a4Nlnn8XkyZNxzTXXYMCAATCbzfj111+RmJiIKVOmICwsDDNnzsSwYcNw5ZVXYvDgwYiNjcWRI0fw9ddfo3PnzpgxY4ZP+yUiqk7y8vJQs2ZNDBw4EK1bt0ZISAjWrVuHX3/91T0axpfP+JSUFKxZswadO3fGAw88AKfTiRkzZqBFixbYvn17udX7Utx3gNKOpnXr1mHatGlITExE3bp10aFDB9x0002YN28ewsPD0axZM2zevBnr1q1DdHS0Zv02bdpAr9fj1VdfRU5ODsxmM66//nppjth7770Xs2bNwsiRI7F161bUqVMHS5YscY+s8TXZ97k8/fTT+Oyzz9CrVy+MHTsWUVFRmDt3Lg4ePIilS5cKOYwuRp8+fRAdHY3FixejV69e58yNS0R0ufTo0QMmkwl9+/bFfffdh/z8fHz44YeIi4uTfplOZvTo0ZgxYwaGDx+OrVu3okaNGpg3b577i9je+uSTT7Bq1Soh/sgjjyA0NBQrVqxwP7fZ7Xb8+eefePHFFwEA/fr1E6bxLlNcXIylS5fihhtugMVikZbp168f3nrrLaSnpyMuLg5vvPEG9u/fj7Fjx2LZsmW46aabEBkZiSNHjmDx4sXYtWuX0Kn/zTffuEeXnq1Tp07uvINEVIodQuST999/H23btsWsWbPwzDPPwGAwoE6dOrjzzjvRuXNnAKUdR1u2bMHnn3+OtLQ0hIeHo3379liwYIEmAd5HH32Ehx9+GOPGjUNJSQkmTJjgU4dQeXj88ccxcuRILFiwACNHjrys+yYiqsoGDBjg/nb06NGj8dtvv2HixImYM2cOMjMzERcXhyuuuAIvvPDCBbcVHx+PLVu2YNKkSVi2bBnee+89REdHo3nz5l5PG9q1a1ds3rwZkydPxowZM5Cfn4+EhAR06NAB9913n1/HOGnSJNStWxfvvPMOnn32WVitVrRq1UozcnXIkCFITEzEK6+8gtdeew3FxcVISkrCNddcI8yvTUREWlarFQ8++CDWrFmDZcuWweVyoUGDBnjvvffwwAMPuMt5+xnftm1bfPPNN3j88cfx/PPPo1atWpg0aRL++ecfaSPSxbgU951p06bh3nvvxXPPPYeioiKMGDECHTp0wFtvvQW9Xo8FCxbAZrOhc+fOWLdunZC7LyEhAe+//z6mTJmCu+++G06nExs2bJB2jAQFBWHjxo14+umnMXfuXOTm5qJx48aYPXt2uT43xcfH46effsJTTz2Fd955BzabDa1atcKKFSvcCcbLi8lkwqBBg/Dee+9xGiIiqhQaN26MJUuW4LnnnsPjjz+OhIQEPPDAA4iNjXVPvX0hVqsV69evx8MPP4x33nkHVqsVQ4cORa9evXDjjTd6XZeZM2dK4yNHjkRoaCiWLl2KuXPnuuPbtm3Dtm3bAAA1a9Y8Z4fQ119/jezsbPTt2/ec++7bty/eeOMNfP755xg7diysViu++eYbzJkzB3PnzsXkyZNRWFiIxMREXH/99ViwYAGSkpI02zjXc+Xs2bPZIUTkQVHLO8sjERERERERUYDo378/du7cib1791Z0VegSGzduHD7++GOkpqb6/O15IiIioqqAOYSIiIiIiIioWigqKtIs7927FytXrkTXrl0rpkJ02dhsNsyfPx+33norO4OIiIio2uKUcURERERERFQt1KtXDyNHjkS9evVw+PBhzJw5EyaTCU8++WRFV40ukfT0dKxbtw5LlixBZmYmHnnkkYquEhEREVGFYYcQERERERERVQs33ngjPvvsM6SmpsJsNqNjx454+eWX0bBhw4quGl0if//9N4YOHYq4uDi8/fbbaNOmTUVXiYiIiKjCMIcQERERERERERERERHReXz//fd47bXXsHXrVpw8eRJffvkl+vfvf951Nm7ciPHjx2Pnzp2oVasWnnvuOYwcOfKy1FeGOYSIiIiIiIiIiIiIiIjOo6CgAK1bt8a7777rVfmDBw+iT58+uO6667B9+3Y8+uijuOeee7B69epLXNNz4wghIiIiIiIiIiIiIiIiLymKcsERQk899RS+/vpr/PXXX+7Y4MGDkZ2djVWrVl2GWoqYQ4iIiIiIiIiIiIiIiAKOzWZDSUmJX+uqqgpFUTQxs9kMs9lcHlXD5s2b0b17d02sZ8+eePTRR8tl+/7wukPoqaeeupT1ICKqEK+++mpFV6Ha8bzREhFVBRx0T+ejKEZJlO8ZIgok4t/wqmqvgHpUb4oia6B0XvZ6EF1enp8/sr+hZO0MF1OOLhVF0h3hUm1+b89ms6Fu3SSkpmb5tX5ISAjy8/M1sQkTJiAlJcXvOp0tNTUV8fHxmlh8fDxyc3NRVFSEoKCgctmPLzhCiIiIiIiIiIiIiIiIAkpJSQlSU7Nw6ODnCAuz+rRubm4h6tQdjKNHjyIsLMwdL6/RQZUVO4SIiIiIiIiIiIiIiCgghYVYEBbi42gbl6t03bAwTYdQeUpISEBaWpomlpaWhrCwsAoZHQSwQ4iIiIiIiIiIiIiIiAKVy+Xu4PFpnUusY8eOWLlypSa2du1adOzY8ZLv+1x0FbZnIiIiIiKiakGVvIiIAgk/xyoHp+RFVNV589nj7WcUP8sqmgqH8Aok+fn52L59O7Zv3w4AOHjwILZv344jR44AAP773/9i+PDh7vL3338/Dhw4gCeffBK7du3Ce++9h0WLFmHcuHEVUX0AHCFERERERERERERERESBSlVLX76u46PffvsN1113nXt5/PjxAIARI0Zgzpw5OHnypLtzCADq1q2Lr7/+GuPGjcNbb72FmjVr4qOPPkLPnj193nd5YYcQEREREREREREREREFJpfqx5RxvncIde3aFep5OpLmzJkjXWfbtm0+7+tSYYcQEREREREREREREREFpkqaQ6gyYocQEREREREREREREREFJnYIeY0dQkREREREREREREREFJjYIeQ1XUVXgIiIiIiIiIiIiIiIiC4tjhAiIiIiIiIiIiIiIqLApPoxQkitniOE2CFEREREREREREREREQBSVFdUHzs4PG1fFXBDiEiIiIiIiIiIiIiIgpMzCHkNXYIERERERERERERERFRYHKppS9f16mG2CFERERERERERERERESBiSOEvKar6AoQERERERERERERERHRpcURQkREREREREREREREFJg4Qshr7BAiIiIiIiIiIiIiogClSGLVMz9MtaWqgOpjB49aPd8j7BAiIiIiIiIiIiIiIqLAxBFCXmOHEBERERERERERERERBSaXWvrydZ1qSFfRFSAiIiIiIiIiIiIiIqJLiyOEiIiIiIiIiIiIiIgoMHHKOK+xQ4iIiIiIiIiIiIiIAlT1nPqLzqL60SGkskOIiIiIiIiIiIiIiIgoYCguFxQfO4R8LV9VsEOIiIiIiIiIiIiIiIgCk6qWvnxdpxpihxAREREREREREREREQUm5hDymq6iK0BERERERERERERERESXFkcIEREREREREREREVElpFTAPqvnVGIBjSOEvMYOISIiIiIiIiIiIiIiCkwutfTl6zrVEDuEiIiIiIiIiIiIiIgoMHGEkNfYIURERERERERERERERIHJpfrRIcQRQkRERERERERERERERIFDVUtfvq5TDbFDiIiIiIiIiIiIiIgqIW8a7RUv1/O2HFHVxQ4hIiIiIiIiIiIiIiIKTMwh5DV2CBERERERERERERERUWBSVd9zAnHKOCIiIiIiIiIiIiIiogDCEUJeY4cQEREREREREREREREFJnYIeY0dQkRERERERERERERUCSkey95O8+W53sWWq57Ti1HVww4hIiIiIiIiIiIiIiIKTC4/cgj5Wr6KYIcQEREREREREREREREFJtVV+vJ1nWqIHUJERERERERERERERBSYOELIa+wQIiIiIiIiIiIiIiKiwORylb58XacaYocQEREREREREREREQUApaIrQJURRwh5TVfRFSAiIiIiIiIiIiIiIqJLiyOEiIiIiIiIiIiIiIgoMLlUP6aMq54jhNghREREREREREREREREgYlTxnmNHUJERERERERERERERBSgXIDq4wgh+Fq+amCHEBEREREREREREREFKJ0k5pTEFElMNkpEVo4qNY4Q8ho7hIiIiIiIiIiIiIiIKDCxQ8hrsu5TIiIiIiIiIiIiIiIiqkI4QoiIiIiIiIiIiIiIiAKTy1X68nWdaogdQkRERERERERERER0GXmbp8dzgquLacSvnlOEVQucMs5r7BAiIiIiIiIiIiIiIqLAxA4hr7FDiIiIiIiIiIiIiIiIAhOnjPOa55g7IiIiIiIiIiIiIiIiqmI4QoiIiIiIiIiIiIiIiAKTqpa+fF2nGmKHEBERERERERERERFdRt42xjvLqYwvqmdHQUBjDiGvcco4IiIiIiIiIiIiIiIKTGUdQr6+/PDuu++iTp06sFgs6NChA7Zs2XLe8m+++SYaN26MoKAg1KpVC+PGjYPNZvNr3+WBHUJERERERERERERERBSYVBfg8vGlunzezRdffIHx48djwoQJ+P3339G6dWv07NkT6enp0vILFy7E008/jQkTJuCff/7Bxx9/jC+++ALPPPPMxR6x39ghREREREREREREREREgekyjRCaNm0aRo8ejVGjRqFZs2Z4//33YbVa8cknn0jL//TTT+jcuTOGDBmCOnXqoEePHrjjjjsuOKroUmKHEBERERERERERERERVTu5ubmaV3FxsbRcSUkJtm7diu7du7tjOp0O3bt3x+bNm6XrdOrUCVu3bnV3AB04cAArV65E7969y/9AvGSosD37qX///kLMbrcLsfz8fCGWnZ19we0HBQUJsZKSEq/qFhoaKsTy8vKEWGpqqmbZ6RQTnymKIsQMBvFyycrJ5iA0m81CzGKxaJZlxx4bG+tVLCwsTIjp9XohptOJfZBRUVGaZdl5lF1j2bZksdzcXCFWVFQkxPbt2yfEPDVq1EiIyd4fERERQiw4OFiIZWVlCTFvjlX2weRwOISY7D2TmZkpxNLS0rwqd+zYMc2y7HeqsLBQiMnOkew6ExERERERERERkbfEtmHAv9w4Ac0F30f8/DtjXK1atTThCRMmICUlRSh+6tQpOJ1OxMfHa+Lx8fHYtWuXdBdDhgzBqVOncPXVV0NVVTgcDtx///0VOmVcwHUIERERERERERERERERAfBvCrh/yx89elQz2EE2sMJfGzduxMsvv4z33nsPHTp0wL59+/DII49g8uTJeP7558ttP75ghxAREREREREREREREQUk1aVC9bFDqKx8WFiYdPYrTzExMdDr9cJMS2lpaUhISJCu8/zzz2PYsGG45557AAAtW7ZEQUEB7r33Xjz77LPS2a4uNeYQIiIiIiIiIiIiIiKiwKSq/r18YDKZ0LZtW6xfv94dc7lcWL9+PTp27Chdp7CwUOj0KUuzovq4//LCEUJERERERERERERERBSYLmLKOF+MHz8eI0aMQLt27dC+fXu8+eabKCgowKhRowAAw4cPR1JSEqZMmQIA6Nu3L6ZNm4YrrrjCPWXc888/j759+7o7hi63gOsQstvtXpWzWq1CzOFwaJaLi4uFMiUlJUIsNTVViGVnZwsxWa/eyZMnL7g9l8sllJENFwsODhZicXFxQsxoNAqxoKCgC8bCw8OFMiEhIUKssLDQq5jsuGTb8+R5nQD5+ZDFFEVMpCb75ZIN45PtNzMzU7MsOybZdc/NzRVisvknZddFtj3PumVlZQllZO9d2Xv80KFDQkx2XLLfNc/t5efnC2Vkvy8ZGRlCrH379kKMiIiIiIiIiIiIvFXeo0zEttXy30fgGjRoEDIyMvDCCy8gNTUVbdq0wapVqxAfHw8AOHLkiKbN+rnnnoOiKHjuuedw/PhxxMbGom/fvnjppZcq6hACr0OIiIiIiIiIiIiIiIgIwGUbIQQAY8aMwZgxY6Q/27hxo2bZYDBgwoQJmDBhgl/7uhTYIURERERERERERERERIHpMnYIBTp2CBERERERERERERERUWBih5DX2CFEREREREREREREREQBSVVVqD528MjyuFcHAdchtGvXLiFWUFDg1bpOp1OznJubK5RxuVxC7MSJE17FZIqKioRYTk7OBcuEhYUJsZo1awox2TFEREQIMZPJJMT0er1m2WAQ3w6yepjNZiFWXFwsxM5OoFXGaDQKMc9zLrueFovFq3rY7Xav6mGz2YRYTEyMEPN8z8iuVWhoqBBTFDEBW35+vhCTnXPZe/D06dOa5by8PKFMSUmJV/v0PCZAfs5l9fA857JrEBQUdMH1iIiIiIiIiIiIqCKJ7ZdU9QVchxAREREREREREREREREAThnnA3YIERERERERERERERFRYGKHkNfYIURERERERERERERERIGJHUJeY4cQEREREREREREREREFJlUtffm6TjUUcB1Cu3btEmKHDh0SYjab7YLbysvLE2Jms1mIOZ1OIZadnS3ELBaLEDMYxFNsNBo1y8XFxUIZWf31er0Qk4mMjBRirVq1EmKe+3W5XEKZ4OBgIRYSEiLEZMdeWFgoxOx2uxDLycnRLGdmZgplHA6HEIuIiBBisnOp0+mEmNVqFWJxcXFCzPM9UlBQIJSRCQoKEmKy8yHbnqxcUVHRBfcpe5/K3s+y6yc7b57vUwAwmUya5dzcXKGM7NxGRUUJMSIiIiIiIiIiIqKLpbpKX76uUx2JLeVERERERERERERERERUYUaMGIHvv/++XLfJDiEiIiIiIiIiIiIiIgpMZTmEfH1Vcjk5OejevTsaNmyIl19+GcePH7/obbJDiIiIiIiIiIiIiIiIAlMV7RD66quvcPz4cTzwwAP44osvUKdOHfTq1QtLliyRpmbxBjuEiIiIiIiIiIiIiIgoIJXlEPL1FQhiY2Mxfvx4/PHHH/jll1/QoEEDDBs2DImJiRg3bhz27t3r0/YMl6iel0xGRoYQO3HihBDLyckRYjabTbMs60WrUaOGEIuNjRViZrNZiAUFBQkxGZdL+27T6cR+OaPRKMRq1qzpVSw6OlqIBQcHC7H4+HjNcn5+vlCmuLhYiBUUFAgxp9MpxHJzc4WY7Liys7M1y3/99ZdQ5tSpU0JMdr4zMzOFmEyTJk2EWHJyshDzvDay8yE7zri4OCFWUlIixPLy8oSYqoq905771ev1QhnZdZeRHUNYWJgQk73HHQ6HZln2XpC914qKiryqBxERERERERERVTSlnLdX+UdiVE+y61Le1/4yUf0Y8SNpg63MTp48ibVr12Lt2rXQ6/Xo3bs3duzYgWbNmmHq1KkYN26cV9vhCCEiIiIiIiIiIiIiIgpMLj9flZzdbsfSpUtx0003ITk5GYsXL8ajjz6KEydOYO7cuVi3bh0WLVqESZMmeb3NgBshREREREREREREREREVJXVqFEDLpcLd9xxB7Zs2YI2bdoIZa677jpERER4vU12CBERERERERFVZXEqkKICewFsVIA/ALgCdEoYIiKqOGYVmOwC8pTS+8kvAEp4P6GKp7pUqD5OGedr+Yowffp03HbbbbBYLOcsExERgYMHD3q9zYDrEJLluZHlAvLMdQKI+VoURfzAioyMFGKyPD0mk0mIyfKwyPIDeeYQkuXf8SwDyPMbJSYmCjFZnh6r1SrEEhISNMtHjx4Vynjm9wHk10CW20mWWyckJOSC20tPTxfKHDt2TIh55oQCgCNHjnhVD1k5WV4hz2sve1/JfuE8zy0gf2/FxMR4FfPcryz3kLdk7zfZcck+aDyvX+3atYUysnxBsmtw+PDh89aTiOhSkOVpmzhxohBLSUm5DLUhIiI6F28b1zyfN8XnSGNSFOxrs6Ac0gO1APWFEgAq8IMBygoj8LERChREhzQV1s0q2C3EzAbxuUaF+IzhdGlzqNod2eJ6qvgszzwTRETekN0nxDZIRVZOEZuDdTptO6fJILZxRkU0QOa8P+CMLoHhoBXFD2bBFW6HfksQ9N8Gw/R2JJQSeXaSohJJzm/Vu/m6XKq2zcrlEtudILkPkb8C9D7szxRwATBl3IYNG9C/f3+hnbagoAAPP/wwPvnkE5+3yRxCRERERERERFVRnAr72izothmg/28HGG6NhjEhHsoNIVC+M0B9wQb1VRvUQG38ISKiy0I1q8ic9wdc4XZEjuuHqAfbokbTLgjuWAeGJaFwDMhF0cLjUE0B0MJOVZPq56uSmzt3rvTL90VFRfj000/92iY7hIiIiIiIiIiqmjgV2OCEbpsB2D8Jju3fwbFlDdS+vYBtBijTzVCuDwYG29kpRERE56SaVZR8kQ5XuB3Bsx9F+vo5SN36CQpG3QTlcAhMn0TC2qs21BgnO4WowpRNGefrq7LKzc1FTk4OVFVFXl4ecnNz3a/Tp09j5cqViIuL82vbATdlHBERERERERGdx7+dQfhdAQ5Oguu+UTB06Am143/geO81KFEhwEefQtmvB64PhvptAQpMRxD8fG359EJERFQtlXUGqREuBM9+FNmvP43oYROhWszIfXYElEbRsDz2IpQcPaw310Lh/x1F0cLjCBqSdM7p44jowiIiIqAoChRFQaNGjYSfK4oinf7eG+wQIiIiIiIiIqpsnnABwy70LWvPzpt/v+kaD2CtAuybANeDo2DoMRC6v/cA23ZA/U8bqNHRZ7bwb6dQ8YbS/A7sFCIiqlrUAU7geSegL4uUCGWc0E5JZVP+zfcd7gKO62H4YBSy33kaUXe9hKA1W0rXqRmHglZJ7nXcnULL2SlEFaCK5RDasGEDVFXF9ddfj6VLlyIqKsr9M5PJhOTkZCQmJvq17YDrEFIU8Q9Tq9UqxEpKxA+3yEht8svg4GChTI0aNYRY3bp1hVhISIhX9TAYxFPscGiTocnmAZQlvU5ISBBiERERQsxoNHpVTqfTfijL6nHy5Ekhlp+fL8RycnKE2KlTpy64TwAoLi7WLJ84ccKr9TzPIwDY7WJSUs/tA8Dhw4eFWFiYmDDP85rKrrHs2Pfu3SvEateuLcQ6dOggxGrVqiXE4uPjNcuyc5ueni7EZO8F2Xs3NzdXiMneg54x2Tnz/D0D5L8HsmtARCQj+zy61FJSUqrFPomI6PJSJI/gis4iFnyhBK4HbNA9HAIUlj4DG/Xi3/EWQ4RmuZP1CgCAvtiAkx1GYueY9rhl8FxEZ10HJFwHAFgb1BC3NgfGDhigWferh814duYC1LkyExGZpc/KNSKj4OlYVqgQq9tG0qJS4vG8Zi99dggrMeGFLW0RZjfhgSliQ8ZnpxcKsfyiA+L2OcUdEVUbejGiF9s0g0yxQky51Ym89w8i+Jna0B83AQBCdGL7YoKqbXf6T0xpWUVVUBDeG1/MGIixTy5C6106oPZVAIBVEbWxPyQJ99QbpFn31xE2/G/BPCjrChG5p7ROVoPY1mVSxM/x5NBCIXaiQNsWd/Lf5kudQ4dm73ZC6JFILM9fJqyXU7BHiAFOSYyqAtVV+vJ1ncqqS5cuAICDBw+idu3a0j4RfwVchxARERERERFRVaU+b4P6QAl0I1oCta8HIv6N68Uvp7kM2s6ZAktzAEBW03js69sc/W6fi+h9GV7tt8axKEy5bxg29NoBVVfaSJck+epsUZrYIVTTJmlRsWm/pKmWlDbCfZd0Er37fYOVy3t5VS8iIvKPo38ebO+nIXTMlVCD+sFVo/TL1g692HFkc0VrlnMiSzuE8qKDsfaeqzHq8SVovUn88rOMOTcINw0dhp3DfoPTVPrlgBCj2Jht0Um+DF8ilrPlar8QkfPv99RzGmRi7bJPccOA4cDfXlWNqrIqNELozz//RIsWLaDT6ZCTk4MdO3acs2yrVq183j47hIiIiIiIiIgqAfV5G9QHS6Ab3Q6u2SuAvQegFBQAAJyKOPq/WGfSLB80xAAA9MVO9Bs0F1F7MgAfZuuJPxGBwR9f417u2uKIUGbVH3WE2G3x4uwNarZ2Zgk1v7SDyKZ3YEDvNejd7xs0njYKpnzJCCkiIroojv55sH2YipAx7VA4bj4AQJdWOtuMS5F8wUAN0iz/YSm9eSgqcPeji9D0p/2ygUrnZM4NwpXvnrmfJASJHT0RRrFD6Oa64qxBG45pRzR9m1r6fxUqfpu0BmuWzYX+xgToDpmEdan6qEojhNq0aYPU1FTExcWhTZs2UBRFOnOKoihwOn0f9cYOISIiIiIiIqIKVtYZhHuuhOuDFVA+mgddyivubD5mozg1c7ApTrPcJ7THpa/oRbI4DVi2sgcG9F6DbxbOR68hd7JTiIioHJV1BpkfaIaix+dDf/AYQkc9C8VR2nAcZagnrFPXVUez3KdmkFCmslGgoN0Lpfe93d/8jpBeddkpVJ2p8H3ETyWdffbgwYOIjY11/7u8sUOIiIiIiIiI6DJRhzqB9xzAv21WKooBBUCOAtxzJfDB11A+1nYGVTVlnUJNmnzHTiEiIj+pVzngWpIPRJS2aucj2/0z873NYH98MQwenUFVTVmn0AH7PuR/c5CdQlQlJCcnS/9dXgKuQygxUUw6abGIfziGhorzGhuN2iH2ERERQpmEBDGxWkxMjBAr66U7m91uF2I63YXH5xsM4mVwucQuTdkQsIJ/pw84W1SUmPhTJicnR7NcVFQklJENRzt9+rQQy8gQ56UuLi4WYvn5+ULMc93s7GyhjOwa22w2IeZ5jQH5+QgPDxdiZrNZiHkeq6z+smssq8epU6eE2B9//CHEZO/doCDtNzNk7zWTSbzh6fXieF5ZfWXvN9l18Nyv7PdF9juam5srxIiIZPeY6iwlJaVcyxERUcVSJI/buuFmON/Ng35kOJSdpT83GyMAAGpEIxQt/hTG2UtQ/40/oIRpc+y0knyj+9ba2r/j+3QW8zsYa2qfc0Y0LkQwQhAXrE0gflObxsK6avCVQmyA5HnFKXvu1Xscv8czhxnAruK+GGCZjO//mY2aaukz9hUnSp8dWmZE4vUNHWB06dDtpZuEzX+fM0PcJ5OFE1G5knXLX/5nGINe/NxteF0X7FnyP9R6pRMiVpc2GEco/+baUaKwffbDiDiYhQHjNkEfcqNmXYtePK5eNQo1yw2ixanbElpr2w3TmjWBPTIcg688oImPbiW2T+murCPEXA3F+xqCxHwowwzatq0Rf+4Uysz+7WY8lvELPv9lPxqfjgAAbD9c2p5rSA9CnXFdYMi2YHvBUmFdu0Nsr6PAo6qlL1/XqYyWL1/uddl+/fr5vP2A6xAiIiIiIiIiCjTqUCec7+ZBd1cDqFc+APWq0gYzuz4IUAD7Hf1gnL0E5snvQDGLHTFVkQUmLLM9jxWGX1CC0i+fqX/+ChXA9P/8hWE3bcS8/3Wt0DoSEVU26lV27FnyPyS9fC2cwQ8jY0Tpl4jzldL7Skb3xgjedwqt7/4M+qDqMVpGgYI3vuuA648kIsdcmrMu5cvSZu+sAfuw+6sVaHxzX0D8Xj1VEVUph1D//v29KsccQkRERERERESVkHqHE3jfAd2o+nClrICSmgZlV+loHlVXOoLHPHkGjLMXV9lp4s7FAhNuc5xJPK7+XTpLw40Ha6Ln7asw7KaNUF/qD8V14dk3iIiqOrW9Hc6v81D7peuQ02067DXCEfLzfgCAE6Wz1dRY9ifqvvUddI5K2tp9iShQcNPB2u7lGYtK769RXzbA/jlrsPv/VkDtBii5vJ9USS74nkOokv6KyGZyKk/sECIiIiIiIiK6lJ53Ag8ZgPhboRQWQt97MJR/H/aDTNEVXLnKKabIgtWLbkS9+75AsyaZCP5bnLadiKi6cT1igzLbDOsfvXH86Tpo1WYCDLmlKRWilbAKrl3lpLPrUX9kD/z93WKoNzmgLAy68EoUcKrSCKFLjR1CRERERERERJeSDsAxBWiuA06muTuD6PxiiiwIchig8svcRESldIByTAfoFOjzi92dQXR+OrsehlNBKNHlVXRV6BKpSjmE3n77bdx7772wWCx4++23z1t27NixPm8/4DqE6tSpI8SCg4OFWFxcnBAzGo2aZbPZLJQJCxN702Ux2bqyOfscDocQO336tGb52LFjQpnCwkIhJtunxWIRYnXr1hVisqFm+fn5muXc3FyhTElJiVfbksXsdvsF9yljs4k3M89zdi6hkgSnISEhQiwiIkKIeb4/ALG+er1eKBMVFSXEatSoIcSKi4uFWGZmphDbv3+/EPPcr9VqFcrIkrPLzuWpU2KyvLS0NCEmu36eMdn5kJ1vf+azJCIiIiIKHJK/i61nnsvylQOwWOJhMMWixBCMiOCG7p/Vg5gvKNkQIcQeayo2Yl05TPuMobSS5B46pX2W0kUEAcEWqKHNNXE1JkZYVTWLz5t+04m9OmqQ+FyjPHCrNmBZjFmDs9AqVRuu+Y54rBm5v0l2XElbe4iokvF2wk7x8977eadkn0fa/SqK2DZVM6yT+9/pxt9gtkSiQ0QUTur06BUb7/7ZiIYnxdrqxLoZ9GIstqX2fqJPkIyiKdbmI9JZ9TDGGhB2jbYtTmnTQFjV1aypEFMNkmZpvSTm0ebo7PAfoYjSoJ4Q+6Wm9p7QrYkOhohuaJrYRhN/77jY4O5wZov1ILpMpk+fjqFDh8JisWD69OnnLKcoSvXoECIiIiIiIiIiIiIiIgIAuJTSl6/rVEIHDx6U/ru8sEOIiIiIiIiIiCotp8JRPkREdPFUPe8nVVV1yCFUNjuUolxcRxZn4iUiIiIiIiKiSqmLsyUe7fsrcs3idOZERETeujajFn55dANyamVVdFXoElBVxa9XIPj444/RokULWCwWWCwWtGjRAh999JHf22OHEBERERERERFVSvNsTyDUZkTfEd962SnEb38TEZHohb87ov7qplj2+RwvO4VU8J4SOMpGCPn6quxeeOEFPPLII+jbty8WL16MxYsXo2/fvhg3bhxeeOEFv7YZcFPGJSYmCjGdJDmlw+G44LYMkuRlkZGRQsxsNguxnJwcIVZQUCDECgsLhdju3bs1ywcOHBDKyOofFhbmVcxkMgkxm80mxNLS0jTLLpf4W6DXi8ny7Ha7EDMaxaR3spjVKiYN9SS7LkFBYjK7kJAQr9YNDQ0VYrLz5s37SPZeKCoqEmKy8y27LrJzvmvXLiHm+d5q0aKFUEb2uyF7T8rqJnufys6H5/uhuLhYKJOenu5VPYiIyD8pKSnlGiMioguRfXtU+7eywRAulLAaY9z/LlQOw6wPRz19I6QqMbjGeN2ZnzmdwroNwsTnsEb1M8RqtGuvWXQl1xbLNNFuS7XEQNXZ4LImaMvJEnlXADVI+8xohhVfRr6OAeFT0ffpbViZ8xzCVCtW/fijsG6nk0dRsjIN+i+tMDwXAQUKioqPXa6qE1FAkzX8yz7/xc9seTkZsZyiaNvOTIYooUxX85Xuf2/U7UesoSY6x+Rhjd6FvonZ7p9FRoltO0FxYn1NzcR7llKnpmZZTUoQysCjnUiJrA2ExkLtfbV23TBx+6rZIm7PW0L7lNhepcbFCzFXr+uE2NZdiRhn/Apfrf8U3+5+EPVKorG9+wih3CZlLpzLc6FkKdANCYNSosDh4MgiuvxmzpyJDz/8EHfccYc71q9fP7Rq1QoPP/wwJk2a5PM2OUKIiIiIiIiIiCotC0xYlvMkwlQreoe/iFxFbPQ8kZCDkjWp0P1khmNwARwvZUPlN7uJiOgsChRMP9of/bNb4PrG7+GAKVMo4wgpgfPrHCg2QE10wfVFLlQT7yeVnar6MUIoAC6r3W5Hu3bthHjbtm29GhAjww4hIiIiIiIiIqrUPDuF8q1nZis4kZCDe99cAt3/rDCOjoa5ZzwcgwrgeFqc2YOIiKq3szuFrmv8LoqSs90/c4SU4K8ly6DkK9ANCIe+VzjUeBdcc/IqrsLklaqaQ2jYsGGYOXOmEP/ggw8wdOhQv7ZZOcaEExERERERERGdR1mn0K3hUzHmtS8x44lbkBtmw71vLsG1m+rj/x7LggIFyn4jjCkRcI7IByZWdK2JiKiyKesUUqDg/f8tRqubboMx04q/liyDvsAI3a3hUGwKYFOgfyAUznXZ4LiKSs6lQHX52MHja/nLZPz48e5/K4qCjz76CGvWrMFVV10FAPjll19w5MgRDB8+3K/ts0OIiIiIiIiIiAKCBSYszXkSPfL/iwdfX4asqEJcu6k+nninC5bjqzMF/ZtFhYiIqgkFCqYdvRlLfs3Dn/9bDNPJEBjyTGg2tB9+sX1+piDvJwFBVX2fAq6yThm3bds2zXLbtm0BAPv37wcAxMTEICYmBjt37vRr+wHXIZSQIElqJpGVJSb6cnok6wwKChLK6PVi8s7i4mIhVlBQIMQyMsQkn6dPnxZiR48eveB6ISEhQsxutwsxm80mxGTHLjuG7OxszbJOSNIG6VyEsnrIYlarVYhZLGISuUOHDmmWTSaTUCYqSkyqFx8vJoyTkR2X7PzKeL5nvH0vqJJPlJKSkgtuHwAiIiKEWGamdk5T2fmWHaeM7JrKfhdk5cLCwjTLsvNYVFQkxPLz872qGxER+SclJaWiq0BEVIVduLXA5RKfy4J0ke5/K9DBrAvBXuc+lKgR+M7+vftnEbpEYV1rTgMhZggW66E2qK9d9iJpt6o3ANABSuA0B6jh2gTlZgBrE57DnTGzUNcRg6ltB0OZo+DTgaHuMj/U3IG11m3YpWifpVRVvFZEVB15jgyQfdbLYrIRBWJ7jKKI7YuqKrYBea5rNoYLJVpEntnn7yYgIQjQKaVV0evO1DH8arEdTnW4xLq1qi/EXDVraAMhoUIZYdumMMBgAiIitXGj2K5XEdQg8Xy4GorHfqRoIJ7CKuyrl4kFuwchaLERt91yn/vnOSHp+E6ZC4eivVaqKrbzUcXxZwq4yjpl3IYNGy7p9gPnL0AiIiIiIiIiIgAW1YQlGQ9XdDWIiCjAKVAw9VCviq4G0WXDDiEiIiIiIiIiIiIiIgpIqh85hHzOOVRBfvvtNyxatAhHjhwRZqBatmyZz9tjNiwiIiIiIiIiIiIiIgpIZTmEfH1Vdp9//jk6deqEf/75B19++SXsdjt27tyJb7/9FuHh4hST3mCHEBERERERERERERERBaSyHEK+viq7l19+GdOnT8eKFStgMpnw1ltvYdeuXbj99ttRu3Ztv7YZcFPG6XRiH5bZbPaqnGesuLhYKJObmyvErFYxCZnBIJ462fYyMjKEWHZ2tma5qKhIKONyiUnfjEajEAsODvaqbnq9mMwuLCxMs5yfny+UkR2T7NzK6ibjdIoJ9Gw2bVJPk0lMPic7Ttl1DwoKEmJ5eXlCTHadZRwOh2ZZdh5l+5Rd0xMnTggxRRE/eGTn1/P9IHt/yGLR0dFCTHadCwoKhJjs2nseqyrpSvf2/UxEREREFLi0f9+qLjGx9JGcjWdKuwqRXvAHjI6ecDptyCs+7v5ZvnJSWLehpa5XtVA9n/0kzxJVgl58xlWjooTYrc+euQ62mg5sT3bheFCypkxu4R7JDgLgK8JEVM78/b2XrSe2damqrB3Ev8/oowVn2o6KHAqySxREhRRCr3MhPuJMm5fjiNiOY2gUIdYtUjKqIEwbUyVtc1A86q8zAooeqtly/gOoRFRriBhLqiHE5g9f5/73zoRsdDO5UGJK0JQpKhbv37L3Al0eLpcCl49TwPlaviLs378fffr0AVDaZl5QUABFUTBu3Dhcf/31mDhxos/brKJ/LRIRERERERERERERUVVXVaeMi4yMdA92SEpKwl9//QWgdMBJYWGhX9tkhxARERERERERVSkmlx5Hg/KghvLb2kRE5D+TU4cioxOuuvaKrgpVQ9deey3Wrl0LALjtttvwyCOPYPTo0bjjjjvQrVs3v7bJDiEiIiIiIiIiqlL6pjZA47woFH51hJ1CRETktwYZoRj9U0OUrE5jp1AlVlVzCM2YMQODBw8GADz77LMYP3480tLScOutt+Ljjz/2a5sBl0NIlpPHbhd/Gb3JwyLLkeKZ3weQ50SR5Y3xzIUDyHPVeMZk+5Tlx4mMjBRiISHi3JeeuYEAeY4fz/PhmS8HkOfMCQ0NveC2AHleGtn58Lx+sn3KyPIRyeohe3/IYrJz5JkjR3ZdLBZxrlRZnh5ZfWX1yMrKEmKe+01LSxPKyOovey/Ifjdk196bPEiyuspyWMnqQUREl19KSsp5l4mILo7soVqci0ORPIaqEP8eDSSqLGeAqj0mVXXC4bJBVe0oduS44xaj+JxXO1jM3RDUNVGIOSW5daoLNUjM9avWr+X+txnA0oyHcbU6A4Vr8pHyyGBYC8y4Zeu7wnoul/j8RkQVqbwbaS/1vFDe1leSV8jjXlFYIrZ7His403ZU6HAhu8SJX0/GoMihx5qDSe6fDeuWKtYsQmw3dEnaEoWcdJ75ggAxT52sTABSY2KEmD337Guq4OVP22FTx0jsX/sPBgweifCjUZh54j1xPcdpyR74pYTLwZ8OHn87hN5991289tprSE1NRevWrfHOO++gffv25yyfnZ2NZ599FsuWLUNWVhaSk5Px5ptvonfv3hfcV9RZORN1Oh2efvppv+p8tqrxm0tEREREREREdBaLasQzTwyEtcCMlLc+R2Gw+KVQIiKiC1Gg4JpJN6L+6qZY9vkc5NQSvyBNFculKn69fPXFF19g/PjxmDBhAn7//Xe0bt0aPXv2RHp6urR8SUkJbrjhBhw6dAhLlizB7t278eGHHyIpKUlaXsbpdGLJkiWYPHkyJk+ejKVLl0q/3O+t6vt1IiIiIiIiIiKq0kwlBjzzxEC8/NoSpLz1OdRrVSh5lX+KGCIiqlzKOoUAYNnnc6Beb4BykE3rlYXqUqC6fBwh5GN5AJg2bRpGjx6NUaNGAQDef/99fP311/jkk0+ko3c++eQTZGVl4aeffnLP7lSnTh2v97dz507069cPqampaNy4MQDg1VdfRWxsLFasWIEWLVr4fAwcIUREREREREREVVZZp5DRroc6QZzqnYiIyBtlnULJGxvC+X5eRVeHyklubq7mJUszA5SO9tm6dSu6d+/ujul0OnTv3h2bN2+WrrN8+XJ07NgRDz30EOLj49GiRQu8/PLL0tQiMvfccw+aN2+OY8eO4ffff8fvv/+Oo0ePolWrVrj33nt9P1iwQ4iIiIiIiIiIqjhTiQEtfq8NhF/qXCJERFSVKVCQ/H0DIEySE4oqjKr69wKAWrVqITw83P2aMmWKdB+nTp2C0+lEfHy8Jh4fH4/UVDGHFwAcOHAAS5YsgdPpxMqVK/H888/jjTfewIsvvujVcW3fvh1TpkxBZOSZnJORkZF46aWXsG3bNq+24SngxrXJTq4sYb3LJf5S2u328y4DkPYAymInT54UYqdPi4nD8vPF5JSeMVk9IiIihJjJJCYWtVgsQqxs+NmFeO7X4JlADkBQUJBX25edb1ndFEUcimc2mzXLsh5SvV4vxFRV/EO+oKBAiMnqKzsumaKiIs2yZ10BeX091wOA8PBwISZ7f+Tk5Agxz2MIDQ0VyqSlpXkVk11n2XHJYp51k81XKVtP9jvq7TUgIiIiosrI2yk2JH/HV4nkyp7PIuL5UNWzj1MFVFfpCzjzfwCKJCm3SS/ZXobkm8iq53NYNfrOp2dycwCQJEoPN5557jXrXLAYoxAe2lBTJi1ni2QHVeF9ShSoZB23svtOZeng9b8envdEl0scxfiP65D733kogEPNQrZdD5eqIKP4zH026/sSYd2YuyRthJJ2IYHsM7YqkB2XcC8FDKHiNf01J9P978zCPCjQw6gP1pSxO8S24cr93q06XPA9J5Dr32tz9OhRTdulrG3T73q5XIiLi8MHH3wAvV6Ptm3b4vjx43jttdcwYcKEC67fqFEjpKWloXnz5pp4eno6GjRo4FedAq5DiIiIiIiIiIiIiIiICABUVYHqY4dQWfmwsDDpl9k9xcTEQK/XC1/AT0tLQ0JCgnSdGjVqwGg0agY7NG3aFKmpqSgpKZEOAMnNzXX/e8qUKRg7dixSUlJw1VVXAQB+/vlnTJo0Ca+++uqFD1KCHUJERERERERERERERBSQVNX3EUK+diCZTCa0bdsW69evR//+/QGUjgBav349xowZI12nc+fOWLhwIVwuF3T/jlDbs2cPatSoIe0MAkpnDjt7li1VVXH77be7Y2WzZvXt29frXERnY4cQERERERER0aV0UgGGuYCV6VA7tIXaqAGUPfsqulbVSl6oDT9dvQ/65eU3DQwR0eVmSAtCbt+jME49jbzoYOzpVA+NfjpQ0dWqVlS9C6du2wWkidPiUsW5mBFCvhg/fjxGjBiBdu3aoX379njzzTdRUFCAUaNGAQCGDx+OpKQkdx6iBx54ADNmzMAjjzyChx9+GHv37sXLL7+MsWPHnnMfGzZs8LlevmCHEBEREREREdGlNMQAbLTDpX4O5ZNWcK7/P+i73XzOTiGXTsH6l/qgIC4ENz24BIZiMXcneS8v1IbH3lyEuPQw5EyNq+jqEBH5LW7SFTi6YCOW//dN9J+ciE/fvh3Dxy46b6fQ63U647MaLbHi9wVILJbkoyOvqXoX9n60CrYG2TD3iK3o6lAFGDRoEDIyMvDCCy8gNTUVbdq0wapVqxAfHw8AOHLkiHskEADUqlULq1evxrhx49CqVSskJSXhkUcewVNPPXXOfXTp0uWSHkPAdQidOHFCiNntdiFWXFwsxBwOxwXLyGI2m5jQ7dixY0Ls9Gkxcdi5hn6dzeBNMjdo5w8sk5+fL8Q8j/Nc9Sh7o5Y5ey7DMrJzK6tHUVGREJMxGsVkdhEREZpl2VC3s4fJlZFdq8LCQiEWFRUlxHSSJHIFBQVCzPPayM5RXp54M5UdQ40aNYRYRkaGEPvrr78uWI/ExEShjOd5BOS/LyUlYpJBi8UixGrWrCnEIiMjNcunTp0SyqSnpwux1NRUIda6dWshRkTVi+yzvWzosz/lSCslJaWiq0BEVYo336CUJaAWEzVXTbL70lnHfhJAVz2wsQTqpieB2XY4138FXNcT9oPa50hVp8NXL9+ErCtrwpRViC9mDcLVdy6AK0d8/iGtEnsRHo3/Av+YzjwHFbxXgJPxeWi0Pwavv9gT1xWuF9ZTFPE5VVV9n4KFiLxRFe8nsmPy9nlFW051iW02R2xbzizYANwagoylBVh501jEPnUKn7x1N2oPewedT8YI635sboGpyZ3R5chuXN9qGNZ+PhU1m4jtXwgK0tZDL2mrlLSlBRyX5H1UIrZ9/r0tBrOH/orN/znsjh0YqMAeaYOiKvhP3zvwR+4PgMfto6hEbDeUP7ryHlPeXPD9U8LfT5UxY8acc4q4jRs3CrGOHTvi559/9nNvQHZ2Nj7++GP8888/AIDmzZvjrrvuQnh4uF/bC7gOISIiIiIiIqKAc1IBrjMDG4qBTc8CswFsWA1Xj8HQ7Sn9Zreq08H+wevIurImWqW8DKcpG/vuS8GP84eiaOtUBDnERisqVQI7BiW9j1R9Dsae7u6OH/v6KEx2Pbr+VA9GB6f3IaLApxTpkDykGw4tXI/TQyehxtPAkXkPY8vzn6L9b3vd5RYM6YrPruqCT/43ERnWXxBe/BJuGPwk1hf+gESnd1/sro5UqHjn3k1YecM/ePDjTjD8e+/44rAeUBXErK0HY474xWqqWJdryrjL7bfffkPPnj0RFBSE9u3bAwCmTZuGl156CWvWrMGVV17p8zbZIURERERERER0GSgnFahlnUI/lnYKlaxZBFP3gVD2HYL9g9eh/qc1Wrw0Gb98MAuqouKKp4pxaOgU3HLrWPzfkrdgdnL6OE8OODFIl4JUfQ5WHXsUka5g98/+Wh987hWJiAKUrsiAOkO64fCCfzuFnlLwzGt345Vn5qDd1n34bNC1mDf0Onz6vwkYc+N7yLIUY9yWseh4/G10a9oDG1JXI8EpzohEwLPBC7Hyhn8wa9xAJB87M1PO99svPAsUVRyXCrh87OBxBcDEI+PGjUO/fv3w4YcfumeQcjgcuOeee/Doo4/i+++/93mbVWCsHxEREREREVFgUMpGCt3lBN6fAN1Pv8J51xCoyTXhGnILTD3vwKEhq9Dw/fa44r83Ys+D63D1HfPwV0xNbE5qUNHVr5S2Yx++xx9CZxARUVWmKzIgeWg32GsWwHBqGe5csAELhnQFAHwy6gZMfmE+tiStwZWp0fh2YW+83Hk73lv1CWKdxfgiuG7FVr6SKoYdU61f4q3/3qzpDKLKr2yEkK+vyu63337DU089pUknYjAY8OSTT+K3337za5vsECIiIiIiIiK6jJSTSunE9TpAOZEK6JTS3AxOJ5TUdKg6FUGpYQg6GQroVBjzSxBeXASXJK8eAS64EAwLO4OIqNrRFRmgP20GdEDsqRz3fUJVlH+XgcS8YNTMs5aWh4oEZ2GlzshUkdR/czrFZYRUcE3IV6UjhHx/VXZhYWE4cuSIED969ChCQ0P92mbATRl37NgxIZadnS3EZAmoTSbt0D6XJJFYbm6uEDt9+rQQy8jIOF813fR6cY7is3v0ZPUCAKdTTC4mixUViXN+yo4hKipKiFks2vkug4PFP55l58hoFBNuyvYpS/jtuU/Z9hwOcQoE2TXIy8sTYjpJgjtvz6/dLs7H7bk9Wd1k+wwJEW8cspjsfVRYWCjEIiO130qQXQOZ4mL/E8/Kzlt0dLRmOT09XShz4sQJIeZtfYmIiIiosvLmiZkJkrXEc6aqHsnCVTuczgLA6YCzpPRva1vJSWQ4TMgqzoFiM6DElYuVBZ/BkD0Wb38Zj6U/nnleeG+Y9nlCjY0Xq1EVkoB7S/LcoVe010GvMwtlVJW5mYguH8/PRllHd6DdT8qvVVmVHHuB7bgQ2+tc7/53sSsPJ4r/wIY0E44V6vH+XivsKvDFYQui95uRFwL8/W0YMAb4c3U4lHtKgPwCKOmnzuzXMzm9QdZk7BHTueSXrzKT3RM1x1raDhoWVIwIu7ZspqJtgy2xi+2SUNnVRuVr0KBBuPvuu/H666+jU6dOAIBNmzbhiSeewB133OHXNgOuQ4iIiIiIiIiIiIiIiAiAX1PABcKUca+//joURcHw4cPdAxWMRiMeeOABvPLKK35tkx1CRERERERERBWhbEIJvb705RkHAP2Zb56rusrfcFFRnHBBhQol4L6uTkRUDv69V6h6BapS+gIAl047YqVs2cksIufl0gfAXGKk4YICl49/A/ha/nJzOp34+eefkZKSgilTpmD//v0AgPr168Nqtfq9Xf72ExEREREREV1uGwHMcgE/fwfccxcwfy6wYSNwpwvOTkXQ/WqB7h8z1CgnSp7MQo3Nh7H5hR4oiva/AaCqqo9EGKHHU1GL3PkfiIiqC933ZjheykHw0X3IbJOEtUtGICg9HwXxf2NJvx1o+0cSwnMsqH8gGilPrcW1uYfxWo122BEUU9FVr3TMMOIqR2P895GNKDYE2tSF1Zuq+veqzPR6PXr06IHs7GxYrVa0bNkSLVu2vKjOIIAdQkRERERERESX3806wALg7i+Bxx8Fjh4FFt8KzHTBclsN6P8wQ3fcgKDeSbCPyUbwiacRtTsd//tiODuFPEQjHOtcb+LzkF/wVNQiFCjF7lehxY5io5gLloioqjA8GQHdT2ZsefVVdHr4QyhOF65MeQnffzIbD3/QGT02NIbRqcf742/F3voZ2Bz6FMakbUW3JgPxV1D0hXdQjShQ8L/855EVbsNDz61GbnAxCs12FJrtcFrtcAUx51xl5VIVv16VXYsWLXDgwIFy3WbATRl35MgRIRYUFCTEwsLChJhn75nTKfb0ZmRkCLHMzEyv6maQJFwrKioSYmazNomlrFdPVv/oaPFD2mQyCbFTp04JMVXS5elyaYeNyuovq4e35WQxz30CQEFBgWa5pKREKKOTJH2THZPsfMjWtdlsQiwvT0wGl5WVpVnOz88XyoR7Jt6DeI0BoLi4WIiFhIQIsUaNGgkxz/oeO3ZMKGOUJFAtm1vybLLfF9kxRERECDHPY5BdT9n2ZdeFiEhGUbz7g0xWTnZfqM5SUlLKpQwREV0i+QrQWwesdAEDZwOL5gBvuoCbdSjZmAfg3+eT3wHlBgt2ffsTOs8fj1DjNKxdMhz33fUpdAe1z8euMPHvetVs0Qb0QpEqoQGS8O3xJ9A98XW8EbHqzA/+B+icCsa+0R39vroCeUVim0JZEnEiuhwqfwPspePnsati206xXdtepd6twvVpMDY/819EvvgpfnhnG6InNkfawmsxw10qHO373oU/fvgYqu1uPPTn67i+2QCsX/kWWhgOaXdQv65YD6NH247BCeidgL3k/OUqE0k7FjymY41AKNav7YHeA1bjisWzheKtZ3fAtSm9cMgZKfyssFhsr+M9hi7Giy++iMcffxyTJ09G27ZtERwcrPm5rP39QgKuQ4iIiIiIiIioSshXgN56YKUTeEsF+uqAb3XCXB7KDj3uu2soZn3yKTrPHw9gGmZ9MhwPZC9CnL2wQqpeGTVwxGPPkSnI1535Qt2m+/dhf8N0vPDKl6WBLRVUOSKiS0hRFcSOvQIZb29D+txfEfNYa4TNrgt4fF85KDMY67++Gd36/B+Ax/HQ36+jW+9HsP7g/6GFzbsvxFcHEcVm/PD5TcgxnxkR9NysJBTGFmD5nPlw6V1QxzBvXWWi+pFDSA2A69e7d28AQL9+/TRfjFVVFYqiSAe8XAg7hIiIiIiIiIgqSr4C9NQDNQAcOHfDROKeBNx313BNp1D3roOxbufn7BQ6iwkGRLnOzMQQlheEK35PxpTxt+G/0xbD9YcRui8q8bfXiYj8VNYpFPFuA5h2nXvUQJzNKnYKtRqA9XuXsVPoLHpVhyjbmR41S44VlhwrBgwahWVfzEbJCxZYJyVVYA3pbP7kBAqESUY2bNhQ7ttkhxARERERERFRRSpSAC+mh/fsFIpq/xa6N2enkDda/JWE/kvaYmG3rQA7hIioilJU5bydQWXKOoW6914O4HE8lDEb3RoOwLq9y9CSnULnFXY8Ap1f7oE1o/8HsEOo0vAnJ1Ag5BDq0qVLuW9TTK5CRERERERERJVSWafQpjt/QpPCx9CiMAPdmw9GulHMTUtaemflb/ghIrpc4mxWrFvZDzuiMrHbMhZjMrahe8MB2GERc5iTls7JJvXKRoXi1ysQnD59Gq+//jruvvtu3H333XjjjTeEvPe+CLgRQunp6UKsVq1aQsxsNgsxnU77y5qfny+Uyc7OFmJ2u12IGY1Gr9Z1OMTEbxaLNqmnbFuyWFBQkBArKCgQYrm5uULMYBAvtWcSKhnZPmXntqioyKtyERERF9ynS5LgLSQkRIgVFxcLMb1ezJBaWCh+U072SyMrZ7PZNMuy61lSUiLEZOdbdj5k762oqCgh5klWf9k+ZduyWsUHxYYNGwqx6GjxDwDPc96oUSOhjOw9k5GRIcSIiMrb2fPpAqVz6hIREVV+4v3K5RKfdV459vWZhWOAsU9dzFizAQ9sHAZHjRm4Pqk/vv1rmTBSyNWquWZZCbIDOhfg8ni20Qdc84BAjRATfCcEnzkfIUY7FKceep32mdzpzLvkdSOiMvwbXevC50OFJEeIKsYO5YhTS522HhZij352zVlLYXjnywF4+MNlQOEojPnzdXRvdjPWH/gSLYu0I4VcSYnaDQXbAGs4FI92vEp9hXWSjhyjOGpU16W5EOuz+Eyb9KbIYqwGoPMYayHLKVSpz0cV4lJLX76uU9l9//336Nu3L8LDw9GuXTsAwNtvv41JkyZhxYoVuPbaa33eJrsziYiIiIiIiAKMYacV/3u7G2Z23YmmJ8eg2clj6N7yDo4UIiIin0RnnxkptCv8cYz5ewO6NRqIHUEcKURU0R566CEMGjQIBw8exLJly7Bs2TIcOHAAgwcPxkMPPeTXNtkhRERERERERBSAWp6I1HQKtSg4dd5OoQOKFX/rQ6Hn95WJiOgsZ08ftyv8cYxJ//28nUKnFBM2m2J4P6FKoyyHkK+vym7fvn147LHHNLNi6fV6jB8/Hvv27fNrm4E/JpyIiIiIiIiomirrFLpp7HqMyRwPYBquazUUvbNKGwlUSwwA4IRiwZfGGrjdfgLDcaICa0xERJVRWadQ997LoahjMSb9bXRrNBDDM/+GAkD9N51DnmLEZ0G10ankFCbZ/WuQJipv/uQECoQcQldeeSX++ecfNG7cWBP/559/0Lp1a7+2yQ4hIiIiIiIiogDm7hR6ciPGHB+PVgVP4aSpLA9r6cQgtV1F2J6/EQ1dBVCDOK0cERGJ3J1Ct64CMBZTjr2MP63xpT9USu8nVtWBb7K+Q0d7JhAeXnGVJTpLVc0hNHbsWDzyyCPYt28frrrqKgDAzz//jHfffRevvPIK/vzzT3fZVq1aebXNKtEhZDabvYoZjUbNsskkJg1zOsWkbEVFRUKsuFhM8ikrZ7fbhVhubu4F9+lZBgB0ksRnDodDiMmOS7bu2UPNzrUtzwTdABAWFuZVPVweSeUA785vSUmJV9uXXWOLxSLEZNdAtm5sbKwQ87wOsmOSxbw9BpmIiAgh5nnOvT3OyEgxqWpiYqIQk71nZO9B2fvBk+f7CpCfbyKiS82bzywASElJubQVISKiAOLvN0XLu0VBfMbQKUYh9uqaRprlRVlGDJywCvesTMfIjQ0AADG3lD7nWJwGxJaUdgS5ulwlbEsNC7BGPclzGCTPXBGhhe5/W8x2qAUuuFzi8xoR0aUny9wh+SzzinjfUV02IZZnOybE3t0VJcT6f3h2O2c4Vu7pjF4PrIPz9P2YPO8KKADM7RMAAHpVQQ1bCBQoUFs3FetRq7ZYXUm7ZIWQ3DtUg9g8rgYFCbH/NDru/ndaYhaMsKKmvo2mTCb+hEh27GL7KF2cqjpC6I477gAAPPnkk9KfKYoCVVWhKIq03V2mSnQIEREREREREVV3zY5EYenEGzH42TWYOnib8PMBJxrh+V2d0bIC6kZERIEjLt+Cb2Z2R797v0XjF74Sft45MwkT/umM69EESgA0qlPVV1VHCB08eLDct8kOISIiIiIiIqIqoumRKPxx32D3ctzQ0ql+Tljy8GrDn9GxyzzMKYrBQHvniqpihTE59FAbOaEaVCgONmASEZ1PXL4FP0/r7V42X5MEAMg1FGNGvd8xuP1yPFhgw8TTt1RUFSuMyaGDI74IjggbDNniLD5E5SU5Obnct1lJxusRERERERER0aWSaAvFWztuwMATjbFPf7Kiq1Mh7lzdGAhR4VqQD9UQAF8LJiKqhMIcZjyzpyOe3n0V9hhTK7o6FeK6vxJh3RaD/V9+A0eEOFUfXX4uVfHrVR0F3AghWX6S/Px8ISabM0+Wm8WbbZ08Kf6xLNuWLE+KLNdQYWGhZlmWe0iWbyZIMn9lSEiIEJPJy8sTYp55bmTnzGYTP9SCg4O9qptBMgenLLeO5zmXXQPZOfI2d5SMrL4ynudEVn9Z/h1veVtfz3Miyxcku36yayBbV3ZcsveW53tXdq1kx+Tt+SYiostLlj+JOZWIqHqTdRKIz6CXfu5/sR6ZBf8IsW2ZXTXL07fWEcrcmp6j3c6zLihJR6Db85Mm7uzVTayG0f9nnUtOlo9CEjMaz+SLiC82Qd8zAs412XAtyIfuzjCOFCKiAOBdB7YquTc5nYVCbFtBuhBLOh2vWU5dX18o0/hX7bYOD1ahxORD2XNAE1diYsS6BXvXfnnJye4dkjROamINIRbWXtu21ev+O/HjB0tw4qt1uP72O2HODsJOQ4SwnsORLW5fOs0ev6hwMVT4fgar6xnnCCEiIiIiIiIiqhaULB30PSKgNnDCNS+XI4WIiMgverseV987ENbjYfh20XwUR4hfZqfLR4Xvo4PkHXNVHzuEiIiIiIiIiKjacHcKNSztFAI7hYiIyA+enUJqpGS4EV0WLj9f1RE7hIiIiIiIiIiqCWuhCT9EH4VdudTT3lVu7k6hFk7gHnYIERH5ylpowrawVGQZq/fImLJOIXOmFa4XxdQKRJUNO4SIiIiIiIiIqon7Pu6EVEsB7vjPCnYKZemg/G4Awiu6JkREgafPyhZonheLG9rNZ6eQXY/4H+tADauuY04qnqoqfr0qo8jISERFRXn18oeYcb6SUxTxQskS29tstgvGnE7xj9+CggIhpqrefVvIbDYLMYfDccH1XC7xwyInJ0eIHTlyRIjVry8meZPJysoSYomJiZplWV2LisQP9IyMDCGWnZ0txDIzM72qm8GgfRvKrqfsHMnY7XYhFhQUJMRk16q4uFiIWSwWzbLVahXKyN5Hsm3J9um5fQAwmcTErZ7HJTsmGVk9ZO8t2fZCQsSEfxEREZrl8HDxyeno0aNC7MSJE+erJhFRhUpJSfEqRkRE1YHey3Kez6WXfoSJooiP7+sLP9cs/2APFcq8eeyUEHv4hlGYP3cuWgetxK2P3ga9Q4+UhO1COWfbK8WK6CugGcHL50FF8tyblqk9J6rq8dzr5fM+EdHF8+azTPaZJGu0lpUTv/evKGLMrohtZ0syDmqW6ylJQhkXxPaqq3vehn2vL0HrpPm4/+7hsOZYMW7WDnHdVs2FmGoV252gu8RjF7y8n6CkRAjpGtXQLLeK0tY1y6rDDp0BRn3wBTdvd5yWVU4S4z3KW/5MAVdZu+/efPNN978zMzPx4osvomfPnujYsSMAYPPmzVi9ejWef/55v7bPEUJERERERERE1Yg124o7R4xAdq3TWPrmYjgN1XukEBER+cdgN2DYY7ch6ngE3v/4UxSGF1Z0laiacqn+vSqjESNGuF+bNm3CpEmT8Nlnn2Hs2LEYO3YsPvvsM0yaNAnfffedX9tnhxARERERERFRNePZKVTdp48jIiL/6B16TadQloGdQnT5qVD8elV2q1evxo033ijEb7zxRqxbt86vbbJDiIiIiIiIiKgaKusUOt76OL6J2F3R1bns1GQn1GvtwMmKrgkRUWAr6xQyF5rwXo2fK7o6l50t2Ia/bvgHysmAy85SZVSlEUJni46Oxv/93/8J8f/7v/9DdHS0X9vku5SIiIiIiIiomrJmWxGWGobioAvnv61K1GQnXOvzoXxpgvpp9Tp2IqJLQe/QI+5ALIrjqteIU1uwDZ98MB9BuRYYX2BTO5WviRMn4p577sHGjRvRoUMHAMAvv/yCVatW4cMPP/RrmwH3Ls3JyRFiqiQJpNlsFmLZ2dma5SxJwkmnU/zQCgkRk5zp9WKy0YKCAiFWWCgOkzQajZplWW9eXFycEDt9Wkw4lpaWJsSSksTEb/n5+ULMs74Gg/h2sNvFRHOe5xEA0tPThdjJk+LXrHJzc4VYcXHxBdez2WxCTHaOPM8tIH8vmExiIjzZNbVarZrl4GAxMZzsusvepy5J4jrZOVcUcbiiw6F9QNFJkuxZLBYhJuPtdZYdg+f5kL2vMjMzhZjs/dGkSZPz1pOIiC69lJSUiq4CEV2Q59+GAfBVxoAm/s2uQHxOUCvgOjgkCahVVfucUFh8TLKmeEwvHnhdW8JWgGlvF2HR8jxNfNG6f8StNRcTg1/yJOCy7csSg0vKHc7TPs+rqgtqHRfUb/OB/zMC48wAHODvFhFVDG8+e7z9fJJ8LkqccO0UYqH6BM3y9/Y/hDJFJaeE2N7UqzXLqYXZaPitCd9/qL1nXf2F2H4Es6wdy8+mam/vQ97eTyTtf4gK1yzeWmcv8qwluHvS16hdZMT7r12HITonEKRd7bBjq7CpXEl7seoqEWPgFxa85c8UcIEwZdzIkSPRtGlTvP3221i2bBkAoGnTpvjxxx/dHUS+CrgOISIiIiIiIiIif7g7g5YboYyzQIHCriAiIvJZWWdQcJER70+6EWa7AUD1Gh1VmfgzBVwgTBkHAB06dMCCBQvKbXvsECIiIiIiIiKiKi89IQfqon87gx4t7QwiIiLyVb6uWNIZRBWpKncIuVwu7Nu3D+np6cIMVNdee63P2+O7lYiIiIiIiIiqvHV9dgC79OwMIiKii7I+bC8yggsw777B7AyqJKrqlHE///wzhgwZgsOHDwtpcxRFkaa/uRC+Y4mIiIiIiIioylMVFTiusDOIiIguigsuRORZ2BlUiah+jBBSA2CE0P3334927drh66+/Ro0aNaS5530VcO9aWRJ7o9EoxIqKioTY6dPahGa5ublCGavVKsRkJ7pQkvzLbrd7VY+goCAh5iksLEyIxcfHC7GQkBAhZjB4d1k9h5ilpaUJZcxmsxDzpv4AkJOTI8QOHz4sxCIjIzXLERERQpnU1FSv6hYTEyPELBYxSZ0sJtuew6FN3iY7t7Jt6fVi4tns7GwhJuPZ2yurh+z9p5MkxpPVTbb98PBwIVZcXCzEDh48qFnOy8sTysi2HxoaKsSIiIiIyBsB8KQasMTnPAXi3/FqpckHIL4XnE7xmdYbLpfn84QLWwpW4dfT6zXR1fc9KKzbY2VNsWZh4vOE1wm+y5OkbSDOYnP/O9jgOMevlHjdmQeCiKoCl0ts28kuOijETqv7NcsqXEIZl8smxPbkrNSWKSnCDzmxOL5T+2G79NlVwrphL3QVYmpsnBCDR1ucKmv3dIr1hV5SziUpJyNp41WDz7QZqxYznPk65Nq0bYkN9NHCeoWK2HZWpD8lxByK2NbndBZIKud5DPxbsSrbu3cvlixZggYNGpTbNivgLzQiIiIiIiIiIiIiIqKL5/LzVdl16NAB+/btK9dtBtwIISIiIiIiIiIqZ3p+w5iIiC6equP9hC4/VVWgqj7mEPKxfEV4+OGH8dhjjyE1NRUtW7YUZkpr1aqVz9tkhxARERERERFRdbZBgfqiDfjJAOUoJxIhIiL/KN/pcey9bYj5pj7Cf0us6OpQNeLPiJ9AGCF06623AgDuuusud0xRFKiqCkVR4HT6PsUtO4SIiIiIiIiIqrNnFSDSAPXbfOD6EHYKERGRX5TPTahfox22L12CNrcOZKcQXTYutfTl6zqVnWc+9/JQJTqECgvFpFsuSZIwnUdSy5CQEKGM57ArAFBV8d0h235YWJgQi4yMvGA97JJEZREREUIsMVH8EI2OFpOVyXoGi4qKhNjx48c1y/n5+UKZOnXqCDFZuaNHjwoxi8UixJKTk4VYcbE2wV1CQoJQJjY2VogFBQUJMavVKsRk9ZXFZNfes26y85iUlCTEZNfv0KFDQqykpESI6fViQtOMjIzzLgPi+woAQkNDhZjJZBJiDofDq1hurjZprez3QHZdZL9rRESVWUpKilcxIiIKZOJzngrxb+BqQVWABx3Au4D6bR7UrjrgqIK+W98Xih6+S3wWSfigh7jJGPEZ7lJTzWYhZjGcuaYGnQs6lwEGvfa5scQlS9pNRFTeLnXrs2z7YhthiV38HFcUbZuYqvo+6qDM4bd3QSkJwtaln8HYJwa6LSY8tW60UO79m/4RYmpHsS0RHu2tiqQtSjXImrgv4p4uaZvD2e23DifMJgfq1s7UFMncJq6X7hCP0+GStWWLbYSBMYaFLiVZW/rFqhIdQkRERERERER0EVQFeAjAuwA2uIDrdMCJiq4UEREFIv37pV8Mtn99CsY+MUD5D3Ig0lDhe5drAAwQwqeffnrenw8fPtznbbJDiIiIiIiIiIiETiG1u6vqTR8XHAjNP0REge/sTqG0O48i/vdaFVyj8lVodkCFCgVKRVeFUDZlnG/XIhCmjHvkkUc0y3a7HYWFhTCZTLBarX51CFWxv+yIiIiIiIiIyG+qAjykAGsUuNblQa1Vdaarue6nenD1LIbzXk4RR0R0OejfD4Hh+TCsXDAfaVeK6SYCVeeCeigyOfDEsC1QA2KcSdWn+vmq7E6fPq155efnY/fu3bj66qvx2Wef+bVNdggRERERERER0Rn/dgopaw2lnUKdHFBbl7521s3EzrqZsBkDL99S032xMPSNgvOlPHYKERFdJvr3Q9D+lW5YuWA+Dt+wG6ean8Sp5iexPTwd28PTkW20VXQVfRbnDMWKKT2wtvVxdgpVEqUjhHx/BaKGDRvilVdeEUYPeSvgpowzGo1CzOEQ/xCVJbGPiorSLJtMJqGMqorvhIIC8Q9F2fabNm0qxJxOMQnb33//rVnOz88XygQFBQkxGb0kyVl4eLgQO3pU7IXPzNQmPgvzSNIGAKdOnRJiO3fuFGInToiTS8uSXtWuXVuImT0Sf0ZHRwtlGjZsKMRKSsRkaxkZYmI82fktLi4WYrJz6Xn9ZO+13NxcIRYXFyfE4uPjvaqH7D2Tnp6uWbZarUIZ2XtXFpO9d2X7zM7OFmKe57ywUEyCJ3vPyK6V7JoSEVVmKSkp5VquMpDVNZDqT0SBytvpPAL0Kb2qUBWoDzqBaSpcy/Lc4d7KSqhGFyy7IlH/tl7Q55qw9ctvxfUH3ahd9njuAwBVJ/mOql7STOGUdD5J1lUkz2YGvXaEk2tjCZQ+QXB+nQuXWgzlfRPk35X1P6E6EVHlJms/Ettt/FVsF9vmfpn6C1w5Bqx+9XPg3+a3VfogqIoKU6EJo0eMRPTRKDz56A/Cukqb+tq6RkeKO5W0dSE01LsKy+5FRUVizKP3YO/3zfDfPUmYMGsejvX5B/dM7YkCZAurFdhOiptyiZ1gqurtfYd/H8m4/n35uk6gMhgM0vZ4r9Yt57oQERERERERUVWgKsA4PTDuTKhlxHC4zA4c+nQd9i/+BvVv6wXAuy80VhbKZj3Qxwr163+/4PZexdaHiKg60M2yQDfL4l5+vsFYqFCx8qnV+HDuHIweMbLiKuen2NRwTLxvGCbMmoePngTUe9szpxCVq+XLl2uWVVXFyZMnMWPGDHTu3NmvbbJDiIiIiIiIiIi8pis2oM7w7qWdQku+Qc6OPggvEUcAVWaaTqHDBuBrzqhPRHS5KVDQ+9WeAIAPP52Nezf0Qf1cceajyuzsTiHjOAMSp7et6CpVS6pa+vJ1ncquf//+mmVFURAbG4vrr78eb7zxhl/b5F88REREREREROSTsk4hw2kzevX5GjkmcTrsyk7ZrAe+NgAtAqBFiIioiirrFGqxujm69V2B/WE5FV0ln8WmhuOGZVeiqHnmhQvTJaFCgcvHl+rnaK53330XderUgcViQYcOHbBlyxav1vv888+hKIrQyXM+LpdL83I6nUhNTcXChQtRo0YNv+rPDiEiIiIiIiIi8llZp1CUzRKwnUJMxUBEVPEUKOjzSk/ceqBewHYKKSqniqtIZSOEfH356osvvsD48eMxYcIE/P7772jdujV69uwp5H/3dOjQITz++OO45ppr/DzC0uniZPnifRVwU8Y1adJEiLlcYgqo2NhYIRYREXHB9YqLxT9gZSfaarV6tc/MzAv3DFssFiHmcIhJM3MlCTKNRqMQO3jwoBArLCwUYp7HcOTIEaGMzSYmOZPVNzk5WYiFhYUJsVq1agkxz2uqkyRzk8Vk10p2DWrWrCnEcnLEG4vsnDud2oRusuu5e/duIVYkST4nq0eoJMGd7H2Zl5enWZYde0aGmLSvoKBAiB07dsyrusmun+e1P3TokFAmKytLiCkKb4pEVH2kpKR4FSMi8o7eY7mqJrqXfVexqh5rIBGfhbdnzxVipzt0Rca8bUho8SXibmsHXa4RWzd8pSkT1UtM+K1cK06ro0ZHidUosXtVW+WomFx5U1qMtoyibQZRoIMK77ZPRETeEO/fDqfYDjf1+FdC7PY+tyDyhdW4ss/X6Hv7SIQfjsIrN/ypKWOJF+9Npl5NhZiaILYRqqHivQiK+DeIUii2pyl7te2mtYO17XcRJjvy1AzscXyviTtdYpusqpaI9aCL4vr35es6vpo2bRpGjx6NUaNGAQDef/99fP311/jkk0/w9NNPS9dxOp0YOnQoJk6ciB9++AHZ2dk+7fPTTz/Fa6+9hr179wIAGjVqhCeeeALDhg3z4wg4QoiIiIiIiIiILoJSrEfssCugyzEiffFvcIWxg4WIiHynQEHHST1R7+tmWLFoDnKSxS8dE8m4VP9eQOkgjLNfsi/iA0BJSQm2bt2K7t27u2M6nQ7du3fH5s2bz1m3SZMmIS4uDnfffbfPxzVt2jQ88MAD6N27NxYtWoRFixbhxhtvxP3334/p06f7vD2AHUJEREREREREdJE8O4Vyg/jtZyIi8p1np9DB2LwLr0R0EWrVqoXw8HD3a8qUKdJyp06dgtPpRHx8vCYeHx+P1NRU6To//vgjPv74Y3z44Yd+1e2dd97BzJkz8eqrr6Jfv37o168fpk6divfeew9vv/22X9tkhxARERERERERXbSzO4UGPbOWnUJEROSXszuF+j61hp1CdEGqny8AOHr0KHJyctyv//73v+VSp7y8PAwbNgwffvghYmJiLryCxMmTJ9GpUych3qlTJ5w8edKvbQZcDiEiIiIiIiIiqpzKOoXCv9mJgc+tQe9fawMArI1MYuGI0oaMREckhuV3goLyzz2qQsWWXn+h5Q8NYc0X8+ESEVHlVNYppE/OQd+n1mDUhkZQABgkaYD0tdIBACFOE+49+R+Y1UvT5L0y4QCa50YjuTD8kmyf/Hf2FHC+rAOU5lGX5VL3FBMTA71ej7S0NE08LS0NCQkJQvn9+/fj0KFD6Nu375l9/ps73mAwYPfu3ahfv/5599mgQQMsWrQIzzzzjCb+xRdfoGHDhhess0zAdQhFRER4VS4qSkxE6XlhS0rEbys5nWLiM1nMYBBPXVFRkRCTzTkYHR2tWTYajUIZnU4cvHXihJgg88CBA0LM4XAIMVmyqrI3YBmr1SqUSUpKEmKxsWJSNtkvjedxAkCTJk2EWJ06dTTLsvMoi8nqW7duXSEmu1aHDh0SYrLzm5GRoVkuS951ttOnTwux4OBgIWY2m4WYXu+ZJFh+XImJiZpl2THJtn/s2DEhlpmZKcRkvwv16tUTYs2bN9csx8XFCWW+++47ISa7fkRE1UlKSsplXc/b7ZX39onoUhCfRSovWWO+7MlcNlGFP2l9qWKI78mjOd8LMUevtsh95iB2xR8HAITvE58Pk0+UJtre3f4gFv6wEwPfuAEj+38rlCs4JNYitKn4LDVljvZ5UIWKaY8vQtao3Qj6PQZ1b7sBLpdNW0YNpN8xIqJAJf49cDp/pxCb7ywQYs0G3QDdmO14r+UpAEBModj+VWtPafvXvkbpWGj4GxP/2x/dBxwUyukSJB059cW2T/W3PUJsmmE7/nvLFsRlB+GryT0w8U9tG+f+rgZAvNXxPnOZqGrpy9d1fGEymdC2bVusX78e/fv3B1Davr5+/XqMGTNGKN+kSRPs2LFDE3vuueeQl5eHt956C7Vq1brgPidOnIhBgwbh+++/R+fOnQEAmzZtwvr167Fo0SLfDuBfAdchRERERERERESVm1KsR/iEBu7lpmo7ocyg2qVfhkuvlYU3Pp4LABixv365jBRSoWLF8yuRd80xNOrYHyde3oKDi9dC7aFCyS3/kUhERHRpKFBQY8YV7uUO4eIX1fsnlXYk5QcX48k3F2HClK9wze9dYHaKXx7wx6ymfyPlP1vx1eSeWNH+MPo/vwYNv49H8KHIctk+XTwXfP96kT9fRxo/fjxGjBiBdu3aoX379njzzTdRUFCAUaNGAQCGDx+OpKQkTJkyBRaLBS1atNCsXzbYxTN+Lrfeeiu2bNmCadOm4auvvgIANG3aFFu2bMEVV1xx/pXPgTmEiIiIiIiIiKjCxB2NwmN3j8BvPXfi6Z6/Q5WOLPPNruv2YGfPv1Gvb0+Y94Ujedh10BXrgRR7OdSYiIgqo5ACM6Y+ejtywoswsM86FOsvfnTO4ZA8PHL1j/ji1e7osCcOk+e3ww3bkrDjzW/KocYUaAYNGoTXX38dL7zwAtq0aYPt27dj1apViI+PBwAcOXLE79w+nux2O+666y5ERkZi/vz52Lp1K7Zu3Yr58+f73RkEsEOIiIiIiIiIiCpYWafQkhaHyqVTqDikGDEHo2E6GgoA0BUbELwpHrhwigAiIgpgZZ1Cp4Js5dIplGe0w+owoMOe0rQJChRc92ciHKFimhCqOGU5hHx9+WPMmDE4fPgwiouL8csvv6BDhw7un23cuBFz5sw557pz5sxxj/S5EKPRiKVLl/pXyfMIuCnjdu3aJcQ8c+EA3uW0keVh8UwKBcjzq8jWlZHldZHlJPIky9MTEiLJmiZhsYiJMmX18MxvlJycLJSJjBSHPsry41x55ZVCrGbNmhfcJ1CaYOtsspxKsusZFBQkxGS5l2T5k2TXQLYPz9w3smOXbUuWB0j2PpWdD9l7yzPBmCy3k+zYZfuU5fOR5UGS5VnyPC7Z9mUxb39fiIhIS5bjh3l/iKjy8vapmnPpVzWqahNiJ7J/0C5jk1Dmu388cjn8A9S4vhPeWb4Js+OLEfV8CyhQEKWKiZpdK8T3227bPPe/HZl5sBfnALlfnlmn2AaoLqjq2aOEmL+KiKhiiH8P5BeJudK32GZrlrcWiG1uy/OuEmLR7fvj+2XLkdTwWzQc1hu6Ej3G1BXb9RSIbWJZ9jP3nRMNFJT0UtDrmzPrntZbUHBdHra4NrhjheoJ2B35yC3UtnPyPnN5qPD+L9Gz16ns+vfvj6+++grjxo0rt22ylZaIiIiIiIiIKgXjwRAk9uuME8tLO5Cinvdujn0iIqKzGXLNaDKgH3YtW46981ai4bDeFV0luoT8GfHj7wihy6lhw4aYNGkSNm3ahLZt2wqDFcaOHevzNtkhRERERERERESVhtAp9FwCFCgVXCsiIgo0np1C9ueHwmhnc3hVpEKB6uPfCr6Wrwgff/wxIiIi3PmDzqYoil8dQswhRERERERERESVivFgCBL7Xo38/idwbPJmn3IKqSYVjtvzoKRqG/2UVAXopgK1/t1WXRXoqgLlk/uZiIgqobJOIXu0DW+9sQh2o8PrdVWo2NJ/O8JOhWrixjQrnA2LYG+XBwBwhTpQ3DcLSC3XqpMPVPiePygABgjh4MGD53wdOCBOsegNdggRERERERERUaVjPBSMxH6dkXXLfq87hVSTiuIFJ6HGOWF+2CM374cm4BsF2OAErlVL/79EAT6t/N8QJiIi/5V1CuVFFHrdKaRCxfLxa7H1xr8weswdmp+F/JqA4JTayFm6CyXXZSNn6S4oOXrgGTEvOlFlE3Bj5DIzM4WYLIl9YWHhBWNFRUVCmfz8fCFmsVi8qptOJ/avec7rBwAhISEX3GdaWppX2zIYvLuEiYmJF6yHbFsJCWLyzpo1awqxa6+9Vojp9Xoh9uOPPwoxu92uWY6OjhbKmM3mC64HAFlZWUIsNzdXiMmuVWxsrBCzWrWJ6mTnSHatnE4xMV5QUJAQCwsLE2Iynu9Vh0O8cXleTwCIj48XYnv37hVisnMk28f3339/3noB8t9H2XuXiIj8k5KSUim3RUREpOXZeSM+IzkcYiLvA6dXagOnAeU6E9LW70Bap7+AgvN13riAWAB5ALoZUZRzQuxEekgB3gXwnRN4UwHGKUAATBlDRFQ9iB3/qmrTLDscNqHM4dNrhNgxg0ebWwFg6RGBQ8uP4u75r0OXUdpuqdeZhHWdrhKoVhVqnAPWHsl4e/96lDjyNGWKp5+CWqxDzle7gFU64BYTYHPJjkA8TCp3VTWH0Pjx46VxRVFgsVjQoEED3HzzzYiKivJ6mwHXIURERERERERE1YeyXw90CgG6nP2lNUmTm8sBuACs1EHJO0cnj6oADwH4TAF+ANgZRERUfSi5elj71oKjRwGgL72PWAyRQrliRw4AQP+jFboT5x71o7xngLpVB2xXoBQr7PqpQCp873oLhOu1bds2/P7773A6nWjcuDEAYM+ePdDr9WjSpAnee+89PPbYY/jxxx/RrFkzr7bJDiEiIiIiIiIiqtSUEzrgs7O/xS3OTOD1V33Vss4gIiKqbpQ8PYxLz4wesprE2XVcJT5s7xdmZKkMquoIobLRP7Nnz3bPNJWTk4N77rkHV199NUaPHo0hQ4Zg3LhxWL16tVfb5DuWiIiIiIiIiIiIiIgCkurnf5Xda6+9hsmTJ2vSjoSHhyMlJQVTp06F1WrFCy+8gK1bt3q9TXYIERERERERERERERFRQCobIeTrq7LLyclBenq6EM/IyHDnhI+IiEBJiffD2gJuyrgmTZoIMVlie51O7Osym82a5YKCAqGMXq8XYvn5+UKssLBQiJ3dU3c+Nps2+ZlnvQAgJCTEq3ocP35ciMmO4eDBg0IsOTlZsyw7ZydPnhRiMrJydrtdiJlMYqK20NBQzXLZm/lCZNtyucRpAwwG8W0eFBQkxBISEoSY57WSnaOaNWsKMdl7MjU1VYjJ3oOy85aZmalZlr0XZLHs7GyvysmO6/RpMcGr53tLdg1k28rKyhJiREREROQNz7/tnRVSC6JLQ9YSI77HXS7xGUZOlg8oAFp7iIjooqhwCDGHQ2yLynOIbV15hfuEmKKIbbWq6tleJ5m6lPccKmc333wz7rrrLrzxxhv4z3/+AwD49ddf8fjjj6N///4AgC1btqBRo0ZebzPgOoSIiIiIiIiIiIiIiIiA0q44X7vjAqH7btasWRg3bhwGDx4Mh6O049NgMGDEiBGYPn06gNIBNB999JHX22SHEBERERERERERERERBSR/poALhCnjQkJC8OGHH2L69Ok4cOAAAKBevXqa2cXatGnj0zaZQ4iIiIiIiIiIiIiIiAKSqvr3ChSpqak4efIkGjZsiJCQEKgXUXl2CBERERERERERERERUUBy+fmq7DIzM9GtWzc0atQIvXv3xsmTJwEAd999Nx577DG/thlwU8bJEiSdPi0mBCsuLhZiFotFs2wwiIefkZEhxPbu3SvEFEVMVmk0GoVYdna2ECub76+M2SwmKrPZbEJMr/dMKAtERkYKMZdLfDunp6cLMdlxedLpxD7DoKAgIda8eXMhVrNmTSHWpEkTIZafr00QeuzYMaGM7BrXrl1biIWFhQkxu90z6RuQm5srxHJycoSY57mUvWdk+5TFZOdty5YtQuzEiRNCzGq1apZl749Tp04JsT179ggx2bHLOJ1iMlfP97jsGkRFRQmxoqIir/ZJRERERJ7Ev8mI6FwC6Ku+RERUAby7T6iq2K7s77aILsa4ceNgNBpx5MgRNG3a1B0fNGgQxo8fjzfeeMPnbQZchxARERERERERERERERFQdXMIrVmzBqtXrxYGXjRs2BCHDx/2a5vsECIiIiIiIiIiIiIiosDkT06gAOgQKigoEGaOAoCsrCzprGPeYA4hIiIiIiIiIiIiIiIKSFU1h9A111yDTz/91L2sKApcLhemTp2K6667zq9tcoQQEREREREREREREREFJNWPEUI+jyiqAFOnTkW3bt3w22+/oaSkBE8++SR27tyJrKwsbNq0ya9tBlyHUGFhoRBzucT+PL1eL8Ty8/M1y7JE9zabTYgZjUYhZjKZvNqnbEhXRkaGZjk3N1co4+2QL9m6wcHBQiw6OlqIeR5XWFiYUMZzfkIAaNu2rRCLiIgQYrLtyY6roKBAs2yxWIQy6enpQszzPALyayCLyfZx6tQpIeZJVv/iYjHRnN1uF2Ky8+F57ADw008/CbHExMQLrldSUiLEvPk9AOTvcVnM87jy8vKEMlFRUUIsMjJSiBEREREREREREVU+AdBTQBr+jPgJhBFCLVq0wJ49ezBjxgyEhoYiPz8fAwYMwEMPPYQaNWr4tc2A6xAiIiIiIiIiIiIiIiKqqux2O2688Ua8//77ePbZZ8ttu+wQIiIiIiIiIiIiIiKigKSqKlQf54DztfzlZjQa8eeff5b7dnXlvkUiIiIiIiIiIiIiIqLLwKX696rs7rzzTnz88cfluk2OECIiIiIiIiIiIiIiooCkwvfMTwHQHwSHw4FPPvkE69atQ9u2bREcHKz5+bRp03zeZsB1CB0/flyImc1mIRYWFibEcnNzNcuFhYVCmcjISK9iGRkZQkw2zExRFCGWk5OjWa5Xr55QRq/XC7H8/HwhJjtOq9UqxDzfLABQp04dzXJMTIxQJigoSIjVqlVLiBmNRiF24sQJr8p5XgeTySSUiYiIEGJFRUVCzPMaA5Am2LJYLBesBwDodNpBdLL6FxcXC7GQkBAhJjuGqKgor7Z37Nix89YLAFJTU4WY7HcjPj5eiMnk5eVdcHuyuh4+fFiIuVximraWLVt6VQ8iIiIiIiIiqirEdjLvBELTLRFVFH9G/ATCCKG//voLV155JQBgz549mp/J+h28EXAdQkREREREREREREREREDV7RDasGFDuW+TOYSIiIiIiIiIiIiIiIgqqWPHjgmzSPmDHUJERERERERERERERBSQSnMI+fpf5edyuTBp0iSEh4cjOTkZycnJiIiIwOTJk6UpOrzBKeOIiIiIiIiIiIiIiCggVdUp45599ll8/PHHeOWVV9C5c2cAwI8//oiUlBTYbDa89NJLPm8z4DqEdDpxUFNERIQQi46OFmJms1mznJOTI5QxGo1CrKCgQIipqviOka2bn58vxCIjIzXLcXFxQpm9e/cKsaZNmwqxdu3aXXD7gPwYTCaTZtnz/ABAWlqaENu3b58QCwsLE2Lh4eFCLDY21qu6eUpMTBRi2dnZQsxutwsxb3tLg4KChJjnOXE4HF5tX/aetFqtQqy4uNirunmSnW+n0ynEPK/xueomO5eFhYVCzPN8xMTECGVOnjzp1faJiIiIyBueyWID4MmViCoJWbJpfobQ5SS+BxXF6LEsNk2qqtj2oqpie48c3+NUkfi5W1FUtfTl6zqV3dy5c/HRRx+hX79+7lirVq2QlJSEBx98sHp0CBEREREREREREREREQGl08W5fOx8C4RJ47KystCkSRMh3qRJE2RlZfm1TeYQIiIiIiIiIiIiIiIiqkRat26NGTNmCPEZM2agdevWfm2TI4SIiIiIiIiIiIiIiCggVdUp46ZOnYo+ffpg3bp16NixIwBg8+bNOHr0KFauXOnXNgOuQygqKkqIeZMvCBDz+cjy48jI8rzk5uYKseDgYCEmy49TVFSkWd6/f79QJiEhQYi1bNnSq3Ky/DLx8fFCzPO4ZPmObDabVzHZ+ZbFZDzzQnm7LVlMlkNIdlyymCznkWd+INlQPFk9ZO+FgwcPehWTHYNnPh9Z7h5ZniVvfg8AIDMzU4jVrFlTiNWrV0+zLDvO0NBQIXbq1CkhRkRERETeCIAnVSKqpPj5QRVNnJhIUbS5jnWSHEIu6YRGYkyeV0jMrxz4mJcmcHh7XXhNy5vr35ev61R2Xbp0wZ49e/Duu+9i165dAIABAwbgwQcflLYFeyPgOoSIiIiIiIiIiIiIiIgAQFVVqD4O+fG1/OV04MAB1K1bF4qiIDExES+99FK5bZs5hIiIiIiIiIiIiIiIKCC5VP9elVXDhg2RkZHhXh40aJDXs51dCDuEiIiIiIiIiIiIiIgoILmg+vWqrDxHL61cuVKamsYf7BAiIiIiIiIiIiIiIiKq4gIuh1BQUJAQk833l5ubK8Q8E9sXFxcLZcxmsxBzOsWEdC6Xd2mnTp8+LcRC/r+9+wmRsv7jAP6Z2VoHW1ZXpbFkyUsgYbmhaQbVZclDFw+BCKFJBBFGsBcrQoMOalR4SJKKOiVKEB4ihFry1IKkEXQJgsqodlVKrS3dbef5HdTtNz6jzfO4f3xmXi+Zw3z6fuf5PrMjbPP28/12ddU9nz9/fmrMQw89lKrdcccdqVp3d3eqtnDhwlTtzz//TNWGh4frnv/666+pMWfOnEnVqtVqqlapVJq6ZqP3/Mpxje5pbGwsVWv0WWhUa5Sejo+nDx6cO3duqnalm25K/5VpdM2///47Vbt88Nf/++6771K1Ruu98hqNflZXfq4iIhYsWJCqNfo833bbbalao/fj7Nmzdc87OztTYxYtWpSqLV++PFUDAAAAWlmj79Pqv/NISjenpyXp79ySBq8VN/C/7p9a7XKf7cTPdKolEZH1SKAb+adQKpWiVCqlalOhcIEQAAAAAABAROTaAu5G3zLuiSeemGxeOX/+fDz99NNxyy231I376KOPMr+2QAgAAAAAACikJMne8ZO1o2gmbd68ue75448/PmWvLRACAAAAAAAKqdU6hN5///1pe22BEAAAAAAAUEi1JEcgdCO3CE2jlgiEarX0YXON3HrrrXXPe3p6UmP++eefVG1kZCRVO3v2bKp24cKFVG10dDRVu/nm+gPzFi5cmBpTLpdTtfnz5zdVO3nyZKr2xx9/pGpX3leje7rppvRHpKOjI1W7vJ/h/2t0D1fee0TE3Llz656Pj4+nxkxMpA8PvHLe1a45NjaWqjW6rzNnzvznuEbr//3331O1b7/9NlUbGhpqam6je+jq6qp73ug9+uWXX5p6rUb3/ttvv6Vqjd63KzX6u3f+/PlUrdH71t3d/Z+vDwAAALSuJEl/33OVkdO6DoB20RKBEAAAAAAA0H6SS3+yzmlHAiEAAAAAAKCQkohobg+x+jntSCAEAAAAAAAUUi1ynCHUppGQQAgAAAAAACikJMmxZVwiECqE3t7e3HOr1Wqueffee2/ua+ZVq6Wb3L7++utpvWZPT09T48bHx1O1H3/8caqX03JWrFjRVA0AAACgPUw0qJVmfBUA7aJwgRAAAAAAAECELeOyKM/2AgAAAAAAAPK4HAhlfeSxd+/eWLp0aVQqlVizZk0cPXr0qmPfeeedePDBB6Onpyd6enqiv7//muNngkAIAAAAAAAopHxxUPrIlv9y8ODBGBgYiB07dsTx48djxYoVsW7dujh58mTD8UeOHImNGzfG559/HkNDQ9Hb2xuPPPJI/Pzzz9d7y7kJhAAAAAAAgEKaqQ6hN954I5566qnYsmVL3HXXXbFv376YO3duvPfeew3Hf/DBB/HMM89EX19fLFu2LN59992o1WoxODh4vbecm0AIAAAAACiYUoMH0I6uJxA6d+5c3ePChQsNrzE2NhbHjh2L/v7+yVq5XI7+/v4YGhpqap1//fVXjI+Px4IFC67/pnMSCAEAAAAAAG2nt7c35s2bN/nYuXNnw3GnT5+OiYmJqFardfVqtRrDw8NNXWvbtm1x++2314VKM+2mWbsyAAAAAADAdahd+pN1TkTETz/9FN3d3ZP1OXPmTOnaLtu1a1ccOHAgjhw5EpVKZVqu0QyBEAAAAAAAUEhJKYmklC0QSi5tGdfd3V0XCF3NokWLoqOjI0ZGRurqIyMjsXjx4mvOfe2112LXrl3x2WefxT333JNpnVPNlnEAAAAAAEAhJTnOD7ocCDWrs7MzVq5cGYODg5O1Wq0Wg4ODsXbt2qvOe/XVV+OVV16Jw4cPx6pVq3Lf41TRIQQAAAAAzIArv4AtNTEmyzigHdWiFqWcW8ZlMTAwEJs3b45Vq1bF6tWrY8+ePTE6OhpbtmyJiIhNmzbFkiVLJs8h2r17d2zfvj32798fS5cunTxrqKurK7q6ujJffyoIhAAAAAAAgEK63PeTdU5WGzZsiFOnTsX27dtjeHg4+vr64vDhw1GtViMi4sSJE1Eu/7sp21tvvRVjY2Px2GOP1b3Ojh074uWXX858/akgEAIAAAAAAPgPW7duja1btzb8b0eOHKl7/sMPP0z/gjISCAEAAAAAAIVUK9WiVJr+LeNagUAIAAAAAAAopJk6Q6gVCIQAAAAAgFmQXMe40nW8Hswmn92pJhBqnkAIAAAAAAAopCRqkWQMeLKObxXl2V4AAAAAAAAA00uHEAAAAAAAUEi1mIhSTGSe044EQgAAAABAwThzhSJo9rwg5wpdjySSHFvGtef7KxACAAAAAAAKqVaqRamULRCqtekZQgIhAAAAAACgkC5uGVfOPKcdCYQAAAAAAICCqmXeMi7atEMoW2wGAAAAAABA4egQAgAAAACAKZdM8TgaqSUTkbX35eKc9iMQAgAAAAAACinJsWVc9i3mWoNACAAAAAAAKKQkJiLJ2CGUhA4hAAAAAACAwqhFLSJjx09NhxAAAAAAAEBxJJHk2DKuPc9tytZHBQAAAAAAQOHoEAIAAAAAAAopSSYiiVLmOe1IIAQAAAAAABSSM4SaJxACAAAAAAAKKYkcHUKhQwgAAAAAAKAwkqQWScaOnyRpzw6h8mwvAAAAAAAAgOmlQwgAAAAAACgkZwg1TyAEAAAAAAAUUpLkOEMocYYQAAAAAABAYSSRZD9DKJJpWs2NTSAEAAAAAAAUUpLUcnQI2TIOAAAAAACgQCZy9Pu055Zx5dleAAAAAAAAANNLhxAAAAAAAFBIF7d/s2VcMwRCAAAAAABAIQmEmicQAgAAAAAACqkWtShlDYRCIAQAAAAAAFAYOoSaJxACAAAAAAAKKUkmZmROKyjP9gIAAAAAAACYXjqEAAAAAACAQkoiich4JtDFOe1HIAQAAAAAABRSnvOAnCEEAAAAAABQIAKh5gmEAAAAAACAQkoybheXd04rKM/2AgAAAAAAAJheOoQAAAAAAIBCsmVc8wRCAAAAAABAIQmEmicQAgAAAAAACipPuCMQAgAAAAAAKAwdQs0TCAEAAAAAAIWU5Oj2yTOnFZRnewEAAAAAAABMLx1CAAAAAABAISVJElnPBLo4p/0IhAAAAAAAgIKaiIhSxjkCIQAAAAAAgMJIklpkDYR0CAEAAAAAABRK9kBIhxAAAAAAAECR5OgQCh1CAAAAAHClrP/qmunR6OfQnl9oAkXVMdsLaHsCIQAAAAAAoJCSHOF4njmtoDzbCwAAAAAAAMinlvOR3d69e2Pp0qVRqVRizZo1cfTo0WuO//DDD2PZsmVRqVTi7rvvjk8++STXdaeKQAgAAAAAACio5OKZQFkeOTqEDh48GAMDA7Fjx444fvx4rFixItatWxcnT55sOP6LL76IjRs3xpNPPhlfffVVrF+/PtavXx/ffPPNdd5vfqUkae70pG3btk33WgBm3O7du2d7CW2nVLL/ONB6mvyVmjZVKtmpGyi69O/wSTI+C+tob6XSzQ2qfgcBiiR9hlCSXMj9aufOnYt58+Zdet2s3zclETERZ8+eje7u7qZmrFmzJu6777548803IyKiVqtFb29vPPvss/H888+nxm/YsCFGR0fj448/nqzdf//90dfXF/v27cu43qnR9P+Z+NIUgKngS1MA2k2S/DPbSwCgBQjhAK4l3/dN586dq3s+Z86cmDNnTmrc2NhYHDt2LF544YXJWrlcjv7+/hgaGmr42kNDQzEwMFBXW7duXRw6dCjXWqeCLeMAAAAAAIBC6ezsjMWLF0fERK5HV1dX9Pb2xrx58yYfO3fubHit06dPx8TERFSr1bp6tVqN4eHhhnOGh4czjZ8J9i4AAAAAAAAKpVKpxPfffx9jY2O55idJkjraoFF3UCsRCAEAAAAAAIVTqVSiUqlM+3UWLVoUHR0dMTIyUlcfGRm51KWUtnjx4kzjZ4It4wAAAAAAAK6is7MzVq5cGYODg5O1Wq0Wg4ODsXbt2oZz1q5dWzc+IuLTTz+96viZoEMIAAAAAADgGgYGBmLz5s2xatWqWL16dezZsydGR0djy5YtERGxadOmWLJkyeQ5RM8991w8/PDD8frrr8ejjz4aBw4ciC+//DLefvvtWbsHgRAAAAAAAMA1bNiwIU6dOhXbt2+P4eHh6Ovri8OHD0e1Wo2IiBMnTkS5/O+mbA888EDs378/XnrppXjxxRfjzjvvjEOHDsXy5ctn6xailCRJMmtXBwAAAAAAYNo5QwgAAAAAAKDFCYQAAAAAAABanEAIAAAAAACgxQmEAAAAAAAAWpxACAAAAAAAoMUJhAAAAAAAAFqcQAgAAAAAAKDFCYQAAAAAAABanEAIAAAAAACgxQmEAAAAAAAAWpxACAAAAAAAoMX9Dxtrm41bArg2AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "test_example = test_ds[0]\n", + "test_image = test_example[\"image\"]\n", + "test_label = test_example[\"label\"]\n", + "test_slice_index = int((test_label[0] > 0).sum(dim=(0, 1)).argmax())\n", + "\n", + "fig, axes = plt.subplots(1, 2 + len(model_names), figsize=(17, 3.5), layout=\"constrained\")\n", + "axes[0].imshow(test_image[0, :, :, test_slice_index], cmap=\"gray\")\n", + "axes[0].set_title(\"Test MRI\")\n", + "axes[1].imshow(test_label[0, :, :, test_slice_index], cmap=\"gray\", vmin=0, vmax=2)\n", + "axes[1].set_title(\"Reference\")\n", + "probability_image = None\n", + "for axis, name in zip(axes[2:], model_names):\n", + " foreground_probability = stored_predictions[name][0, 1:].sum(dim=0)\n", + " probability_image = axis.imshow(\n", + " foreground_probability[:, :, test_slice_index],\n", + " cmap=\"magma\",\n", + " vmin=0,\n", + " vmax=1,\n", + " )\n", + " axis.contour(\n", + " test_label[0, :, :, test_slice_index],\n", + " levels=[0.5, 1.5],\n", + " colors=[\"lime\", \"cyan\"],\n", + " linewidths=0.8,\n", + " )\n", + " axis.set_title(name)\n", + "for axis in axes:\n", + " axis.axis(\"off\")\n", + "fig.colorbar(\n", + " probability_image,\n", + " ax=axes[2:],\n", + " label=\"Foreground probability\",\n", + " fraction=0.02,\n", + " pad=0.02,\n", + ")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "3e7b7ba1", + "metadata": {}, + "source": [ + "## Inspect publication-style dataset reliability histograms\n", + "\n", + "A conventional pooled reliability curve hides variation between volumes. The paper therefore introduces a\n", + "**dataset reliability histogram**. For every held-out volume and foreground class, we first use MONAI's\n", + "`calibration_binning` to calculate the empirical foreground frequency in each predicted-probability bin. The\n", + "top row then shows the distribution of those per-volume frequencies: each heatmap column is normalized\n", + "independently, and perfect calibration lies on the dashed diagonal. A narrow distribution along that diagonal\n", + "is desirable; vertical spread exposes variation between volumes that an average curve would conceal.\n", + "\n", + "The lower row reports the total number of foreground-class voxel probabilities in each prediction bin, using a\n", + "log scale when needed. To keep the comparison compact, the two hippocampal foreground classes contribute to\n", + "the same histogram, while background remains excluded. As with the paper's figure, this is a descriptive\n", + "visualization; the tabulated metrics retain their stated per-volume, per-class reductions." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2154c8c2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "num_bins = 20\n", + "bin_edges = torch.linspace(0.0, 1.0 + torch.finfo(torch.float32).eps, num_bins + 1)\n", + "bin_width = 1.0 / num_bins\n", + "bin_positions = torch.linspace(bin_width / 2, 1.0 - bin_width / 2, num_bins)\n", + "\n", + "fig, axes = plt.subplots(\n", + " 2,\n", + " len(model_names),\n", + " figsize=(4.8 * len(model_names), 6.2),\n", + " sharex=True,\n", + " gridspec_kw={\"height_ratios\": [4, 1]},\n", + " layout=\"constrained\",\n", + ")\n", + "if len(model_names) == 1:\n", + " axes = axes[:, None]\n", + "\n", + "heatmap_images = []\n", + "for column, name in enumerate(model_names):\n", + " probabilities = stored_predictions[name][:, 1:]\n", + " targets = stored_targets[:, 1:]\n", + " _, empirical_frequency, counts = calibration_binning(probabilities, targets, num_bins=num_bins)\n", + "\n", + " # Match the paper's dataset histogram: bin each per-volume empirical frequency along the y-axis.\n", + " empirical_frequency = empirical_frequency.reshape(-1, num_bins).cpu()\n", + " heatmap = torch.zeros(num_bins, num_bins, dtype=torch.float32)\n", + " for probability_bin in range(num_bins):\n", + " frequency = empirical_frequency[:, probability_bin]\n", + " frequency = frequency[torch.isfinite(frequency)]\n", + " frequency_bin = torch.bucketize(frequency.contiguous(), bin_edges[1:], right=False)\n", + " frequency_bin = frequency_bin.clamp(max=num_bins - 1)\n", + " heatmap[:, probability_bin].scatter_add_(\n", + " 0, frequency_bin, torch.ones_like(frequency_bin, dtype=heatmap.dtype)\n", + " )\n", + "\n", + " column_total = heatmap.sum(dim=0, keepdim=True)\n", + " heatmap = torch.where(column_total > 0, heatmap / column_total, torch.zeros_like(heatmap))\n", + " reliability_axis = axes[0, column]\n", + " heatmap_images.append(\n", + " reliability_axis.imshow(\n", + " heatmap.numpy(),\n", + " origin=\"lower\",\n", + " extent=(0, 1, 0, 1),\n", + " aspect=\"equal\",\n", + " cmap=\"YlOrRd\",\n", + " vmin=0,\n", + " vmax=1,\n", + " interpolation=\"nearest\",\n", + " )\n", + " )\n", + " reliability_axis.plot([0, 1], [0, 1], linestyle=\"--\", color=\"black\", linewidth=1)\n", + " reliability_axis.set_title(name)\n", + " reliability_axis.set_xlim(0, 1)\n", + " reliability_axis.set_ylim(0, 1)\n", + " if column == 0:\n", + " reliability_axis.set_ylabel(\"Empirical foreground frequency\")\n", + "\n", + " count_axis = axes[1, column]\n", + " aggregate_counts = counts.sum(dim=(0, 1)).cpu()\n", + " count_axis.bar(bin_positions, aggregate_counts, width=0.9 * bin_width, color=\"#4c78a8\")\n", + " nonzero_counts = aggregate_counts[aggregate_counts > 0]\n", + " if len(nonzero_counts) and nonzero_counts.max() / nonzero_counts.min() > 100:\n", + " count_axis.set_yscale(\"log\")\n", + " count_axis.set_xlim(0, 1)\n", + " count_axis.set_xlabel(\"Predicted foreground probability\")\n", + " if column == 0:\n", + " count_axis.set_ylabel(\"Voxel count\")\n", + "\n", + "fig.colorbar(\n", + " heatmap_images[-1],\n", + " ax=list(axes[0]),\n", + " label=\"Fraction of volume-class observations\",\n", + " fraction=0.025,\n", + " pad=0.02,\n", + ")\n", + "fig.suptitle(\"Held-out dataset reliability histograms\", fontsize=14)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e1412067", + "metadata": {}, + "source": [ + "## Optional Ignite handler example\n", + "\n", + "`CalibrationError` wraps the metric for an Ignite evaluator. The engine below evaluates complete 3D volumes\n", + "and writes the aggregate foreground ECE to `engine.state.metrics`." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2d94999f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'foreground_ece': 0.0010597537038847804}\n" + ] + } + ], + "source": [ + "handler_model = make_model()\n", + "handler_model.load_state_dict(states[\"segmentation only\"])\n", + "\n", + "\n", + "def evaluation_step(engine, batch):\n", + " del engine\n", + " image = batch[\"image\"].to(device)\n", + " label = batch[\"label\"].to(device)\n", + " handler_model.eval()\n", + " with torch.no_grad():\n", + " probability = torch.softmax(handler_model(image), dim=1)\n", + " target = F.one_hot(label[:, 0], num_classes=3).movedim(-1, 1).float()\n", + " return {\"pred\": probability, \"label\": target}\n", + "\n", + "\n", + "evaluator = Engine(evaluation_step)\n", + "CalibrationError(\n", + " num_bins=20,\n", + " include_background=False,\n", + " calibration_reduction=\"expected\",\n", + " output_transform=from_engine([\"pred\", \"label\"]),\n", + ").attach(evaluator, \"foreground_ece\")\n", + "evaluator.run(test_loader)\n", + "print(evaluator.state.metrics)" + ] + }, + { + "cell_type": "markdown", + "id": "68da8b6d", + "metadata": {}, + "source": [ + "## Practical guidance and limitations\n", + "\n", + "- Split medical data by patient or volume before constructing datasets.\n", + "- Use genuinely 3D inputs when calibration bins should represent volume-scale voxel distributions.\n", + "- Select the bin count and auxiliary coefficient on validation data, never on the test cohort.\n", + "- Report segmentation quality beside calibration because lower calibration error can accompany lower Dice.\n", + "- Decide whether background is scientifically meaningful; it can dominate small foreground structures.\n", + "- Empty target classes contribute zero in these losses, matching the paper's reference implementation.\n", + "- Hard assignments have discrete bin boundaries. Soft assignments interpolate between neighboring centers.\n", + "- Finite-bin estimates depend on bin count, spatial support, and aggregation. State whether results are\n", + " per-volume or pooled.\n", + "- This tutorial uses a modest cohort and one seed to remain runnable. A study should use all available\n", + " training data, multiple seeds, and confidence intervals.\n", + "- Calibration does not by itself establish uncertainty quality, robustness, or clinical safety." + ] + }, + { + "cell_type": "markdown", + "id": "4413ded9", + "metadata": {}, + "source": [ + "## Clean up\n", + "\n", + "A user-specified data directory is preserved for reuse. Only a temporary directory created by this notebook is\n", + "removed." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e9def49f", + "metadata": {}, + "outputs": [], + "source": [ + "torch.use_deterministic_algorithms(False)\n", + "set_determinism(seed=None)\n", + "if directory is None:\n", + " shutil.rmtree(root_dir)\n", + " print(\"Removed temporary dataset directory\")" + ] + }, + { + "cell_type": "markdown", + "id": "260d815f", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "1. T. Barfoot, L. C. Garcia-Peraza-Herrera, S. Akcay, B. Glocker, and T. Vercauteren,\n", + " “Average Calibration Losses for Reliable Uncertainty in Medical Image Segmentation,”\n", + " *IEEE Transactions on Medical Imaging*, vol. 45, no. 7, pp. 3412–3423, 2026.\n", + " [doi:10.1109/TMI.2026.3673118](https://doi.org/10.1109/TMI.2026.3673118).\n", + "2. T. Barfoot, L. C. Garcia Peraza Herrera, B. Glocker, and T. Vercauteren,\n", + " “Average Calibration Error: A Differentiable Loss for Improved Reliability in Image Segmentation,”\n", + " MICCAI 2024. [Paper](https://papers.miccai.org/miccai-2024/091-Paper3075.html).\n", + "3. M. Antonelli et al., “The Medical Segmentation Decathlon,” *Nature Communications*, vol. 13,\n", + " article 4128, 2022. [doi:10.1038/s41467-022-30695-9](https://doi.org/10.1038/s41467-022-30695-9).\n", + "4. C. Guo, G. Pleiss, Y. Sun, and K. Q. Weinberger, “On Calibration of Modern Neural Networks,”\n", + " ICML 2017." + ] + } + ], + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 2f206db72d7a36fc0329ab25872133135d1c3da1 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 3 Sep 2026 15:39:31 +0000 Subject: [PATCH 2/2] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- calibration/segmentation_calibration.ipynb | 57 +++++----------------- 1 file changed, 11 insertions(+), 46 deletions(-) diff --git a/calibration/segmentation_calibration.ipynb b/calibration/segmentation_calibration.ipynb index d2d226b83..3465937e3 100644 --- a/calibration/segmentation_calibration.ipynb +++ b/calibration/segmentation_calibration.ipynb @@ -459,11 +459,7 @@ "\n", "\n", "image_paths = sorted(\n", - " (\n", - " path\n", - " for path in (data_dir / \"imagesTr\").glob(\"hippocampus_*.nii.gz\")\n", - " if not path.name.startswith(\"._\")\n", - " ),\n", + " (path for path in (data_dir / \"imagesTr\").glob(\"hippocampus_*.nii.gz\") if not path.name.startswith(\"._\")),\n", " key=natural_key,\n", ")\n", "split_rng = random.Random(seed)\n", @@ -474,10 +470,7 @@ "\n", "\n", "def files(paths):\n", - " return [\n", - " {\"image\": str(path), \"label\": str(data_dir / \"labelsTr\" / path.name)}\n", - " for path in paths\n", - " ]\n", + " return [{\"image\": str(path), \"label\": str(data_dir / \"labelsTr\" / path.name)} for path in paths]\n", "\n", "\n", "train_files, val_files, test_files = files(train_paths), files(val_paths), files(test_paths)\n", @@ -733,12 +726,7 @@ "probe_model.load_state_dict(initial_state)\n", "with torch.no_grad():\n", " probe_logits = probe_model(example_image[None].to(device))\n", - " probe_target = (\n", - " F.one_hot(example_label[None, 0].long(), num_classes=3)\n", - " .movedim(-1, 1)\n", - " .float()\n", - " .to(device)\n", - " )\n", + " probe_target = F.one_hot(example_label[None, 0].long(), num_classes=3).movedim(-1, 1).float().to(device)\n", " hard_value = hard_ace(probe_logits, probe_target).item()\n", " soft_value = soft_ace(probe_logits, probe_target).item()\n", "print(f\"Same 3D logits: hard L1-ACE={hard_value:.6f}, soft L1-ACE={soft_value:.6f}\")\n", @@ -792,11 +780,7 @@ " label = batch[\"label\"].to(device)\n", " probability = torch.softmax(model(image), dim=1)\n", " target = F.one_hot(label[:, 0], num_classes=3).movedim(-1, 1).float()\n", - " prediction = (\n", - " F.one_hot(probability.argmax(dim=1), num_classes=3)\n", - " .movedim(-1, 1)\n", - " .float()\n", - " )\n", + " prediction = F.one_hot(probability.argmax(dim=1), num_classes=3).movedim(-1, 1).float()\n", " dice_metric(y_pred=prediction, y=target)\n", " for metric in calibration_metrics.values():\n", " metric(y_pred=probability, y=target)\n", @@ -804,12 +788,7 @@ " probabilities.append(probability.cpu())\n", " targets.append(target.cpu())\n", " scores = {\"Dice\": dice_metric.aggregate().item()}\n", - " scores.update(\n", - " {\n", - " name: metric.aggregate().item()\n", - " for name, metric in calibration_metrics.items()\n", - " }\n", - " )\n", + " scores.update({name: metric.aggregate().item() for name, metric in calibration_metrics.items()})\n", " if store_predictions:\n", " return scores, torch.cat(probabilities), torch.cat(targets)\n", " return scores\n", @@ -863,16 +842,10 @@ " if val_scores[\"Dice\"] > best_val_dice:\n", " best_val_dice = val_scores[\"Dice\"]\n", " best_epoch = epoch\n", - " best_state = {\n", - " key: value.detach().cpu().clone()\n", - " for key, value in model.state_dict().items()\n", - " }\n", + " best_state = {key: value.detach().cpu().clone() for key, value in model.state_dict().items()}\n", " model.load_state_dict(best_state)\n", " val_scores = evaluate(model, val_loader)\n", - " print(\n", - " f\"selected epoch {best_epoch}: Dice={val_scores['Dice']:.4f}, \"\n", - " f\"ACE={val_scores['ACE']:.4f}\"\n", - " )\n", + " print(f\"selected epoch {best_epoch}: Dice={val_scores['Dice']:.4f}, \" f\"ACE={val_scores['ACE']:.4f}\")\n", " return best_state, val_scores" ] }, @@ -1024,10 +997,7 @@ "source": [ "print(f\"{'configuration':<20} {'Dice':>10} {'ECE':>10} {'ACE':>10} {'MCE':>10}\")\n", "for name, scores in validation_results.items():\n", - " print(\n", - " f\"{name:<20} {scores['Dice']:10.6f} {scores['ECE']:10.6f} \"\n", - " f\"{scores['ACE']:10.6f} {scores['MCE']:10.6f}\"\n", - " )" + " print(f\"{name:<20} {scores['Dice']:10.6f} {scores['ECE']:10.6f} \" f\"{scores['ACE']:10.6f} {scores['MCE']:10.6f}\")" ] }, { @@ -1074,10 +1044,7 @@ "\n", "print(f\"{'configuration':<20} {'Dice':>10} {'ECE':>10} {'ACE':>10} {'MCE':>10}\")\n", "for name, scores in test_results.items():\n", - " print(\n", - " f\"{name:<20} {scores['Dice']:10.6f} {scores['ECE']:10.6f} \"\n", - " f\"{scores['ACE']:10.6f} {scores['MCE']:10.6f}\"\n", - " )\n", + " print(f\"{name:<20} {scores['Dice']:10.6f} {scores['ECE']:10.6f} \" f\"{scores['ACE']:10.6f} {scores['MCE']:10.6f}\")\n", "\n", "baseline = test_results[\"segmentation only\"]\n", "calibrated = test_results[calibrated_name]\n", @@ -1155,7 +1122,7 @@ " fraction=0.02,\n", " pad=0.02,\n", ")\n", - "plt.show()\n" + "plt.show()" ] }, { @@ -1226,9 +1193,7 @@ " frequency = frequency[torch.isfinite(frequency)]\n", " frequency_bin = torch.bucketize(frequency.contiguous(), bin_edges[1:], right=False)\n", " frequency_bin = frequency_bin.clamp(max=num_bins - 1)\n", - " heatmap[:, probability_bin].scatter_add_(\n", - " 0, frequency_bin, torch.ones_like(frequency_bin, dtype=heatmap.dtype)\n", - " )\n", + " heatmap[:, probability_bin].scatter_add_(0, frequency_bin, torch.ones_like(frequency_bin, dtype=heatmap.dtype))\n", "\n", " column_total = heatmap.sum(dim=0, keepdim=True)\n", " heatmap = torch.where(column_total > 0, heatmap / column_total, torch.zeros_like(heatmap))\n",