From 538904b3909af44045a22339c497e412807fdb84 Mon Sep 17 00:00:00 2001 From: mperikov <145544228+mperikov@users.noreply.github.com> Date: Wed, 15 Oct 2025 22:59:31 +0300 Subject: [PATCH] hw4 --- cell_segmentation.ipynb | 8254 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 8254 insertions(+) create mode 100644 cell_segmentation.ipynb diff --git a/cell_segmentation.ipynb b/cell_segmentation.ipynb new file mode 100644 index 0000000..c7104e8 --- /dev/null +++ b/cell_segmentation.ipynb @@ -0,0 +1,8254 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Сегментация изображений клеток" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Вам предстоит обучить модель сегментировать изображения с дрожжевыми клетками и микроструктурами (см. [segmentation.ipynb](../notebooks/segmentation.ipynb)), по пути поэкспериментировав с разными архитектурами и функцими ошибки." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Задание 1 (2 балл). Метрики сегментации\n", + "Перед экспериментами нужно определиться с метриками. Выберите 3-5 метрик, по которым вы будете оценивать качество модели. В этом задании объясните свой выбор и найдите нужные метрики в `torchmetrics` (а если их нет - реализуйте самостоятельно, здесь вам может помочь [lightning_etc.ipynb](../notebooks/lightning_etc.ipynb))" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "import torchmetrics\n", + "\n", + "from torchmetrics.classification import Dice, Accuracy, JaccardIndex\n", + "\n", + "def create_classification_metrics(\n", + " num_classes: int, prefix: str\n", + ") -> torchmetrics.MetricCollection:\n", + " return torchmetrics.MetricCollection(\n", + " [\n", + " Accuracy(num_classes=num_classes, task=\"multiclass\", ignore_index=0),\n", + " Dice(num_classes=num_classes, average='macro', ignore_index=0),\n", + " JaccardIndex(num_classes=num_classes, task=\"multiclass\", ignore_index=0),\n", + " ],\n", + " prefix=prefix,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Выбраны следующие метрики:\n", + "\n", + "Каждая метрика не будет учитывать класс фона, т.к. он занимает основную часть изображения. Это поможет объективно оценивать качество распознования двух оставшихся классов." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Задание 2 (4 балла). Обучение модели\n", + "Возьмите модель и датасеты из практики по сегментации и запустите обучение.\n", + "\n", + "Указания:\n", + "- Каждую эпоху сохраняйте значения ошибки и выбранные в задании 1 метрики как для обучающего датасета (`train`), так и для валидационного (`val`).\n", + "- Каждую эпоху сохраняйте примеры работы модели на 8 случайных изображениях из валидационного датасета (одной картинкой, как в практике).\n", + "- После окончания обучения выведите графики значений ваших метрик и примеры предсказаний (достаточно 4-5 изображений: для первой эпохи, 2-3 в середине обучения и для последней эпохи).\n", + "- Можете использовать `lightning` (вместо `lightning.pytorch.loggers.TensorBoardLogger` можно использовать `lightning.pytorch.loggers.CSVLogger`, а сохранение изображений можете реализовать как `lightning.pytorch.Callback`), а можете всё написать вручную." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import lightning as L\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torchvision\n", + "from torch import Tensor\n", + "from torch.utils.data import Dataset\n", + "from torchvision import transforms" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import torchvision.transforms.functional as TF\n", + "\n", + "class YeastSemanticSegmDataset(Dataset):\n", + " def __init__(self, subset_dir: Path) -> None:\n", + " super().__init__()\n", + " self.subset_dir = subset_dir\n", + " self.items = list((self.subset_dir / \"inputs\").glob(\"*.pt\"))\n", + " self.transform = None\n", + "\n", + " def __getitem__(self, index: int) -> tuple[Tensor, Tensor]:\n", + " image_path = self.items[index]\n", + " image = torch.load(image_path, weights_only=True).unsqueeze(0) # (W, H) -> (1, W, H)\n", + " # 0 класс - фон, поэтому прибавляем 1 к меткам классов\n", + " labels = torch.load(self.subset_dir / \"classes\" / image_path.name, weights_only=True) + 1\n", + " masks = torch.load(self.subset_dir / \"instances\" / image_path.name, weights_only=True)\n", + "\n", + " # формируем маску: тензор размера W x H, где для каждого пиксела указан класс\n", + " masks = ((masks * labels.view(-1, 1, 1)).sum(dim=0)).long()\n", + " \n", + " return image, masks\n", + "\n", + " def __len__(self) -> int:\n", + " return len(self.items)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import lightning as L\n", + "from lightning.pytorch.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS\n", + "from torch.utils.data import DataLoader\n", + "\n", + "class DataModule(L.LightningDataModule):\n", + " def __init__(\n", + " self,\n", + " datadir: Path,\n", + " batch_size: int,\n", + " train_subdir: str = \"train\",\n", + " val_subdir: str = \"val\",\n", + " test_subdir: str = \"test\",\n", + " ) -> None:\n", + " super().__init__()\n", + " self.batch_size = batch_size\n", + " datadir = Path(datadir)\n", + " self.train_dir = datadir / train_subdir\n", + " self.val_dir = datadir / val_subdir\n", + " self.test_dir = datadir / test_subdir\n", + "\n", + " def setup(self, stage: str) -> None:\n", + " if stage in (\"fit\", \"validate\"):\n", + " self.val_dataset = YeastSemanticSegmDataset(self.val_dir)\n", + " if stage == \"fit\":\n", + " self.train_dataset = YeastSemanticSegmDataset(self.train_dir)\n", + " elif stage == \"test\":\n", + " self.test_dataset = YeastSemanticSegmDataset(self.test_dir)\n", + "\n", + " def train_dataloader(self) -> TRAIN_DATALOADERS:\n", + " return DataLoader(\n", + " self.train_dataset,\n", + " batch_size=self.batch_size,\n", + " shuffle=True,\n", + " )\n", + "\n", + " def val_dataloader(self) -> EVAL_DATALOADERS:\n", + " return DataLoader(\n", + " self.val_dataset,\n", + " batch_size=self.batch_size,\n", + " shuffle=False,\n", + " )\n", + "\n", + " def test_dataloader(self) -> EVAL_DATALOADERS:\n", + " return DataLoader(\n", + " self.test_dataset,\n", + " batch_size=self.batch_size,\n", + " shuffle=False,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "torch.manual_seed(42)\n", + "batch_size = 8\n", + "datamodule = DataModule(\n", + " datadir=Path(\"yeast_cell_in_microstructures_dataset\"),\n", + " batch_size=batch_size,\n", + ")\n", + "datamodule.setup(\"fit\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class DoubleConv(nn.Module):\n", + " \"\"\"(convolution => [BN] => ReLU) * 2\"\"\"\n", + "\n", + " def __init__(\n", + " self, in_channels: int, out_channels: int, mid_channels: int | None = None\n", + " ) -> None:\n", + " super().__init__()\n", + " if not mid_channels:\n", + " mid_channels = out_channels\n", + " self.double_conv = nn.Sequential(\n", + " nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),\n", + " nn.BatchNorm2d(mid_channels),\n", + " nn.ReLU(inplace=True),\n", + " nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),\n", + " nn.BatchNorm2d(out_channels),\n", + " nn.ReLU(inplace=True),\n", + " )\n", + "\n", + " def forward(self, x: Tensor) -> Tensor:\n", + " return self.double_conv(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class Down(nn.Module):\n", + " \"\"\"Downscaling with maxpool then double conv\"\"\"\n", + "\n", + " def __init__(self, in_channels: int, out_channels: int) -> None:\n", + " super().__init__()\n", + " self.maxpool_conv = nn.Sequential(\n", + " nn.MaxPool2d(2), DoubleConv(in_channels, out_channels)\n", + " )\n", + "\n", + " def forward(self, x: Tensor) -> Tensor:\n", + " return self.maxpool_conv(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def create_downscaler(channel_sizes: list[int], bilinear: bool = False) -> nn.ModuleList:\n", + " \"\"\"\n", + " Создаём список модулей на основе размеров каналов.\n", + " если используется билинейная интерполяция вместо обратной свёртки,\n", + " то размер последнего (самого большого) канала делаем вдвое меньше\n", + "\n", + " Args:\n", + " channel_sizes (list[int]): список размеров каналов, напр. [16, 32, 64]\n", + " bilinear (bool, optional): если True, в модели используется билинейная интерполяция\n", + " для выравнивания размеров активаций.\n", + " \"\"\"\n", + " modules = []\n", + " for i in range(len(channel_sizes) - 1):\n", + " in_channels = channel_sizes[i]\n", + " out_channels = channel_sizes[i + 1]\n", + " is_last_module = i == len(channel_sizes) - 2\n", + " # Определяем факторы масштабирования для каждого слоя\n", + " dfactor = 2 if bilinear and is_last_module else 1\n", + " modules.append(Down(in_channels, out_channels // dfactor))\n", + "\n", + " return nn.ModuleList(modules)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "class Up(nn.Module):\n", + " def __init__(self, in_channels: int, out_channels: int, bilinear: bool = True) -> None:\n", + " super().__init__()\n", + "\n", + " # if bilinear, use the normal convolutions to reduce the number of channels\n", + " if bilinear:\n", + " self.up = nn.Upsample(scale_factor=2, mode=\"bilinear\", align_corners=True)\n", + " self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)\n", + " else:\n", + " self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)\n", + " self.conv = DoubleConv(in_channels, out_channels)\n", + "\n", + " def forward(self, x_prev: Tensor, x_skip: Tensor) -> Tensor:\n", + " x_prev = self.up(x_prev)\n", + " x = torch.cat([x_skip, x_prev], dim=1)\n", + " return self.conv(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def create_upscaler(channel_sizes: list[int], bilinear: bool = False) -> nn.ModuleList:\n", + " \"\"\"\n", + " Создаём список модулей на основе размеров каналов.\n", + " Если используется билинейная интерполяция вместо обратной свёртки,\n", + " то размер первого (самого большого) канала делаем вдвое меньше\n", + "\n", + " Args:\n", + " channel_sizes (list[int]): список размеров каналов, напр. [64, 32, 16]\n", + " bilinear (bool, optional): если True, в модели используется билинейная интерполяция\n", + " для выравнивания размеров активаций.\n", + " \"\"\"\n", + " modules = []\n", + " for i in range(len(channel_sizes) - 1):\n", + " in_channels = channel_sizes[i]\n", + " out_channels = channel_sizes[i + 1]\n", + " is_last_module = i == len(channel_sizes) - 2\n", + " # Определяем факторы масштабирования для каждого слоя\n", + " dfactor = 2 if bilinear and not is_last_module else 1\n", + " modules.append(Up(in_channels, out_channels // dfactor, bilinear=bilinear))\n", + "\n", + " return nn.ModuleList(modules)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "class UNet(nn.Module):\n", + " def __init__(\n", + " self,\n", + " n_channels: int,\n", + " n_classes: int,\n", + " channel_sizes: list[int],\n", + " bilinear: bool = False,\n", + " ):\n", + " super().__init__()\n", + " self.in_conv = DoubleConv(in_channels=n_channels, out_channels=channel_sizes[0])\n", + " self.downscaler = create_downscaler(channel_sizes, bilinear)\n", + " self.upscaler = create_upscaler(channel_sizes[::-1], bilinear)\n", + " self.head = nn.Conv2d(channel_sizes[0], n_classes, kernel_size=1)\n", + "\n", + " def forward(self, x: Tensor) -> Tensor:\n", + " # делаем входную свёртку\n", + " x = self.in_conv(x)\n", + "\n", + " # downscaling\n", + " xs = []\n", + " for conv in self.downscaler:\n", + " xs.append(x)\n", + " x = conv(x)\n", + "\n", + " # разворачиваем промежуточные активации и делаем upscaling\n", + " xs.reverse()\n", + " for conv, act in zip(self.upscaler, xs):\n", + " x = conv(x, act)\n", + "\n", + " # финальная свёртка для получения логитов пикселей\n", + " logits = self.head(x)\n", + " return logits" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Any\n", + "from lightning.pytorch.utilities.types import STEP_OUTPUT\n", + "\n", + "\n", + "class Lit(L.LightningModule):\n", + " def __init__(self, model: nn.Module, learning_rate: float, loss_func=F.cross_entropy, milestones:[int] = [], weight_decay=1e-4) -> None:\n", + " super().__init__()\n", + " self.save_hyperparameters()\n", + " self.model = model\n", + " self.learning_rate = learning_rate\n", + " self.train_metrics = create_classification_metrics(\n", + " num_classes=3, prefix=\"train_\"\n", + " )\n", + " self.val_metrics = create_classification_metrics(num_classes=3, prefix=\"val_\")\n", + " self.loss_func = loss_func\n", + " self.milestones = milestones\n", + " self.weight_decay = weight_decay\n", + "\n", + " def training_step(\n", + " self, batch: tuple[Tensor, Tensor], batch_idx: int\n", + " ) -> STEP_OUTPUT:\n", + " x, y = batch\n", + " y_hat = self.model(x)\n", + " loss = self.loss_func(y_hat, y)\n", + " self.log(\"train_loss\", loss, on_epoch=True, on_step=False)\n", + " self.train_metrics.update(y_hat, y)\n", + " self.log_dict(self.train_metrics.compute(), on_epoch=True, on_step=False)\n", + " return loss\n", + "\n", + " def validation_step(\n", + " self, batch: tuple[Tensor, Tensor], batch_idx: int\n", + " ) -> STEP_OUTPUT | None:\n", + " x, y = batch\n", + " y_hat = self.model(x)\n", + " loss = self.loss_func(y_hat, y)\n", + " self.log(\"val_loss\", loss, on_epoch=True, on_step=False)\n", + " self.val_metrics.update(y_hat, y)\n", + " self.log_dict(self.val_metrics.compute(), on_epoch=True, on_step=False)\n", + " return y_hat\n", + "\n", + " def configure_optimizers(self) -> dict[str, Any]:\n", + " optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad, self.model.parameters()),\n", + " lr=self.learning_rate, momentum=0.9,\n", + " weight_decay=self.weight_decay\n", + " )\n", + " return {\n", + " \"optimizer\": optimizer,\n", + " \"lr_scheduler\": torch.optim.lr_scheduler.MultiStepLR(\n", + " optimizer, milestones=self.milestones, gamma=0.1\n", + " ),\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from lightning.pytorch.callbacks import Callback\n", + "import random\n", + "\n", + "class ImageSaveCallback(Callback):\n", + " def __init__(self) -> None:\n", + " super().__init__()\n", + " self.x = []\n", + " self.pred = []\n", + "\n", + " def on_validation_batch_end(\n", + " self,\n", + " trainer: L.Trainer,\n", + " pl_module: L.LightningModule,\n", + " outputs: STEP_OUTPUT | None,\n", + " batch: Any,\n", + " batch_idx: int,\n", + " dataloader_idx: int = 0,\n", + " ) -> None:\n", + " x, _ = batch\n", + " self.x.append(x)\n", + " self.pred.append(outputs)\n", + " \n", + "\n", + " def on_validation_epoch_end(\n", + " self, trainer: L.Trainer, pl_module: L.LightningModule\n", + " ) -> None:\n", + " x = torch.cat(self.x, 0)\n", + " pred = torch.cat(self.pred, 0)\n", + " indicies = random.sample(range(0, len(x)), 8)\n", + " IMAGE_EXAMPLES.append((x[indicies], pred[indicies]))\n", + " self.x = []\n", + " self.pred = []" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "from lightning.pytorch.callbacks import EarlyStopping, ModelCheckpoint\n", + "from lightning.pytorch.loggers import CSVLogger\n", + "\n", + "IMAGE_EXAMPLES = []\n", + "\n", + "callbacks = [\n", + " ImageSaveCallback()\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "HPU available: False, using: 0 HPUs\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params | Mode \n", + "-----------------------------------------------------------\n", + "0 | model | UNet | 268 K | train\n", + "1 | train_metrics | MetricCollection | 0 | train\n", + "2 | val_metrics | MetricCollection | 0 | train\n", + "-----------------------------------------------------------\n", + "268 K Trainable params\n", + "0 Non-trainable params\n", + "268 K Total params\n", + "1.074 Total estimated model params size (MB)\n", + "83 Modules in train mode\n", + "0 Modules in eval mode\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7db23533165249198506fe0322dd05d2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "260c2135e164458fb18c3abe366c84f8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3b8e975883dd4160849160e34ac5d2b9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f0c15bea9b34465c998ed64aa444c034", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f17c7f59a0b2476fb4af80abedbeff73", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c77b91a7231f497bbb3ebf3f1b3cb146", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "eb6af5a8091f4ebda9470c2b0ef22185", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ba20ba2221cb49d5a2381f37dcda8855", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5d8feb5f705f44dbbcda7905718936ac", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d501e7b80804407c8e3edf8670bca8bc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d70028f4b9a14117b22c565feac0b71d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "de175db3dc7d4373a20e98ab6d8e4ec7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c4a612eeeab9420e98f7076333011598", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9ae5aff6623343cd8c194aaaf780d148", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "de429165b61b4e4b8fc4df1bf1618015", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "594b41384be045e591751472b2d7114a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a5c64bd6fd8d4afa9aae1d952a044fe7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ad90dbc54ca3432d9fddb74938d1257d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "684d997b1ad34735a2d18a74face90e1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "278a1ab3279b4da8a9a12e0c8edcbf98", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "28dfde9921de45328248b9306e6ecf4e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "11399c35daf3450f850dcc7057a226ac", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4182e3ac2d6b4ba896bbd30777ea86e8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d2b1dead8501447f8e07c46807e23d6e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "da26ebdc6b7d4856bc9b2b4f5fbd30fb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d0423d53c09b4e26bdd378ca400e08fa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3ec5881f088941c2b54ded6efb325ec2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2865cd7029254c769886a265799185ab", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b4881f1b6ba84f79b6c96bef5351b4c1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ec68bcaa83c04619ac4127f5dd0f120c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "40bae571727f41d28130a556bfa35938", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "be07dbabff6b487189d39171a25a6b44", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6336437bbd2644eba78f1019a1a0de13", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4b3b0f97986f425aa94775ebff5f2805", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7871926a7cd64b26b38201cfb6c70cb4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bf0047a85fa0425d8b59930045a1739e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "79ef90ebca0a40fea800dd1245f24690", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "36b2cdfde62b41ef885ea9411ae17362", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "654233ff43ad4d208b6879218db44aa2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7b0d7fcce3ff4c4bbb7a62d74592bfca", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2fc4389b316e4d8c81ddfa63facfdb83", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8ac30dd5f45d4435b8503ba2ab9c5cf7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bc62c7d46b544b6193dc297097344283", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8a742d6ad9784c23ac102e5cd725b9a6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2f9dacd641334a848b9a090ceda8bc18", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bbc30c5255304f6c9c2f07da2124a0e3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5222f88b2d5f4e54a005ca942e0bf61c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "deda31237ff44270a75875e674ecb7a4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c2c0d63e21d24707a82f8179a9871aaa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "749013f2c00641b6ba313441211340af", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0f6e28266a414bd2aed3ec69ee840178", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b0820924977b42e2b8ec998692257584", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=50` reached.\n" + ] + } + ], + "source": [ + "torch.manual_seed(42)\n", + "\n", + "trainer = L.Trainer(\n", + " accelerator=\"auto\",\n", + " max_epochs=50,\n", + " logger=CSVLogger(name=\"csv_logs\", save_dir=\".\"),\n", + " callbacks=callbacks,\n", + ")\n", + "lit_module = Lit(\n", + " model=UNet(n_channels=1, n_classes=3, channel_sizes=[16, 32, 64, 128], bilinear=True),\n", + " learning_rate=0.01,\n", + ")\n", + "trainer.fit(\n", + " model=lit_module,\n", + " datamodule=datamodule,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import csv\n", + "\n", + "def draw_graph(value, data):\n", + " plt.title(value)\n", + " plt.plot(data[\"epoch\"], data[f\"train_{value}\"], label=\"train\")\n", + " plt.plot(data[\"epoch\"], data[f\"val_{value}\"], label=\"val\")\n", + " plt.grid()\n", + " plt.legend()\n", + " plt.yticks([i/10 for i in range(0, 11)])\n", + " plt.show()\n", + "\n", + "def draw_stat(version):\n", + " data = {\n", + " \"epoch\" : [],\n", + " \"train_Dice\" : [],\n", + " \"train_Accuracy\" : [],\n", + " \"train_JaccardIndex\" : [],\n", + " \"train_loss\" : [],\n", + " \"val_Dice\" : [],\n", + " \"val_Accuracy\" : [],\n", + " \"val_JaccardIndex\" : [],\n", + " \"val_loss\" : [],\n", + " }\n", + " \n", + " with open(f'csv_logs/version_{version}/metrics.csv','r') as csvfile:\n", + " lines = list(csv.reader(csvfile))\n", + " for i in range(1, len(lines), 2):\n", + " data[\"epoch\"].append(int(lines[i][0]))\n", + " data[\"train_Dice\"].append(float(lines[i + 1][2]))\n", + " data[\"train_Accuracy\"].append(float(lines[i + 1][3]))\n", + " data[\"train_JaccardIndex\"].append(float(lines[i + 1][4]))\n", + " data[\"train_loss\"].append(float(lines[i + 1][5]))\n", + " data[\"val_Dice\"].append(float(lines[i][6]))\n", + " data[\"val_Accuracy\"].append(float(lines[i][7]))\n", + " data[\"val_JaccardIndex\"].append(float(lines[i][8]))\n", + " data[\"val_loss\"].append(float(lines[i][9]))\n", + " \n", + "\n", + " \n", + " plt.figure(figsize=(8, 4), dpi=100)\n", + " draw_graph(\"loss\", data)\n", + " draw_graph(\"Dice\", data)\n", + " draw_graph(\"Accuracy\", data)\n", + " draw_graph(\"JaccardIndex\", data)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "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": [ + "draw_stat(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "def draw_images(images, predictions, title):\n", + " original_images_grid = torchvision.utils.make_grid(images, nrow=4, normalize=True)\n", + " masks_grid = torchvision.utils.make_grid(\n", + " torch.nn.functional.one_hot(predictions.argmax(dim=1), 3).permute(0, 3, 1, 2)[:, 1:]\n", + " > 0,\n", + " nrow=4,\n", + " )\n", + " \n", + " predictions_grid = torchvision.utils.draw_segmentation_masks(\n", + " original_images_grid,\n", + " masks=masks_grid,\n", + " alpha=0.4,\n", + " colors=[\"red\", \"green\"],\n", + " )\n", + " \n", + " plt.figure(figsize=(12, 5), dpi=50)\n", + " plt.axis(\"off\")\n", + " plt.title(title)\n", + " plt.imshow(transforms.ToPILImage()(predictions_grid))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "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": [ + "for i in [1, 5, 20, 50]:\n", + " draw_images(IMAGE_EXAMPLES[i][0][:4], IMAGE_EXAMPLES[i][1][:4], f\"Epoch {i}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Задание 3 (3 балла). Выбор другой функции ошибки\n", + "\n", + "Полезная ссылка:\n", + "https://www.jeremyjordan.me/semantic-segmentation/#loss\n", + "\n", + "Повторите эксперимент из задания 2, но попробуйте модифицировать функцию ошибки:\n", + "- (2 балла) учитывайте пиксели на границе объектов с большим весом, как предлагается в статье [U-Net](https://arxiv.org/abs/1505.04597)\n", + "- (1 балл) используйте soft Dice loss\n", + "\n", + "Опишите свои наблюдения, что изменилось? Обратите внимание на скорость обучения, визуальные артефакты предсказаний, динамику метрик.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def get_borders(img):\n", + " conv = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=3, padding=1, bias=False)\n", + " conv.weight.data = torch.tensor([[[\n", + " [ -4, -5, -4],\n", + " [-5, 36, -5],\n", + " [ -4, -5, -4],\n", + " ]]], dtype=torch.float, device=torch.device(\"cuda\"))\n", + " return torch.clip(conv(img).detach(), 0, 36)\n", + "\n", + "def soft_dice_loss(y_pred, y_true, epsilon=1e-7):\n", + " y_true = y_true.unsqueeze(1)\n", + "\n", + " weight = torch.cat([get_borders((y_true == i).float()) for i in range(3)], dim=1) + 1\n", + " y_true = torch.cat([y_true == i for i in range(3)], dim=1).float()\n", + " \n", + " y_pred = F.softmax(y_pred, dim=1)\n", + " axes = (2, 3)\n", + " numerator = 2. * torch.sum(y_pred * y_true * weight, axes)\n", + " denominator = torch.sum((torch.square(y_pred) + torch.square(y_true)) * weight, axes)\n", + " return 1 - torch.mean((numerator + epsilon) / (denominator + epsilon))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Trainer already configured with model summary callbacks: []. Skipping setting a default `ModelSummary` callback.\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "HPU available: False, using: 0 HPUs\n", + "/home/mperikov/dl/dl-mcs/.venv/lib/python3.13/site-packages/lightning/pytorch/callbacks/model_checkpoint.py:701: Checkpoint directory ./csv_logs/version_54/checkpoints exists and is not empty.\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params | Mode \n", + "-----------------------------------------------------------\n", + "0 | model | UNet | 268 K | train\n", + "1 | train_metrics | MetricCollection | 0 | train\n", + "2 | val_metrics | MetricCollection | 0 | train\n", + "-----------------------------------------------------------\n", + "268 K Trainable params\n", + "0 Non-trainable params\n", + "268 K Total params\n", + "1.074 Total estimated model params size (MB)\n", + "83 Modules in train mode\n", + "0 Modules in eval mode\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d7cdd60ff5a6457ab39172fbb5be3433", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a9a4f21be44d40cda629a8ee01a5b356", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bb076d1c0e794e7b88bd68198bd4b6ef", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "10fdfa19c03148308ac7af56070093c2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1e6e4ee81798481b9dcb2a6a2ead5760", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b526da564503467ab6aa3d4c12bdbf15", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ed2c40243c5143c5800fbbbc8947c34e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "63bd4fea67114bd48fe20879838f80f5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "49cc89c686dc4b719472d46d9b9413b1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c5d4448eb30d41458898f794e72fc92f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "96f602dd8b5f465e94751fb7d92b5a77", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3f96de154beb470bb7619acd04d433ab", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "246d9669377d40538c1d4264e731bd77", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cb85a7c01f574b838334950b0610d89f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5df3e9c4b82e4679b17f4271e0f2f206", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "285f793aa5d74b43af4c3a7b2de26717", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3ccc4f3729f04192ad9a8bb5a78ef7be", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b411a3700295413480ceacf992365e11", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "23edccaa53c740b59b6ce2d6673140a9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f4dc2bb99cf7480fa859f044208f4e88", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c3c25e8a9660422aa78f649bc14c05c8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "01fb69665ddc476eb2ecbe7e391f4dab", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "310487b0046644bdaee5feecccd9c195", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bf2299a903704e2ca0b5a998bb749617", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "480de0d4002a4bbeabf22106d050977e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "61884c91bee0458683d9ba66eef6d869", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "247520552ab74abcbcbf4ce5629db666", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f9a6c2454a0943cf8177fb023252e279", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "659f6a5b90cc470a994cde464eae8c45", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "08a3051dfad64feea2300904ea1e0362", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "81ec710920fe4c3098d64b572af2d91d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0abe3e83d4eb4a419574fd864e522508", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "01277da56d1248c0ba119afba473f442", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b000c14205864e99b52ac080686cdc1d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "552dfbe448d94d428d860d8694cccf42", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ec54cc3eb4df4ccabb90f183e6572a91", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "25628b965c2c48a6b81f7c3a2ec5fece", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "97f16bec41d54bbe8c8810890f12f997", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ca1d918afeb647cfae78e092053d54aa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d1a362ff34c44eaaae31412c850d6043", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "90eb4a5cc6404071818e7d8e95318c46", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "66c95ce4d5c84a0d9d4f1687825e105f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "61ddc787ab0a4916a7728196810f57c2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b993b70c134a48ba8fe4fe8eac665ece", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "750b4c4ac261497292f995f9b41e162d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "68046d9db0254296a3d87f3660f9dea5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "19cace1154844d4f93ab8ed3798e01d6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3fbc4b65bb2b42a78c2648f2ebf436b4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "02eda95464f14140b535384e4c4d7ef8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "073c311ac1e5469eae90faf6d125f43a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "303f55333fc44c059a102c0907f1a653", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3b5bb33e7246433a92a550977dcc3e1c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=50` reached.\n" + ] + } + ], + "source": [ + "IMAGE_EXAMPLES = []\n", + "\n", + "trainer = L.Trainer(\n", + " accelerator=\"auto\",\n", + " max_epochs=50,\n", + " logger=CSVLogger(name=\"csv_logs\", save_dir=\".\"),\n", + " callbacks=callbacks,\n", + ")\n", + "lit_module = Lit(\n", + " model=UNet(n_channels=1, n_classes=3, channel_sizes=[16, 32, 64, 128], bilinear=True),\n", + " learning_rate=0.01,\n", + " loss_func=soft_dice_loss,\n", + ")\n", + "trainer.fit(\n", + " model=lit_module,\n", + " datamodule=datamodule,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "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": [ + "draw_stat(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "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": [ + "for i in [1, 5, 20, 50]:\n", + " draw_images(IMAGE_EXAMPLES[i][0][:4], IMAGE_EXAMPLES[i][1][:4], f\"Epoch {i}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Судя по графикам метрик для валидационной выборки, точность модели с *soft dice loss* немного выше. \n", + "По графику *JaccardIndex* и изображениям можно сказать, что модель с увеличенным весом для границ лучше их распознает, как и ожидалось. \n", + "Также по изображениям и значениям метрик на первой половине обучения, можно сделать вывод о скорости обучения: модифицированная модель обучается быстрее." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Задание 4 (3 балла). Модификация архитектуры\n", + "\n", + "Ваша задача - извлечь максимальную точность из модели, в которой будет не более 50k параметров. Для этого внесите правки в архитектуру модели.\n", + "\n", + "В частности, попробуйте заменить в блоке `Down` комбинацию conv+maxpool на dilated conv с увеличенным stride (`nn.Conv2d(..., dilation=2, stride=2)`). В остальном - полная свобода творчества, можете перерабатывать архитектуру как угодно.\n", + "\n", + "Ожидается, что просадка в точности по всем метрикам не будет превышать 10%; в частности, accuracy 90% вполне достижима.\n", + "\n", + "Как обычно, запустите эксперимент (или несколько) с выводом всех графиков и картинок." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "class Down(nn.Module):\n", + " def __init__(self, in_channels: int, out_channels: int) -> None:\n", + " super().__init__()\n", + "\n", + " self.dilated_conv = nn.Conv2d(in_channels, out_channels, kernel_size=3, dilation=2, stride=2, padding=2)\n", + " \n", + " def forward(self, x: Tensor) -> Tensor:\n", + " return self.dilated_conv(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "datamodule = DataModule(\n", + " datadir=Path(\"yeast_cell_in_microstructures_dataset\"),\n", + " batch_size=batch_size,\n", + ")\n", + "datamodule.setup(\"fit\")" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Trainer already configured with model summary callbacks: []. Skipping setting a default `ModelSummary` callback.\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "HPU available: False, using: 0 HPUs\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params | Mode \n", + "-----------------------------------------------------------\n", + "0 | model | UNet | 46.5 K | train\n", + "1 | train_metrics | MetricCollection | 0 | train\n", + "2 | val_metrics | MetricCollection | 0 | train\n", + "-----------------------------------------------------------\n", + "46.5 K Trainable params\n", + "0 Non-trainable params\n", + "46.5 K Total params\n", + "0.186 Total estimated model params size (MB)\n", + "56 Modules in train mode\n", + "0 Modules in eval mode\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "24a05086492d4d8e9c500c49838fe078", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "09849bad022f47afb243cd4f377a6627", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "550166f5db24421296b1da9b2ed1b6aa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cc3d0144ea954d978e19eae8004aa677", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6fb0ac1b2d2044d2997a310be972b3d2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "aa9730b791d443db89a2d025b5892b08", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8e36add3aff941b7867c3bbb76bd1b4c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "12ab688c98a44167b6101e6e566a7a1c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "422ab0873e4f4ed38ca0c4a6dacd40f0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "93533278ca8241c4b5c3663c8578cc3c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "245014221f534f0e8951e77eb9863476", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5b6969d4db5940cdb271857fd90f5fa0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "aa2edf57b9ac4b80b74d63b54caab024", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "662eb84d731e46eb919c1a1d8bf5ec0a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bdcadcd246ce42c280108fd93af6c577", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4df39e4bc84b416d9c73bbc0aba62e13", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "eceeec83774f4f68ad7bef4816523038", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e43e20a21b454fa8b82aebb0741421b3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "386920ec6a3d4430831a99057f413bed", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a75ce292bdd648bab0f229283de0bb3e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "37d8afaf802b4518993d5134b69c63c7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cb0019a691694fc686350b49bdfbdebc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c47ece5960e14f1cbe993626e5e11bf6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7f57706e631041de8e1b908ac1042713", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2ebb735dfe4c4dc88685102967f9831c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "53f18d52de114cc0a41d2f6fe068acba", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f57ad27b6f52436daf3aa256eb789400", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c3473e325dc94165959f8f4ecf7a8665", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9ebfdb250a0c47178b48d40dcc2d5fbb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "89fe9784768047eb8c2efd7f6c829d9f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5b7c909ac58f497a83f40dfd95119a5f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "17b78593ae97406ca74641ef22afced1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dfb197ce72ac4ff597ad52730e81e23e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6e07361977da40418bf21d86b08ad5b1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "66815f3882b842cba8cbe2215a8d3d81", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "696139a16f434a78b44a3b4f71c67815", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2e588e6444d441c98f33cf567a9608b5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "feeed473ae1045edb8a0102931deb0d5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "95ded2cd19b8430aaea1f0dcd212e57e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "172b456cbd7e4f28904c8eb4ccfd823b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fd32178a172f413c8019d4a7815e25ba", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8227b7eea58d42fd9d64b1c710290135", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8af97a07ab5f4bd5acbbb951c503705c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9c7456623c4847119e7a118f4f418937", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c592b946d0a149c3b2786a016a8a2c10", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b1a09f3064b644e0ad442277e55f03c6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c1dd4db3290c490da42f7c88009b6d60", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0dc74972b94a4125bdc8ee8d87bc91db", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "60d5b442a07846f9a2f7281f8290b3de", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0e5d9e787f32449f844fe0bfcc600529", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3830f41bd8a94c1485cd1f71172f7c9b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "42b3f2c2f9854e0d8aa4e78e04361301", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "adf5ad3f99cd46abb2088b946fe21b4a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3cad400c3cbf43db9d84d34dd82539b7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2efe3a5c58fd432db093b7fd57320f70", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2a89249b08474ecdb259302f8957d493", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f480a5965f94423092c452cac44926d9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d06612b8ccb14c3eaebff88a5c52d657", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "32fd6abda48b4c0e8603b3c13aeab3f7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c469375436a94f05950c15f6d2f0e787", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4bc82f43c2504befba04058670592651", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "31323c011daf44978da4ef0da2c40da7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0896e54c8f12499db7aaa7e099c92835", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9434a2cec1884de1978336f99e1c0b23", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "50006fedcea84d0893467d101dd031ef", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "67664e8e3c30414aba28a44c46048485", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dd851d33bece47b98b593831713edc54", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "914c476488954e37a65f30ba5fe655d3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "eda7de9d4a314627ad2c0ebc0228a880", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "58d50afee0164e09bd75855a3fdd55a0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "73a16194e36c4f60aa2ae9b011b1e955", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4ea6ad1d2a2c4c96b0228e8651b57ebe", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9f081db17779491686639e73e6f57cf8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dfc8e5e1c51c4402b3207ba7a5343f3a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84d26870f93c45c2b131d53cafb0fa1f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dc4c22da34104c059db8ffc84d313425", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4e09d9e9a97e4f229311b70610c01af0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0082b62d58d14c158c40b028b08c8cb8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5733a17003ea42dd9bb5a76db6e34e2a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ebcf052fb28a4ff6b2b1d01ce0b9d97b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9243ec8adf334e53ab8d0ea009602261", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "75069ce43756472bb81de0381d5c40f8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4e2806a4fa9a431bb82ce6bde0fb7553", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dee56f5d07f043c5b85db447072fa17e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7fb72b094cc04dc7bb4e01348458414f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "888b90c1f0bd4bfdab67caeb8e0aa7c5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "41e226045f7b4906abe4977b39e6a7b2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "54fadfb604714801997f73956339fd09", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e66a05d606de4f96919f142c5b36f5e4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c7388a0b12354c0c9c4aa0c4d10f9a45", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5321ad8225d642a3aaffdc49aaf93a8e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "194a76c0ce074a90be9e18835f1aa9f5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f4ddd86246814acb96d663121355a4f1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c4d8646360cd4bc5b9e00fbbeb09b410", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c5138bfb248b4c4a852b8b14d827987b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0d8c0c43121b4fb3998ffa9de632b735", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0da44d82805c4951bef08b263f3ed08d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "20e7918e68c34ec69a8f7ef1c04f2797", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "709777e56327482bbe99ed9da3e0ebb1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "846f9e242391401e88a39be6f1e00ec4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9a71a9c781d14758a215638a339eb899", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3813c08698094717a7ddac129f9b621a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ec60f0746d494eba8dc8cce4d02282d0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "31683b7dd81b46d7862f91d696203e22", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "971401d6428e488e8e8a7c86560e789c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ba912ea3218448969874846b6178d621", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "27cd730e9b054fefb1dea52488c7dad3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5ce9a2e8de6f4302bc8584d0e593c8d0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bea5f9596dc04baa8baa030a4e827e2d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "91cbc4e33cb34692bac6c207a5af8d0f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e0c7f9ba759f453db1eca565287331ea", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0852c728993b41fcaef01e5e0e19d602", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5b35eb6c50ce44e5981f78265bc7d6c4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "476d5463ae944705862cf1082b94d47f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "53d7986da1114eb18e2f4a44cfa65557", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1e5ce70181b242f089a6dfa8a7d3390a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b5d163a03eda400a96de83adb44995a4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d535de206b304bb1bae8b7c1d5ccaa02", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "626c660845964ebba9e737a3ea01295c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d877b251defc4cfabff85916413996f1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1e8907463eb64bfa8afd2839ba30625a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e728e44737f8465eb8ef10fa8f19b830", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "02436fb5b0a547f2afa892b6d846bbfc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ce10e7f5263b4e478db77b925b62fdb0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "365b99548ec643bb8d61222501f05d74", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "779aefe787ae429e95ec519cba171105", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "86fe5b9a2721418dbb26a0167b35ca02", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e9c280055fe5412cad9d3b4494c41112", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8b1f37fa6f174d7ebde0c2056b0dc166", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "89766a1ae41b43bcab56cf0824b0b41d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4a81e1bc8a904e938075a19c3e2591a5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5e8663f16be848088aa1ce221900ee6f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7921400db7ab493e939be656341e0733", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6f8bd06d9675494cb777f73f489fd7db", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2711d21414084a97ae289800015b96d6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fcb4d610008047baa69eb5340d24e3d3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "46f7ecd5bd9d4341abedda806f0c7d44", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7182299d9ed24e7b92d04092be495876", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6107ab26667f40c1a950bc5e4d6dee46", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "43626da78dac49b391d36db38843aaba", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8a3f7df0ee8e4acebde63b9ad20c514d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "95bc54d957b241118643a989f308991d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9222d63ec15540408cc3f016e6c02c2a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "77a99b945b8245548e595af3f53b0c72", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7b97649041b14986a0145f4b2fb12397", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e3a6940a92e847f4a1587c981d6ecd63", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cac68cba3bfe486cb327018cc812ae3b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ffc8523bed5442f1b8f016cfc4fa2cc3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cd871f5d30d64460a04da37f3711af98", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1204c0cd1c8849df82b28b1f2555d034", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9aeacbe5951a4822b9c3631477752fa5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "beb0f46d317545a78a349055c404e47c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "78d550f2a2ad4dd58cb075ae49aeb687", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d8ab538cf7d949038398c490d99c3f94", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "06cd4be205d14f15a66ee047ab1df2b7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e3c8a0a752704310b99f9c1ffb21f4a9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2ac09103e3c444a48f2906520bd87f9e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7fda60e7a29e4ecf9666a420a43c833f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4c400d18ad7a4e60bda1da8d8cbc6d6d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c3af41b505294c508509def90f11b61e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8b677bce93a148af94bf5ea9fbe4260a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "da831dd0e49f459ea0967c3968d9f2cc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "001efba09a824cc69a857f2c65dcd71c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2dee9c9cf10b476c8989d09bf92f4f71", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c9302bd20e8d40d584ed175d92b7f2d8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fafa1827cf814314b7f193db47aa2caf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "709f8cf85982464ab3e74f6391d074bd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "37e3bd58b0b646c2899fcfd2151a4bcb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cdd4d2e77ee14a2bab9f4e1684be652c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a79174679df44ce48d072c04821d7e72", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "62bb5e5f9ce040f1b2395ac3ca19c9fc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4b27b7757bd448b2bed2c2c7a2b1d76e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "01c7c069564b4779aa4f21645d72ad6b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d46553b76d954bafa08d32ae432cf7e4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "28f5f94404514f15a2595f771ac24d5d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bdf1ae2ee4e940c397309d34965c43c9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a403984683eb40729f3dd12c03f9a140", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "126ca28fab7344d4b670fd41d733d006", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9accb86c7a064c6a9b958f6b2be88cef", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4dedd6df631b4e4cb62dd21d8f06a2df", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e9138584272341bd8a2af0f9b5bef17b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6e501b194a8e4dcca83c00de027c6cb0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f68163323b44428b800a564fa47c94b1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fac1e4a64619417989ab76db45f555c4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "89f2f51ab04e4b6a989570d1d106b7a5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "deafd9747c3c4b3ea11a73781c5e99d4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ae6909c5ca3b485fae453f48b2e0427a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d21e613d800e4c8cbb4a7665596842ff", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ecfbcd7fff274920823ffd0b87ea9cb2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e301cf751e9e47f794d767b16fd77c8e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "965996cd8a884fdf82dd5923427fe746", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "47bcf4d230cf410aba99f562ac433ee1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6810f3a6a0e64223a65d4953b5cb1970", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e8b9da3a77bc46a2aad29a6cda742c6a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "800076a433e34b7984feb63f76441b49", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cfb9b997e60d4fc5afd49d740f974ed0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "91d1cd37e0a7487fa250586289ef323a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "72d6ba83ba264e6b95c258918eff6fa9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "17dd57c1b7584d8d895990aaf78b0eaf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ee6866ce07bd409a90ecbe01e89bb692", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0bf6e78bdb8d4f528bf59fd22e64c419", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "58d12ad74d4745d4b7f58750762630d4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "230843ccbcdf45118b8cacdf97c4d4f2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9fff173acb474a0297422798a7455f1b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c6f84790f1184058bc58d48390f58c45", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2e70143ca8d844ae9773fcedbb84da48", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a9803f9b3d474266961bc3b2bb82f5c7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d356587da47c44529435ac648122b5b1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "caf4c1b8fa7a47ddba01feb98df15fcc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "87ed39a45bea4b69a4671e3751db4a31", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2479ee9449084a1ba38ac958ff733b7c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8bc2f00aeba84292b8d83a2325334775", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "afa1d087e7614f278bc95d8d641673bf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8a02987098c74711afab4efde66c5303", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "28cea12f537a418aa6a2ac50944405fd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "20c8ca784b4746a78f0b98567cc7cf03", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "61f7ec36721c473cb72a8f2f7c934315", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "91098cbaf696482fb354e608ce592c39", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2181831e3c0641ac9eeef052bae87c94", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "351eeedb413042a09bc9efd85f5159cd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c9371034ec784b8799033b8a6c6a4223", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a3cc072e8fe244d7bd1a7bb3bd10bb97", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c7a74a9c4dd7464f9b58de5bc742efaf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "916a33ebb5b549d183a791d5c037a16f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "502811d663c846cb9c2a6a7200436218", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5ecfaaa8959e43e193e90335f3613149", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cc23ef15cdb14be1ba0d425011c1c3ca", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b0245e2fe2644b8c8ee0852d81440269", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7ce1cd9ab7374677998526972f2c6f51", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c5cd886471ad4432a77635a5031981da", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "32bf9f4b2c6e49bf99d3eccebeb46cd6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e3688e711c17431ba30e83daa849af70", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e0d89f884f9b46dc8eafa4c36a8aa5f7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "35f2860b175f42ff867a86b3e6882812", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "677758175f004da3923db7917d7cd63a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5931f51612aa44dd80bf43f6199b1823", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8fb9f2fb5d3949558b0ec575ce36cd44", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ded7d168c26d41d58244fece427a0874", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "88334a8dfa9c4a62aca2b61a12cfb65e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "846222a53b5840e9ae55e11425457c13", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fb65b36f8f7141ef90a522520aba6b70", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cf30cc827d3040b484b32ecfa0a4f27c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5131f54741084599a01a2e99b568315b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "50506a3d280a4a43a76fc44e1d957ccd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1673775715ff4cba8cce9d68c926545e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "12d69396b42b4512a47c578040d185fa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e9fe9f3905e248fb8f7e91b9f00d553e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1172239d3d63442695768af8ef6c5d00", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ade62e67446241798368090495fd25bc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8a816773799b4d8b8c360c518538217a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "578a7049a4394d459e185fb9b27465dd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9dd01a6e88ba4741bde11a0135d5efdd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "08160942b0074b8b809153ca1299bd09", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "61140f18be5a4d82bf14479c093d01ba", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dee2ace18c064d0480b47e47fa86d1af", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "304971e458764932987c68ad651ce73a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e0dbbf2331f54b8ab1e15e5773f48adf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "531104f2309e4e088dbf682d6eb2945b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c7c7356363d842bbadbf6c3d79f85604", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9abd0f935c714140b254ae200e8f613e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "98f51f1a37c142d98a44caa15ada702b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4f6bcf731ccf4f4d8563dc4ba295e17b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b15f6dd5ece2420c95d5db72ee7e3fa0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "08c4c6abf9d74330ab0958c69592b7b1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dcd25f03e9d649cf9497084aab89c246", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "98c2ad9427044afcb8c02606cdce5f2b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a6e590cc13134dd19fc5e1e892ae0258", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "68cf8870b4b6432ba9a58566f2cc3c81", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4886befbdc42479b85c22f6d948900eb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b1b799a0e11145b5a71e0f98fc71a6ff", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a7d1c829a8fc40d5850e743c6b2c6f6f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cf017f6e81f54d1b97cad22374312c5a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b5da68008a6b48dc94731832c9cc827c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a036d8748145483ea075469ed3b24614", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "508075c886b44471aeeb2740e2696872", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8c71dce9f36d4debb20f8b24d7247e8c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c53386559b3a44ed813e5934a01a526b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b5ab3921966f4dbaa1b5c5f99a84b60d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bad2ee5e98a7429bbb65cad8455487be", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b274928336d6433cb9dd28f81bd954bd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a8f66940bbca48a3b15d44c536018e65", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d6293d5e7ffe49d3a0e613c40522ab34", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "932b9dad6b7747a3b95065af1f04f5ed", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0d3c27f4dd4844e7867af1049ebf04e7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "62de051c43b64d9bb2c7f0bd6c2b4ec2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "aad270f3bb6940078abbb9f0e0ea71b9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "11aaa82568c24068b99c23dad675a409", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "afee4d66e1f34ea08ff4359972b130ac", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "184c97aa822f4bf0bb8b59668e96b2f2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9fb6686ad4234921912059bce18187e5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9988aebded3f410cb82333e845e54f6e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d1ac3e5625e2498898f88b15079c2b0d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a47153e19b1f41aab693649ab0bd404a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8c31f378a85b43e2b60ab1f7877474bd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1a55c17561254b77a607de5d76389829", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "63338714da274a028f54d2d34b33758a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fa26fa12f46b47b8adae2fd153bfeb59", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3d1c1eb8394748458d5482fb2800dddc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f094c68880d245fdb059c55e93ee0a24", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "03af11cab0eb48d0a7a2270c921f7ce3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8686e260b6404e3cbc714ad16cdf40ac", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3555a825ebe745edb3b494186c6284c8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "878b0dbbb332475080129acf1e3bcaa9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "622341c5705d44c5a2f11aac0405b859", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3cb1e713e1164b6f8c8a5bed19c9ec4d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b0b479ad262d4d6f900d2d158d438e47", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f1af37dc57b142feb067b080efdf73ac", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1090e5012b0042e689206a82cf363d4e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "eb18897fa5524b0387141b9d9dc2dbe5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "928a2e3b2759479b87f7cef96bba1514", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dc4f287ae78d40ce8cd5fba8f9548eb8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a39f84d9c88145c9988879ab4fd2be1d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6107208c4c8b446f8f12978ac0bd3384", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d7fb1310b1c9472daa5763c2679daaf1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2f30fc4cbd6144c9a232f84d9c4f5873", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4e68fc075f8141719a5d57c477bc1abb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84627866154146688d344db15303c208", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9233abf647e745f38c53d02365bf012c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "68755ca0df1248dcada52b399939de43", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "297a278187844c7eb14fba8d4aa38ff0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "19aada00cd624c17a6b743931b8c6685", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9e61ace846344e479b306a7d392a1a83", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8126247a97ba41aa83aacaae41bbcf8c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f8b026973f9f4505bd39abed525f11a7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "843482f4b1054c008426c071df984cc6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "44088efc8cd244e096ed35f04f6ca8d5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9b49409be2fe410c912328b7fe7e5410", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "345b371e83c14004a0093c6eed40a1a2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "07a246d82f604480a6309a060bcf34da", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7445fea0af74457886eaca2fa2d59693", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3e584655a6144a579985ad0317229186", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ba544689847246369f57919a93919eff", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0eba02d3c0cb4fb0996ebdd09de25d59", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d94e1941d3ca430dbe63c08400bd10d7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e28c2a4d959e424497d9a47ab48c886b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e5a5003e86364bef8e32bda0333719d6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cbb74a38b5ab44478d083ea0d3832734", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "094dd157a3c34c64948c3011d30386db", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8700571e819f4310a8d3b98809408170", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bd7a43da0158439c8b4e54610d048ede", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b5e680f2a2fa4895a498a5b741e24f44", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "42535d769ee347e8975bd5e5113075dd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bd9f884af8fb40e3afba7d495c003c60", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a2e9564f6eb146cd9a9aa2a377a5fa34", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d8453707fb92455797b9d20b5c4e6ecf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4c38cdd00de74958a43f5040137a4eae", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "882416fb670647b094adf2ae7a4fd979", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a2b8305be04f42ff91249eec5d2ba6c3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "16232298ff1e4d3b980994b524017b15", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4c9527d1bd8046f28659df50a8d02c41", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ee46d6ea74244157ad9c03c7e381b785", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "64fe3f9e6aca4433a9620eaedf4ced3f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dbeab048447d44fc84eb27825c0a6baa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c6b307dbbc0343e8b6c416659127fd23", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8684da4d229a43e5b3eed7191dfa8b46", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b5dc0028f8634dac861470bad9fb4f18", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "43090e4e06ab4994b5d84911866ca5fc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8b17f5b7e9454e4baa56017864b0f539", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f6fc13c4f4b64a44a468e2c047282670", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "237696e047c44604a4d6c08bd40d1daa", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "76eaeb2af7d24ff78c66b1d2614da6d9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b0aca058d10446f6963641fa52edf9e3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cb2de9b6f7fb443fbef726c094fa611f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "00216f2bdd9c4b5db386f06d0e663112", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "40708181b21a4b02a2a643c4341b52da", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8d9d94208d054cfc906ab6996b5fd13f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0df3eae65b3e4672a480ff21bbcdfdc1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bfa05039541248a88dd59d393c25d847", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f6f684d5508b45d7b2ab17f1056c2cc2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f390fb744a2a4a1b9eea30c10538729e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8345a378d2a448a299c63b9cf652d65b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "df64c696661442659a24fe9b27b6fd4c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f96e4deaa5f94925ba7ed381f62877a4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7b0c487c32e647d98615716f510519b2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "23d2b1f0606240548b573be3ec2618f3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fe81fbfa2f4e4efcb457e71d8e75f3ec", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b4ee81bb0db14ddcbbca3265382a536b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "01c5da692edc48dd87213249b6d972fe", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "547d244633a9468389495fd0ca4d66c0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7892b213f6fe41c68d27c0c8cee063d9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0c5d9fc016aa4aea9e1597a98971dd4f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2ec9faca648548b9b1a26a5bafce4d7a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6566005000a943219434f7c0b068dc03", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "861fa427d96a4c6884beb9a4ea6fd36a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9460577c380746fca786e45d060f2903", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4721c2dbba5f44daaf268e8d3137d6ca", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b96539fa18ff4cb382ebc20cce792605", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5e6857407e6a4b799feb2bc4969c1468", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7bf8f40e657548eb8f68cc1c6f0abb56", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4ef307e269e040b0a299d355a0c21cb7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "86753906fe824b829e51a33f921c2a8a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6bdbc7a88bc14de4a88dbc8317e32cdb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c00a16419eb34be598c3fc9257fdeee9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "26deab8a06e048e5bc8ee250b7069f58", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5a55664afa774e1a88a77dd5a6d3532b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cf5a385812154594b01b655c72ae2525", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f181aaa8aca94d44a1e5f19a714764d4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a11edcd605344289a21c8a0fd66acd17", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2519ab84340b4514a8625a8dc7390d2d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ed481ed071ca4f0693a330f16fd6d9c1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9b05604ccc9d4269bec91a271da57d75", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "85ee7256ad984e688111099d4d761cd9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: | | 0/? [00:00…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_epochs=400` reached.\n" + ] + } + ], + "source": [ + "IMAGE_EXAMPLES = []\n", + "\n", + "trainer = L.Trainer(\n", + " accelerator=\"auto\",\n", + " max_epochs=400,\n", + " logger=CSVLogger(name=\"csv_logs\", save_dir=\".\"),\n", + " callbacks=callbacks,\n", + ")\n", + "lit_module = Lit(\n", + " model=UNet(n_channels=1, n_classes=3, channel_sizes=[8, 16, 32, 64], bilinear=True),\n", + " learning_rate=0.01,\n", + " loss_func=soft_dice_loss,\n", + " milestones=[200, 300],\n", + ")\n", + "trainer.fit(\n", + " model=lit_module,\n", + " datamodule=datamodule,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAp8AAAF2CAYAAAAoS/PfAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAV/ZJREFUeJzt3Xl8VPW9//HXmT1DSEIISSAsYVEQhaAgGK1bDeBSKra2KLRgbou3Slo1tSr+lM1WvNVSbIvSqtReqxX1utUFjVGwSArKUjdAQSBs2YDsyazn98fAYMwMMBAmBN7Px2MeZL7zPed8z4cDvPmeZQzTNE1EREREROLA0t4DEBEREZFTh8KniIiIiMSNwqeIiIiIxI3Cp4iIiIjEjcKniIiIiMSNwqeIiIiIxI3Cp4iIiIjEjcKniIiIiMSNwqeIiIiIxI3Cp4jIMXjyyScxDIOtW7e291BERDoEhU8RERERiRuFTxERERGJG4VPEREREYkbhU8RkTb2yCOPcOaZZ+J0OunRowfTpk2jurq6RZ8vv/yS73//+2RmZuJyuejZsyfXXXcdNTU14T5FRUV861vfIiUlhcTERAYOHMjdd98d570REWlbtvYegIjIyWTWrFnMnj2bvLw8brrpJjZu3Mijjz7Khx9+yAcffIDdbsfr9TJ27Fg8Hg8///nPyczMZOfOnbz22mtUV1eTnJzMZ599xne+8x2GDh3KnDlzcDqdbNq0iQ8++KC9d1FE5JgofIqItJHKykrmzp3LmDFjePPNN7FYQieXBg0aREFBAX//+9/Jz8/n888/Z8uWLTz//PNce+214eVnzJgR/rmoqAiv18ubb75JWlpa3PdFROR40Wl3EZE28s477+D1ern11lvDwRNg6tSpJCUl8frrrwOQnJwMwFtvvUVjY2PEdaWkpADwyiuvEAwGj+/ARUTiSOFTRKSNbNu2DYCBAwe2aHc4HPTr1y/8ed++fSksLOTxxx8nLS2NsWPHsmDBghbXe06YMIELLriAn/70p2RkZHDdddfx3HPPKYiKSIen8Cki0g5+97vf8fHHH3P33XfT1NTEL37xC84880x27NgBQEJCAu+//z7vvPMOP/7xj/n444+ZMGECo0ePJhAItPPoRUSOnsKniEgb6dOnDwAbN25s0e71etmyZUv48wOGDBnCPffcw/vvv8+//vUvdu7cycKFC8OfWywWLrvsMubNm8fnn3/Ob37zG959913ee++9478zIiLHicKniEgbycvLw+Fw8Ic//AHTNMPtTzzxBDU1NVx11VUA1NbW4vf7Wyw7ZMgQLBYLHo8HgL1797Za/7BhwwDCfUREOiLd7S4i0ka6devG9OnTmT17Npdffjnf/e532bhxI4888gjnnnsuP/rRjwB49913KSgo4Ac/+AGnn346fr+fp556CqvVyve//30A5syZw/vvv89VV11Fnz59qKio4JFHHqFnz55861vfas/dFBE5JgqfIiJtaNasWXTr1o0//elP3HbbbaSmpnLjjTdy//33Y7fbAcjJyWHs2LH885//ZOfOnbjdbnJycnjzzTc577zzAPjud7/L1q1bWbRoEVVVVaSlpXHxxRcze/bs8N3yIiIdkWF+/dyQiIiIiMhxpGs+RURERCRuFD5FREREJG4UPkVEREQkbmIOn++//z7jxo2jR48eGIbByy+/fNhlli5dyjnnnIPT6WTAgAE8+eSTRzFUEREREenoYg6fDQ0N5OTksGDBgiPqv2XLFq666iouvfRS1q1bx6233spPf/pT3nrrrZgHKyIiIiId2zHd7W4YBi+99BLjx4+P2ufOO+/k9ddf59NPPw23XXfddVRXV7NkyZKj3bSIiIiIdEDH/TmfJSUl5OXltWgbO3Yst956a9RlPB5Pi2/wCAaD7N27l65du2IYxvEaqoiIiIgcJdM0qauro0ePHlgs0U+uH/fwWVZWRkZGRou2jIwMamtraWpqIiEhodUyc+fOZfbs2cd7aCIiIiLSxrZv307Pnj2jfn5CfsPR9OnTKSwsDL+vqamhd+/ebNmyhc6dOx/37ft8Pt577z0uvfTS8DeSSIhqE5nqEp1qE5nqEp1qE51qE5nqEl08a1NXV0ffvn0Pm9WOe/jMzMykvLy8RVt5eTlJSUkRZz0BnE4nTqezVXtqaipJSUnHZZxf5/P5cLvddO3aVQfxN6g2kaku0ak2kaku0ak20ak2kaku0cWzNgfWf7hLJI/7cz5zc3MpLi5u0VZUVERubu7x3rSIiIiInGBiDp/19fWsW7eOdevWAaFHKa1bt47S0lIgdMp88uTJ4f4/+9nP+Oqrr7jjjjvYsGEDjzzyCM899xy33XZb2+yBiIiIiHQYMYfPjz76iLPPPpuzzz4bgMLCQs4++2xmzJgBwO7du8NBFKBv3768/vrrFBUVkZOTw+9+9zsef/xxxo4d20a7ICIiIiIdRczXfF5yySUc6tGgkb696JJLLmHt2rWxbkpERESkTQUCAXw+X3sPI258Ph82m43m5mYCgcAxrctut2O1Wo95TCfk3e4iIiIibck0TcrKyqiurm7vocSVaZpkZmayffv2NnlWekpKCpmZmce0LoVPEREROekdCJ7p6em43e5T5ktrgsEg9fX1JCYmHvLB74djmiaNjY1UVFQA0L1796Nel8KniIiInNQCgUA4eHbt2rW9hxNXwWAQr9eLy+U6pvAJhB+RWVFRQXp6+lGfgj/uj1oSERERaU8HrvF0u93tPJKO70ANj+W6WYVPEREROSWcKqfaj6e2qKHCp4iIiIjEjcKniIiIyCkgOzub+fPnt/cwdMORiIiIyInqkksuYdiwYW0SGj/88EM6dep07IM6RgqfIiIiIh2UaZoEAgFstsNHum7dusVhRIen0+4iIiIiJ6AbbriBZcuW8fDDD2MYBoZh8OSTT2IYBm+++SbDhw/H6XSyfPlyNm/ezNVXX01GRgaJiYmce+65vPPOOy3W983T7oZh8Pjjj3PNNdfgdrs57bTTePXVV4/7fil8ioiIyCnHNE0avf52eR3qa8q/7uGHHyY3N5epU6eye/dudu/eTa9evQC46667eOCBB1i/fj1Dhw6lvr6eK6+8kuLiYtauXcvll1/OuHHjKC0tPeQ2Zs+ezQ9/+EM+/vhjrrzySiZNmsTevXuPub6HotPuIiIicspp8gUYPOOtdtn253PG4nYcPoIlJyfjcDhwu91kZmYCsGHDBgDmzJnD6NGjw31TU1PJyckJv7/vvvt46aWX+Oc//8mPf/zjqNu44YYbuP766wG4//77+cMf/sCqVau4/PLLj2rfjoRmPkVEREQ6mBEjRrR4X19fz+23384ZZ5xBSkoKiYmJrF+//rAzn0OHDg3/3KlTJ5KSksJfoXm8aOZTRERETjkJdiufzxnbbts+Vt+8a/3222+nqKiIhx56iAEDBpCQkMC1116L1+s95HrsdnuL94ZhEAwGj3l8h6LwKSIiIqccwzCO6NR3e3M4HAQCgcP2++CDD7jhhhu45pprgNBM6NatW7n44ouP9xBjptPuIiIiIieo7OxsVq5cydatW6mqqoo6K3naaafx4osvsm7dOv7zn/8wceLE4z6DebQUPkVEREROULfffjtWq5XBgwfTrVu3qNdwzps3jy5dunD++eczbtw4xo4dyznnnBPn0R6ZE3++WUREROQUdfrpp1NSUtKi7YYbbmjVLzs7m3fffbdF27Rp0wgGg9TW1gKwdevWFp9HeuRTdXX1MY33SGjmU0RERETiRuFTREREROLmqMLnggULyM7OxuVyMWrUKFatWhW1r8/nY86cOfTv3x+Xy0VOTg5Lliw56gGLiIiISMcVc/hcvHgxhYWFzJw5kzVr1pCTk8PYsWOjPpD0nnvu4c9//jN//OMf+fzzz/nZz37GNddcw9q1a4958CIiIiLSscQcPufNm8fUqVPJz89n8ODBLFy4ELfbzaJFiyL2f+qpp7j77ru58sor6devHzfddBNXXnklv/vd74558CIiIiLSscR0t7vX62X16tVMnz493GaxWMjLy2t1J9YBHo8Hl8vVoi0hIYHly5dH3Y7H48Hj8YTfH7hLy+fz4fP5YhnyUTmwjXhsq6NRbSJTXaJTbSJTXaJTbaJTbSI7XF18Ph+maRIMBk/YZ18eLwfuaD+w/8cqGAximiY+nw+rteU3NR3pcWmYke6zj2LXrl1kZWWxYsUKcnNzw+133HEHy5YtY+XKla2WmThxIv/5z394+eWX6d+/P8XFxVx99dUEAoEWAfPrZs2axezZs1u1P/PMM7jd7iMdroiIiAg2m43MzEx69eqFw+Fo7+F0aF6vl+3bt1NWVobf72/xWWNjIxMnTqSmpoakpKSo6zjuz/l8+OGHmTp1KoMGDcIwDPr3709+fn7U0/QA06dPp7CwMPy+traWXr16MWbMmEPuTFvx+XwUFRUxevToVt95eqpTbSJTXaJTbSJTXaJTbaJTbSI7XF2am5vZvn07iYmJrc7GnuxM06Suro7OnTtjGMYxr6+5uZmEhAQuuuiiVrU8cKb6cGIKn2lpaVitVsrLy1u0l5eXk5mZGXGZbt268fLLL9Pc3MyePXvo0aMHd911F/369Yu6HafTidPpbNVut9vj+oct3tvrSFSbyFSX6FSbyFSX6FSb6FSbyKLVJRAIYBgGFosFi+XUesrkgVPtB/b/WFksFgzDiFjrIz0mYxqFw+Fg+PDhFBcXh9uCwSDFxcUtTsNH4nK5yMrKwu/383//939cffXVsWxaRERERGLUr18/Hn300fYeRgsxn3YvLCxkypQpjBgxgpEjRzJ//nwaGhrIz88HYPLkyWRlZTF37lwAVq5cyc6dOxk2bBg7d+5k1qxZBINB7rjjjrbdExERERE54cUcPidMmEBlZSUzZsygrKyMYcOGsWTJEjIyMgAoLS1tMa3b3NzMPffcw1dffUViYiJXXnklTz31FCkpKW22EyIiIiLSMRzVyf+CggK2bduGx+Nh5cqVjBo1KvzZ0qVLefLJJ8PvL774Yj7//HOam5upqqrif//3f+nRo8cxD1xERETkZPaXv/yFHj16tHpE0tVXX81//dd/sXnzZq6++moyMjJITEzk3HPP5Z133mmn0R65U+uqWxEREREA0wRvQ/u8jvAplz/4wQ/Ys2cP7733Xrht7969LFmyhEmTJlFfX8+VV15JcXExa9eu5fLLL2fcuHGUlpYer6q1ieP+qCURERGRE46vEe5vpzOxd+8CR6fDduvSpQtXXHEFzzzzDJdddhkAL7zwAmlpaVx66aVYLBZycnLC/e+77z5eeuklXn31VQoKCo7b8I+VZj5FRERETlCTJk3i//7v/8JfzPP0009z3XXXYbFYqK+v5/bbb+eMM84gJSWFxMRE1q9fr5lPERERkROO3R2agWyvbR+hcePGYZomr7/+Oueeey7/+te/+P3vfw/A7bffTlFREQ899BADBgwgISGBa6+9Fq/Xe7xG3iYUPkVEROTUYxhHdOq7vblcLr73ve/x9NNPs2nTJgYOHMg555wDwAcffMANN9zANddcA0B9fT1bt25tx9EeGYVPERERkRPYpEmT+M53vsNnn33Gj370o3D7aaedxosvvsi4ceMwDIN777231Z3xJyJd8ykiIiJyAvv2t79NamoqGzduZOLEieH2efPm0aVLF84//3zGjRvH2LFjw7OiJzLNfIqIiIicwCwWC7t2tb4+NTs7m3fffbdF27Rp01q8/+qrr6itrT2u44uVZj5FREREJG4UPkVEREQkbhQ+RURERCRuFD5FREREJG4UPkVEREQkbhQ+RURE5JTQEZ6BeaJrixrqUUsiIiJyUnM4HOHHFXXr1g2Hw4FhGO09rLgIBoN4vV6am5uxWI5+ztE0TbxeL5WVlVgsFhwOx1GvS+FTRERETmoWi4W+ffuye/fuiM/LPJmZpklTUxMJCQltErjdbje9e/c+piCr8CkiIiInPYfDQe/evfH7/QQCgfYeTtz4fD7ef/99LrroIux2+zGty2q1YrPZjjnEKnyKiIjIKcEwDOx2+zGHsI7EarXi9/txuVwnzH7rhiMRERERiZujCp8LFiwgOzsbl8vFqFGjWLVq1SH7z58/n4EDB5KQkECvXr247bbbaG5uPqoBi4iIiEjHFXP4XLx4MYWFhcycOZM1a9aQk5PD2LFjqaioiNj/mWee4a677mLmzJmsX7+eJ554gsWLF3P33Xcf8+BFREREpGOJOXzOmzePqVOnkp+fz+DBg1m4cCFut5tFixZF7L9ixQouuOACJk6cSHZ2NmPGjOH6668/7GypiIiIiJx8YgqfXq+X1atXk5eXd3AFFgt5eXmUlJREXOb8889n9erV4bD51Vdf8cYbb3DllVcew7BFREREpCOK6W73qqoqAoEAGRkZLdozMjLYsGFDxGUmTpxIVVUV3/rWtzBNE7/fz89+9rNDnnb3eDx4PJ7w+9raWiD0uACfzxfLkI/KgW3EY1sdjWoTmeoSnWoTmeoSnWoTnWoTmeoSXTxrc6TbMEzTNI90pbt27SIrK4sVK1aQm5sbbr/jjjtYtmwZK1eubLXM0qVLue666/j1r3/NqFGj2LRpE7fccgtTp07l3nvvjbidWbNmMXv27FbtzzzzDG63+0iHKyIiIiJx0tjYyMSJE6mpqSEpKSlqv5jCp9frxe1288ILLzB+/Phw+5QpU6iuruaVV15ptcyFF17Ieeedx4MPPhhu+/vf/86NN95IfX19xCfkR5r57NWrF1VVVYfcmbbi8/koKipi9OjRJ8wzsU4Uqk1kqkt0qk1kqkt0qk10qk1kqkt08axNbW0taWlphw2fMZ12dzgcDB8+nOLi4nD4DAaDFBcXU1BQEHGZxsbGVgHTarUCoa98isTpdOJ0Olu1x/vBsKfag2hjodpEprpEp9pEprpEp9pEp9pEprpEF4/aHOn6Y/6Go8LCQqZMmcKIESMYOXIk8+fPp6Ghgfz8fAAmT55MVlYWc+fOBWDcuHHMmzePs88+O3za/d5772XcuHHhECoiIiIip4aYw+eECROorKxkxowZlJWVMWzYMJYsWRK+Cam0tLTFTOc999yDYRjcc8897Ny5k27dujFu3Dh+85vftN1eiIiIiEiHcFTf7V5QUBD1NPvSpUtbbsBmY+bMmcycOfNoNiUiIiIiJxF9t7uIiIiIxI3Cp4iIiIjEjcKniIiIiMSNwqeIiIiIxI3Cp4iIiIjEjcKniIiIiMSNwqeIiIiIxI3Cp4iIiIjEjcKniIiIiMSNwqeIiIiIxI3Cp4iIiIjEjcKniIiIiMSNwqeIiIiIxI3Cp4iIiIjEjcKniIiIiMSNwqeIiIiIxI3Cp4iIiIjEjcKniIiIiMSNwqeIiIiIxI3Cp4iIiIjEzVGFzwULFpCdnY3L5WLUqFGsWrUqat9LLrkEwzBava666qqjHrSIiIiIdEwxh8/FixdTWFjIzJkzWbNmDTk5OYwdO5aKioqI/V988UV2794dfn366adYrVZ+8IMfHPPgRURERKRjiTl8zps3j6lTp5Kfn8/gwYNZuHAhbrebRYsWReyfmppKZmZm+FVUVITb7Vb4FBERETkFxRQ+vV4vq1evJi8v7+AKLBby8vIoKSk5onU88cQTXHfddXTq1Cm2kYqIiIhIh2eLpXNVVRWBQICMjIwW7RkZGWzYsOGwy69atYpPP/2UJ5544pD9PB4PHo8n/L62thYAn8+Hz+eLZchH5cA24rGtjka1iUx1iU61iUx1iU61iU61iUx1iS6etTnSbRimaZpHutJdu3aRlZXFihUryM3NDbffcccdLFu2jJUrVx5y+f/+7/+mpKSEjz/++JD9Zs2axezZs1u1P/PMM7jd7iMdroiIiIjESWNjIxMnTqSmpoakpKSo/WKa+UxLS8NqtVJeXt6ivby8nMzMzEMu29DQwLPPPsucOXMOu53p06dTWFgYfl9bW0uvXr0YM2bMIXemrfh8PoqKihg9ejR2u/24b68jUW0iU12iU20iU12iU22iU20iU12ii2dtDpypPpyYwqfD4WD48OEUFxczfvx4AILBIMXFxRQUFBxy2eeffx6Px8OPfvSjw27H6XTidDpbtdvt9rgeVPHeXkei2kSmukSn2kSmukSn2kSn2kSmukQXj9oc6fpjCp8AhYWFTJkyhREjRjBy5Ejmz59PQ0MD+fn5AEyePJmsrCzmzp3bYrknnniC8ePH07Vr11g3KSIiIiIniZjD54QJE6isrGTGjBmUlZUxbNgwlixZEr4JqbS0FIul5U30GzduZPny5bz99tttM2oRERER6ZBiDp8ABQUFUU+zL126tFXbwIEDieG+JhERERE5Sem73UVEREQkbhQ+RURERCRuFD5FREREJG4UPkVEREQkbhQ+RURERCRuFD5FREREJG4UPkVEREQkbhQ+RURERCRuFD5FREREJG4UPkVEREQkbhQ+RURERCRuFD5FREREJG4UPkVEREQkbhQ+RURERCRuFD5FREREJG4UPkVEREQkbhQ+RURERCRuFD5FREREJG4UPkVEREQkbhQ+RURERCRujip8LliwgOzsbFwuF6NGjWLVqlWH7F9dXc20adPo3r07TqeT008/nTfeeOOoBiwiIiIiHZct1gUWL15MYWEhCxcuZNSoUcyfP5+xY8eyceNG0tPTW/X3er2MHj2a9PR0XnjhBbKysti2bRspKSltMX4RERER6UBiDp/z5s1j6tSp5OfnA7Bw4UJef/11Fi1axF133dWq/6JFi9i7dy8rVqzAbrcDkJ2dfWyjFhEREZEOKabw6fV6Wb16NdOnTw+3WSwW8vLyKCkpibjMq6++Sm5uLtOmTeOVV16hW7duTJw4kTvvvBOr1RpxGY/Hg8fjCb+vra0FwOfz4fP5YhnyUTmwjXhsq6NRbSJTXaJTbSJTXaJTbaJTbSJTXaKLZ22OdBuGaZrmka50165dZGVlsWLFCnJzc8Ptd9xxB8uWLWPlypWtlhk0aBBbt25l0qRJ3HzzzWzatImbb76ZX/ziF8ycOTPidmbNmsXs2bNbtT/zzDO43e4jHa6IiIiIxEljYyMTJ06kpqaGpKSkqP1iPu0eq2AwSHp6On/5y1+wWq0MHz6cnTt38uCDD0YNn9OnT6ewsDD8vra2ll69ejFmzJhD7kxb8fl8FBUVMXr06PClAhKi2kSmukSn2kSmukSn2kSn2kSmukQXz9ocOFN9ODGFz7S0NKxWK+Xl5S3ay8vLyczMjLhM9+7dsdvtLU6xn3HGGZSVleH1enE4HK2WcTqdOJ3OVu12uz2uB1W8t9eRqDaRqS7RqTaRqS7RqTbRqTaRqS7RxaM2R7r+mB615HA4GD58OMXFxeG2YDBIcXFxi9PwX3fBBRewadMmgsFguO2LL76ge/fuEYOniIiIiJy8Yn7OZ2FhIY899hh/+9vfWL9+PTfddBMNDQ3hu98nT57c4oakm266ib1793LLLbfwxRdf8Prrr3P//fczbdq0ttsLEREREekQYr7mc8KECVRWVjJjxgzKysoYNmwYS5YsISMjA4DS0lIsloOZtlevXrz11lvcdtttDB06lKysLG655RbuvPPOttsLEREREekQjuqGo4KCAgoKCiJ+tnTp0lZtubm5/Pvf/z6aTYmIiIjISUTf7S4iIiIicaPwKSIiIiJxo/ApIiIiInGj8CkiIiIicaPwKSIiIiJxo/ApIiIiInGj8CkiIiIicaPwKSIiIiJxo/ApIiIiInGj8CkiIiIicaPwKSIiIiJxo/ApIiIiInGj8CkiIiIicaPwKSIiIiJxo/ApIiIiInGj8CkiIiIicaPwKSIiIiJxo/ApIiIiInGj8CkiIiIicaPwKSIiIiJxc1Thc8GCBWRnZ+NyuRg1ahSrVq2K2vfJJ5/EMIwWL5fLddQDFhEREZGOK+bwuXjxYgoLC5k5cyZr1qwhJyeHsWPHUlFREXWZpKQkdu/eHX5t27btmAYtIiIiIh1TzOFz3rx5TJ06lfz8fAYPHszChQtxu90sWrQo6jKGYZCZmRl+ZWRkHNOgRURERKRjssXS2ev1snr1aqZPnx5us1gs5OXlUVJSEnW5+vp6+vTpQzAY5JxzzuH+++/nzDPPjNrf4/Hg8XjC72trawHw+Xz4fL5YhnxUDmwjHtvqaFSbyFSX6FSbyFSX6FSb6FSbyFSX6OJZmyPdhmGapnmkK921axdZWVmsWLGC3NzccPsdd9zBsmXLWLlyZatlSkpK+PLLLxk6dCg1NTU89NBDvP/++3z22Wf07Nkz4nZmzZrF7NmzW7U/88wzuN3uIx2uiIiIiMRJY2MjEydOpKamhqSkpKj9Ypr5PBq5ubktgur555/PGWecwZ///Gfuu+++iMtMnz6dwsLC8Pva2lp69erFmDFjDrkzbcXn81FUVMTo0aOx2+3HfXsdiWoTmeoSnWoTmeoSnWoTnWoTmeoSXTxrc+BM9eHEFD7T0tKwWq2Ul5e3aC8vLyczM/OI1mG32zn77LPZtGlT1D5OpxOn0xlx2XgeVPHeXkei2kSmukSn2kSmukSn2kSn2kSmukQXj9oc6fpjuuHI4XAwfPhwiouLw23BYJDi4uIWs5uHEggE+OSTT+jevXssmxYRERGRk0DMp90LCwuZMmUKI0aMYOTIkcyfP5+Ghgby8/MBmDx5MllZWcydOxeAOXPmcN555zFgwACqq6t58MEH2bZtGz/96U/bdk9ERERE5IQXc/icMGEClZWVzJgxg7KyMoYNG8aSJUvCj08qLS3FYjk4obpv3z6mTp1KWVkZXbp0Yfjw4axYsYLBgwe33V6IiIiISIdwVDccFRQUUFBQEPGzpUuXtnj/+9//nt///vdHsxkREREROcnou91FREREJG4UPkVEREQkbhQ+RURERCRuFD5FREREJG4UPkVEREQkbhQ+RURERCRuFD6/wTRNmrwBGv3tPRIRERGRk4/C5zdsrmxg6H3F3LfG2t5DERERETnpKHx+g9MWKokv2M4DERERETkJKXx+g8semvH0mQamabbzaEREREROLgqf3+CyHyyJ16/pTxEREZG2pPD5DQdmPgGaFT5FRERE2pTC5zfYrRasFgOAZl+gnUcjIiIicnJR+IzgwE1HmvkUERERaVsKnxEcCJ8ezXyKiIiItCmFzwgOXPfp0cyniIiISJtS+IzAdeC0ux72KSIiItKmFD4jcO6f+Wz267S7iIiISFtS+Izg4DWfmvkUERERaUu29h7ACSfgI8tSxV5jrx61JCIiItLGjmrmc8GCBWRnZ+NyuRg1ahSrVq06ouWeffZZDMNg/PjxR7PZ+Ni7hUcqpvCa4//phiMRERGRNhZz+Fy8eDGFhYXMnDmTNWvWkJOTw9ixY6moqDjkclu3buX222/nwgsvPOrBxoXNCYATn57zKSIiItLGYg6f8+bNY+rUqeTn5zN48GAWLlyI2+1m0aJFUZcJBAJMmjSJ2bNn069fv2Ma8HFncwHgMnx4vP52HoyIiIjIySWmaz69Xi+rV69m+vTp4TaLxUJeXh4lJSVRl5szZw7p6en85Cc/4V//+tdht+PxePB4POH3tbW1APh8Pnw+XyxDPgo27Pt/am5ujMP2OpYD9VBdWlJdolNtIlNdolNtolNtIlNdootnbY50GzGFz6qqKgKBABkZGS3aMzIy2LBhQ8Rlli9fzhNPPMG6deuOeDtz585l9uzZrdrffvtt3G53LEOOmSXoY9z+n7/6YiNveLcd1+11VEVFRe09hBOS6hKdahOZ6hKdahOdahOZ6hJdPGrT2Nh4RP2O693udXV1/PjHP+axxx4jLS3tiJebPn06hYWF4fe1tbX06tWLMWPGkJSUdDyGepBpwn9CP/bskcGVV15wfLfXwfh8PoqKihg9ejR2u/3wC5wiVJfoVJvIVJfoVJvoVJvIVJfo4lmbA2eqDyem8JmWlobVaqW8vLxFe3l5OZmZma36b968ma1btzJu3LhwWzAYuonHZrOxceNG+vfv32o5p9OJ0+ls1W632+NyUPkMJ3bTAwGvDuIo4vV70dGoLtGpNpGpLtGpNtGpNpGpLtHFozZHuv6YbjhyOBwMHz6c4uLicFswGKS4uJjc3NxW/QcNGsQnn3zCunXrwq/vfve7XHrppaxbt45evXrFsvm4CVgdoV99Te08EhEREZGTS8yn3QsLC5kyZQojRoxg5MiRzJ8/n4aGBvLz8wGYPHkyWVlZzJ07F5fLxVlnndVi+ZSUFIBW7SeSoCUUPk1fczuPREREROTkEnP4nDBhApWVlcyYMYOysjKGDRvGkiVLwjchlZaWYrF07G/tDFj2n/JX+BQRERFpU0d1w1FBQQEFBQURP1u6dOkhl33yySePZpNxZVpD4TOo8CkiIiLSpjr2FOVxEtz/oHkCnkN3FBEREZGYKHxGcGDmE79mPkVERETaksJnJPu/393wa+ZTREREpC0pfEay/7S7odPuIiIiIm1K4TMC48DMp8KniIiISJtS+IzAsIdmPq0BbzuPREREROTkovAZgWV/+LQENfMpIiIi0pYUPiM4ED6tQQ+mabbzaEREREROHgqfEVgcCQA48eENBNt5NCIiIiInD4XPCKz7w6cLL80+hU8RERGRtqLwGcGB0+5OfHh8gXYejYiIiMjJQ+EzggOPWnIaPs18ioiIiLQhhc9IbAdnPpv9mvkUERERaSsKnxGYB2Y+8eHRzKeIiIhIm1H4jCQ88+nVzKeIiIhIG1L4jKTFNZ8KnyIiIiJtReEzEuvB0+664UhERESk7Sh8RmI/+JB5j067i4iIiLQZhc9I9p92d+CjweNv58GIiIiInDyOKnwuWLCA7OxsXC4Xo0aNYtWqVVH7vvjii4wYMYKUlBQ6derEsGHDeOqpp456wHFhPXjNZ12zwqeIiIhIW4k5fC5evJjCwkJmzpzJmjVryMnJYezYsVRUVETsn5qayv/7f/+PkpISPv74Y/Lz88nPz+ett9465sEfL+b+u91deKlV+BQRERFpMzGHz3nz5jF16lTy8/MZPHgwCxcuxO12s2jRooj9L7nkEq655hrOOOMM+vfvzy233MLQoUNZvnz5MQ/+uPnacz5rm3ztPBgRERGRk0dM4dPr9bJ69Wry8vIOrsBiIS8vj5KSksMub5omxcXFbNy4kYsuuij20cbL157zqdPuIiIiIm3HFkvnqqoqAoEAGRkZLdozMjLYsGFD1OVqamrIysrC4/FgtVp55JFHGD16dNT+Ho8Hj8cTfl9bWwuAz+fD5zv+M5E+04IdcBgBahsa47LNjuJALVSTllSX6FSbyFSX6FSb6FSbyFSX6OJZmyPdRkzh82h17tyZdevWUV9fT3FxMYWFhfTr149LLrkkYv+5c+cye/bsVu1vv/02brf7OI8WrIFmvrP/5127dvLGG5GvZz2VFRUVtfcQTkiqS3SqTWSqS3SqTXSqTWSqS3TxqE1jY+MR9YspfKalpWG1WikvL2/RXl5eTmZmZtTlLBYLAwYMAGDYsGGsX7+euXPnRg2f06dPp7CwMPy+traWXr16MWbMGJKSkmIZ8lHxeZrg49DP7oQErrxyzHHfZkfh8/koKipi9OjR2O329h7OCUN1iU61iUx1iU61iU61iUx1iS6etTlwpvpwYgqfDoeD4cOHU1xczPjx4wEIBoMUFxdTUFBwxOsJBoMtTqt/k9PpxOl0tmq32+1xO6gCWLESwOdt0oEcQTx/LzoS1SU61SYy1SU61SY61SYy1SW6eNTmSNcf82n3wsJCpkyZwogRIxg5ciTz58+noaGB/Px8ACZPnkxWVhZz584FQqfQR4wYQf/+/fF4PLzxxhs89dRTPProo7FuOq4CFjvWYABvc1N7D0VERETkpBFz+JwwYQKVlZXMmDGDsrIyhg0bxpIlS8I3IZWWlmKxHLyJvqGhgZtvvpkdO3aQkJDAoEGD+Pvf/86ECRPabi+Og6BhB5rxexsxTRPDMNp7SCIiIiId3lHdcFRQUBD1NPvSpUtbvP/1r3/Nr3/966PZTLsKWuwQALvpo8EbINEZl3uzRERERE5q+m73KEIzn6EHzdc169ENIiIiIm1B4TOKoGV/+DR81DbpQfMiIiIibUHhM4rA/vDpwquZTxEREZE2ovAZxddPu9cqfIqIiIi0CYXPKAIWBwBumvX97iIiIiJtROEzCo+tMwCpRh21TZr5FBEREWkLCp9ReGyhr/FMM2qo1cyniIiISJtQ+IzCY08GoJtRo2s+RURERNqIwmcUHlsofKZRo2s+RURERNqIwmcULU6765pPERERkTah8BnFgdPuaYZmPkVERETaisJnFAdmPrtSy7765nYejYiIiMjJQeEzCo89FD5tRpCG6sp2Ho2IiIjIyUHhMwrTsBF0dQHA0lRFo1en3kVERESOlcLnIRiJ3YDQdZ879zW182hEREREOj6Fz0Mw3WkAdKOGHdUKnyIiIiLHSuHzUDodnPncoZlPERERkWOm8HkIZqd04ED4bGzn0YiIiIh0fAqfh3Jg5hPNfIqIiIi0BYXPQzB12l1ERESkTR1V+FywYAHZ2dm4XC5GjRrFqlWrovZ97LHHuPDCC+nSpQtdunQhLy/vkP1PKEk9AOhlVLJTp91FREREjlnM4XPx4sUUFhYyc+ZM1qxZQ05ODmPHjqWioiJi/6VLl3L99dfz3nvvUVJSQq9evRgzZgw7d+485sEfb2b6mQD0M3ZRV19Psy/QziMSERER6dhiDp/z5s1j6tSp5OfnM3jwYBYuXIjb7WbRokUR+z/99NPcfPPNDBs2jEGDBvH4448TDAYpLi4+5sEfd4kZmO40rIbJQGM72/Zo9lNERETkWMQUPr1eL6tXryYvL+/gCiwW8vLyKCkpOaJ1NDY24vP5SE1NjW2k7cEwMDKHAHCGpZS1pfvaeUAiIiIiHZstls5VVVUEAgEyMjJatGdkZLBhw4YjWsedd95Jjx49WgTYb/J4PHg8nvD72tpaAHw+Hz6fL5YhH5UD2/D5fFjSz8T61XsMNray8qsqvn929+O+/RPZ12sjB6ku0ak2kaku0ak20ak2kaku0cWzNke6jZjC57F64IEHePbZZ1m6dCkulytqv7lz5zJ79uxW7W+//TZut/t4DrGFoqIieu71MxwYbNnGH9bv4o03tsdt+yeyoqKi9h7CCUl1iU61iUx1iU61iU61iUx1iS4etWlsPLLLE2MKn2lpaVitVsrLy1u0l5eXk5mZechlH3roIR544AHeeecdhg4desi+06dPp7CwMPy+trY2fKNSUlJSLEM+Kj6fj6KiIkaPHo29uh/8ZSFnGKXs9Zic861vk5kUPTif7FrUxm5v7+GcMFSX6FSbyFSX6FSb6FSbyFSX6OJZmwNnqg8npvDpcDgYPnw4xcXFjB8/HiB881BBQUHU5X7729/ym9/8hrfeeosRI0YcdjtOpxOn09mq3W63x/Wgstvt2DPOAKuTxEAzOcZXrCsdwrihWWA9tQ/ueP9edBSqS3SqTWSqS3SqTXSqTWSqS3TxqM2Rrj/mu90LCwt57LHH+Nvf/sb69eu56aabaGhoID8/H4DJkyczffr0cP//+Z//4d5772XRokVkZ2dTVlZGWVkZ9fX1sW66fVhtMPi7ADxkX8glr10Mf74YTLOdByYiIiLS8cR8zeeECROorKxkxowZlJWVMWzYMJYsWRK+Cam0tBSL5WCmffTRR/F6vVx77bUt1jNz5kxmzZp1bKOPlzG/wb/xLQZ4d0EAqKiG+gronHG4JUVERETka47qhqOCgoKop9mXLl3a4v3WrVuPZhMnls4Z2Mb9Hs+L03CazaG2fVsUPkVERERipO92P1JDruXTyZ+xIjAYgLKt69t5QCIiIiIdj8JnDIb3TSOQ0geADz5ajWma4GuGxr3tPDIRERGRjkHhM0ZDzhoW+mHfVv6xajssngTzzoB9W9tzWCIiIiIdgsJnjFKyTgOgt1HO315ZApveAX8zbF3eziMTEREROfEpfMaqSzYApzv28D3L0nBz/faP22c8IiIiIh2IwmesuvQFINm/hymOpeHmjz/6gKdKtrbPmEREREQ6CIXPWCV0AWcyAK5gA6ZhBeA0o5R7X/mMxR+WtufoRERERE5oCp+xMgzwNR58O+Y+TAy6GbWkUcOd//cJv/jHWpZ9Uclnu2ooq2lux8GKiIiInFgUPo/GmdeEfs0aAefdjJHaD4Dbz/ZjMeDV/+xiyqJVXPWH5eQ+UMyC9zaFHsskIiIicoo7qm84OuVddi/0GgnDJoZmQjMGw97NXNe9gjNyv8PfSkpZu72aumY/VfUeHnxrIyWb93DV0O5YDYMLT0+je3JCe++FiIiISNwpfB6NlN4wcurB9xlnwfp/wrv3kZOwgHn9LoHLLoMzvsvf1uxlzmufs3xTFcs3VQFgMaBnFzcJdivXDu/JkJ7J+AJBLIbB8D5dcNmt7bNfIiIiIseZwmdbOOvaUPis3ABNe+GzF0OvFX9iyn+/z6UD0/nfkq1sqqynpsnH2tJqSveGrhv9zRstv6YzKyWBAemJbNvTwA/P7cW3BqQRCJoM7ZmC1WK0x96JiIiItBmFz7aQNgBu+gACPtjxEWwuhg+fgMr18OHj9M69mXu+MxhMEwyD0j2NVNZ7+LK8jmc/3I69sZwMo5p/N/VkZ3UTO6ubAPjtko38lo2hTSQ6uXJIJoO7J7G7pplNFfX0TE3g2wPT+aK8jm6dXZzTJ4X0zq72rISIiIjIISl8tiWrHfrkhl7JveCfv4BlD4CvAT5+LhRO89+k955P6N2pK8NHDue6czJhwbmwbyuBft/m+ay72GPpSorbzqNLN+PxB/H4AlTVe/jfkm2tNvnnZV+1eN8j2UX3lAT6pnUiLdFJyVd76JmSwBVDMhmU2RkwaPYFCJomA9ITcTt0CIiIiEj8KHkcL2f/CD58DMo+gXd/fbD98Tyo3QFWB9y4DHZ+FP5eeOtX73KdxQpX/wk2vsGkn48Hdypef5AVm6t485MyKuqa6dbZSd+0RJZvqmTD7joG90iiss7DxvI6dtU0s6ummdXb9oU3+Z/t1bz+ye5WQ7QYMCA9keyunfAGgmR0dpGd1oleqQkYGGQmu+iVmsCminpMExIcVmyYbK+HrXsa6JnamQSHrk8VERGRI6fwebxYrDD5VVj9V9j+IXQbCCsXhoInQMALL90IzbWh98PzYc3fYFNRKKDWbId3fwP9L8XhSuGS0bO5ZODQFpu46ZL+Ld7XVe9h96fL2Nx5OJ+VNbOrponz+nbli/I6Vm7Zy9aqBiwWgwS7FX8wSFW9ly/K6/mivD7GnbPx0CcfAJDittM9OYHuyS4yklx0cljxBoJ4/UH6pnUitZMDi2Fgsxr0S0uka6KDvQ1eend1k+SyU9fsY2tVIyluO1kpCVh0XauIiMhJTeHzeHKnwoW/PPi+20B46//BiPzQNaFln4TaE7rAmF+DtwE+eS4UPAEaq+CT50M/exvgmkdDPwf8YLVB1Zfw+SuwqRgsVjqXfUzn5hpOP/tHXHH1gv19fWDpGXok1DdU1Dbzyc4adtU047Aa7K5pZktVA7v2X3M6qPx1RvuX8fvE22hwpNHoDdDsC+DzePAZNhq9AaobfVQ3+li/uzbm8lgtBoHgweefJtit9E51s6/Ri8cfxO2wkuCwEgyauOxWcvt3JdFp23/ZAAzK7IzTbqWu2Rfqa7fRyWnF7Qj9mpnkIjnBTnWjj0SXDbtVj7UVERFpbwqf8TRsIuRcHwqCfS+Gj54I3YR09o/BmQgXFh4Mm5NegPpyqN4G7z8I/3kGElJCbZ+9BLaE0LWkkax9GnqNgs3vwobXQw/DH/cwpPQC+8Hni6YnubjMtxMcpdDvkpYBtb4C8+G/YpgNXHTmB/CdeQD4fD7eeP11rrhiNE1BC7trmthd08zu6mbKa5vx+IPYLAZWi8HmynrqPX6CJnh8AdbvrqXRGyApwc7eBm84eHbt5KC22UeTz4+vYiOVZiYmFmqafAw0StllplGHmw1ldYctsRMvYy0f8VZwBB4cOKwWvIEgdqtBemcX/mCQlAQHTb4AZbXN2CwGqZ0cZKUk0CMlAavFIBg0CZgmgaBJF7eDzi4bW/c0kJmUQK/UBBq9ATq7bNgsFgLBIE6blU92VvPZlxa2uL9icI9keqSE6ry3wcueBg/+gMnAzM6hQOy247TpcoVTzicvhG5IHD0HbI72Ho2ISLtR+Iy3AwGv38Wh19elnxEKnQYwIO9gu9Ueum70348cbPM1gMUWCo2DvgOOTuBKgf/8I/SYp1d/frBv6YrQTU0AWcNDYTTggYYq2PgGmEG4+M7Qdaqb34WK9bBvG8aBcLv276HPO2dAxXouW38ntrJ5JP/wbyRn9mWQ/wvY+hLUlcHIG0P7sXU5XHRhaOZ187uwex3mlVdjZo3AEvDgeXsmwcZqrJ264ti7kcCZ36e6YjtdS+6n6qyfUn/2jaQuu5uk0nfwuruz4vzHWLo3FdMMzYL6Aiaf7aoBICnBTrMvQIPHT8G+/+HbvmW8YIzm9qZ8vIFgqFwBc/9TBEwS676i2XTjpQteoNHbxI59TUf129nTqGCytYgtwaGsCQ5hTfGmI1rO7bCSkmAnxe3AbrNQUduMxQySbA+AoxMuu4XyWg8Vdc37Q2sCYLKnron/3vcQnY1mXsooYLOvK50cNronu3DZrbisJl07uzgtI4nPd9Wyp8GL02ahd1c3XTs5SXTa8AWCLN1Ygc1q4fKzMhmS3IzLnYTX6qbZH6Cz04ax/zitafThclhahGWvP0izP0CSyw6APxDEdphZ5X4VS7A+9zR8/zFwJR9VrTu05prQn0lfY+jP4NAftPeIRETajcLniea0vNZtF94O3QaFTtWbQfj2vaF/wBPTQ7OhX9dtIGx6B/zNoVnWwVfDB/Nhy/uhz3euDr2+adn/hF7f1Lk71O2G+UPAYsNmBrH7m6CsDB6/LLT+Nf8LQX+o/5dFkNQ99MxTVzL4mkNBFzBW/gVjzH2w+V2cXyxpsRnr5vfoagkdjmmfLSKtdEn4+lhH424u+dckLsmZAPUV0OiFrHPgsp+ELm3w1MG2ktCs8KvLALjWsowrfzWfKlJJT3JSWeeh6asS+rz/S5y1W/A7kqi4/m18iT1w/OsBLOWf8Fb/e2hwdMNqAYthYDEMqmuqqW/ykJneje17m9jb4KGbpY4yXyIX1r7KD6sewY6PfKOI36XMoCz9AjZWNLC3wYNpQqrbzkTeYKDnU37r+yFrG9MImtDoDdDoDbCrphmAAcYOHrP/jiRPIz/0zmCwZRNZpp1tZgYPVD5OSflgfu2fxHjLB1zuCO3jkB2fkO/9FcvNgaE64WOx4z56GFVM9/0UP1a2m+lsMTM509jKVjOTBlp+s9ZHHxTxnGMO9dhYFRxEAl5es17CisSx1Db52NPgxWG10DM1gQaPn9omP02+ABB6Jq0vEKSy3kNWSgIOq4WgaeJ22Eh0hi59sFktdN23jvv3/QMLJitemE9J+nU0eQNYLAaVdR7sVoPkBDvNviBOm4XMZBdDe6bgCwTxB00S7FZcdgsuuxWvP8iu6iYSXTa6JTrpmugkJcEe9VrhA19reyBM+/ev84i+yKG5Bja/B4OugtqdUP45DLwi9B/Iz1+FJdPh6j9C/2+3XM7XDNtXhr4FzZ4QOrvxn2dDwRNC/znc+REWvxfMiw4/DhGRk4xhHsWXji9YsIAHH3yQsrIycnJy+OMf/8jIkSMj9v3ss8+YMWMGq1evZtu2bfz+97/n1ltvjWl7tbW1JCcnU1NTQ1JSUqzDjZnP5+ONN97gyiuvxG63H/fttbn6CjCs0KnrwbaAHxoqYcNrULsr9I+izQl9LgjNTL73m9AyPUeEvrFp+yrodS4MvAqe/n6L1e/pdBpdOruxlP3nYOPAK0Mzn7vW7G8wgP2HVvpgcHYO/YN8gM0V+pYoX1Pobv9N74TaLbaDQTalD3zvMXj7HtixqvV+pvSG7sPgy7dDYfsAwwpmAHrngmGByo2hsLp9FTRXH+yXMSQUkLctD73vNQqmvAbb/w0r/wzln4XGZhhw3s2hGasPnwj1754Du/fvf0IqNO2lwdEN5/V/w9b3gtDvQWkJfPE2rPt7qJ/djXnujXhsnQjs/pQ9Gefjry0jdcd7JNWsx7I/pPscydi9oVldEwNjfx2/6jmezH0f4W7YgdeZisOzF4+zK1/1ugZr7Q4aLZ0ZVvZ8ixJ5LS42JZ3H4OqllFszucs9h21mBiP7puLxBZi04WZG8Hmr0v4zcB4vBi7ko+BAbra9wjBjMzP8N/Cl2RMbflJooIpk7PjpYVSxzcwkiQYSaWIXaQwwdmBiUGUm85xjDgMtof9IbAz2ZKz3f7BgkkodVSTtP1Zas+PHhzX8+QBjB+lGNSuCZ7XoZzEgxe2gk9OKP2DiC5g4bRY6Oa1s29NIgsPK6emdSUqws2rLHuo9fs7onsSFzs3U4+LT5m5cWvtPvnQOpiJpSOiSi0CA++v+H4M9/+Ft9ziGeVaRHijn+dT/5r1OV/A/u26gc6CasoTTWHD6XwkAfn+Afrtf49rqv5IWrGKvux/ezr3pWrUKL3Y6BWpa7eOHfW5m2I/mdMy/Z46jFn8H12wN/V2V0ru9h3VowWDoRlL7IZ61XF8ROkvl6ATBQOjG1Ei8jaG/Iy2tzyickP8+HbgPoS2YZqiONmdMi52QdTneDtTK6oh4X8cB8azNkea1mMPn4sWLmTx5MgsXLmTUqFHMnz+f559/no0bN5Kent6q/4cffshzzz3H8OHDue2227jzzjsVPk9EFRugc2brmVSAyi9CM66GBX/DHt5Yt5srxo7GvvGf8OmLkP0tuOAWaNwDf/9e6FT7hL9DzY5QuOueE1r+/YdCQdewwCV3hi4ZgNDNVIsuD13fOuFpWPyjUAj9r7dCD/APBkIBc+MboX+AHImhJwfsf0QVEGr3NkKnbqGxvPyzyPuZNQK++0f46+WhmS0Auzu0PU9tOEgesdwCuPCXmH++GKOmNNTm6Azeb1yfmjEEyj859Lp6nw8Vnx8MyDZXKFSnnxlqPxDmEzPgphL436sjr7P3+aGg70gEzzcCj2EJ/UfAmRSq1a41mFYn1Zf/CZd3H7b6XdhKHg4H3q+HX78zmUCX03BUfoIR8LA361ISGnaQUP0lDV2H4KrZhNXfRFOnniQ0hMKmz+rGHmik3tIZJ17sQQ/ruoxlQP1HJPr2sCv5HHZ3Pgtb8x48zq5sc5/Fu96zqNv9BfN9c/AYTh515DPc+xHfDb6DlSCvu75Dkr+Knv5SmoJ2lgfP4jRjB72NCj4MDmS32RWn4SPdqKYb1XxlduefgVy6G3s53bIDj2kjgJXp9n/gM618YvblHMsmmkwH13pn8pnZl8nWt5hj/1ur0vpMKyuDg/iW9bNw21/8V9HD2EMvo4Icy1etljmg0XRSaSbTx1IRbttuplPkvhK71UKtI4NGZzdSzFqSzRoc+Gm2JxO0urAaQQj6McwABINYTS+dfXvwW1w021Po2/gxzfYUyjufQSffPjr7qjDMIA2ONIL7w3tqUyn9q1fQ4EilPHEwDY5uuIL1uL37sPkbaLYm4rUn4XMmE7C6sdXtwBFowG63U5+QRdDqxGr6sJp+zGCQJsNNnT2VHjXrQtdoOzPBDGANerEEfWAGqbGnYw16SPGW47YGSDZrcAWb8FrdeCyd8Fjd+LHi9lbR7OhKvas77qbd1Nq7sauiilzrevrUhP7jWZ4yDK81kSZHKnXODOocGXgtLhL8tXSv/5TeVf/CNKzUJ/ahMaE7ruZK7P56AhYHptWBaXEQsCfS5O5OYu0mHJ59eB3J1Cdm0+DuhWEG6LL3P7iayzENG7WJ/Uhs2IYt0EzAloDDuw9L0I/fkUR9Yl+Sa9bjbK4iYEsgaHHgbKrAEvRQnTYCZ1N56D+H7u54OmViCfhw127G2VQOQMDqwhpopsGdRV3KYIKdu9Np3waCVicWfxPJlR8RsCbgTUjDNKyYhgWfPRnT5iKhYQe+5gYcrk6hS7IsdkyLFdNiB4sN82svDBvWpgrsdbsIOJOx+BuxeOsI2hPxJfUm4EjC2rwPqyf0d07Q3omgPZGAvROG6cfWWEnQ0RmCfqyeGsAk4EwJHZONlViCXuyevVg9NQScyfjd6QRtCdgaqwBz/zjsmIYVI+jF6q3H4qvfvy03AXcGRsCDxVOLEfTiT0jH1liB1VdHwN4Jv7MLQXtiaCzNe8CwYdrdGL5GgrYETIsdI+gj6EyCgBd/XSVOlzu07xYrWOwEDCumYQWLjYBp2f+ZDYsBjvrtWJv2YpgBgvZOBOydCdoSMILe/bUM/ftvr9uOJeAhaHVh2lyhXy1WLAEvRsAT+rvZsEB4WxYMw0rQsGL6vVh8DQTsbixBP5agF19iFhgWLL4GjKCXgCsVi68BW2MFfnc6psWOJeDB2P8yrU78rlTw1GPz1oAZxNcpE2fdNmz7/60JHjjOrQ78hgNsTiyGieGtp/6M63if8zp2+Bw1ahTnnnsuf/rTnwAIBoP06tWLn//859x1112HXDY7O5tbb71V4bMDO2xtDhxOh/hfWER+b+h/cM7E0LWoFmvoKQDRNFXD0rmhGdwzr4HMoQe3GQzC8nmhWYbuOdAlO3RpQOMeuGYhdEoLXYaw8s+h61OH/CD0hIHnbtgfGo3QEwnOvAa6nRF6Fuuy34bG1OMcGHItrHs6dEnCxXeCYeDbt4Ndf7+Z3nuXhwICQOYQSBsIQ38YuoZ3/avw2cuh/ew2EDYuAVdS6IazrOGhsWx6B96+F3Jvhr4XhWZrz/huKHyvfQpqd8Mld8EZ34F92+Af1x+8hrJ0RWiZya+GZo9NE167FTa+CZfdG7p2N9IlF+dNg8vvP/h++6rQaeIvloRON7u7QnLPgzO9R8JiC23fDGB2HcCytB9zkeMzLJ88d/hl7Z1CsyjNrWcKjzevI4XalMGkVawAoN6RTqI3FBb3JfanS/3mcN9diWfSo/6zFsv7LS42nXEzq5MvY8DHv6c5aLAhcRSX+ZdT1yePzs1lDFj/J3bYs3F4q0k3quO2bx2Vz7RiJYjFiPkk3QknaBonxX5Ix/Jh13Hs6v2Djhs+vV4vbrebF154gfHjx4fbp0yZQnV1Na+88sohlz/S8OnxePB4POH3tbW19OrVi6qqqriFz6KiIkaPHq3w+Q0ndW38zRjln2ImdIHU/ofv/zXhulx8PvamylCoTMw4TgONIBjA2PkhZubQ0Ezu1+3/WldMM3RdrKcOw1MDlRsxGqsInju19TIHltu3JbwflnVPYbq7YvY4B3xNWN+eDu5uBC64Dcv2Eswu/TAzzsLY/m/MrBGAibFzNd7sb1O0dDljzumD6/WfY6b2J3jm9zG7DcKy5q+hSy86d4eaHVg2v4NRuzO0+fSzMLtkY3y5BHPAaIIjfwZ7NmF9dxZmv28TPHsKNO3BsrkYMzETs8c5GLtWh0KrxQ6dMzFdKVi+eBNj9zrMLtmh/wzs24KldAWB8wrA24Bl/SsE8uZg/fcCjMr1B0uaM4nAtwqxPXU1ZtZwAt/5A5Y1T0LtLsxuAzH7fRvb45eAGSR47o2YSVmY/S4NBfVovA1YPnyM4JnX0FS6Fu+SmfjTz8RvOHE27sbZXEGzLZkGRxoBw4rTWx2a2cESmt0yrJiGDdOw0ujoisNfj9tTwY7Eobi9laQ076LO3pU6exoAbv8+jP2//x5rIl8kX4DTX0Na0xY6+fbSZEmk3tYFv60TCcEGXP5aHL4anIEGmhMyaLR1IeBtJsW7Gwt+AtgIGDaCho3kwF5SfBXs6HQmfouTZF8VAYudgMVO0HBgGCYpnjICFjv7HD2oD9qoDHSmJuiik9FMIk10ogkHPmqtqXTxlZHk30O1PYNUfxm+5kb2dMlhXdp38Pp89Kj9GBsBkgP7SPVXkBKowmF6aDbc7Lb3Ym3CeTSaDtK8O+kaqKDGkkq9NQmb6cMS9GEEvXQK1JIeKKPc2oMKWybJwRp6+kvpGqzCagbY7BhIma0nCTSR5Sulwt6DOqMz9mAztUZnvIadlMA+svyl7LD2Yqe1JzbTh8P0UG0kETQtDPWtpdLSjTJLJl0DVXQNVuLDzi5LJpst/bAEPSTSiMWRQH9jF709X5LorWCLJRurEcRmBlhtH44dP8nUYSWI1QiQFKzDEWxisz+Nfc0mCXYLNgIYph87Qayh3x1s+LGaQWz4sRsBaunETiODzmYDTYaLWjqRTANZZhkJeKihM7VGIgbgphk3TbhpIoiFPaTQiWaCGNTQGYBk6kgwvNTbUmkIOtgTcLE7kEwqdXQz9uE2vOwzksGwhsZkBrDix4udBhKoJwETg0Sznq5U02w6qDfcBAw76eZeaizJVBhd6WLU08WsxUUz/qDBHjpDMIDLbKbZSMBt8eIkgN+w0inYQHPQSpXPicNuwWEE958l8NPJZuKwBLGYQTrZTKwEQmfTzAA7za6Um13AsJJoNJNII068+LBhIYgDHxaClNONeiMBF16cZuhlJYAXO17DTsA0sBAMvwgECAT8uGxgtzsI2t04g400Bmx4ghYyqcQ0DRpx4cNGKjU0m3YqjK6kmtVYCOLBgQc7Xmwk4CGFenB0osHSGdM0SQtWsYtu7CYNS9AXOisR9OGy+ElPAL/XE3qCjC2RcwefRraxJy7/btfW1pKWlta24XPXrl1kZWWxYsUKcnNzw+133HEHy5YtY+XKlYdY+sjD56xZs5g9e3ar9meeeQa3O8I/kiJycjBNUpq2kNKwhZ1dRuGzJWKYgdCprK/1iXlm/RusQQ8By/5ryvZfUmIJeulW9zmJnt1Udj6T2oTDX2No9zcQtNgOrktE5BTW2NjIxIkTDxs+T8i73adPn05hYWH4/YGZzzFjxmjms52pNpGpLtEdbW0GH8cxRTcegIFx2JKOmehUm+hUm8hUl+jiWZva2iP7wpmYwmdaWhpWq5Xy8vIW7eXl5WRmZsayqkNyOp04na1nEux2e1wPqnhvryNRbSJTXaJTbSJTXaJTbaJTbSJTXaKLR22OdP0xfd+gw+Fg+PDhFBcXh9uCwSDFxcUtTsOLiIiIiEQS82n3wsJCpkyZwogRIxg5ciTz58+noaGB/Px8ACZPnkxWVhZz584FQjcpff755+Gfd+7cybp160hMTGTAgAFtuCsiIiIicqKLOXxOmDCByspKZsyYQVlZGcOGDWPJkiVkZITuiC0tLcXytQfj7tq1i7PPPjv8/qGHHuKhhx7i4osvZunSpce+ByIiIiLSYRzVDUcFBQUUFBRE/OybgTI7O5uj+BIlERERETkJxXTNp4iIiIjIsVD4FBEREZG4UfgUERERkbhR+BQRERGRuFH4FBEREZG4UfgUERERkbhR+BQRERGRuFH4FBEREZG4UfgUERERkbhR+BQRERGRuFH4FBEREZG4UfgUERERkbhR+BQRERGRuFH4FBEREZG4UfgUERERkbhR+BQRERGRuFH4FBEREZG4UfgUERERkbhR+BQRERGRuFH4FBEREZG4OarwuWDBArKzs3G5XIwaNYpVq1Ydsv/zzz/PoEGDcLlcDBkyhDfeeOOoBisiIiIiHVvM4XPx4sUUFhYyc+ZM1qxZQ05ODmPHjqWioiJi/xUrVnD99dfzk5/8hLVr1zJ+/HjGjx/Pp59+esyDFxEREZGOJebwOW/ePKZOnUp+fj6DBw9m4cKFuN1uFi1aFLH/ww8/zOWXX86vfvUrzjjjDO677z7OOecc/vSnPx3z4EVERESkY7HF0tnr9bJ69WqmT58ebrNYLOTl5VFSUhJxmZKSEgoLC1u0jR07lpdffjnqdjweDx6PJ/y+pqYGgL179+Lz+WIZ8lHx+Xw0NjayZ88e7Hb7cd9eR6LaRKa6RKfaRKa6RKfaRKfaRKa6RBfP2tTV1QFgmuYh+8UUPquqqggEAmRkZLRoz8jIYMOGDRGXKSsri9i/rKws6nbmzp3L7NmzW7X37ds3luGKiIiISJzV1dWRnJwc9fOYwme8TJ8+vcVsaTAYZO/evXTt2hXDMI779mtra+nVqxfbt28nKSnpuG+vI1FtIlNdolNtIlNdolNtolNtIlNdootnbUzTpK6ujh49ehyyX0zhMy0tDavVSnl5eYv28vJyMjMzIy6TmZkZU38Ap9OJ0+ls0ZaSkhLLUNtEUlKSDuIoVJvIVJfoVJvIVJfoVJvoVJvIVJfo4lWbQ814HhDTDUcOh4Phw4dTXFwcbgsGgxQXF5Obmxtxmdzc3Bb9AYqKiqL2FxEREZGTV8yn3QsLC5kyZQojRoxg5MiRzJ8/n4aGBvLz8wGYPHkyWVlZzJ07F4BbbrmFiy++mN/97ndcddVVPPvss3z00Uf85S9/ads9EREREZETXszhc8KECVRWVjJjxgzKysoYNmwYS5YsCd9UVFpaisVycEL1/PPP55lnnuGee+7h7rvv5rTTTuPll1/mrLPOaru9aGNOp5OZM2e2OvUvqk00qkt0qk1kqkt0qk10qk1kqkt0J2JtDPNw98OLiIiIiLQRfbe7iIiIiMSNwqeIiIiIxI3Cp4iIiIjEjcKniIiIiMSNwuc3LFiwgOzsbFwuF6NGjWLVqlXtPaS4mzVrFoZhtHgNGjQo/HlzczPTpk2ja9euJCYm8v3vf7/VFwmcLN5//33GjRtHjx49MAyDl19+ucXnpmkyY8YMunfvTkJCAnl5eXz55Zct+uzdu5dJkyaRlJRESkoKP/nJT6ivr4/jXrS9w9XlhhtuaHUMXX755S36nIx1mTt3Lueeey6dO3cmPT2d8ePHs3HjxhZ9juTPT2lpKVdddRVut5v09HR+9atf4ff747krbe5IanPJJZe0Om5+9rOftehzMtbm0UcfZejQoeGHgOfm5vLmm2+GPz9Vj5nD1eVUPV4ieeCBBzAMg1tvvTXcdiIfNwqfX7N48WIKCwuZOXMma9asIScnh7Fjx1JRUdHeQ4u7M888k927d4dfy5cvD39222238c9//pPnn3+eZcuWsWvXLr73ve+142iPn4aGBnJycliwYEHEz3/729/yhz/8gYULF7Jy5Uo6derE2LFjaW5uDveZNGkSn332GUVFRbz22mu8//773HjjjfHahePicHUBuPzyy1scQ//4xz9afH4y1mXZsmVMmzaNf//73xQVFeHz+RgzZgwNDQ3hPof78xMIBLjqqqvwer2sWLGCv/3tbzz55JPMmDGjPXapzRxJbQCmTp3a4rj57W9/G/7sZK1Nz549eeCBB1i9ejUfffQR3/72t7n66qv57LPPgFP3mDlcXeDUPF6+6cMPP+TPf/4zQ4cObdF+Qh83poSNHDnSnDZtWvh9IBAwe/ToYc6dO7cdRxV/M2fONHNyciJ+Vl1dbdrtdvP5558Pt61fv94EzJKSkjiNsH0A5ksvvRR+HwwGzczMTPPBBx8Mt1VXV5tOp9P8xz/+YZqmaX7++ecmYH744YfhPm+++aZpGIa5c+fOuI39ePpmXUzTNKdMmWJeffXVUZc5FepimqZZUVFhAuayZctM0zyyPz9vvPGGabFYzLKysnCfRx991ExKSjI9Hk98d+A4+mZtTNM0L774YvOWW26JusypUhvTNM0uXbqYjz/+uI6ZbzhQF9PU8WKapllXV2eedtppZlFRUYt6nOjHjWY+9/N6vaxevZq8vLxwm8ViIS8vj5KSknYcWfv48ssv6dGjB/369WPSpEmUlpYCsHr1anw+X4s6DRo0iN69e59yddqyZQtlZWUtapGcnMyoUaPCtSgpKSElJYURI0aE++Tl5WGxWFi5cmXcxxxPS5cuJT09nYEDB3LTTTexZ8+e8GenSl1qamoASE1NBY7sz09JSQlDhgwJf3EHwNixY6mtrW0x49PRfbM2Bzz99NOkpaVx1llnMX36dBobG8OfnQq1CQQCPPvsszQ0NJCbm6tjZr9v1uWAU/14mTZtGldddVWL4wNO/L9rYv6Go5NVVVUVgUCgxW8CQEZGBhs2bGinUbWPUaNG8eSTTzJw4EB2797N7NmzufDCC/n0008pKyvD4XCQkpLSYpmMjAzKysraZ8Dt5MD+RjpmDnxWVlZGenp6i89tNhupqakndb0uv/xyvve979G3b182b97M3XffzRVXXEFJSQlWq/WUqEswGOTWW2/lggsuCH+j25H8+SkrK4t4TB347GQQqTYAEydOpE+fPvTo0YOPP/6YO++8k40bN/Liiy8CJ3dtPvnkE3Jzc2lubiYxMZGXXnqJwYMHs27dulP6mIlWFzi1jxeAZ599ljVr1vDhhx+2+uxE/7tG4VNaueKKK8I/Dx06lFGjRtGnTx+ee+45EhIS2nFk0lFcd9114Z+HDBnC0KFD6d+/P0uXLuWyyy5rx5HFz7Rp0/j0009bXC8tIdFq8/VrfocMGUL37t257LLL2Lx5M/3794/3MONq4MCBrFu3jpqaGl544QWmTJnCsmXL2ntY7S5aXQYPHnxKHy/bt2/nlltuoaioCJfL1d7DiZlOu++XlpaG1WptdSdYeXk5mZmZ7TSqE0NKSgqnn346mzZtIjMzE6/XS3V1dYs+p2KdDuzvoY6ZzMzMVjes+f1+9u7de0rVq1+/fqSlpbFp0ybg5K9LQUEBr732Gu+99x49e/YMtx/Jn5/MzMyIx9SBzzq6aLWJZNSoUQAtjpuTtTYOh4MBAwYwfPhw5s6dS05ODg8//PApf8xEq0skp9Lxsnr1aioqKjjnnHOw2WzYbDaWLVvGH/7wB2w2GxkZGSf0caPwuZ/D4WD48OEUFxeH24LBIMXFxS2uLzkV1dfXs3nzZrp3787w4cOx2+0t6rRx40ZKS0tPuTr17duXzMzMFrWora1l5cqV4Vrk5uZSXV3N6tWrw33effddgsFg+C/KU8GOHTvYs2cP3bt3B07eupimSUFBAS+99BLvvvsuffv2bfH5kfz5yc3N5ZNPPmkRzouKikhKSgqfbuyIDlebSNatWwfQ4rg5GWsTSTAYxOPxnNLHTCQH6hLJqXS8XHbZZXzyySesW7cu/BoxYgSTJk0K/3xCHzfH9XamDubZZ581nU6n+eSTT5qff/65eeONN5opKSkt7gQ7Ffzyl780ly5dam7ZssX84IMPzLy8PDMtLc2sqKgwTdM0f/azn5m9e/c23333XfOjjz4yc3Nzzdzc3HYe9fFRV1dnrl271ly7dq0JmPPmzTPXrl1rbtu2zTRN03zggQfMlJQU85VXXjE//vhj8+qrrzb79u1rNjU1hddx+eWXm2effba5cuVKc/ny5eZpp51mXn/99e21S23iUHWpq6szb7/9drOkpMTcsmWL+c4775jnnHOOedppp5nNzc3hdZyMdbnpppvM5ORkc+nSpebu3bvDr8bGxnCfw/358fv95llnnWWOGTPGXLdunblkyRKzW7du5vTp09tjl9rM4WqzadMmc86cOeZHH31kbtmyxXzllVfMfv36mRdddFF4HSdrbe666y5z2bJl5pYtW8yPP/7YvOuuu0zDMMy3337bNM1T95g5VF1O5eMlmm/e/X8iHzcKn9/wxz/+0ezdu7fpcDjMkSNHmv/+97/be0hxN2HCBLN79+6mw+Ews7KyzAkTJpibNm0Kf97U1GTefPPNZpcuXUy3221ec8015u7du9txxMfPe++9ZwKtXlOmTDFNM/S4pXvvvdfMyMgwnU6nedlll5kbN25ssY49e/aY119/vZmYmGgmJSWZ+fn5Zl1dXTvsTds5VF0aGxvNMWPGmN26dTPtdrvZp08fc+rUqa3+E3cy1iVSTQDzr3/9a7jPkfz52bp1q3nFFVeYCQkJZlpamvnLX/7S9Pl8cd6btnW42pSWlpoXXXSRmZqaajqdTnPAgAHmr371K7OmpqbFek7G2vzXf/2X2adPH9PhcJjdunUzL7vssnDwNM1T95g5VF1O5eMlmm+GzxP5uDFM0zSP79yqiIiIiEiIrvkUERERkbhR+BQRERGRuFH4FBEREZG4UfgUERERkbhR+BQRERGRuFH4FBEREZG4UfgUERERkbhR+BQRERGRuFH4FBEREZG4UfgUERERkbhR+BQRERGRuFH4FBEREZG4+f/MMGl4FIDf7AAAAABJRU5ErkJggg==", + "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": [ + "draw_stat(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": {}, + "outputs": [ + { + "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" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i in [1, 50, 100, 200, 400]:\n", + " draw_images(IMAGE_EXAMPLES[i][0][:4], IMAGE_EXAMPLES[i][1][:4], f\"Epoch {i}\")" + ] + } + ], + "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.13.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}