From 2708a1c320210ccafc51720e357e98b429913555 Mon Sep 17 00:00:00 2001 From: bmandracchia Date: Tue, 15 Oct 2024 20:32:25 +0200 Subject: [PATCH] update core --- nbs/00_core.ipynb | 51 ++++++++ nbs/07_callbacks.ipynb | 9 +- nbs/901_demo_RI2FL_2d.ipynb | 6 +- nbs/902_tutorial_1.ipynb | 227 ++++++++++++++++++++++++++++++------ 4 files changed, 252 insertions(+), 41 deletions(-) diff --git a/nbs/00_core.ipynb b/nbs/00_core.ipynb index 4e28422..ac50795 100755 --- a/nbs/00_core.ipynb +++ b/nbs/00_core.ipynb @@ -450,6 +450,57 @@ " print('Inferred learning rate: ', lr)\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class visionTrainer(Learner):\n", + " \"\"\"\n", + " A custom implementation of the FastAI Learner class for training models in bioinformatics applications.\n", + "\n", + " \"\"\"\n", + " \n", + " def __init__(self, \n", + " dataloaders: DataLoaders, # The DataLoader objects containing training and validation datasets.\n", + " model: callable, # A callable model that will be trained on the dataset.\n", + " loss_fn: Any | None = None, # The loss function to optimize during training. If None, defaults to a suitable default.\n", + " optimizer: Optimizer | OptimWrapper = Adam, # The optimizer function to use. Defaults to Adam if not specified.\n", + " lr: float | slice = 1e-3, # Learning rate for the optimizer. Can be a float or a slice object for learning rate scheduling.\n", + " splitter: callable = trainable_params, # \n", + " callbacks: Callback | MutableSequence | None = None, # A callable that determines which parameters of the model should be updated during training.\n", + " metrics: Any | MutableSequence | None = None, # Optional list of callback functions to customize training behavior.\n", + " csv_log: bool = False, # Metrics to evaluate the performance of the model during training.\n", + " show_graph: bool = True, # Whether to log training history to a CSV file. If True, logs will be appended to 'history.csv'.\n", + " show_summary: bool = False, # The base directory where models are saved or loaded from. Defaults to None.\n", + " find_lr: bool = False, # Subdirectory within the base path where trained models are stored. Default is 'models'.\n", + " find_lr_fn = valley, # Weight decay factor for optimization. Defaults to None.\n", + " path: str | Path | None = None, # Whether to apply weight decay to batch normalization and bias parameters.\n", + " model_dir: str | Path = 'models', # Whether to update the batch normalization statistics during training.\n", + " wd: float | int | None = None, \n", + " wd_bn_bias: bool = False, \n", + " train_bn: bool = True, \n", + " moms: tuple = ..., # Tuple of tuples representing the momentum values for different layers in the model. Defaults to FastAI's default settings if not specified.\n", + " default_cbs: bool = True, # Automatically include default callbacks such as ShowGraphCallback and CSVLogger.\n", + " ):\n", + " cbs = callbacks if callbacks is not None else [] # Ensure cbs is a list\n", + " if default_cbs:\n", + " if show_graph:\n", + " cbs.append(ShowGraphCallback())\n", + " if csv_log:\n", + " cbs.append(CSVLogger(fname='history.csv', append=False))\n", + " \n", + " super().__init__(dataloaders, model, loss_fn, optimizer, lr, splitter, cbs, metrics, path, model_dir, wd, wd_bn_bias, train_bn, moms)\n", + " \n", + " if show_summary:\n", + " print(self.summary())\n", + " if find_lr:\n", + " self.lr_find(suggest_funcs=find_lr_fn)\n", + " lr = float('%.1g'%(lr))\n", + " print('Inferred learning rate: ', lr)" + ] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/nbs/07_callbacks.ipynb b/nbs/07_callbacks.ipynb index f1866f9..a30b7cc 100644 --- a/nbs/07_callbacks.ipynb +++ b/nbs/07_callbacks.ipynb @@ -85,7 +85,7 @@ } ], "source": [ - "show_doc(ShortEpochCallback)\n" + "show_doc(ShortEpochCallback)" ] }, { @@ -124,7 +124,6 @@ } ], "source": [ - "\n", "show_doc(GradientAccumulation)" ] }, @@ -535,9 +534,13 @@ ], "metadata": { "kernelspec": { - "display_name": "python3", + "display_name": "bioMONAI-env", "language": "python", "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11.5" } }, "nbformat": 4, diff --git a/nbs/901_demo_RI2FL_2d.ipynb b/nbs/901_demo_RI2FL_2d.ipynb index 3f5403f..e84f6f7 100644 --- a/nbs/901_demo_RI2FL_2d.ipynb +++ b/nbs/901_demo_RI2FL_2d.ipynb @@ -281,9 +281,13 @@ ], "metadata": { "kernelspec": { - "display_name": "python3", + "display_name": "bioMONAI-env", "language": "python", "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11.5" } }, "nbformat": 4, diff --git a/nbs/902_tutorial_1.ipynb b/nbs/902_tutorial_1.ipynb index 52b6b93..4c4312e 100644 --- a/nbs/902_tutorial_1.ipynb +++ b/nbs/902_tutorial_1.ipynb @@ -217,42 +217,42 @@ "Building one sample\n", " Pipeline: BioImageMulti.create -> Tensor2BioImage -- {}\n", " starting from\n", - " ../_data/medmnist_data/train/5/train_2282.png\n", + " ../_data/medmnist_data/train/0/train_4525.png\n", " applying BioImageMulti.create gives\n", " BioImageMulti of size 3x28x28\n", " applying Tensor2BioImage -- {} gives\n", " BioImageMulti of size 3x28x28\n", " Pipeline: parent_label -> Categorize -- {'vocab': ['0', '1', '2', '3', '4', '5', '6', '7'], 'sort': True, 'add_na': False}\n", " starting from\n", - " ../_data/medmnist_data/train/5/train_2282.png\n", + " ../_data/medmnist_data/train/0/train_4525.png\n", " applying parent_label gives\n", - " 5\n", + " 0\n", " applying Categorize -- {'vocab': ['0', '1', '2', '3', '4', '5', '6', '7'], 'sort': True, 'add_na': False} gives\n", - " TensorCategory(5)\n", + " TensorCategory(0)\n", "\n", - "Final sample: (BioImageMulti([[[209., 222., 224., ..., 252., 253., 253.],\n", - " [219., 211., 210., ..., 252., 253., 253.],\n", - " [212., 211., 219., ..., 252., 253., 253.],\n", + "Final sample: (BioImageMulti([[[255., 255., 253., ..., 215., 225., 216.],\n", + " [253., 255., 254., ..., 198., 206., 203.],\n", + " [239., 253., 255., ..., 187., 194., 198.],\n", " ...,\n", - " [255., 255., 255., ..., 199., 215., 231.],\n", - " [251., 255., 255., ..., 212., 232., 242.],\n", - " [250., 255., 255., ..., 223., 242., 250.]],\n", + " [230., 206., 194., ..., 255., 255., 255.],\n", + " [244., 217., 197., ..., 255., 255., 255.],\n", + " [254., 226., 200., ..., 255., 255., 255.]],\n", "\n", - " [[171., 187., 189., ..., 232., 231., 231.],\n", - " [184., 177., 176., ..., 232., 231., 231.],\n", - " [179., 178., 186., ..., 232., 231., 231.],\n", + " [[232., 230., 225., ..., 178., 186., 175.],\n", + " [226., 229., 226., ..., 162., 168., 163.],\n", + " [213., 227., 229., ..., 153., 158., 163.],\n", " ...,\n", - " [230., 233., 232., ..., 176., 194., 210.],\n", - " [228., 233., 233., ..., 190., 210., 221.],\n", - " [228., 233., 235., ..., 200., 221., 228.]],\n", + " [192., 167., 155., ..., 229., 229., 231.],\n", + " [206., 179., 158., ..., 229., 229., 231.],\n", + " [217., 189., 162., ..., 229., 230., 231.]],\n", "\n", - " [[182., 194., 193., ..., 207., 208., 207.],\n", - " [188., 178., 175., ..., 207., 207., 207.],\n", - " [172., 171., 179., ..., 205., 207., 208.],\n", + " [[225., 221., 213., ..., 196., 204., 189.],\n", + " [217., 218., 212., ..., 174., 179., 171.],\n", + " [200., 212., 210., ..., 152., 158., 161.],\n", " ...,\n", - " [190., 196., 197., ..., 184., 189., 193.],\n", - " [187., 195., 195., ..., 192., 199., 200.],\n", - " [187., 194., 196., ..., 194., 204., 204.]]]), TensorCategory(5))\n", + " [191., 168., 156., ..., 206., 202., 201.],\n", + " [203., 178., 161., ..., 206., 202., 201.],\n", + " [208., 181., 161., ..., 204., 200., 201.]]]), TensorCategory(0))\n", "\n", "\n", "Collecting items from ../_data/medmnist_data\n", @@ -260,19 +260,25 @@ "2 datasets of sizes 13674,3418\n", "Setting up Pipeline: BioImageMulti.create -> Tensor2BioImage -- {}\n", "Setting up Pipeline: parent_label -> Categorize -- {'vocab': ['0', '1', '2', '3', '4', '5', '6', '7'], 'sort': True, 'add_na': False}\n", - "Setting up after_item: Pipeline: Resample -> ToTensor\n", + "Setting up after_item: Pipeline: ScaleIntensity -> RandCrop2D -- {'size': (128, 128), 'lazy': False, 'p': 1.0} -> RandRot90 -- {'prob': 0.5, 'max_k': 3, 'spatial_axes': (0, 1), 'ndim': 2, 'lazy': False, 'p': 1.0} -> RandFlip -- {'prob': 0.75, 'spatial_axis': None, 'ndim': 2, 'lazy': False, 'p': 1.0} -> ToTensor\n", "Setting up before_batch: Pipeline: \n", "Setting up after_batch: Pipeline: \n", "\n", "Building one batch\n", "Applying item_tfms to the first sample:\n", - " Pipeline: Resample -> ToTensor\n", + " Pipeline: ScaleIntensity -> RandCrop2D -- {'size': (128, 128), 'lazy': False, 'p': 1.0} -> RandRot90 -- {'prob': 0.5, 'max_k': 3, 'spatial_axes': (0, 1), 'ndim': 2, 'lazy': False, 'p': 1.0} -> RandFlip -- {'prob': 0.75, 'spatial_axis': None, 'ndim': 2, 'lazy': False, 'p': 1.0} -> ToTensor\n", " starting from\n", - " (BioImageMulti of size 3x28x28, TensorCategory(5))\n", - " applying Resample gives\n", - " (BioImageMulti of size 3x14x14, TensorCategory(5))\n", + " (BioImageMulti of size 3x28x28, TensorCategory(0))\n", + " applying ScaleIntensity gives\n", + " (BioImageMulti of size 3x28x28, TensorCategory(0))\n", + " applying RandCrop2D -- {'size': (128, 128), 'lazy': False, 'p': 1.0} gives\n", + " (BioImageMulti of size 3x28x28, TensorCategory(0))\n", + " applying RandRot90 -- {'prob': 0.5, 'max_k': 3, 'spatial_axes': (0, 1), 'ndim': 2, 'lazy': False, 'p': 1.0} gives\n", + " (BioImageMulti of size 3x28x28, TensorCategory(0))\n", + " applying RandFlip -- {'prob': 0.75, 'spatial_axis': None, 'ndim': 2, 'lazy': False, 'p': 1.0} gives\n", + " (BioImageMulti of size 3x28x28, TensorCategory(0))\n", " applying ToTensor gives\n", - " (BioImageMulti of size 3x14x14, TensorCategory(5))\n", + " (BioImageMulti of size 3x28x28, TensorCategory(0))\n", "\n", "Adding the next 3 samples\n", "\n", @@ -299,7 +305,7 @@ " 'get_items': get_image_files,\n", " 'get_y': parent_label,\n", " 'splitter': GrandparentSplitter(),\n", - " 'item_tfms': [Resample(2)],\n", + " 'item_tfms': [ScaleIntensity(min=0.0, max=1.0),RandCrop2D(size), RandRot90(prob=0.5), RandFlip(prob=0.75)],\n", " 'bs': bs,\n", "}\n", "\n", @@ -320,7 +326,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeMAAAH2CAYAAABDbOQQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAi6klEQVR4nO3de3CVhb3u8d+7riFZ5EZIQhJJYiI3K0ppOV5G3WrbXS27e9eNemz3VsfLsI8X5szRdnpqFUUdnakznem0VMciOOo+cuxmRnToBZXS3X2oG7RYS0EJEgiXhBBuua/be/7oyBQBWT4Bfjv4/czwR9P1rHetZL3r4Y0hTxCGYWgAAMBNxPsBAADwWUcZAwDgjDIGAMAZZQwAgDPKGAAAZ5QxAADOKGMAAJxRxgAAOKOMAQBwRhmfREuWLLEgCGzdunUn5f6CILC77777pNzXX9/nQw89JOe///3v2+zZs62+vt6CILBbbrnlpD02YLThnMfJQhnjU/nhD39oPT099vWvf90SiYT3wwFwinHOnx4x7weA0aW3t9cikb/8He755593fjQATjXO+dODK+PTbGhoyO6991674IILrKyszCorK+2iiy6yV1555biZp59+2iZNmmTJZNKmTZtmL7300lG36ezstLlz51pDQ4MlEglrbm62hx9+2LLZ7El9/B+dlAAKwzmPQnBlfJoNDw/bvn377L777rP6+npLp9P2+uuv27XXXmuLFy+2m2666YjbL1++3FatWmULFiywkpISW7hwod14440Wi8Vszpw5ZvaXk3LWrFkWiUTswQcftJaWFluzZo09+uij1t7ebosXL/7Ex9TU1GRmZu3t7afiKQOfaZzzKEiIk2bx4sWhmYVr164tOJPNZsNMJhPedttt4YwZM474/8wsHDNmTNjZ2XnE7adMmRK2trYe/tjcuXPDVCoVbtu27Yj8k08+GZpZuGHDhiPuc/78+UfcrqWlJWxpaSn4MX+kpKQkvPnmmz91DjhTcM7jZOH7Dw5efvllu+SSSyyVSlksFrN4PG6LFi2yjRs3HnXbq666ympqag7/72g0ajfccIO1tbXZjh07zMzstddesyuuuMLq6uosm80e/nP11Vebmdnq1as/8fG0tbVZW1vbSXyGAP4a5zxOhDI+zZYtW2bXX3+91dfX2wsvvGBr1qyxtWvX2q233mpDQ0NH3b62tva4H+vp6TEzs66uLnv11VctHo8f8efcc881M7O9e/eewmcE4JNwzqMQ/Dfj0+yFF16w5uZmW7p0qQVBcPjjw8PDx7x9Z2fncT82btw4MzOrqqqy6dOn22OPPXbM+6irqxvpwwYg4pxHISjj0ywIAkskEkeclJ2dncf9yco33njDurq6Dn/bKpfL2dKlS62lpcUaGhrMzGz27Nm2YsUKa2lpsYqKilP/JAAUjHMehaCMT4E333zzmD+leM0119js2bNt2bJlduedd9qcOXOso6PDHnnkEZswYYJt3rz5qExVVZVdeeWV9sADDxz+ycpNmzYd8U8dFixYYCtXrrSLL77Y5s2bZ5MnT7ahoSFrb2+3FStW2FNPPXX4JD6W1tZWM7OC/hvS6tWrrbu728z+8iaxbds2+/nPf25mZpdffrmNHz/+hPcBnGk45zFi3j9Bdib56Ccrj/dn69atYRiG4RNPPBE2NTWFyWQynDp1avjMM8+E8+fPDz/+5TCz8K677goXLlwYtrS0hPF4PJwyZUr44osvHnXs7u7ucN68eWFzc3MYj8fDysrKcObMmeH9998f9vX1HXGfH//JysbGxrCxsbGg53j55Zcf9/mtWrXq03y6gFGPc37Vp/l04RMEYRiGp77yAQDA8fDT1AAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4K/g1c21avlw8ynN0vZzv2vCdnp5x7tpwtqxgnZ4uSZXJ2cHBQzsbjUTkbOVAsZ7dt/0DObt/xvpytqzv6F+oXKp3W/x7a36ePt1/8T/8sZ13s+k89m8/L0VxmJL/+YKyc3PTn7XI2HuivqVTJsX9PdSHyYbeczUT0X8J4VlOznI0ESTmbz8bl7M5te+TsoZ5+OXveP8454W24MgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBGGQMA4IwyBgDAGWUMAIAzyhgAAGeUMQAAzihjAACcUcYAADgreD+ra9eH8kEi0YycjaXlqCUz+jxYKl+kH7hfn39LZfR5sNyAPu03mD4kZ2sn6HOTrZP+Rs4eOHBAzm7auFXOhmFCzo42HZv1eb6Ssfr5V1lXIWfDrP5abj5Hnz/d1b5Xzg4P6e8ZJcXVcraqWp9OjQUjeI8sSsnRXW075OzGjfpkazIYI2cLwZUxAADOKGMAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBGGQMA4IwyBgDAWcEbZ/nMQfkgg/39crZ5YpOcrUrq02KdG3bJ2b079Sm1voP65yrM6DNsu0L9MadKS+TszJkz9eOmyuVsLhuVs/GEPg042kQDfcrwwL49+oFjfXJ0bIU+7RdL6NnWqZPkbP6Qfl0USehzhJbS5yYtm5ej+YP6rO5wv76rO3asPpFZFBnBZGQBuDIGAMAZZQwAgDPKGAAAZ5QxAADOKGMAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4K3gLbvqF5+hHycblaCJbLGfX/e5dOdvVvkPOFoVJOZscwUzX0EBOziZqGuRs/179uP++sl3OTjlXn6wrH6s/3zAYkLOjTVGRPhcZRPVpzb5D+mRrWVmVnB3o15/v79f8Uc7u69RfU/v27pOz9Q369diUc6fK2cYRZIuL9NnHbLpLzvZl9VnPQnBlDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBGGQMA4IwyBgDAGWUMAIAzyhgAAGeUMQAAzihjAACcUcYAADijjAEAcFbwXlh83Aim1NL6lNrOP/fL2aKSs+RsaENydjiXlbPJonFytiiiTzeeVfd5ObvkuX+Vs3nT5zX/9M7bcraselDO3vIvfytnR5tEsX7+DR3M6MeN1MvZ7R+k5OwD//vHcjbIJORsdZU+nfqlL8+Us4P7d8rZ3//2D3J2+zZ9yvDSv/uynN24caOcTRbp76+F4MoYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBGGQMA4IwyBgDAGWUMAIAzyhgAAGeUMQAAzihjAACcUcYAADijjAEAcEYZAwDgrOBdxEiJPg/W15eXs5s/3C9n1705grmsUI5aZYU+Gbnyd7+TsxUVE+Xs2BFMVQ706PNvQUSfu+s9qL82+tMH5Gxpqf6YR5v+IX1ibzitv2dUlU2Vs4/P1yc9+/bWydnK0nI5u79b/zwPDujvr+FgVM6Wl42Xszvbd8vZ7i3tcnZivf717djVIWcLwZUxAADOKGMAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBGGQMA4IwyBgDAWcETins69ImvsLdGzq587S05Gx+qkrN7eg/I2dRY/bhjq8+Ssz2HAjnb3KBvRu7pzMlZy+sTbsn4WDkb5rvk7ODQgJwdIyd9pIczcnb8+Ho5myqrlLPbO7bI2Vi8Wc7msvo5VFZaLWeLk7Vytqa8XM529eidEAv1835HxzY5O3V6q5zdvkt/XRWCK2MAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBGGQMA4IwyBgDAGWUMAICzgicUq5Ll8kG2fHBIzsaH9dG5wb36pFlp2Tg529+blbMDg/pjTodxOTu+vl/O1h3Ky9lB/bDWtW+/nL3y8gvlbDSqf41Gm7MaP6eH8wW/vRwlTHfL2Tn//VI5u25Np5wdPqhPifb26ifCy//nDTl7frP+Wj7rbH26MUjKUSsp0juhaFyZnL3kMv09oxBcGQMA4IwyBgDAGWUMAIAzyhgAAGeUMQAAzihjAACcUcYAADijjAEAcEYZAwDgjDIGAMAZZQwAgDPKGAAAZ5QxAADOKGMAAJwVvHEWj1XqBykZlrN7Mhk5W17XLGd37tan1KrrS+TstOrdcjaV6JKztQfPkbOJMn2GLTlxUM7u7NVfGxMq9WzC9Am30SYMq+RsOqdPXMaLeuXshInFcnbnv+2Rs8n8uXJ2XFmLnN1/aKuc7e1IyNmi5iY529P7jpwdN34E51/QJ0ejiah+3AJwZQwAgDPKGAAAZ5QxAADOKGMAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBW8IRiOKxPzhVF9M4f7u2Rs5lQnxSM5g7K2YGefjk7aXK1nA2G83I2Ho/L2URCn2HLmT6/WFmlz3p2dHTI2Sn9+tykPu7nY2hYn5wrKi747eUomeyAnK2uqZCzVVVFcnbn1h1yNj2sv88Vl6blbDgm0LPxMjk7ob5czo5rqZOzYfqQnI0l9NdGIbgyBgDAGWUMAIAzyhgAAGeUMQAAzihjAACcUcYAADijjAEAcEYZAwDgjDIGAMAZZQwAgDPKGAAAZ5QxAADOKGMAAJxRxgAAOCt442zr+1vkg6QHxsrZ6nL97wu5/m1ytqYsKWfPrtdnEBNZfaqytrJBznbu3Stni1IlcjYo0T/PkYQ+v5iN6HOTXXu75WyznPQRi+uf43RGnxJNJqNy9nPnny1nr/rb/XL2/z6/Ws7m8/rrsXWq/qqqTQ3J2ezYnXL20iu/IGetSJ99DIb1uVeL6jOzheDKGAAAZ5QxAADOKGMAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBGGQMA4CwIw7CgjbSdv/mFfJCdHQfl7OChIjnbvVOfQwuHBuTsmNywnK1OpfTs2Co5275Tn8gM4gUvcR4lVzSCvw+W6vOLDZMn6scdo0cnffUaPewgu22dnM2F+jmUGMGEYpDVzyHL6fOnuUH9hfHOurVyNhvq73ONjaVytq55gpy1RE7PZvW5SQv194wD+/vkbPn0i054G66MAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBGGQMA4IwyBgDAGWUMAIAzyhgAAGeUMQAAzgrevssl9EmzVPVYOTuU75WzLeePl7PVFfpj3vC2Pod2YOCQnD20X59ujBbrM4gDmSE5WzK2TM5OnXmunN1zqEfOdu3qlrOT5KSPfKi/phKxuJwN4vrU3fY2fQ50T9d6OZuI6tONTefo71Xja0fwqirW39c7d2yXs127O+XsmKJKOVuaqpWzb77xWzn7TSYUAQD4r48yBgDAGWUMAIAzyhgAAGeUMQAAzihjAACcUcYAADijjAEAcEYZAwDgjDIGAMAZZQwAgDPKGAAAZ5QxAADOKGMAAJwVvJvXnx2UD5IbQeUHY/L6cRP6tN+ESc1ytrrpUjl7sLtfzh7Ym5azsQH985wP5KhZUg/35wbkbLRIn47L79c/V6NNoighZ3PprJ49oH9td+7cJWfHlpTK2TEjeK/q6PiznB0a0icFoyXlcnbv3v1ytrKiRs4O94/g/Evr5/1Xv3y1ftwCcGUMAIAzyhgAAGeUMQAAzihjAACcUcYAADijjAEAcEYZAwDgjDIGAMAZZQwAgDPKGAAAZ5QxAADOKGMAAJxRxgAAOKOMAQBwFoRhGHo/CAAAPsu4MgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBGGQMA4IwyBgDAGWUMAIAzyhgAAGeUMQAAzihjAACcUcYAADijjAEAcEYZAwDgjDIGAMAZZQwAgDPKGAAAZ5QxAADOKGMAAJxRxifRkiVLLAgCW7du3Um5vyAI7O677z4p9/XX9/nQQw9J2Y6ODvvGN75hZ599tpWUlFhZWZnNmDHDfvzjH1s2mz2pjxMYDc70c/6hhx6yIAiO++ell146qY/1syzm/QAwevT391tpaak98MADNnHiREun07ZixQq75557bP369fazn/3M+yECOIluv/12++pXv3rUx++44w7bsmXLMf8/aChjFGzKlCn23HPPHfGxq6++2vbs2WPPPfec/eQnP7FkMun06ACcbA0NDdbQ0HDEx9rb223Dhg32rW99y8rLy30e2BmIb1OfZkNDQ3bvvffaBRdcYGVlZVZZWWkXXXSRvfLKK8fNPP300zZp0iRLJpM2bdq0Y35rqLOz0+bOnWsNDQ2WSCSsubnZHn744dPy7ePx48dbJBKxaDR6yo8FjDZn2jn/7LPPWhiGdvvtt5/S43zWcGV8mg0PD9u+ffvsvvvus/r6ekun0/b666/btddea4sXL7abbrrpiNsvX77cVq1aZQsWLLCSkhJbuHCh3XjjjRaLxWzOnDlm9peTctasWRaJROzBBx+0lpYWW7NmjT366KPW3t5uixcv/sTH1NTUZGZ/+RtvIcIwtFwuZ729vfbrX//alixZYvfee6/FYrycgI87E875j+TzeVuyZIm1trba5Zdf/qmyOIEQJ83ixYtDMwvXrl1bcCabzYaZTCa87bbbwhkzZhzx/5lZOGbMmLCzs/OI20+ZMiVsbW09/LG5c+eGqVQq3LZt2xH5J598MjSzcMOGDUfc5/z584+4XUtLS9jS0lLwY3788cdDMwvNLAyCILz//vsLzgJnks/KOf+RX/ziF6GZhY8//vinzuKT8W1qBy+//LJdcskllkqlLBaLWTwet0WLFtnGjRuPuu1VV11lNTU1h/93NBq1G264wdra2mzHjh1mZvbaa6/ZFVdcYXV1dZbNZg//ufrqq83MbPXq1Z/4eNra2qytra3gx3/LLbfY2rVr7Ve/+pV95zvfsR/84Ad2zz33FJwHPmtG+zn/kUWLFlksFrNbbrnlU2fxyfi+4mm2bNkyu/766+26666zb3/721ZbW2uxWMx++tOf2rPPPnvU7Wtra4/7sZ6eHmtoaLCuri579dVXLR6PH/OYe/fuPanPoba29vBj+MpXvmIVFRX23e9+12699VabMWPGST0WMNqdCef8R/e5fPly+9rXvnbMx4iRoYxPsxdeeMGam5tt6dKlFgTB4Y8PDw8f8/adnZ3H/di4cePMzKyqqsqmT59ujz322DHvo66ubqQP+xPNmjXLzMw++OADyhj4mDPlnH/++ectnU7zg1unCGV8mgVBYIlE4oiTsrOz87g/WfnGG29YV1fX4W9b5XI5W7p0qbW0tBz+JwezZ8+2FStWWEtLi1VUVJz6J/Exq1atMjOz1tbW035s4L+6M+WcX7RokdXV1R3+VjhOLsr4FHjzzTeP+VOK11xzjc2ePduWLVtmd955p82ZM8c6OjrskUcesQkTJtjmzZuPylRVVdmVV15pDzzwwOGfrNy0adMR/9RhwYIFtnLlSrv44ott3rx5NnnyZBsaGrL29nZbsWKFPfXUU0f9W8G/9lGJnui/Ic2fP9+6urrssssus/r6ejtw4ID98pe/tGeeecauu+46mzlzZoGfIeDMcqae8x956623bMOGDfa9732Pf8J4qnj/BNmZ5KOfrDzen61bt4ZhGIZPPPFE2NTUFCaTyXDq1KnhM888E86fPz/8+JfDzMK77rorXLhwYdjS0hLG4/FwypQp4YsvvnjUsbu7u8N58+aFzc3NYTweDysrK8OZM2eG999/f9jX13fEfX78JysbGxvDxsbGEz6/5cuXh1/60pfCmpqaMBaLhalUKpw1a1b4ox/9KMxkMp/68wWMdmf6Of+RO+64IwyCINyyZUvBGXw6QRiG4emtfwAA8Nf4p00AADijjAEAcEYZAwDgjDIGAMAZZQwAgDPKGAAAZ5QxAADOCv4NXJlda+WDRMK8nA1zQ/pxTR/ZTg8d+/fGFqKotFzODg9l5GwsXiRnzcwiSf0366SH9a/TcH9azq57609yNmmVcjYSJuTsRTddL2dPu93r9Gygv57yef3XH2RHMEaXiKfkbNfubjn77ro/ytlJrZPk7Pia8XJ246Z35awF+vvr9PMny9k1a9bIWQuTcvTyb5541Y4rYwAAnFHGAAA4o4wBAHBGGQMA4IwyBgDAGWUMAIAzyhgAAGeUMQAAzihjAACcUcYAADijjAEAcEYZAwDgjDIGAMAZZQwAgLOCJxSzWX3mbkxSn/YLRzBVF6YLfnpHKUqMlbO5vkDOJhMVctby+vM1MwuH9KnLZLJczsZy/XL28+d/Uc5u3bxDzsYiI/tcjxojmCPMDOmzmrEi/T0jGMFkazrTJ2dLy8bI2WgsJ2f7+vfL2eJ+/f01l9MnaktSxXI2kdBnLi/8b5fK2ba2djlbCK6MAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBGGQMA4IwyBgDAGWUMAIAzyhgAAGeUMQAAzgregYvHo/JBcll9aivI6BNfkXi5nLVQn+nq29UjZ/+wfqOc7d6rT6mZmYUj+Bo3NtXK2c9/cbKcLS8rkbMzZpbKWYvoM32jyaGeA3K2dHyVnA3DYTlrgf5+Ewn0cyBRrL9XNTXXyNld23bJ2b09u+VseVmlnJ02+Tw5axF9XjMS6vO2514wQ84WgitjAACcUcYAADijjAEAcEYZAwDgjDIGAMAZZQwAgDPKGAAAZ5QxAADOKGMAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAs4InFHP59AgOos/cRaLlcnb3+4fk7H+s/J2cXb92s5xNxsbK2XRmZLN+fZmMnF0TeV/Ovrd2i5y98ear5Gxxpf58LTIoR/URt9Pv7bfXy9nzP3++nK2o0t8zglCfUMyNYLoxGujnX8vkVjnbWD9RzuZHdD2mZ9etfVfOHjzYJ2erq8fJ2bNb6+Xs2OoT34YrYwAAnFHGAAA4o4wBAHBGGQMA4IwyBgDAGWUMAIAzyhgAAGeUMQAAzihjAACcUcYAADijjAEAcEYZAwDgjDIGAMAZZQwAgLOCJxQjkYJvepRomJCzmd6onF3zW33W799f3yRnq8ub5ez+bn0erKREn180M4tm9Pm4IJKTswf2xOXs888ul7Nz/9fVcjaI6DN9o0kurf99PcyGcjaI6K+JINTnXvNp/esaxJP6cQf1z3MsWiFnzfQp0PV/eE/O7tndLWdTJeVydqBXf76bNuid8MVpF57wNlwZAwDgjDIGAMAZZQwAgDPKGAAAZ5QxAADOKGMAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnBW8ixiPjJEPku6Xo7byl/8hZ99Zu1XORqxcziaTVfpxo3k5e6BXn180Myur1KfYkokiOduze5+cnXBWo5zt7tLn1MY3BHJWT55+jQ1NcnZcebV+4FCf5LScPruaiOkzpLlBfSp232599nHTe/pU7MwLG+RsPFIiZ4uLBuTs2FSxnA0i+vtrIqnPCBeCK2MAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBGGQMA4IwyBgDAGWUMAICzgjehcsP6QRLJcjn7p/Wb5Wx/rz55FU2Uytn2XbvkbCSakbOpqricNTPrG9gjZ/cf1OfjilNlcjYejJezq1e+LWevu/1SOTuaTDzrbDm7c2ennK2o0idbiyv1GURLVsrRt36pv55e/fl/ytn+Hv197s3fdMnZu+7+H3K2q6tbzg4N65u82eyQnE1mRvb+eiJcGQMA4IwyBgDAGWUMAIAzyhgAAGeUMQAAzihjAACcUcYAADijjAEAcEYZAwDgjDIGAMAZZQwAgDPKGAAAZ5QxAADOKGMAAJwVvL0VjeuzZAd3H5Sz6eFQzpaMYJpvx9b9crY4VSJnS8r1KcL+fI+cNTPL5fWdzExOf86JbIWcbftAn+lLx7bJ2esGLpOzo8mqN38jZ4N4Xs4m9AVFO++C8+TsmDH6HGFFWZOcHTj4rpwtTjTI2Z69W+RseVm1nP3c56bL2T9tWCtny8pTcjaf17uoEFwZAwDgjDIGAMAZZQwAgDPKGAAAZ5QxAADOKGMAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnBW+F5beJR+krLJWzjY11svZd38/IGcnVDXJ2aJkXM5mMl1ytjSlz4OZmWUSWT0c1f9eN/U8/WscFuXk7L6+CXLWikr17CiSqtSzTU1Ncrajo0POtn/4oZz9woWNcjZVNihn68+Ro/bBpt/L2Yuu0M+9WNkhORv29snZIKJPGQ71ZeSs5fR5zUJwZQwAgDPKGAAAZ5QxAADOKGMAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBW+CZUokg/yrA+c7djd7ucbT7nPDnb9uf9cjbdH5WzyTGBnD3Up0+4mZnVTND38r446xI5mzH987Vz31Y5O+1zLXLWLD2C7OgRi1TI2THJKjmbzXXK2cQIXk9m+oxo7YQyOfvNf/o7OVtTrc8+Rir1KcOwT8/W1IyXs+9v1K8hMzl9QjGqvzUXhCtjAACcUcYAADijjAEAcEYZAwDgjDIGAMAZZQwAgDPKGAAAZ5QxAADOKGMAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAs8InFPXlKcvn9Vmyr/39VXL2F6++I2cnT2+Ss8NDctTyWX1usqy8ST+wmU2o0Wcyg5i+LzY8eEDObtjw/+TstTf+i5y1YFjPjiKHDuqvx/Xr2+RsPgzl7LRpZ8vZ/oN75ezGjRvlbHpYf4/s7NKPO2mS/rkqKdMnI830r++sC78oZ9u2fihng+DUbihyZQwAgDPKGAAAZ5QxAADOKGMAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBW8IRiLl/42uLR2bycnX7hZDn73iZ9Wmzzhj/K2ZqqVjmbKq6Ws8ND+iyZmVna9O3HDzs65eymtvfk7D3/82Y5W1IRlbOW79Wzo0jL5CY5m84MyNmKypScHddYL2ff+/1v5Ww+r+/M1tXXyNkD+w7K2T+8s07OXnLJJXI2SI6Rs0UpPXvueVPkbBjoPVYIrowBAHBGGQMA4IwyBgDAGWUMAIAzyhgAAGeUMQAAzihjAACcUcYAADijjAEAcEYZAwDgjDIGAMAZZQwAgDPKGAAAZ5QxAADOCt5FfHudPnPX369PqY0dWyZn/+Ef/0bOvj1xk5xd/3abnD04qM8YBkGxnDUz2z/UL2f7BvVJwX+++e/l7IQJpXJ2e5s+k2nBoBydeNbn9eOeZmdP0T+/QaRcP3CgR7N9PXJ2eDgtZ8tLq+Rs01n6tN/2zA4529f3vpxNp/XPVTIal7MW1ed8Q9NnZiNF+nELuv9Teu8AAOCEKGMAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHBGGQMA4IwyBgDAWcGbUIf26/N6paUpOdt38ICc3bFzi5z9wqxJcvayKy+Sswd69AlFC5N61swsuk+OlqYq5GwunZGzW9r+JGcHB/WpvZwNy9mJcvL0C2P6ayIf6juI0aBIzsbi+jzfWQ3Ncnbndv31tPnP+gxi/yF9zrO0XJ+oTRbr7+vb2/Xnu6uzS87GR/DaqJ9YI2drx517wttwZQwAgDPKGAAAZ5QxAADOKGMAAJxRxgAAOKOMAQBwRhkDAOCMMgYAwBllDACAM8oYAABnlDEAAM4oYwAAnFHGAAA4o4wBAHAWhGEYej8IAAA+y7gyBgDAGWUMAIAzyhgAAGeUMQAAzihjAACcUcYAADijjAEAcEYZAwDgjDIGAMDZ/wc2FX1kpTpZWwAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeMAAAH2CAYAAABDbOQQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABJCUlEQVR4nO3daaxld3nn+99aezr7zGPNdlX5GNvY4AGCO4S+uQxJKxDfjoJIUKSrqAF10yKBbl2SbqSEOIDptJS86O50aEhCbK6ILggJJQ7tC2EwZLgO2HRowJhAgavsKtep+dQZ97jWfeGOhWM/v7XjKvvvKr4fiRep5/z3XntNz97O/u0nK8uyFAAASCZPvQEAAPywoxkDAJAYzRgAgMRoxgAAJEYzBgAgMZoxAACJ0YwBAEiMZgwAQGI0YwAAEqMZX0R33XWXsizTAw88cFEeL8sy/fIv//JFeawffMzf/M3ffEZrH330Uf3sz/6srrrqKk1MTGhmZka33HKL/ut//a8aDAYXdTuBSwHXPC6WeuoNwKVjc3NT09PTeve7360rr7xSvV5P99xzj97+9rfra1/7mv7wD/8w9SYCuIi45p87NGOM7LrrrtNHPvKRJ/3ba1/7Wp08eVIf+chH9Hu/93tqtVqJtg7AxcY1/9zhP1M/xzqdjt75znfq5ptv1szMjObn5/Xyl79cf/qnfxqu+dCHPqRrrrlGrVZL119/vT72sY895W9WVlb01re+Vfv27VOz2dTBgwf1nve85zn5T0lLS0vK81y1Wu1Zfy7gUsM1j1Hwyfg51u12dfbsWf3Kr/yK9u7dq16vp8997nN6/etfrzvvvFO/+Iu/+KS/v/vuu3Xvvffqve99ryYmJvSBD3xAv/ALv6B6va43vOENkh6/KG+99Vblea7f+I3f0PLysu677z7dcccdOnz4sO688067TQcOHJAkHT58eKTXUJalhsOh1tfX9ed//ue666679M53vlP1OqcT8A9xzWMkJS6aO++8s5RU3n///SOvGQwGZb/fL9/ylreUt9xyy5Nqksp2u12urKw86e+vu+668uqrr37i39761reWk5OT5ZEjR560/nd+53dKSeWDDz74pMe8/fbbn/R3y8vL5fLy8sjb/Fu/9VulpFJSmWVZ+Wu/9msjrwUuJ1zzuFj4z9QJfOITn9ArXvEKTU5Oql6vq9Fo6MMf/rAeeuihp/zta17zGu3cufOJ/7tWq+mNb3yjDh06pKNHj0qSPvWpT+lVr3qV9uzZo8Fg8MT/Xvva10qSvvSlL9ntOXTokA4dOjTy9v+Lf/EvdP/99+szn/mM/t2/+3f67d/+bb397W8feT3ww4ZrHlX4bwzPsU9+8pP6+Z//ef3cz/2cfvVXf1W7du1SvV7Xf/tv/01/9Ed/9JS/37VrV/hvZ86c0b59+3TixAn92Z/9mRqNxtM+5+nTpy/qa9i1a9cT2/DP/tk/09zcnN71rnfpzW9+s2655ZaL+lzApY5rHqOgGT/HPvrRj+rgwYP6+Mc/rizLnvj3brf7tH+/srIS/tvCwoIkaXFxUTfeeKPe//73P+1j7Nmz50I327r11lslSd/5zne4MIF/gGseo6AZP8eyLFOz2XzSRbmyshJ+s/Lzn/+8Tpw48cR/thoOh/r4xz+u5eVl7du3T5J022236Z577tHy8rLm5uae/RfxD9x7772SpKuvvvo5f27g+Y5rHqOgGT8LvvCFLzzttxRf97rX6bbbbtMnP/lJve1tb9Mb3vAGPfroo3rf+96n3bt367vf/e5T1iwuLurVr3613v3udz/xzcpvf/vbT4o6vPe979VnP/tZ/diP/Zje8Y536Nprr1Wn09Hhw4d1zz336IMf/OATF/HT+fsLqur/h3T77bfrxIkT+vEf/3Ht3btXq6ur+vSnP60/+IM/0M/93M/ppS996Yh7CLi8cM3jgqX+Btnl5O+/WRn97+GHHy7Lsiz/43/8j+WBAwfKVqtVvvCFLyz/4A/+oLz99tvLf3g4JJW/9Eu/VH7gAx8ol5eXy0ajUV533XXlH//xHz/luU+dOlW+4x3vKA8ePFg2Go1yfn6+fOlLX1r+2q/9WrmxsfGkx/yH36zcv39/uX///srXd/fdd5c/8RM/Ue7cubOs1+vl5ORkeeutt5b/5b/8l7Lf7/+j9xdwqeOax8WSlWVZPrftHwAA/CCiTQAAJEYzBgAgMZoxAACJ0YwBAEiMZgwAQGI0YwAAEqMZAwCQ2Oi/wPXIalzrb9mlm+dOhrXjK4/Ytaur8dpi0LFrpaKiHms0WmHtBddea9dO7n7qD70/obtu13b7m2GtNekHeZdZP6ydW/U/HP8/v/T0PzgvSVvb5+3arB4f/6Wd43bt7j2zYa015k/PtbWNsLZ6Lt6PknT82NmwNuj7/bwwHx/f3bt327VXv/ZVtv588+kPfTys/eDPOz5tvR7vx7xiKH1vOAhrVft4UAzD2vETT/3d5x80HMZrJ6en7dp2ux3W3P1EkrJBfA1tbPl7xnY3vg+2J+NtkqQdu3aEtcWdi3Ztqz0W1kp/aqjbj+9VlZ8RS3fuVK2N7ym5fVxJFzDkcOdVfl9KfDIGACA5mjEAAInRjAEASIxmDABAYjRjAAASoxkDAJDYyNGm4XocBamKzZw8cSysra2fsWvLIv4KfJ77r6LX7Mvz70M2t+KIw6mTcaRGktrteJtrc0t2bas5FdaKno84DMxX8yfbJm4lqdmMoxWDYc+uHZooSTGsOMXKZrxNFXGQsVb8vI16HI2RpPHxybBWFYvq9bphrSLtc8kpMjdh1U9fzRXvjLzmz4v5uYWw1p6asGu3OvH5mjXi802S+v342J5d27Zr61vxdd9q+XO5VcT7Ms99PHBudjauLc77tQtxXKvZ8Meoa/bzds/HXcfG3WuqiKS6i6wqfpTFj12Y87VKfgGxpyce44IfAQAAXBCaMQAAidGMAQBIjGYMAEBiNGMAABKjGQMAkBjNGACAxEbOGbsxemfOnLBrz5+PM8r1hs92zZi8YZ779xL97Thr2uv6jOTWIM4bbq75fPPJ4/HzNs/5/N12L864blWMX+wNTf41jzO5klTP58Ja1ajK82vx8d3u+Ey2yxTOzcdZYElaX4/PyePH49GbkjQxHr/eKs1mnFWdmY1z4peiiYk40zswvwEgSTWTE3fj9yRp7xX7zFqfM25sxNfYdt9nWM+vxdff9lZ8fUmSzO8eNFr+XJ4y199Y22ejp6biMYnTc/58nJg0j13z9wxl8bVdVuRuczNjsbigrH7V2Fy3Xb4n+IzyheOTMQAAidGMAQBIjGYMAEBiNGMAABKjGQMAkBjNGACAxEaPNnXOhbVuf80/SSv+rvrOHX6k4OLcYvy8Xf/V+5MrcfSl1/exjHoWRwIG3XjsmCR97+9Ww9qRRx6za89vxNtcb/pIVa+II0irq/Hxk6QdMwfD2p69/hhdsfe6sNYfrtq1Z0+fimtn4n0hSY1m/F5yvO2P0aaJv1SNu1tYnAlr8/P+eS81N7z4+rDWN6MzJanRimMzYxXxpIEZKdho+pGCWT2O+qjm105Nx/eFbTMiUZIaJso1Ox9HNCWpuxLvq27Xj248/lh8nRw96mOnTbOrZuZ8/Gx6Pl48PhnftyVpMIyvv7wihumCRNWxKBNCupBIVVa1zdX4ZAwAQGI0YwAAEqMZAwCQGM0YAIDEaMYAACRGMwYAIDGaMQAAiY2cM149H+dBO9147JgkZVkc4KrX/fuBrBZvYr/ns12bG/Eow7XVuCZJg24jrJ0wuT5JOnIk3leHvv+IXbu1HY9pG5/yGcnBsBfWzq6esWsXpuL9cfTR+PVI0u49s2FtftFndmcX4jz35GT8uJJUZvHrrcpmjo3Fme25uThHLEm7du0Ia7nJPl+Kas34OlDpc+/bnTj3Pj7t93HRjc/HQUWYtJbH+dd+z49B3LVjf1jb2vL3jE/d85mwdvLEabv2zN/FOeNO149drdXj7Gx7yh+j8Ym4PjPnr93la/aGtWuuu8KuXdo9G9bGJiquoSw+DoX8MarV4/x6p+9HxfbNb1O4saqjurzuHAAAXIJoxgAAJEYzBgAgMZoxAACJ0YwBAEiMZgwAQGIjR5s6/Y2wVhRxxESSyjL+Ovn6+rpdO+zHm7heEU86dyb+qvrZ037tqZV4LOSxo36bV1bieq/vowaN1lxY21rz752KLI4iTLQm7drtjfj4fuOxh+3arz4Q76sdu/yovBtefGVYe+ENccxEkhZ3xOMK2zP+9e7YGe/n2Vk/BnFqwcRySh+dudR87ev/M6zFV/XjtntxFGRxxUft9h+4Oqxtrfrrb2lxV1ibmohjaZL0pS/cH9b+9m8fsmsfOxZHAPt9H8PMzsUjTMvSX0PK4v3c2TQjAyV13EMP/P3msUZ8z9haP2LXXrE/PobL18aRKUmano/vc1WRRtXi+369ohvmtfiM7/bifTEqPhkDAJAYzRgAgMRoxgAAJEYzBgAgMZoxAACJ0YwBAEiMZgwAQGIj54xbY/GIqKLwWbaBGYfmRgZKUq8T59HWz/vnPXM6zr8eP+rzaI8+EufGzpyMc32StLZmsmyNeGSgJNXr8ZhEN4pSkmrmrVXNFSV1ijgHOTW1264tytmwtrV1zq796lf/LqytrvlRla+77ZVh7Z+88kftWg3N2E+T25QkuWlpw6r07aVl9bzJ9FacU1ub5horzWhGSbt2xdf2/IzPCh85HI8r/P/+Ms5NS9ID938zrG1t+KxwXouz7SeOHbdrl+rx2MeqMbOl4vO11/P3udy8pO26P0Yrg/jeffyoz5Fvr8e/TdGqj9m1+7UzrNUn4v0oSbWaubYz34tqpRkF3PC/HzEKPhkDAJAYzRgAgMRoxgAAJEYzBgAgMZoxAACJ0YwBAEhs5GjT2Jj5urn5yrckbZuv3pcVKZJeL44JbW/5qMHZc3E86dhjZ+3ac2fjx67VzQg9SS0TfTm/vmXXbnfi1zs950f75fX4OJzvxjEvSVqang9r6xurdm23H8cnGi0//m1iPI5ytZp+P3e242O0ddaP2RtfiA9SvyKOVRvGsZu8fXm9v21PxHEdNxpVkrY246hIZ9tf+GdOxcdgccZH7b7y13F86TP//V67dmZqj3neeNynJPW68fU3M+ajL80yvr9mVcMqs/g23qj5W7y5Zai/5Z932IvjSUXFuXFqLI4WPlR71K7t9+Nz5wXX+/GLM1Px/Wht66RdOxi6e7Mf2TqKy+vOAQDAJYhmDABAYjRjAAASoxkDAJAYzRgAgMRoxgAAJEYzBgAgsZFzxks74rFVjZqbKSdtrHfiDchadu2ZU3Eu9/D34/F7ktTtxnm0mek5u3bFjDyr1/zoRtXiTOHYuH+9WT1eu93z2dlaEWf7pqbjPK8kFUX8vuzUSZ/JXlgyGbuKDHqzEY9pm5qMs8+SdPrUaljb3o7POUkajyOSajQrLovcjFob+Oe91Oy78oqw1jejUSWpZ3bTcOA/Bxw/Fo/gO3bkfrv2O9/8fli7at91du38zP6w9ncP+fzrxnqce5+f3WfXbq3Fudt+RSa7Zu43421/vykH8fW5sWnGjEqq1eP74PikH4O4etJcgMWqXZub3PV4xf11rL0rrDUafpsHw3ibu1vm9YyIT8YAACRGMwYAIDGaMQAAidGMAQBIjGYMAEBiNGMAABIbOdo0MTsbFzM/Hmw6i6NPxTCOtkjScGC+8j/wEaOeiV6cMiPaJElZ/JX/ZkX0pczi9zh98/V4SRqWpp7711tkcbRiUPhxk/3t+DXt2B2PlZOkwTA+Rq0xP1rs9NlTYe3GiRfYtVudODvTr3i9ZWb2Ze7XyuxnZT7u44Nezz+7d8cj6ba3THZJ0rmz8QjTzQ2/nzpm/OJf/cVX7NqyF59zN7/4pXbtqeNxNK2/5a/7sTwecdrf9Pe5fu9EWOt04xGlklSvxZGciTEf4czN+MViUDG60ZWHFXFXM952dtbfMzob8RMf+X68HyVpejaOPh24dodd2xiL99W5Vf+8o+CTMQAAidGMAQBIjGYMAEBiNGMAABKjGQMAkBjNGACAxGjGAAAkNnLO2Br6XGZ9zIy1qsijZSazOzbmxwK2J+IsY6d32q7t9+MsW32yasRenLve6vixZMMiHpfmRpZJUlaPj0NR+mOUZVNhbdeueOyYJHW67bDW7a/ZtRNTi2FtccHn/sYm4kzo1JTPKipzY+kqRmTaLHFFNvMS0x/Gr6eo2E0D8zsAnW2ft+9tx9fQsOf38e7FOBtdDv1vIqyfizO9S3M+bz/sx/eyMyfP27V5I37eRstnshvmXM7kxy+2mvG9uWly05I0NPf9ou9PjuEwTtzXFd9PJCkr4vvv5prPvq+dMznyiumnjbE4z92oT/jFI+CTMQAAidGMAQBIjGYMAEBiNGMAABKjGQMAkBjNGACAxEaONhW9rbhmvqYuSfWGiSDV/fuBzNQnJvzXyafNN/OzirGP3W4cQSoq5uDVGvFjl5Vvf+LYRq3hn7hm9lXW8HGQ3kb8es+vxWMOJalhRkqeOHHMrn3py24wz+vHXObNeH8cP+6fd3lqIS5WjEGU3AjFirzPJaZWi8/lRsOPBWw24ihIq+7Px5WzcfRw1659du3+vQfDWtExMUtJzWYcq+l34rF/knT8WDxGb2J81q5VLY56jdX9fq6V5r7gxn1Katbj4zs26e+vPRNPO3++YkRtHt+rOls+jtXrmp5Q+pbmInVnTpy1ayfm48ceb/k41ij4ZAwAQGI0YwAAEqMZAwCQGM0YAIDEaMYAACRGMwYAIDGaMQAAiY2cM85t1M1n2ZSbesXbgXoj/oOGyfNKPiOZm5yb5HPIee53W2ZGKOYV+Wb3vFlFvrnI4uxmXhF/bY7Fa7e7fgxix4y0azT9fp5fiMPg3W48Vk6S1tbizODKCf+8y9fOmWrF+WyzxJdXzjivx/nzs2f8WMCNXnx8Ngc+77tyymRJa36UYW8rPrYzTXfcpXw7ztRvnX7Yrp1vxce+t3nEru03Z+NixazKRi3eV62K3xfoDONj2F3zuWqZcZStlj++jfpsWDt+1N9vlnZdEdbOr/q1Dx+Js8TLNx6wa+vteDzjZv+MXTujeFTs3+OTMQAAidGMAQBIjGYMAEBiNGMAABKjGQMAkBjNGACAxEaONpWKYwoVQRA7frHe9F+Bb7fjervtx1aNmbjOwsKSXbt6Ov6qelax24phXM/kX29uYjPDgd/TRRG/3oopbGo24rGBVTGwbjf+yv+1L7zarp2Zmwprk24GpiTVVsPSwtK8XVq60XJVYxAvYExiRTrteWd9fT2sra6u2rWdTnzd12qzdm2/H59TZ877kZ7jtXg85vrAx+UeW1kJa0M3qlBSzV0nedOunRyPrwO3LyQpN9GnwaDiXO3H4wqLgR9lmBVxtKlW8XrddjXH/NqyjO9zW1s+jjU+iLd5MIh7nCQNh/H+cDHaUfHJGACAxGjGAAAkRjMGACAxmjEAAInRjAEASIxmDABAYjRjAAASGzlnPBh2wtrQ5FslqbcV16eycbt2YiLOEo9N+LXjprx3TzyGS5KOHI7zasOBzxsOhi7b5/NoeTYW1orC5w2LMs4KZw1/qNc34tFiYy2f5x43x2hyyq8tyzjv2+v73N+OxTiHPDnpzw076rAyR+zql9f72/Nn4xF7VTnjwSC+7ifM7wdIUmssPl8fPXbSrp0Z3xVvU8VUwNWNeATfxPikXVuvxfeF5pi/Dor6RFirFf7aHZbxvTkb+t8m6Jt62au4Dsxtv6zH9yJJ6vfjvPfOOf8bEP1B/HrXNs/ZtfPlTFhz909J6g/N/dVHo0dyed05AAC4BNGMAQBIjGYMAEBiNGMAABKjGQMAkBjNGACAxEaONjVaZlxWxfSozmb8VfSqr5O3WvFosQsZWzU5GT+uJKmM36f0+xVxATe2rPS7vFaLn7csfdQgM8MsG3UfJZEZW9Zs+v28vHzQVP02j7Xj5z11+jG79qoXXBPWqvYVRnP0aHwMTp2JY0+Pi+M687P+nJpfjCMoDz34qF27sR3HkzSMo4OSpHq8XfVxH08a9uIRe2MV417XtuP7YDn00dFc8XzUPPOzU/Msft5h7kcolsUzHwjaL+LnHWv7be504+O73fXZtbF2PF6zXvefTYcm2lQzYx1HxSdjAAASoxkDAJAYzRgAgMRoxgAAJEYzBgAgMZoxAACJ0YwBAEhs5Jxx2YvH1ZWFz3TOzsZrVfOzp0ozHmxh0T/v6RPxOK3hKZNFlLSwFNdXz/i1c7N7w9rxE6t2rco4D7xzcYddeuTokbC2tuX31dRcnO17+Y/eatdOTMbHcFD4LOrY+HpY21mRbz51+lBYW77uJrvWvg8tKjLZmbtsLq9887mz8fGpilYuLs6FtSsP7LNrz56OM66Nls+3bnVXw1qrNm/XNsbjc3mr70eYnj0dn+vTE3784nAYv6a84iNTqxmfj3WTm6568DLzB7i0o0b92va4+d2Kpr+GuoOtsDbWfub5dfdbGpLUN7/jMBj438sYBZ+MAQBIjGYMAEBiNGMAABKjGQMAkBjNGACAxGjGAAAkNnK0aWhG0uVZxSgtV6/IR2T1eBMnJ31cYHom/hr71JQfg7hjRxwj2tqMI1OSVJqvwLdafjxYlsf1fuGjFYUZS9Zqj9u1L3npdWFt795ddq2yXlja7sY1SWqaWMbYuD++s/PxvhofrxiVd5lFkJ4tN910c1gbVIypnJiIY0S7dy/ZtefOxpHGq66Oo4OStH42vv6yzF/3E7Px2MfzZ7bt2rVOHLnp+qfV3Fh8rpdlxf3VjDLMKsYclubzWJb5z2pZPb531+v+ecem4/tRXvOjG4dZfB/cuSeO00nSnr3xedeoiFJ2zWZljFAEAODSRzMGACAxmjEAAInRjAEASIxmDABAYjRjAAASoxkDAJDYyDljl8vMTRZYkuRycsOK0VN5nP1qT7bt0tm5eHTj6ak4xyhJC0txXu3YMT8WcG1zNax1+j5w2KjH+3lY+P08Mx9nJPfs2WPXuvxdKZ9v7g82wlpR+rXDIg7vzc7447trd3yMxipyxkWxaet43BV7D4S17b6/hoZF/F6/2/Nr9+xdDGs33nKNXfv1r8ajRDtbPsM6vRhno4vSX3/TG/Fr6nV9JrvdqhjbafifcagYg2h+E6FZMVJwbCze5rFJ/3sKeSt+3qLm89yNdrwvD1y1265d2u1GaFaNQYyft17VA0fAJ2MAABKjGQMAkBjNGACAxGjGAAAkRjMGACAxmjEAAImN/n3s3Hx/vlHxMIP4a+z9no8aNPL4/UK96aMvYxNxvKU96UcKLu2Kv5q/Y3cc5ZGk48fXw9pWJ65J0tCMI6x4uZrfGY99vOqqK+3avB7HCdY2zvonzuJjODbuoxWtdhyPmJ3zx2hhMY6uyUQ2JClz4/+yqjjID4+vfPmrYW1+cdaunZlfCGuNho+ejU/EIwWvPLDTrv32Qw+HtY11f/3NTMfRl9kyjg5KUqcXR2POnV2za8fNKNHB0I8hLQoTh6w4W83tVY0xH22aNlHK2QV/7Z7fPhXWitxHm1oT8XYt7pqya6dn4vOuM1y1a91n11rtwj/X8skYAIDEaMYAACRGMwYAIDGaMQAAidGMAQBIjGYMAEBiNGMAABIbOWdcZC6X6ceDKY/rRUUOzj1vbrJ5kjQ1E+fg5hd9vrko4nFoL7juoF07PRNnCh9bOWPX9s0Ur+lZn6GbmYnrY1MmJy6p1ohfb63wYxAnzLi0haU4LypJc/NxHnHHznhEoiRNTMWZwXLos4r+nPXns48hX17vb08ePxnWvve9Q3btjBlH+Ip/+r/Zta1mnCW94sp4vKIkvfRl14W1L3z2Abv2sZXvh7UXXHWLXbtz966wduTwY3Zt/7F4P5elzxmX5nxtNpt27fhEXJ+a8lnh6bn4hw8mZn1G+fjDp8PaC160z6696aUvCGu797sRidJ2x4x7rfme4MYkDgcX/usDl9edAwCASxDNGACAxGjGAAAkRjMGACAxmjEAAInRjAEASGzkaNPQjJwrhn5cXVnGX/vO/DfgldfMH9T9e4mJ6TjatHuP/8r/yRPfM4/rx78tKd7msSk/B3EwjPdVzcQ9JKlpol5Zw0d9eoPVsFZv+ljUjBl1uLTDR5vmF+I41vRsPF7x8Q0zEaSByYhJ+uEahPjM1WvxuZ5XjLobmvGo5876iN/uXfGxHx/31+6LX3xVWMvNtSlJ9//N34W1b3/Xx6JajZmwNje7264dPxiPA83dnENJtVocLcwyf+32enGksdPfsmvPd86Htc1Vf33d8JL4GO074ONJ8zvi+01z3L/ezNwzSvm1eREfh8IvHQmfjAEASIxmDABAYjRjAAASoxkDAJAYzRgAgMRoxgAAJEYzBgAgsZFzxs6g8JnOrIxDWFUZOjtCcehHi+X1OCM5NRdnkCVpbjHODPb68YhESeoO1sNaY8zv8rYZ01Vkfj+7kYLtcZ/ZHfbi/Tw97bPCC0tx7m9mzj/v5HSckay5HLEkDeIca0W8UqXJzV9QZLC8vN7fthrx8Ztq+5GeDZOLL/v+2h0zazv9+PqSpMnJ+Nr+Jz96vV27OL8Q1r7y5Yfs2seOnQtrWS3O5EpSp7ca1qqy0dkwrg/N7xY8/rzxeNQs978fMWfuoQuL/v5648viMYgzC/E9QZJmZuOcedbw90jXq7LK3x6I7825+S2NUV1edw4AAC5BNGMAABKjGQMAkBjNGACAxGjGAAAkRjMGACCxkaNNLoJU9a3u8gLG1RVuFN4gHv8lSZl5r5Hn/uvzN950Q1h7oP8tu/b7h4+EtcLEvCSpMWa2q+ajBvPtOIaytDOOaklSe2xX/Ljzs3btjIk+tdt+3F19zMQ2ijh2IUkDE22qNyriIBeSRHDxpYrje6mp1+PjN1ERS5yYjs/HibGKUaL9eDzjuVOn7NqtTnzezE7vtGuvueaKsHbFXr/2u4dWwtrhh4/Ztb1OfG0XFQm/sojP9WJYMRYwnw1r07M+nnTl/ngs5N4r/BjEeju+dlt+Qq3KRnx8h6W/Rw6LuJ5XzPPNMhM7vQgTWflkDABAYjRjAAASoxkDAJAYzRgAgMRoxgAAJEYzBgAgMZoxAACJjZwzrtXMOLSKoLGrZxVZRZ/98hm6YhAH9IbDOOcmSc1GvHZm1mcklcU5uEHF8+5a2hdvU9vvq8XFeJTh0k6fGdyzK84KVxwi5eYQ1TKf+5MZaebGHEpSZsLCRd/vZ3dO1poVx7cfv6aN9S271A+jfP4Z9ONjUG/428dEO361rYbPn59eiTO75877nPHq6mpYO3syflxJ2tgZjzrcsbjfrn3R9XFW/9qr45okndt+1FSr7pFxMDev+f2cKf5dg6rrfqwdX/jjk/7evNnZDGtF3Y9BLBSP3yyG/n7jMtlZHt8/JSlzvy8wvPDPtXwyBgAgMZoxAACJ0YwBAEiMZgwAQGI0YwAAEqMZAwCQ2MjRpk4n/jq5iz1JUt1kX/ILGD2VZRXjCOtmHGHDz+kqunE05lsPft2u/X8/fXdYm19csGtvePGBsPaSW2+ya93Is2ERH7/H/+BkWMoq3rJl7g9qFSMFbXzJnxw1c/yrTqt8zOyrDR9POnnybFg7vRLXJOnFL/6nfsOeb4p4H7cqriEXbWpURG6Onz0d1jY2zti1uYnTtdt+mztbcWzq0Uc37NqlhSvD2hX79tq15SC+V1WNQXRjO+s1PypWiu/NvZ4fUdsdxvujU3ENNVrxdZ/lPtqUy8Qh82e+r6qUZm1hrpNR8ckYAIDEaMYAACRGMwYAIDGaMQAAidGMAQBIjGYMAEBiNGMAABIbOWecZ/Gf1vOqh4kzZS6/LEkb51fDWnfbj9hT0QpLjcyPy+psx0nVTtfnDRfmp8Pa3n2Ldu2OnXNhbWLS7+c8j0c3dvrrdm2rFmczq/LcPodckb8zj30hyT077kySenFW8dSpc3bpsSPHw9rqqt/PL/Zb9byztLQU1qan4/NckhZM7r2R+2u3HMQ5/9zcTySpPRFna3fs8NusMl579qy/7s+di8cgtnysWsOleKRgf+hT88NhfF+oldt2bZ6ZDfM/H6G8Ed8z6g2/eDgw21Wr+JUAMzo1KyrOK9PyqkYB5+aeklftrBHwyRgAgMRoxgAAJEYzBgAgMZoxAACJ0YwBAEiMZgwAQGIjR5ua9TgmVM99Tx8M4hjJ1ob/6v2JlZWwdv5MHAeQpEE//rp5rSLatDC/K6y95CY/ynD/vn1hbXHXvF27fM0VcbFWMQaxjPfzxLj/6n0RJ0lc+uh/1U3UoCqf5EaaVS2uii8Znc04BrZ6es2uXVuLz7vcRGMuRQcOHAhrrVZ8T5CkVtPFA1ef4RZJ7bZ/3rFWfK4XfX8NDcyFUK+I3DRNSqgo4/Otqp7V/XnebJjYacV429KM/nP3bUkqFUebirJiP5v6hYSEyopAZGG2uepukpktq+UXft3zyRgAgMRoxgAAJEYzBgAgMZoxAACJ0YwBAEiMZgwAQGI0YwAAEsvKqrlRAADgWcUnYwAAEqMZAwCQGM0YAIDEaMYAACRGMwYAIDGaMQAAidGMAQBIjGYMAEBiNGMAABKjGQMAkBjNGACAxGjGAAAkRjMGACAxmjEAAInRjAEASIxmDABAYjRjAAASoxkDAJAYzRgAgMRoxgAAJEYzBgAgMZrxRXTXXXcpyzI98MADF+XxsizTL//yL1+Ux/rBx/zN3/zNi/JYn/vc55RlmbIs0+nTpy/KYwKXkh+Ga77f7+s973mPDhw4oFarpeuuu06/+7u/e/E2EJJoxniGNjY29C//5b/Unj17Um8KgGfR2972Nv3Wb/2WfumXfkmf+cxn9LM/+7P6N//m3+g//If/kHrTLiv11BuAS9O73vUuzc3N6ad/+qd1xx13pN4cAM+CBx98UB/+8If1/ve/X7/6q78qSXrlK1+pM2fO6I477tC//tf/WvPz84m38vLAJ+PnWKfT0Tvf+U7dfPPNmpmZ0fz8vF7+8pfrT//0T8M1H/rQh3TNNdeo1Wrp+uuv18c+9rGn/M3Kyore+ta3at++fWo2mzp48KDe8573aDAYXPTX8Jd/+Zf6/d//ff3hH/6harXaRX984HJyKV/zf/Inf6KyLPWmN73pSf/+pje9Sdvb2/r0pz990Z7rhx2fjJ9j3W5XZ8+e1a/8yq9o79696vV6+tznPqfXv/71uvPOO/WLv/iLT/r7u+++W/fee6/e+973amJiQh/4wAf0C7/wC6rX63rDG94g6fGL8tZbb1We5/qN3/gNLS8v67777tMdd9yhw4cP684777TbdODAAUnS4cOHK7d/e3tbb3nLW/Rv/+2/1Ute8hLdfffdz2g/AD8sLuVr/pvf/KaWlpa0a9euJ/37jTfe+EQdF0mJi+bOO+8sJZX333//yGsGg0HZ7/fLt7zlLeUtt9zypJqkst1ulysrK0/6++uuu668+uqrn/i3t771reXk5GR55MiRJ63/nd/5nVJS+eCDDz7pMW+//fYn/d3y8nK5vLw80va+853vLK+66qpya2urLMuyvP3220tJ5alTp0ZaD1xOLvdr/id/8ifLa6+99mlrzWaz/Ff/6l9VPgZGw3+mTuATn/iEXvGKV2hyclL1el2NRkMf/vCH9dBDDz3lb1/zmtdo586dT/zftVpNb3zjG3Xo0CEdPXpUkvSpT31Kr3rVq7Rnzx4NBoMn/vfa175WkvSlL33Jbs+hQ4d06NChyu3+yle+ov/0n/6TPvShD6ndbv9jXjLwQ+1Svealx7+N/Uxq+MehGT/HPvnJT+rnf/7ntXfvXn30ox/Vfffdp/vvv19vfvOb1el0nvL3//A/D/3gv505c0aSdOLECf3Zn/2ZGo3Gk/53ww03SNJFix29+c1v1utf/3r9yI/8iFZXV7W6uvrENq+trWl9ff2iPA9wObmUr/mFhYUnnvMHbW5uqtfr8eWti4j/n/Fz7KMf/agOHjyoj3/84096V9ntdp/271dWVsJ/W1hYkCQtLi7qxhtv1Pvf//6nfYyLFT968MEH9eCDD+oTn/jEU2rLy8u66aab9LWvfe2iPBdwubiUr/kXv/jF+tjHPqaVlZUnvUn4xje+IUl60YtedFGeBzTj51yWZWo2m0+6KFdWVsJvVn7+85/XiRMnnvjPVsPhUB//+Me1vLysffv2SZJuu+023XPPPVpeXtbc3Nyztu333nvvU/7trrvu0kc+8hH9yZ/8ifbu3fusPTdwqbqUr/mf+Zmf0a//+q/rIx/5iP79v//3T/z7XXfdpXa7rZ/6qZ961p77hw3N+FnwhS984Wm/pfi6171Ot912mz75yU/qbW97m97whjfo0Ucf1fve9z7t3r1b3/3ud5+yZnFxUa9+9av17ne/+4lvVn77299+UtThve99rz772c/qx37sx/SOd7xD1157rTqdjg4fPqx77rlHH/zgB5+4iJ/O1VdfLUmV/z+kV77ylU/5ty9+8YuSpFe84hVaXFy064HL1eV6zd9www16y1veottvv121Wk0ve9nL9Od//uf6/d//fd1xxx38Z+qLiGb8LPjBd5A/6OGHH9ab3vQmnTx5Uh/84Af1R3/0R7rqqqv0rne9S0ePHtV73vOep6z55//8n+uGG27Qr//6r+uRRx7R8vKy/viP/1hvfOMbn/ib3bt364EHHtD73vc+/fZv/7aOHj2qqakpHTx4UD/1Uz9V+c752cgiAz9MLudr/gMf+ID27t2r3/3d39XKyooOHDig//yf/7Pe/va3j/wYqJaVZVmm3ggAAH6Y8W1qAAASoxkDAJAYzRgAgMRoxgAAJEYzBgAgMZoxAACJ0YwBAEhs5B/9+Kv/5/dsPc/jhyqGvucXw3hA/fj4pF3797/V+nR27lyya8fnp8xG9ezaorcV1rLcR7ezWtM8cMX7o7IRLx34td1O3z9243xYarVadmnunjob+ufN4v01HD797/f+vVLxY9cb8Xn1+OILidibF1w1DG33j17A8z63vvSxz4e1Rsucx5JmF+Nrc/de/9vJRVGEte1exTlhjmut5s8Jt3bQfepQhx/khjMcP37crl186myIJ8xMx/tRkmZn4vtcvenvn5sb8X1u5fgpu3arsx3Wxif8/eKKK3aHtTKvuF8o/sGSonKIlLs2q+695typuOavvKb6p4L5ZAwAQGI0YwAAEqMZAwCQGM0YAIDEaMYAACRGMwYAILGRo021ir9sNuOvfQ/6vuf3uvFX2ft9H8fZ3NwMaxsbE3bt+NR4XLRZHSnL3Nfc41iGJMmVs4rv5hdx9GJtLY4mSdLx4yv+sWtxZGTv3jiKIEnTs25f+whRUcSRkawi5pBlZi5rVnEc7HZVHAcXZcgunzHh9Xr8OodDf21ubK6FtTNn4oieJE1OxpGcwcDHDnu9uD4c+vOpnsWvt9n0Ua7JyemwtrDg5wcPB3EsKqs4n7a34+OwcfqkXbu1Fe+rft9vc8tE26r2lYsz+huk/HVdFW2yt6Kqz6ZmceW9phqfjAEASIxmDABAYjRjAAASoxkDAJAYzRgAgMRoxgAAJEYzBgAgsZEDkfPzs7Y+NhZndrsdn8FaOx+P4hr0fUZ1ezte6zLIkjToxbnAessH1jKXk7MZOkly+cyKTG4ZZ/9Onjpq1z74rW/aepbH2cBWxSi26Zk588B2qc3s5vWKMYhmhGJR+FF7ucuSV41BdK/pQiYzPs+MT8TnxGY3vvYkaXt7PaydOevvCa2xOIfcbPqMcr0e39Z6234Mohvd2O/7jPLGWvx6z505a9e2p+Lz/Mwpfx8ry/g4lIW/fhr1sbjW8GMQ3WjUqgy6G4Mo99sBFc9b9emycPfmquvW5b2r7hcj4JMxAACJ0YwBAEiMZgwAQGI0YwAAEqMZAwCQGM0YAIDERo42LSws2Hq7HUdftjb9yLPhIH5PsLnh4ynDYfw1+P7ARy+KIv76fTn033PPai7aVPHV/NKsrXh7NCzifbl6/oRde+SR79h6Vu4Ma1cd8MdQQxODqFdlm8xjm5F2j9dNvKLnoyh2SuYFxLEqR8BdQqbMaMxy3b/O9a34+ut2t+xaNyZxbCKO40hSbo7NsFcVuTHHtWoyahGfNGVF9OXcqXhfTUz4KNfEeHzvrdf92m4n3s+Dob/3Lu6cDWtXXb3Xrj2/cSoumvimJJUuFlWhrLqf+MWu+Mwf93/hkzEAAInRjAEASIxmDABAYjRjAAASoxkDAJAYzRgAgMRoxgAAJDZyznh21ueMB/04hNdq+TFe09NxRqvX86PHBtsu/+pzpr3+RlirNfyuyYo465ZX5WpzU7fhV6kxHucG9x/YZ9d2urf4x9b1Ya3dmrJrv/mN74W1Zssfh4PLu8Na3vL5vYEZ49doxhlZSTb/POz4UXtuhGaeV419vHS023F+vNv3+2izEx+bYUWWdDCI88CDrl/bN/nyrS2fnW3V41Gw4624Jkn1hXZYmxlftGuHg/h+s7XlM9mnT8f3yG7fj19cWIxHn+7cM2PXtkzc+/Qpf99umrU2zlulYnxtbspFZVbYBc0ZoQgAwCWPZgwAQGI0YwAAEqMZAwCQGM0YAIDEaMYAACQ2crRpY93HGFxfd1EDSdrcjL9+v73txyCWJiLRaPrvyDea5r1I5ket5WNm11W8xelvxJGq4dBv89jkfFjbue8Ku3a87eNJk41XhLVvPfQNu/arX/3bsDY140+zHTt2hbXZBR8JqZtRl8NevJ8lSf04FlcUPp5kR9PlfmzdpWRYxnGOQeFnCpZmVGhpxg0+Lt7/mfz+rdeaYW28ZUZ9SmrV4vhSZ8tHqk6fXAtrW1v+/vmtbzwW1paWluxa5fH11e360aezk/G+mp2Mr0tJGosnN+r8evx6JMmcVtUjEk18qToWZdZWLjUPfkF5rMfxyRgAgMRoxgAAJEYzBgAgMZoxAACJ0YwBAEiMZgwAQGI0YwAAEhs5Z3zq5DlbbzTivNpg4HNj58+fD2udjh8fNjkVjy1rm3GDktRsxe9FstxnKFWa7PTAJ9ayLN6uRs3MFpOk3GSFuz7r1t32+/KuD/zfYe3U6RW7dnMrHpl2y49cY9eWQxNY3PbHcNCJT+G8VjFC0Zz+tYrjn8ns64HP1V9KNjfinH+367P4hcle1uvx/UKSGvX4uq7X4prkr69m6fPjXRMHfvi737dr//arXw9rZ874kYJf/fKRsDY9PW3XTs/G94Tde3xGuVmfDWtLi37c5EwRZ7Ybdb/NKuJ7UZFV5NddsWKt7PGvaIelq5MzBgDgkkczBgAgMZoxAACJ0YwBAEiMZgwAQGI0YwAAEhs92nTqtK23zGiyomLU2raJ3NQb/ivjMzNxfGVysiIC4b7lnvvn7W/HGYg882Pa6uM74mLh4zgbK3HU5Otf+65d+42vf9vWH/hKHL9wEwMlaWIyfs0b5/17vkcPx9G2svBrxyfjkXdj8z4+o1488k51H08qB/Hxr4rj+bPy+WVzOx7B16+I8LnroFH3ET4XXyr6/ra1tRFHKfvbPma5uRYf98OHTtm1h74Vx//OnVu1ayeb+8La1qo/n/qbZhRoxRjRE8fvC2uf/cy9du2Lbj4Y1v73n3iZXbu4yxz/qpRQHkeusqE/vmUW30/y0t9rCjPW8x/RSuPnv+BHAAAAF4RmDABAYjRjAAASoxkDAJAYzRgAgMRoxgAAJEYzBgAgsZHDUd2uH6c1HMb5vLwis1tvxO8JZmf9KK6FxdmwNj5RMY6wNDnJQUXYrYwzlLXGjF87iF/TyvfjzK0k/c1ffyusfeVvvmnXPvz9x2y93VwOa4NunGWUpFMbcZ7xIfnnnZuNx7w1Gz6VOzEdH8Phykm7dnYuPoYzc/7cKc2lU1Rkoy8lZ8+th7Vm0++jqan4PJ8Y99dILY/z4zKj+yRp0InvVZ1Nn43+qy8+ENYe+sb37Nrjj8bXwMT4vF27vh5nWMvSjBiVVJr86+pJn5ff6MSjcbe7fuzjo48cC2v/43/8D7v27f/Xm8LawRfstGs7g/geudX1uepGy7S8ipxxrRb/bkFmf7RiNJfPXQMAgEsUzRgAgMRoxgAAJEYzBgAgMZoxAACJ0YwBAEhs5GjT9PSUrWdZHAVy0SVJarfjqMLcvH/e6en4a/95zceTyiL+2r9JakmSGmNzpupjG0e/E0cGPvPf77drv/zXcbxi9awfVVnPr7T17jA+HdyITEmqmdFkZ07FYx8l6YGvxKMdVyriSXl9M6ytb56wa3/6/3hlWDuYmzGXkqZm4v3RavrjcCmZno7P80bFOTExEV+7401/XauMz8VjR/058RdfiK+hI9/1YxC/8+CjYa0mP960XsZRrloxa9dOj8f7cmvLj1DsuRGKuR8pmOVxdLBRc/c4qWtG3z72qBlPKunb3zoa1toTJtYmaW6HGZva9BGjrBZfmy6eK0n9vusXPvo5Cj4ZAwCQGM0YAIDEaMYAACRGMwYAIDGaMQAAidGMAQBIjGYMAEBiI+eMr9y/z9aLIs6z1ev+adrjjbDWasVjqyQpN7mxoiI35rLRWeWuicfHnTm6ald+8fNfDWt/ca8fg3j+TLw/psd9jrhRm7X106uPhLVs2u+PeiPOYG53+nbtkYfj3Ojamh8puWdfnFedX1q0a1fPxfnnfs9n1LM8Pv61zGc7LyWz8/Hov0Yjvm4fr5sMa+YzyqdPnglrx475rPDfPvCNsHbkUDwyUJK2VuMRi1fu3mPXTpoxieXQf+4Za5rxfBWj/bKyE9a6/bgmSbkZCzje9qMbh3k8rrA7OG3XfvGzX463KfdjLn/kR68Pa61Jv6+KQXxt5nW/1v1chuslo+KTMQAAidGMAQBIjGYMAEBiNGMAABKjGQMAkBjNGACAxEaONi3t8iPl7MzBilGGapnNqBhNNeysh7Wi8KPsGo04XlFr+uhF2Ylf76HvxhEhSfrq/d8KaydX4riAJO1ZuiWsTY3vt2uPH1u19ekpE80ofTypGMb7ut324/IKE93odvz4xTOn41FthXz0Js/iWEejEUeXHl8cn7ODro82+a16fhmfqtgPzjDeD52KyM3kZByrWZj11/X09GxY27no9/6qzIi9irjbWid+TZ1tf/1ceWAprE1OxKMZJWncjKA9cdI/7+ZGPAax1/cRo7wR17tDv68eORKPNz3+WDxiVpKKYTwmMav4fNntxv1irO7PjVotfuxmVY8bAZ+MAQBIjGYMAEBiNGMAABKjGQMAkBjNGACAxGjGAAAkRjMGACCxkXPG/eaDtl4O4hF6WbFg19a24xxdWfi8b1HGucBaw2dU3asfbPnxi/2NOKP65S8es2tPHon31Vxrp107cHnF8aN+bXnI1psmO1sM/Pu2Xide2zTjFSVpYmpXWMtqPme+tRaPaut0/Ki96WkzjnKxIjeYr4SlofyYvkspZ1yruxGlPoc6MGNVB0Off5W9/HyOuzSZ96YZVShJWRFnhc+s+uM6Oxnfqxbn/O80HH8svjanJn3OuGeuzfU1n9nd6nTD2ngZj8CUpKYZOVjL/X1b5hhtbcbbJPnfh2i3fUvrmFMny/151R/E96Ky9NeCVPE7HeKTMQAAydGMAQBIjGYMAEBiNGMAABKjGQMAkBjNGACAxEaONmWKx1ZJUmn6etUow9x8LTyveLtQy812uZokmeetm6/tS9K5jXjU4dmzPk7Q6cRjyyZaPsbg9uVg4L+aPzsbj0iUpEEZxzoyMz5MkkpTN5P0JElbW3EErSh9PK3M4xhEsyoCU5jXNKiINjXiS6dev4Cxg88zhUzMJK+Ic5jLLzNj8CSpPR7Xp2d8VK7RjI9rvea3uduNr4GTG/H4PUkqtuPQWk0+UqXcjU71Ybh6zcQKW/48LkwLqIqBuSPYK/x+Pnf2fFh75GE/gvbMmTNhrW3GZ0pSbs7ZRtPvq4EZ55pVJZtGwCdjAAASoxkDAJAYzRgAgMRoxgAAJEYzBgAgMZoxAACJ0YwBAEhs5JyxyorBb2X8UHn5zHt+VhU0dmUzXvHxcpxDzWo+y7jVjbPCm1txhk6SBsM4u9lq+Wzf9nacg9zYiLdJksbafqzZsBfvj7xiJNqwHmf0Bj2fKe11TXbaHCNJysyIv/qYf96hGT23veFH/JX1uD6syNVP2erzi80ZV42Ny+L9n9d8pvP8+TirPxj6c7HXi6+D0tynJGl6Kr7u+5v+Hjg3NRsXK3K3e66cCWtLi7vt2kYjPqNOrKzZtUePxWNG103+X5K6W/G1Ocz86NOZ2bmwtrXl72Nra/Fr6vaqRu7G21Wr+bV5LZ7raaLeI+OTMQAAidGMAQBIjGYMAEBiNGMAABKjGQMAkBjNGACAxEb+Qvb2uo+YNBtxX2/UfVwnK+MIRFnGXyeXpMxEX8rMr3WPneU+ntI0Y9rGJ/xX5LN8NS7mFa/XJEI21n0kYDj00YzMjEyrGqGZmfd1tYrv/WfuRQ0rIkaZeU2lP+8G/Xibz531+7I3XA1r3f6mXXvttbb8PGPiKxXXZlnEx70idaiJycmw1s/adu2wiM+ZjU1/XMsyvnYnp8bt2rFmvPb8qj8nHj1yKKy12/71XrlvKayVO/y1t7YRx5eGFcm1san49c7M77Vr9y0vhLWiFo9IlKSFudl4m8b8NW9SpVJFv3CR1CyvGLk6Aj4ZAwCQGM0YAIDEaMYAACRGMwYAIDGaMQAAidGMAQBIjGYMAEBiI+eMjx2NR5pJ0uJCnDmbn/U930xakwY+Z1qUZuxf3QflsobJqFaMPJuajjOHu3bP27XfqD0W1ja3Vu3aRj3OX+Z1nwXuDyqy0434dKjYHRqaUGJVAq9eN3nUinxz32xYr+uz8W4s6PqaHwF3fj0ek9ntbdi1l1LMuJbNhrU8qwgL1+LrPq8YyTrRiK+hk+f8/r3p+hvD2hePPmDX9vpm/GLFmXxm9VhYy3P/ehvNF4e1I0f87xa0GvH4xaPHTtq1yveEpeUXxPcaSTq7eSSsveTlV9u1w3q8rybmfVta2BuPkW20K7LCW3FWuL/tc+SNcn9Yqw99FnwUfDIGACAxmjEAAInRjAEASIxmDABAYjRjAAASoxkDAJDYyNGmo4/4sVa1YjqsTY/7r5s3x1zVxyfcGMSyrIg2ydX9845PxKO69u7f4ddOxhGJ1dMn7Nr52fh5Jyf9V/PtqEJJ/SyOkZVDvz+GZiZeVjEvLy/i+rBwM8+kwSCOIBXm9UhS3Yz27HX9qL2tzfix+wN/vl9K+v1nfk6Uw/h8y/p+7fq543Gx8DGSyemJsDYxaW826m2bqGTp157rxefMyfM+Gtot4hGL9Zp/vd/53rfC2okV/7ylyZWeW4/3oyTVx+PXe271lF3bz+L68vXL/nlNFHJry1+3TTMmVhVjEAtzn6pIYI6ET8YAACRGMwYAIDGaMQAAidGMAQBIjGYMAEBiNGMAABKjGQMAkNjIOeONVT+OrrMQZ7AGFZnC5pjJZWY+szkcxjnI3ta2XTsYxK9pasKPLcvM+Lgr9++0a/fuXwxrq+dNvlJSX/H4uFbdj2mr1Xy91zeZ3oqMclaLM9uFGa8oST1zehRZPC5Nkhqt+Pxomyy4JDUa8WuymUJJrpzZmaCXlsyM5czzivfy5pTJ84pbzyA+ZxpjPne7+4o45798bTwGT5KONs+FtbOn/bmoWnz9NHJ/H+sO45GckzM+3zzQelibmPH7ebsbv6aT53xGuW3unw99J94mSdq1Pz6vrtgfj3WUpKwen1jbG/4YTUzFYyHLijmxhbkHDit+l2IUfDIGACAxmjEAAInRjAEASIxmDABAYjRjAAASoxkDAJDYyNGmPPNxApVxbCYrK3r+BYzfK8zX6zc2/DitzY04+tRuxfGjx7crft6lnfE4SUnaf3AprB057KNNw34cbeoM/eGslT7qM1Acr6hVxKZyM8qyqBqDaep5rWKUpRlHOTfnz9m8Fm/zoPTjF93ozlrmIxKXEjd2s1bz13Vmok+1wse/cpeL6vuY0D4zwrT+qn9i1z60cDis/c1ffc2u7edxnGdyzr/eWjPeV5MLfj+fXz0d1ga5f95eGUeBNjp+bO7C3vgeWeQ+Vrq084qwNrPg75+DIn7sqlRh3jDjFzf8NZ/X44iZGyE7Kj4ZAwCQGM0YAIDEaMYAACRGMwYAIDGaMQAAidGMAQBIjGYMAEBiI+eMB2a6niRNjs884404c2olrPUHPiuc53GmM6/I2M3OLoS1esNncot+/LxLO3xO7taXvzCsHTsa7wtJ+tY3Hw1rFdMmNVafsvW180fDWrvtM7szM7NhbXY2rknSoBfn+06dfsyunZqJ9/XNL7nars1qccZyaz3OXEtSLpOrLvy40UuJG39alR93cetB6a/N7nZ8TmRFz64dn4rvRddef6VdOzEZj9jr9P29aGhGKJ4/u2bXbnbietaMt0mSisZmWJsy16UkTczFo2Knh3N27QtvjPflxIw/N66/6QVxsWrcZD++blvj/j5VKD4p+xXnVXssPg79XsXNdwR8MgYAIDGaMQAAidGMAQBIjGYMAEBiNGMAABKjGQMAkNjI0aa9u3wkIDdRhTNn/Ciuze14BFgpn6nyY9wqxpbl8df6+12/axbmd4a15mz8uJL0opsPxttU98/75fseCmsPfv0Ru/bcWR/Xedkrrg1rN998s117y003hbVu1x/D++7767D2vUM+bnDdC5fD2mte/U/t2kcePRTW+oN4VKXkRzvWaxVz3C4hNfNaLmRSZFaaEYmSxqfjcXUa+Gtk0I/Pt+HAb/SOPRNh7Sd/+hV27YEX7A1r3/lOfK5J0te/8dWwVhY+UtU/F98/t0t//czOzIe16w5eZdf+5Ot+PKxdeVUcG5WkshaPm+wP/f2iMNdeXveR1P4wjiCVZlyoJBWFW2uXjoRPxgAAJEYzBgAgMZoxAACJ0YwBAEiMZgwAQGI0YwAAEqMZAwCQWFaW5UhpwSOfv8/Wh2WchdvYOmnXdvtnw9pY22c283oj3qaKPGKmOA88Z8YrStLSzh3x41YGMOPX1Gz48YurZ+KM3cnjPo9Yq/kRigt74sfuV8zQHB8fD2vtps9db2/HI+B6ZlyaJG1txHngU6dP2LWnT8b1ouL1NlvxudVq+PPu5f/nm239+eThbx8Oa1VpajfBtOoSabfjvO+g68fzbZvxi51tP+quVYvP48mJOJMrSb1u/NgnT8ZZYEnKs3js5uaWPxdXz8XXT1n4o1SYn5qYmPTjCPftj++B41P+c94wj6/bzmDVrm2NxY89KCvGl5bx2sz87oQkdTvx8W214vNGkq66Ot5Xf49PxgAAJEYzBgAgMZoxAACJ0YwBAEiMZgwAQGI0YwAAEht5hGKzaUaaSVpdOxfWOh0fuWm1482YnIwjDpKUZ3G0qdvzL68s4nFbLi4gSWPj8Qiwqel4mySp3jDztlxN0vRCfBymZ5fs2ry9aOu93sNhragYPTc27XIsfoxbU3F8qSoi0WjG9WPH/cjIQtthzcVyJKlej5+32fRj3C4l2xvxPqrX/blab8T7qJb543r2bBwFKnyySeMmFjU/OWnXbm7E5+LptaN2bb0eR2Pmd/noS5bFcaz2tj8Z91wZX/e1ur9vF0V8XWd2PK1UKr6uu0N/z1cW72c/FldqjMX31/Wz8X1Zkhqmj022/XV7fm01rI2N+z41Cj4ZAwCQGM0YAIDEaMYAACRGMwYAIDGaMQAAidGMAQBIjGYMAEBiI+eMO1tx3lCSuttxbqzZ8Dm5ubk4ozU17fN5xSDO9uW5f6/R78Yvv1us2bWdTvx6F3f7bZaJOg7X4nGSkjQs45xcLfdZ4K3VigzeVJwNLAo/xq0YxpnDcujH1vXKeF82Wj4XWu/G+czSZBklaczkFcuBD7PW63EmMc9Hvqye977z7b8La62Wz9Mv7Yhz7fv27XnG26Tc55sLxcduuxuP7pOk3GSj2zV/HyvL+Dwflv5567X4NY1NVH1mis/zQhUjBc090l+1kszYxyyvWJ2ZesXx7Xbia358wo+JdRn17W3f46am4j5VFBX7eQR8MgYAIDGaMQAAidGMAQBIjGYMAEBiNGMAABKjGQMAkNjIGYxez4/Bc1/tHjMjEiWpPfbM40lDk+Yphv55++YlNRs+UuP2R6/jYwx2GmVesdaNZ2z519s664+h6nF8qe6iCJIdiVaYUWuSpDyuVyUGijJeOzvrj+HJTjz2syh9vKLfNa+p8GsvJd3t+HUO+/7grLfiKN25CT/ecnzcj/6zsji/UnloyviGUlZEB83SSmVmNszVJPnPVHEMSJKKZ+3zWMWcS13Azrqgba7arlhm1174Nc8nYwAAEqMZAwCQGM0YAIDEaMYAACRGMwYAIDGaMQAAidGMAQBIbOScca1ifJirZ5nPlPV6cUa1b0bzSVI5jMdalQP/8lx0ujfw47TGp+NstBstJkky4whrdb92OIjzmf0Nv6821nxWeGFHPH6srBio1jOhbZ/Pk8ba5j1hUXH8zYi4+YU5u7a7HW9Xb8u/3ryMRyg2GubcuMQU3Xg/dHs+w7pRjzPz59tVOeN4DGlZFRV1eeCqzK7JKFdGSV1GuTKE7O5Vfm1R9RsA1jNfWxHFvwBVnxHjJ65oNRcWbzaq7nGj4JMxAACJ0YwBAEiMZgwAQGI0YwAAEqMZAwCQGM0YAIDERo42tVo+rtHpx319OPRfn9/ejiMSVV+fb9TiiEmW+RF6LoowPu7X7tw5H9aa45t27aAXxzqqok2l+W5+w85mlBYP7rP13sbJ+LErom2FyZvUav49X60Vb3ex6SNmmdmspaUF/7xqh7Xupo8q5GV86bRacdzuUtPIzHVdERMpBvEf9Ds+FqVh/LxZxShDe9OouKGULtpUwY5nrIhUFc9S5MZGtS70oU2tvIDPeXnVMbqAcYWZe+yKXFRm7r0XI+XFJ2MAABKjGQMAkBjNGACAxGjGAAAkRjMGACAxmjEAAInRjAEASCwrq2d7AQCAZxGfjAEASIxmDABAYjRjAAASoxkDAJAYzRgAgMRoxgAAJEYzBgAgMZoxAACJ0YwBAEjs/wc1b08UkJKMbwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -353,23 +359,92 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n", + "Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet18_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet18_Weights.DEFAULT` to get the most up-to-date weights.\n" + ] + } + ], "source": [ - "# model = densenet121(spatial_dims=2, in_channels=1, out_channels=8)\n", - " \n", + "# model = densenet121(spatial_dims=2, in_channels=3, out_channels=8)\n", + "model = resnet18\n", + "\n", "loss = CrossEntropyLossFlat()\n", - "# metrics = [SSIMMetric, MSELoss]\n", + "metrics = accuracy\n", "\n", "# trainer = fastTrainer(data, model, loss_fn=loss, metrics=metrics, show_summary=False)\n", "\n", - "trainer = vision_learner(data, resnet18, loss_func=loss, metrics=partial(accuracy_multi, thresh=0.5))" + "trainer = vision_learner(data, model, loss_func=loss, metrics=accuracy)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
epochtrain_lossvalid_lossaccuracytime
01.2519361.0087120.65506100:31
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "trainer.fit(1)" ] @@ -378,7 +453,85 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "trainer.show_results(cmap='gray')" ]