{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "/home/seb/Perso/git/sudoku/sudoku_clean_v2\n" ] } ], "source": [ "%cd .." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import torch\n", "import pytorch_lightning as pl\n", "from torch import nn\n", "import torch.nn.functional as F\n", "import pandas as pd\n", "import seaborn as sn\n", "import matplotlib.pyplot as plt\n", "\n", "from sudoku.models import SmallNet, SymPreprocess\n", "from sudoku.loader import DataIterBuffer, train_dataset, test_dataset, data_loader, get_datasets\n", "from sudoku.helper import display_as_dataframe\n", "\n", "from collections import deque\n", "from typing import Tuple\n", "\n", "\n", "from torchmetrics import AUROC\n", "from torch.utils.data.dataset import IterableDataset\n", "from torch.utils.data import DataLoader\n", "\n", "from pytorch_lightning.callbacks import ModelCheckpoint\n", "from lightning_lite.utilities.seed import seed_everything\n", "\n", "import numpy as np\n", "\n", "\n", "import math\n", "def sigmoid(x):\n", " return 1 / (1 + math.exp(-x))\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "torch.cuda.is_available()\n", "tensorboard = pl.loggers.TensorBoardLogger(save_dir=\"\")" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Global seed set to 1\n" ] }, { "data": { "text/plain": [ "1" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "seed_everything(seed=1)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "train_dataset, test_dataset = get_datasets(train_size=1280, test_size=1280)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "test_x, test_y = tuple(next(iter(data_loader(batch_size=1)[1])))" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def transform_to_number_1(input_tensor):\n", " tensor = input_tensor.reshape(input_tensor.shape[0], 2, 9, 9, 9)\n", " max_value, chiffre_tensor = torch.max(tensor[:,1,:,:,:],-1)\n", " chiffre_tensor = chiffre_tensor+1\n", " return chiffre_tensor\n", "\n", "def transform_to_number_0(input_tensor):\n", " tensor = input_tensor.reshape(input_tensor.shape[0], 2, 9, 9, 9)\n", " max_value, chiffre_tensor = torch.min(tensor[:,0,:,:,:],-1)\n", " chiffre_tensor = chiffre_tensor+1\n", " return chiffre_tensor" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor(0.9820)" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "torch.sigmoid(torch.tensor(4))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- test clip -4 4: ne fonctionne pas\n", "- analyse des distributions:\n", "- la recherches des absent marche : beaucoup d'exemple dans la data.\n", "- la recherche des present est disfonctionel: très très peu d'exemple\n", "\n", "idée:\n", "- entrainer la recherche des present seulement sur le second tour et plus.\n", "- entrainer la recherche des present seulement sur les nons absents et non present?" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def coef_scheduler(epoch,start_decay=10, end_decay=18):\n", " if epoch<= start_decay:\n", " return 1.\n", " if epoch>=end_decay:\n", " return 0.1\n", " coef = 1-0.9*(epoch-start_decay)/(end_decay-start_decay)\n", " \n", " return coef" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "class SudokuLightning(pl.LightningModule):\n", " def __init__(\n", " self,\n", " lr=0.1,\n", " train_dataset=train_dataset,\n", " val_dataset=test_dataset,\n", " margin=0.1,\n", " prev_nets = None,\n", " coef_0 = 10\n", " ):\n", " \n", " super().__init__()\n", " self.net=SmallNet()\n", " self.sym_preprocess = SymPreprocess()\n", " pos_weight = torch.ones((2,9*9*9))\n", " pos_weight[0,:] = 1./8.\n", " pos_weight[1,:]= 1.\n", " pos_weight /= coef_0\n", " weight = torch.ones((2,9*9*9))\n", " weight[0,:] = 8.\n", " weight[1,:]= 1.\n", " weight *= coef_0\n", " \n", " self.bcewll = nn.BCEWithLogitsLoss(pos_weight=pos_weight, weight=weight, reduce=False)\n", " self.lr = lr\n", " self.auroc = AUROC(task='binary')\n", " self.train_dataset = train_dataset\n", " self.test_dataset = test_dataset\n", " self.n_bins = 99\n", " self.bins = np.linspace(0,1,self.n_bins+1)\n", " self.train_freq_abs_gr_0 = np.zeros((self.n_bins,))\n", " self.train_freq_abs_gr_1 = np.zeros((self.n_bins,))\n", " self.train_freq_pres_gr_0 = np.zeros((self.n_bins,))\n", " self.train_freq_pres_gr_1 = np.zeros((self.n_bins,))\n", " \n", " self.margin = margin\n", " self.threshold_pres = None\n", " self.threshold_abs = None\n", " self.threshold_pres_train = -10\n", " self.threshold_abs_train = -10\n", "\n", " self.prev_nets = prev_nets\n", " self.below_threshold_coef = 1\n", "\n", " def configure_optimizers(self):\n", " optimizer = torch.optim.Adam(self.parameters(), lr=self.lr)\n", " return optimizer\n", "\n", " def forward(self, x):\n", " x = self.sym_preprocess.forward(x)\n", " return self.net(x)\n", " \n", " def predict_from_net(self, x, net, th_abs, th_pres):\n", " x = self.sym_preprocess.forward(x)\n", " x = net(x)\n", " new_x = torch.empty(x.shape, device=x.device)\n", " new_x[:,0] = (x[:,0] > th_abs).float()\n", " new_x[:,1] = (x[:,1] > th_pres).float()\n", " return new_x\n", " \n", " def predict(self, x):\n", " return predict_from_net(x,self.net, self.threshold_abs, self.threshold_pres)\n", " \n", " def process_batch(self, batch, dataset):\n", " x, y = batch\n", " new_x = torch.zeros(x.shape, device=x.device)\n", "\n", " if self.prev_nets:\n", " for net, (th_abs, th_pres) in self.prev_nets:\n", " with torch.no_grad():\n", " sub_new_x = self.predict_from_net(x, net.to(x.device), th_abs, th_pres)\n", " new_x[sub_new_x==1]=1\n", " new_x[x==1]=1\n", " new_x[(new_x==1)&(y==0)]=0\n", " mask_no_improve = new_x.sum(dim=(1,2))<=x.sum(dim=(1,2))\n", " dataset.append(new_x[~mask_no_improve].cpu(), y[~mask_no_improve].clone().cpu())\n", "\n", " if mask_no_improve.sum()>0: \n", " return x[mask_no_improve], y[mask_no_improve], y[mask_no_improve]\n", " else:\n", " return None, None, None\n", " return x,y,y\n", " \n", " @staticmethod\n", " def mask_uncomplete(x,y):\n", " mask_uncomplete = (x.reshape(-1,2,9,9,9).sum(-1)th_enforce)&(y==0)).float()\n", "# loss+=5*loss*mask_add*(output.detach()-th_enforce)\n", " \n", "# mask_below_th = torch.zeros(x.shape, device=x.device)\n", "# mask_below_th[:,0][(output[:,0]= 35:\n", "# mask_lower_than_0 = (output<0)&(y==1)\n", "# loss = loss*mask_lower_than_0.float()\n", " loss = (loss*mask).sum()\n", " \n", " return loss\n", "\n", " def training_step(self, batch, batch_idx):\n", " x, y, true_y = self.process_batch(batch, self.train_data_iter)\n", " if x is None:\n", " return None\n", " \n", " output = self.forward(x)\n", " loss = self.computing_loss(x, y, output, true_y)\n", " ##\n", "# y[:,0][output[:,0].detach()0).float()\n", "# new_X[:,0] = (output[:,0].detach()>self.threshold_abs_train).float()\n", "# new_X[:,1] = (output[:,1].detach()>self.threshold_pres_train).float()\n", "# new_X[x.detach()==1]=1\n", "# mask_no_improve = new_X.sum(dim=(1,2))<=x.sum(dim=(1,2))\n", "# self.no_improve_counter+= mask_no_improve.sum().item()\n", "# self.item_counter+= mask_no_improve.shape[0]\n", "# self.train_data_iter.append(new_X[~mask_no_improve].cpu(), y[~mask_no_improve].clone().cpu())\n", " # TODO rempve solved\n", " new_X = (output.detach()>0).float()\n", " new_X[:,0] = (output[:,0].detach()>self.threshold_abs_train).float()\n", " new_X[:,1] = (output[:,1].detach()>self.threshold_pres_train).float()\n", " new_X[x.detach()==1]=1\n", " mask_no_improve = new_X.sum(dim=(1,2))<=x.sum(dim=(1,2))\n", "# self.no_improve_counter+= mask_no_improve.sum().item()\n", "# self.item_counter+= mask_no_improve.shape[0]\n", " self.train_data_iter.append(new_X[~mask_no_improve].cpu(), y[~mask_no_improve].clone().cpu())\n", "\n", " return loss\n", " \n", " def on_validation_epoch_end(self):\n", " tensorboard = self.logger.experiment\n", " f = plt.figure()\n", " fig, (ax1,ax2) = plt.subplots(2,1)\n", " \n", " ax1.axvline(sigmoid(self.threshold_abs_train), color='black')\n", " ax1.bar(self.bins[:-1], self.train_freq_abs_gr_0, width=np.diff(self.bins)/2, align=\"edge\", label='gr_0')\n", " ax1.bar(self.bins[:-1], self.train_freq_abs_gr_1, width=np.diff(self.bins)/2, align=\"center\", label='gr_1')\n", " ax1.set_yscale('log')\n", " ax1.set_title('abs')\n", " \n", " ax2.axvline(sigmoid(self.threshold_pres_train), color='black')\n", " ax2.bar(self.bins[:-1], self.train_freq_pres_gr_0, width=np.diff(self.bins)/2, align=\"edge\", label='gr_0')\n", " ax2.bar(self.bins[:-1], self.train_freq_pres_gr_1, width=np.diff(self.bins)/2, align=\"center\", label='gr_1')\n", " ax2.set_yscale('log')\n", " plt.legend()\n", " ax2.set_title('pres')\n", " \n", "\n", " tensorboard.add_figure('hist', f)\n", " plt.show()\n", " plt.close()\n", " self.log('no_improve_counter', self.no_improve_counter)\n", " print(f\"No improve counter : {self.no_improve_counter}\")\n", " print(f\"item counter : {self.item_counter}\")\n", " print(f\"ratio : {self.no_improve_counter/(self.item_counter+1)}\")\n", " ratio_number_predicted_per_items = self.number_predicted/(self.item_counter+1)\n", " print(f\" ratio number predicted/items: {ratio_number_predicted_per_items}\")\n", " self.log(\"ratio_number_predicted_per_items\", ratio_number_predicted_per_items)\n", " print(f\"current epoch: {self.current_epoch}\")\n", " self.no_improve_counter = 0\n", " self.item_counter = 0\n", " self.number_predicted = 0\n", " \n", " self.train_freq_pres_gr_0 = np.zeros((self.n_bins,))\n", " self.train_freq_pres_gr_1 = np.zeros((self.n_bins,))\n", " self.train_freq_abs_gr_0 = np.zeros((self.n_bins,))\n", " self.train_freq_abs_gr_1 = np.zeros((self.n_bins,))\n", " \n", " \n", " self.threshold_abs = self.threshold_abs_train\n", " self.threshold_pres = self.threshold_pres_train\n", "\n", " def on_validation_start(self):\n", " \n", " self.no_improve_counter = 0\n", " self.item_counter = 0\n", " self.number_predicted = 0\n", " \n", " def validation_step(self, batch, batch_idx):\n", " \n", " x, y, true_y = self.process_batch(batch, self.val_data_iter)\n", " if x is None:\n", " return None\n", " \n", " output = self.forward(x)\n", " val_loss = self.computing_loss(x, y, output, true_y)\n", "\n", " max_th_abs = output[:,0][(x[:,0]==0)&(y[:,0]==0)].max().item()\n", " if self.threshold_abs_train< max_th_abs+self.margin:\n", " self.threshold_abs_train = max_th_abs+self.margin\n", " max_th_pres = output[:,1][(x[:,1]==0)&(y[:,1]==0)].max().item()\n", " if self.threshold_pres_train< max_th_pres+self.margin:\n", " self.threshold_pres_train = max_th_pres+self.margin \n", " \n", " self.log(\"val_loss\", val_loss)\n", " loss_0 = F.binary_cross_entropy_with_logits(output[:,[0],:], y[:,[0],:])\n", " loss_1 = F.binary_cross_entropy_with_logits(output[:,[1],:], y[:,[1],:])\n", " self.log_dict({'val_loss_1': loss_1, 'val_loss_0': loss_0})\n", " accuracy_1 = torch.mean(torch.eq(transform_to_number_1(output), transform_to_number_1(x)).type(torch.float))\n", " accuracy_0 = torch.mean(torch.eq(transform_to_number_0(output), transform_to_number_0(x)).type(torch.float))\n", " self.log_dict({'val_accuracy_1': accuracy_1, 'val_accuracy_0': accuracy_0}, on_epoch=True)\n", " new_X = (output.detach()>0).float()\n", " if self.threshold_abs:\n", " new_X[:,0] = (output[:,0].detach()>self.threshold_abs).float()\n", " new_X[:,1] = (output[:,1].detach()>self.threshold_pres).float()\n", " new_X[x.detach()==1]=1\n", " mask_no_improve = new_X.sum(dim=(1,2))<=x.sum(dim=(1,2))\n", " abs_gr_0 = torch.sigmoid(output[:,0][(x[:,0]==0)&(y[:,0]==0)])\n", " abs_gr_1 = torch.sigmoid(output[:,0][(x[:,0]==0)&(y[:,0]==1)])\n", " pres_gr_0 = torch.sigmoid(output[:,1][(x[:,1]==0)&(y[:,1]==0)])\n", " pres_gr_1 = torch.sigmoid(output[:,1][(x[:,1]==0)&(y[:,1]==1)])\n", " \n", " freq, _bins = np.histogram(abs_gr_0.detach().cpu().numpy(), bins=self.bins) \n", " self.train_freq_abs_gr_0 += freq\n", " freq, _bins = np.histogram(abs_gr_1.detach().cpu().numpy(), bins=self.bins) \n", " self.train_freq_abs_gr_1 += freq\n", " freq, _bins = np.histogram(pres_gr_0.detach().cpu().numpy(), bins=self.bins) \n", " self.train_freq_pres_gr_0 += freq\n", " freq, _bins = np.histogram(pres_gr_1.detach().cpu().numpy(), bins=self.bins) \n", " self.train_freq_pres_gr_1 += freq\n", " \n", " \n", "# batch = transfer_batch_to_device(batch)\n", " new_X = (output.detach()>0).float()\n", " new_X[:,0] = (output[:,0].detach()>self.threshold_abs_train).float()\n", " new_X[:,1] = (output[:,1].detach()>self.threshold_pres_train).float()\n", " new_X[x.detach()==1]=1\n", " mask_no_improve = new_X.sum(dim=(1,2))<=x.sum(dim=(1,2))\n", " self.no_improve_counter+= mask_no_improve.sum().item()\n", " self.item_counter+= mask_no_improve.shape[0]\n", " self.number_predicted += new_X.sum().item()-x.sum().item()\n", "# self.train_data_iter.append(new_X[~mask_no_improve].cpu(), y[~mask_no_improve].clone().cpu())\n", " \n", "\n", " self.val_data_iter.append(new_X[~mask_no_improve].cpu(), y[~mask_no_improve].clone().cpu())\n", "\n", " def train_dataloader(self):\n", " self.train_data_iter = DataIterBuffer(self.train_dataset)\n", " return DataLoader(self.train_data_iter, 32)\n", " \n", " def val_dataloader(self):\n", " self.val_data_iter = DataIterBuffer(self.test_dataset)\n", " return DataLoader(self.val_data_iter, 32)\n", " " ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "class DistillationLightning(SudokuLightning):\n", " def process_batch(self, batch, _, validation=True):\n", " x, y = batch\n", " new_y = torch.zeros(y.shape, device=y.device)\n", "\n", " if self.prev_nets:\n", " for net, (th_abs, th_pres) in self.prev_nets:\n", " with torch.no_grad():\n", " sub_new_y = self.predict_from_net(x, net.to(x.device), th_abs, th_pres)\n", " new_y[sub_new_y==1]=1\n", " new_y[x==1]=1\n", " new_y[(new_y==1)&(y==0)]=0\n", " return x, new_y, y\n", " return x,y, y\n", " \n", " def computing_loss(self, x, y, output, true_y):\n", " loss = self.bcewll(output, y)\n", " mask = ((x==0)& ~((true_y==1)&(y==0))).float()\n", " loss = (loss*mask).sum() \n", " return loss\n", "\n", " \n", " " ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# class Speeduplightning(SudokuLightning):\n", "# def process_batch(self, batch, dataset):\n", "# x, y = batch\n", "# new_x = torch.zeros(x.shape, device=x.device)\n", "\n", "# if self.prev_nets:\n", "# for net, (th_abs, th_pres) in self.prev_nets:\n", "# with torch.no_grad():\n", "# sub_new_x = self.predict_from_net(x, net.to(x.device), th_abs, th_pres)\n", "# new_x[sub_new_x==1]=1\n", "# new_x[x==1]=1\n", "# new_x[(new_x==1)&(y==0)]=0 \n", "# return new_x, y, y\n", "\n", "# return x,y,y" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "scrolled": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "-----------------------------------------------------\n", "0 | net | SmallNet | 514 \n", "1 | sym_preprocess | SymPreprocess | 8.5 M \n", "2 | bcewll | BCEWithLogitsLoss | 0 \n", "3 | auroc | BinaryAUROC | 0 \n", "-----------------------------------------------------\n", "514 Trainable params\n", "8.5 M Non-trainable params\n", "8.5 M Total params\n", "34.014 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 64\n", "item counter : 64\n", "ratio : 0.9846153846153847\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/seb/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/logger_connector/result.py:212: UserWarning: You called `self.log('no_improve_counter', ...)` in your `on_validation_epoch_end` but the value needs to be floating point. Converting it to torch.float32.\n", " warning_cache.warn(\n", "/home/seb/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:430: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 12 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4d88e9a89c0641edab3229c7d02db506", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1216\n", "item counter : 1216\n", "ratio : 0.9991783073130649\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1280\n", "item counter : 1280\n", "ratio : 0.9992193598750976\n", " ratio number predicted/items: 0.0\n", "current epoch: 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1280\n", "item counter : 1280\n", "ratio : 0.9992193598750976\n", " ratio number predicted/items: 0.0\n", "current epoch: 2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1280\n", "item counter : 1280\n", "ratio : 0.9992193598750976\n", " ratio number predicted/items: 0.0\n", "current epoch: 3\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1280\n", "item counter : 1280\n", "ratio : 0.9992193598750976\n", " ratio number predicted/items: 0.0\n", "current epoch: 4\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1280\n", "item counter : 1282\n", "ratio : 0.9976617303195635\n", " ratio number predicted/items: 0.001558846453624318\n", "current epoch: 5\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1239\n", "item counter : 4123\n", "ratio : 0.3004364694471387\n", " ratio number predicted/items: 40.74272550921435\n", "current epoch: 6\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1237\n", "item counter : 4670\n", "ratio : 0.2648255191607793\n", " ratio number predicted/items: 74.6859344894027\n", "current epoch: 7\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1244\n", "item counter : 4183\n", "ratio : 0.29732313575525815\n", " ratio number predicted/items: 87.81477055449331\n", "current epoch: 8\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=10` reached.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1246\n", "item counter : 3768\n", "ratio : 0.3305916688776864\n", " ratio number predicted/items: 98.57283098965243\n", "current epoch: 9\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "/home/seb/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/callbacks/model_checkpoint.py:612: UserWarning: Checkpoint directory lightning_logs/version_81/checkpoints exists and is not empty.\n", " rank_zero_warn(f\"Checkpoint directory {dirpath} exists and is not empty.\")\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "-----------------------------------------------------\n", "0 | net | SmallNet | 514 \n", "1 | sym_preprocess | SymPreprocess | 8.5 M \n", "2 | bcewll | BCEWithLogitsLoss | 0 \n", "3 | auroc | BinaryAUROC | 0 \n", "-----------------------------------------------------\n", "514 Trainable params\n", "8.5 M Non-trainable params\n", "8.5 M Total params\n", "34.014 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_3278/2863678930.py:187: UserWarning: Data has no positive values, and therefore cannot be log-scaled.\n", " ax1.set_yscale('log')\n", "/tmp/ipykernel_3278/2863678930.py:193: UserWarning: Data has no positive values, and therefore cannot be log-scaled.\n", " ax2.set_yscale('log')\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 0\n", "item counter : 0\n", "ratio : 0.0\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6f510ca040dc4b46887049903f061007", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "/home/seb/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/loops/optimization/automatic.py:129: UserWarning: `training_step` returned `None`. If this was on purpose, ignore this warning...\n", " self.warning_cache.warn(\"`training_step` returned `None`. If this was on purpose, ignore this warning...\")\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1246\n", "item counter : 1246\n", "ratio : 0.9991980753809142\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1246\n", "item counter : 1246\n", "ratio : 0.9991980753809142\n", " ratio number predicted/items: 0.0\n", "current epoch: 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1246\n", "item counter : 1246\n", "ratio : 0.9991980753809142\n", " ratio number predicted/items: 0.0\n", "current epoch: 2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGzCAYAAAD0T7cVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA6jUlEQVR4nO3de3xU1b3//3cSyAQ0F0MkFwlEpFCDmlhCIipfQdPSIIhaC60ejGij1kkvjpeGWhO8cGkPh3KKozy0xdhzoKBWqUcoVaOeeIlFEmI9AlZK0FjNAEVyGTQJk/X7wx+jI+Eyydx25vV8PPbj4axZs/dnlmnn7d5r7R1jjDECAACIELHhLgAAAODLCCcAACCiEE4AAEBEIZwAAICIQjgBAAARhXACAAAiCuEEAABEFMIJAACIKIQTAAAQUQgnAMKqurpaMTEx2rJlS7hLARAhCCcAACCiEE4AAEBEIZwAAICIQjgBEBTvv/++brnlFo0bN05DhgzRsGHD9N3vfle7d+/utf/Bgwd10003adiwYUpKStK1116rTz75xKfPli1bNG3aNKWlpWnIkCE6/fTTdf3114fg2wAIpUHhLgDAwPTmm2/q9ddf1/e+9z2NGDFCu3fv1kMPPaQpU6Zo27ZtGjp0qE//8vJypaSkaMGCBXr33Xf10EMP6f3339fLL7+smJgY7dmzR9/61rd06qmnqqKiQikpKdq9e7eeeuqpMH1DAMFCOAEQFJdeeqmuuuoqn7aZM2dq0qRJ+uMf/6i5c+f6vBcfH6+amhoNHjxYkjRq1Cjdeeed+p//+R9ddtllev311/XJJ5/oueeeU0FBgfdz999/f/C/DICQ4rIOgKAYMmSI95+7u7v1r3/9S2PGjFFKSooaGhqO6H/jjTd6g4kk/fCHP9SgQYO0ceNGSVJKSook6dlnn1V3d3dwiwcQVoQTAEHx6aefqrKyUtnZ2bLZbEpLS9Opp56qAwcOqLW19Yj+X/va13xen3zyycrMzPTOUbnooov0ne98R/fcc4/S0tI0a9YsPfroo+rs7AzF1wEQQoQTAEHxox/9SAsXLtTs2bP1+OOP67nnntPzzz+vYcOGqaenx+/9xcTE6Mknn1RdXZ3Ky8v1z3/+U9dff70mTJigjo6OIHwDAOFCOAEQFE8++aRKS0v1H//xH7rqqqv0zW9+UxdeeKEOHDjQa//33nvP53VHR4c+/vhj5eTk+LSfd955WrhwobZs2aLVq1frnXfe0dq1a4P0LQCEA+EEQFDExcXJGOPTtmLFCnk8nl77P/zwwz5zSR566CEdOnRIJSUlkqRPPvnkiP3l5+dLEpd2gAGG1ToAgmLGjBn6r//6LyUnJys3N1d1dXV64YUXNGzYsF77d3V16ZJLLtHs2bP17rvv6sEHH9SFF16oyy67TJL02GOP6cEHH9QVV1yhM844Q+3t7XrkkUeUlJSk6dOnh/KrAQgywgmAoPjP//xPxcXFafXq1frss890wQUX6IUXXtC0adN67f/AAw9o9erVqqysVHd3t77//e/rN7/5jWJiYiR9PiF28+bNWrt2rVwul5KTk1VYWKjVq1fr9NNPD+VXAxBkMear50kBAADCiDknAAAgohBOAABARCGcAACAiEI4AQAAEYVwAgAAIgrhBAAARBTL3eekp6dHH330kRITE733PwAAAJHNGKP29nZlZWUpNvbY50YsF04++ugjZWdnh7sMAADQB83NzRoxYsQx+1gmnDidTjmdTh06dEjS518uKSkpzFWFltvtVlZWlqTPQ9pJJ50U5ooAADgxbW1tys7OVmJi4nH7Wu4OsW1tbUpOTlZra2tUhpOTTz5Z0udPbCWcAACswp/fb8tMiHU6ncrNzdXEiRPDXQoAAAgizpxYCGdOAABWxZkTAABgWZw5sRDOnAAArIozJ8G2IPnzDQAABJxlwondbte2bdv05ptvhrsUAAAQRJYJJwAAIDpY7iZsHo8n3KUc6cuXeBa0hq8OAAAGAMucObHcZR3mpQAA0CeWCScAACA6WCachHK1Tk7FBuVUbAj6cQAAwJEsE04sd1kHAAD0iWXCCQAAiA6Ek+NhYisAACFlmXASUXeIDRSCDwAAR7BMOGHOCQAA0cEyN2GzPG7UBgDACbHMmZNwY3kxAAChQTjpB8IKAACBRzgBAAARxTLhZECu1gEAAEewTDhhtQ4AANHBMuEEAABEB8IJAACIKIQTAAAQUcIWTg4ePKhRo0bp9ttvD1cJQcHyYgAA+ids4WThwoU677zzwnV4AAAQocISTt577z3t2LFDJSUl4Tg8AACIYH6Hk9raWs2cOVNZWVmKiYnR+vXrj+jjdDqVk5OjhIQEFRUVafPmzT7v33777Vq8eHGfiwYAAAOX3+HE7XYrLy9PTqez1/fXrVsnh8OhqqoqNTQ0KC8vT9OmTdOePXskSX/60580duxYjR07tn+VAwCAAcnvpxKXlJQc83LMsmXLVFZWpnnz5kmSVq5cqQ0bNmjVqlWqqKjQG2+8obVr1+qJJ55QR0eHuru7lZSUpMrKyl7319nZqc7OTu/rtrY2f0sOq5yKDdq95NJwlwEAgGUEdM5JV1eX6uvrVVxc/MUBYmNVXFysuro6SdLixYvV3Nys3bt3a+nSpSorKztqMDncPzk52btlZ2cHsmQAABBhAhpO9u3bJ4/Ho/T0dJ/29PR0tbS09Gmf8+fPV2trq5YuXapx48ZpzJgxgSgVAABEKL8v6wTSddddd9w+NptNNptNt912m2677Ta1tbUpOTk5+MUBAICwCOiZk7S0NMXFxcnlcvm0u1wuZWRk9GvfPJUYAIDoENBwEh8frwkTJqimpsbb1tPTo5qaGk2aNKlf++apxAAARAe/L+t0dHRo586d3tdNTU1qbGxUamqqRo4cKYfDodLSUhUUFKiwsFDLly+X2+32rt7pK6fTKafTKY/H06/9AACAyOZ3ONmyZYumTp3qfe1wOCRJpaWlqq6u1pw5c7R3715VVlaqpaVF+fn52rRp0xGTZP1lt9tlt9uZcwIAwADndziZMmWKjDHH7FNeXq7y8vI+F9UbzpwAABAdwvbgP39FzZyTBcmfbwAARCnLhJOBJKdiQ7hLAAAgYlkmnLCUGACA6GCZcDKQL+twJgUAgC9YJpwAAIDoYJlwwmUdAACig2XCyUC+rAMAAL5gmXACAACiA+EEAABEFMuEE+acAAAQHSwTTphzAgBAdLBMOAEAANGBcAIAACIK4QQAAEQUwgkAAIgolgknrNYBACA6WCacsFoHAIDoYJlwAgAAogPhBAAARBTCCQAAiCghDycHDhxQQUGB8vPzddZZZ+mRRx4JdQkAACCCDQr1ARMTE1VbW6uhQ4fK7XbrrLPO0pVXXqlhw4aFuhQAABCBQn7mJC4uTkOHDpUkdXZ2yhgjY0yoywAAABHK73BSW1urmTNnKisrSzExMVq/fv0RfZxOp3JycpSQkKCioiJt3rzZ5/0DBw4oLy9PI0aM0B133KG0tLQ+fwEAADCw+B1O3G638vLy5HQ6e31/3bp1cjgcqqqqUkNDg/Ly8jRt2jTt2bPH2yclJUVvvfWWmpqatGbNGrlcrr5/AwAAMKD4HU5KSkp0//3364orruj1/WXLlqmsrEzz5s1Tbm6uVq5cqaFDh2rVqlVH9E1PT1deXp5eeeWVox6vs7NTbW1tPhsAABi4AjrnpKurS/X19SouLv7iALGxKi4uVl1dnSTJ5XKpvb1dktTa2qra2lqNGzfuqPtcvHixkpOTvVt2dnYgSwYAABEmoOFk37598ng8Sk9P92lPT09XS0uLJOn999/X5MmTlZeXp8mTJ+tHP/qRzj777KPuc/78+WptbdXSpUs1btw4jRkzJpAlAwCACBPypcSFhYVqbGw84f42m002m0233XabbrvtNrW1tSk5OTl4BQIAgLAK6JmTtLQ0xcXFHTHB1eVyKSMjo1/75qnEAABEh4CGk/j4eE2YMEE1NTXetp6eHtXU1GjSpEn92jdPJQYAIDr4fVmno6NDO3fu9L5uampSY2OjUlNTNXLkSDkcDpWWlqqgoECFhYVavny53G635s2b169CnU6nnE6nPB5Pv/YDAAAim9/hZMuWLZo6dar3tcPhkCSVlpaqurpac+bM0d69e1VZWamWlhbl5+dr06ZNR0yS9ZfdbpfdbmfOCQAAA5zf4WTKlCnHvd18eXm5ysvL+1xUb6LtzElOxQbtXnJpuMsAACDkQv5snb5izgkAANHBMuEEAABEB8uEE5YSAwAQHSwTTrisAwBAdLBMOAEAANHBMuGEyzoAAEQHy4QTLusAABAdLBNOAABAdCCcAACAiEI4AQAAEcUy4YQJsQAARAfLhBMmxAIAEB0sE04AAEB0IJwAAICIQjgBAAARhXACAAAiimXCCat1AACIDpYJJ6zWAQAgOlgmnAAAgOhAOAEAABEl5OGkublZU6ZMUW5urs455xw98cQToS4BAABEsEEhP+CgQVq+fLny8/PV0tKiCRMmaPr06TrppJNCXQoAAIhAIQ8nmZmZyszMlCRlZGQoLS1N+/fvJ5wAAABJfbisU1tbq5kzZyorK0sxMTFav379EX2cTqdycnKUkJCgoqIibd68udd91dfXy+PxKDs72+/CAQDAwOR3OHG73crLy5PT6ez1/XXr1snhcKiqqkoNDQ3Ky8vTtGnTtGfPHp9++/fv17XXXquHH364b5UDAIABye/LOiUlJSopKTnq+8uWLVNZWZnmzZsnSVq5cqU2bNigVatWqaKiQpLU2dmpyy+/XBUVFTr//POPebzOzk51dnZ6X7e1tflbMgAAsJCArtbp6upSfX29iouLvzhAbKyKi4tVV1cnSTLG6LrrrtPFF1+suXPnHnefixcvVnJysnfjEhAAAANbQMPJvn375PF4lJ6e7tOenp6ulpYWSdJrr72mdevWaf369crPz1d+fr7efvvto+5z/vz5am1t9W7Nzc2BLBkAAESYkK/WufDCC9XT03PC/W02m2w2m5xOp5xOpzweTxCrAwAA4RbQMydpaWmKi4uTy+XyaXe5XMrIyAjkoQAAwAAV0HASHx+vCRMmqKamxtvW09OjmpoaTZo0qV/75sF/AABEB78v63R0dGjnzp3e101NTWpsbFRqaqpGjhwph8Oh0tJSFRQUqLCwUMuXL5fb7fau3ukrLusAABAd/A4nW7Zs0dSpU72vHQ6HJKm0tFTV1dWaM2eO9u7dq8rKSrW0tCg/P1+bNm06YpKsv+x2u+x2u9ra2pScnNyvfQEAgMjldziZMmWKjDHH7FNeXq7y8vI+FwUAAKJXyJ9K3FdOp1O5ubmaOHFiuEsBAABBZJlwwoRYAACig2XCCWdOAACIDpYJJ5w5AQAgOlgmnAAAgOhAOAEAABHFMuGEOScAAEQHy4QT5pwAABAdLBNOAABAdCCcAACAiGKZcMKcEwAAooNlwglzTgAAiA6WCScAACA6EE4AAEBEIZwAAICIQjgBAAARxTLhhNU6AABEB8uEk6hdrbMg+fMNAIAoYZlwAgAAogPhBAAARBTCCQAAiChhCSdXXHGFTjnlFF111VXhODwAAIhgYQknP/nJT/T73/8+HIcGAAARLizhZMqUKUpMTAzHoQEAQITzO5zU1tZq5syZysrKUkxMjNavX39EH6fTqZycHCUkJKioqEibN28ORK0AACAK+B1O3G638vLy5HQ6e31/3bp1cjgcqqqqUkNDg/Ly8jRt2jTt2bOnTwV2dnaqra3NZwMAAAOX3+GkpKRE999/v6644ope31+2bJnKyso0b9485ebmauXKlRo6dKhWrVrVpwIXL16s5ORk75adnd2n/QAAAGsI6JyTrq4u1dfXq7i4+IsDxMaquLhYdXV1fdrn/Pnz1dra6t2am5sDVS4AAIhAgwK5s3379snj8Sg9Pd2nPT09XTt27PC+Li4u1ltvvSW3260RI0boiSee0KRJk3rdp81mk81mk9PplNPplMfjCWTJAAAgwgQ0nJyoF154IRyHBQAAFhDQyzppaWmKi4uTy+XyaXe5XMrIyOjXvqP2wX8AAESZgIaT+Ph4TZgwQTU1Nd62np4e1dTUHPWyzYlyOp3Kzc3VxIkT+1smAACIYH5f1uno6NDOnTu9r5uamtTY2KjU1FSNHDlSDodDpaWlKigoUGFhoZYvXy6326158+b1q1C73S673a62tjYlJyf3a18AACBy+R1OtmzZoqlTp3pfOxwOSVJpaamqq6s1Z84c7d27V5WVlWppaVF+fr42bdp0xCRZAACA3vgdTqZMmSJjzDH7lJeXq7y8vM9F9YbVOgAARIewPFunL5gQCwBAdLBMOGFCLAAA0cEy4YQzJwAARAfLhBMAABAdCCcAACCiWCacMOcEAIDoYJlwwpwTAACig2XCCQAAiA6EEwAAEFEsE06YcwIAQHSwTDhhzgkAANHBMuEEAABEB8IJAACIKIQTAAAQUQgnAAAgogwKdwEnyul0yul0yuPxhLuUsMip2KCers/CXQYAAEFnmTMnrNYBACA6WCacAACA6EA4AQAAEYVwAgAAIgrhBAAARBTCCQAAiCiWWUp8mDFGktTW1ha0Y/R0HvziGJ3mmG1fft1bm199pKN+rqfzoM9S4ra2tqhdVg0AsJ7Dv3OHf8ePJcacSK8I8uGHHyo7OzvcZQAAgD5obm7WiBEjjtnHcuGkp6dHH330kRITExUTExPw/be1tSk7O1vNzc1KSkoK+P7xOcY5dBjr0GCcQ4NxDp1Aj7UxRu3t7crKylJs7LFnlVjusk5sbOxxE1cgJCUl8YcfAoxz6DDWocE4hwbjHDqBHOvk5OQT6seEWAAAEFEIJwAAIKIQTr7CZrOpqqpKNpst3KUMaIxz6DDWocE4hwbjHDrhHGvLTYgFAAADG2dOAABARCGcAACAiEI4AQAAEYVwAgAAIkpUhhOn06mcnBwlJCSoqKhImzdvPmb/J554Ql//+teVkJCgs88+Wxs3bgxRpdbmzzg/8sgjmjx5sk455RSdcsopKi4uPu6/F3zB37/pw9auXauYmBhdfvnlwS1wgPB3nA8cOCC73a7MzEzZbDaNHTuW//84Af6O8/LlyzVu3DgNGTJE2dnZuvXWW/XZZ58d8zPRrra2VjNnzlRWVpZiYmK0fv36437m5Zdf1je+8Q3ZbDaNGTNG1dXVwSvQRJm1a9ea+Ph4s2rVKvPOO++YsrIyk5KSYlwuV6/9X3vtNRMXF2d+9atfmW3btplf/OIXZvDgwebtt98OceXW4u84X3311cbpdJqtW7ea7du3m+uuu84kJyebDz/8MMSVW4+/Y31YU1OTOe2008zkyZPNrFmzQlOshfk7zp2dnaagoMBMnz7dvPrqq6apqcm8/PLLprGxMcSVW4u/47x69Wpjs9nM6tWrTVNTk/nLX/5iMjMzza233hriyq1l48aN5q677jJPPfWUkWSefvrpY/bftWuXGTp0qHE4HGbbtm1mxYoVJi4uzmzatCko9UVdOCksLDR2u9372uPxmKysLLN48eJe+8+ePdtceumlPm1FRUXmpptuCmqdVufvOH/VoUOHTGJionnssceCVeKA0ZexPnTokDn//PPNb3/7W1NaWko4OQH+jvNDDz1kRo8ebbq6ukJV4oDg7zjb7XZz8cUX+7Q5HA5zwQUXBLXOgeREwsmdd95pxo8f79M2Z84cM23atKDUFFWXdbq6ulRfX6/i4mJvW2xsrIqLi1VXV9frZ+rq6nz6S9K0adOO2h99G+evOnjwoLq7u5WamhqsMgeEvo71vffeq+HDh+uGG24IRZmW15dxfuaZZzRp0iTZ7Xalp6frrLPO0qJFi+TxeEJVtuX0ZZzPP/981dfXey/97Nq1Sxs3btT06dNDUnO0CPVvoeUe/Ncf+/btk8fjUXp6uk97enq6duzY0etnWlpaeu3f0tIStDqtri/j/FU/+9nPlJWVdcT/GOCrL2P96quv6ne/+50aGxtDUOGJ6+npUVdXlxISEsJdyhH6Ms67du3Siy++qGuuuUYbN27Uzp07dcstt6i7u1tVVVWhKNty+jLOV199tfbt26cLL7xQxhgdOnRIN998s37+85+HouSocbTfwra2Nn366acaMmRIQI8XVWdOYA1LlizR2rVr9fTTT0fkD5WVtbe3a+7cuXrkkUeUlpYWlGMsWLBAMTEx2rFjh2bPnq2kpCQNGzZMP/nJT3wmKcbExKi8vFyrV6/W+PHjZbPZtGnTJknSP//5T11//fVKT0+XzWbT+PHjtWrVqiOOtWLFCo0fP15Dhw7VKaecooKCAq1ZsyYo38tfPT09Gj58uB5++GFNmDBBc+bM0V133aWVK1eGu7QB5eWXX9aiRYv04IMPqqGhQU899ZQ2bNig++67L9yloR+i6sxJWlqa4uLi5HK5fNpdLpcyMjJ6/UxGRoZf/dG3cT5s6dKlWrJkiV544QWdc845wSxzQPB3rP/xj39o9+7dmjlzpretp6dHkjRo0CC9++67OuOMMwJS2+zZs5WTk6PFixfrjTfe0G9+8xt98skn+v3vf+/t8+KLL+rxxx9XeXm50tLSlJOTI5fLpfPOO88bXk499VT9+c9/1g033KC2tjb99Kc/lfT5Cq8f//jHuuqqq7zB529/+5v++te/6uqrrw7IdzisL3/TmZmZGjx4sOLi4rxtZ555plpaWtTV1aX4+PiA1jgQ9GWc7777bs2dO1c/+MEPJElnn3223G63brzxRt11112KjeW/wQPhaL+FSUlJAT9rIin6VusUFhaa8vJy72uPx2NOO+20Y06InTFjhk/bpEmTmBB7HP6OszHG/PKXvzRJSUmmrq4uFCUOGP6M9aeffmrefvttn23WrFnm4osvNm+//bbp7Ozsdz1VVVVGkrnssst82m+55RYjybz11lvGmM8n4cXGxpp33nnHp98NN9xgMjMzzb59+3zav/e975nk5GRz8OBBY4wxs2bNOmKCXjD5+zc9f/58M2rUKOPxeLxty5cvN5mZmUGv1cr8HedvfOMb5s477/RpW7NmjRkyZIg5dOhQUGsdKHSCE2LPOussn7bvf//7QZsQG3XhZO3atcZms5nq6mqzbds2c+ONN5qUlBTT0tJijDFm7ty5pqKiwtv/tddeM4MGDTJLly4127dvN1VVVSwlPgH+jvOSJUtMfHy8efLJJ83HH3/s3drb28P1FSzD37H+qkCv1jkcTv7yl7/4tG/fvt1I8v7ISDJTp0716dPT02NSUlLMjTfeaPbu3euzPfroo0aSefXVV711Jycnm82bNwes9mPxd5w/+OADk5iYaMrLy827775rnn32WTN8+HBz//33h6Req/J3nKuqqkxiYqL5wx/+YHbt2mWee+45c8YZZ5jZs2eH6ytYQnt7u9m6davZunWrkWSWLVtmtm7dat5//31jjDEVFRVm7ty53v6HlxLfcccdZvv27cbpdLKUONBWrFhhRo4caeLj401hYaF54403vO9ddNFFprS01Kf/448/bsaOHWvi4+PN+PHjzYYNG0JcsTX5M86jRo0yko7YqqqqQl+4Bfn7N/1lwQonu3bt8mnv6uoysbGx3rOOksz111/v08flcvX6d/Dl7amnnjLGGLNt2zZz2mmnGUlmzJgx5pZbbvEGl2Dxd5xff/11U1RUZGw2mxk9erRZuHAh/zV/AvwZ5+7ubrNgwQJzxhlnmISEBJOdnW1uueUW88knn4S+cAt56aWXev3f1+GxLS0tNRdddNERn8nPzzfx8fFm9OjR5tFHHw1afTHGGBP4i0UAotWCBQt0zz33aNeuXTr99NO97YcOHZLNZlNZWZlWrlypmJgY2e12PfDAA94+LS0tyszM1L/927+ptLS01/2fc845Gj58uCTJ7Xbr2Wef1aZNm/TnP/9ZLpdLlZWVuueee4L7JQEEVVRNiAUQOu+9955PONm5c6d6enqUk5Nz1M+ceuqpSkxMlMfjOaFl5CeddJLmzJmjOXPmqKurS1deeaUWLlyo+fPns9ILsDCmMQMICqfT6fN6xYoVkqSSkpKjfiYuLk7f+c539Mc//lH/93//d8T7e/fu9f7zv/71L5/34uPjlZubK2OMuru7+1M6gDDjzAmAoGhqatJll12mb3/726qrq9N///d/6+qrr1ZeXt4xP7dkyRK99NJLKioqUllZmXJzc7V//341NDTohRde0P79+yVJ3/rWt5SRkaELLrhA6enp2r59ux544AFdeumlSkxMDMVXBBAkhBMAQbFu3TpVVlaqoqJCgwYNUnl5uf793//9uJ9LT0/X5s2bde+99+qpp57Sgw8+qGHDhmn8+PH65S9/6e130003afXq1Vq2bJk6Ojo0YsQI/fjHP9YvfvGLYH4tACHAhFgAAXV4QuzevXuDdhdaAAMbc04AAEBEIZwAAICIQjgBAAARJSxzTpqamnT99dfL5XIpLi5Ob7zxhk466aRQlwEAACJQWMLJRRddpPvvv1+TJ0/W/v37lZSUpEGDWDgEAADCsJT4nXfe0eDBgzV58mRJUmpqql+f7+np0UcffaTExETFxMQEo0QAABBgxhi1t7crKytLsbHHmVXi78N4/vd//9fMmDHDZGZmHvUxyw888IAZNWqUsdlsprCw0Pz1r3/1vvf000+bWbNmmRkzZphzzz3XLFy40K/jNzc3H/fBYGxsbGxsbGyRuTU3Nx/3t97vMydut1t5eXm6/vrrdeWVVx7x/rp16+RwOLRy5UoVFRVp+fLlmjZtmt59910NHz5chw4d0iuvvKLGxkYNHz5c3/72tzVx4kR985vfPKHjH77zY3Nzs5KSkvwtP6K43W5lZWVJkj766CPm3QAABqy2tjZlZ2ef0B2c/Q4nJSUlx3w2xrJly1RWVqZ58+ZJklauXKkNGzZo1apVqqio0GmnnaaCggJlZ2dLkqZPn67GxsajhpPOzk51dnZ6X7e3t0uSkpKSLB9O4uLivP+clJREOAEADHgnMiUjoEuJu7q6VF9f7/M00djYWBUXF6uurk6SNHHiRO3Zs0effPKJenp6VFtbqzPPPPOo+1y8eLGSk5O92+FQAwAABqaAhpN9+/bJ4/EoPT3dpz09PV0tLS2SpEGDBmnRokX6f//v/+mcc87R1772Nc2YMeOo+5w/f75aW1u9W3NzcyBLBgAAESYs63ePd2noy2w2m2w2m5xOp5xOpzweT5CrAwAA4RTQcJKWlqa4uDi5XC6fdpfLpYyMjH7t2263y263q62tTcnJyf3aFwAAx9LT06Ourq5wl2EpgwcP9plL2R8BDSfx8fGaMGGCampqdPnll0v6/F9wTU2NysvL+7VvzpwAAEKhq6tLTU1N6unpCXcplpOSkqKMjIx+34fM73DS0dGhnTt3el83NTWpsbFRqampGjlypBwOh0pLS1VQUKDCwkItX75cbrfbu3qnr0J55iSnYoMkafeSS4N6HABAZDHG6OOPP1ZcXJyys7OPf7MwSPp83A4ePKg9e/ZIkjIzM/u1P7/DyZYtWzR16lTva4fDIUkqLS1VdXW15syZo71796qyslItLS3Kz8/Xpk2bjpgk6y/OnAAAgu3QoUM6ePCgsrKyNHTo0HCXYylDhgyRJO3Zs0fDhw/v1yWesDxbpz8OnzlpbW0N2n1OQnXmxO126+STT5b0+Rkp7nMCAOH12WefqampSTk5Od4fW5y4Tz/9VLt379bpp5+uhIQEn/f8+f3mfBUAAF/Bs9v6JlDjZplw4nQ6lZubq4kTJ4a7FAAAEESWCSd2u13btm3Tm2++Ge5SAABAEIXlJmwAAFjJ4bmIoRLtq0Utc+aEyzoAAITW/v37dc011ygpKUkpKSm64YYb1NHREfTjWiaccFkHAIDAOZE74F5zzTV655139Pzzz+vZZ59VbW2tbrzxxqDXZplwAgAAjq69vV3XXHONTjrpJGVmZurXv/61pkyZop/+9KeSpJycHN1333269tprlZSUdNyQsX37dm3atEm//e1vVVRUpAsvvFArVqzQ2rVr9dFHHwX1uxBOAAAYABwOh1577TU988wzev755/XKK6+ooaHBp8/SpUuVl5enrVu36u677z7m/urq6pSSkqKCggJvW3FxsWJjY/XXv/41KN/hMMtMiOUOsQAA9K69vV2PPfaY1qxZo0suuUSS9OijjyorK8un38UXX6zbbrvthPbZ0tKi4cOH+7QNGjRIqampamlpCUzhR2GZMyfMOQEAoHe7du1Sd3e3CgsLvW3JyckaN26cT78vnwWJZJYJJwAAoH/8eUxKRkaG90F+hx06dEj79+9XRkZGoEvzQTgBAMDiRo8ercGDB/tcXWhtbdXf//73Pu9z0qRJOnDggOrr671tL774onp6elRUVNSveo/HMnNOAABA7xITE1VaWqo77rhDqampGj58uKqqqhQbG9vn592ceeaZ+va3v62ysjKtXLlS3d3dKi8v1/e+970j5rIEGuEEAIDjsMIdW5ctW6abb75ZM2bMUFJSku688041Nzcf8XRgf6xevVrl5eW65JJLFBsbq+985zv6zW9+E8Cqe2eZcMJqHQAAji4xMVGrV6/2vna73brnnnu89zPZvXu33/tMTU3VmjVrAlXiCbPMnBNW6wAAcHRbt27VH/7wB/3jH/9QQ0ODrrnmGknSrFmzwlyZ/ywTTgAAwLEdvslacXGx3G63XnnlFaWlpfXad9GiRTr55JN73UpKSkJcuS/LXNYBAABHd+655/qsrDmem2++WbNnz+71vSFDhgSqrD4hnAAAEIVSU1OVmpoa7jJ6xWUdAAAQUQgnAAAgolgmnDidTuXm5mrixInhLgUAAASRZcIJS4kBAIgOlgknAAAgOrBaBwCA41mQHOLjtYb2eBGGMycAAKBXCxcu1Pnnn6+hQ4cqJSUlZMclnAAAEIW6urpOqM93v/td/fCHPwxBRV8gnAAAMAC0t7frmmuu0UknnaTMzEz9+te/1pQpU/TTn/5UkpSTk6P77rtP1157rZKSkrwPBDyWe+65R7feeqvOPvvsIFfvKyzhJCcnR+ecc47y8/M1derUcJTQbzkVG5RTsSHcZQAAIElyOBx67bXX9Mwzz+j555/XK6+8ooaGBp8+h5+9s3XrVt19991hqvT4wjYh9vXXX9fJJ58crsMDADBgtLe367HHHtOaNWt0ySWXSJIeffRRZWVl+fS7+OKLddttt4WjRL9wWQcAAIvbtWuXuru7VVhY6G1LTk7WuHHjfPoVFBSEurQ+8Tuc1NbWaubMmcrKylJMTIzWr19/RB+n06mcnBwlJCSoqKhImzdv9nk/JiZGF110kSZOnKjVq1f3uXgAAHDiTjrppHCXcEL8Didut1t5eXlyOp29vr9u3To5HA5VVVWpoaFBeXl5mjZtmvbs2ePt8+qrr6q+vl7PPPOMFi1apL/97W99/wYAAES50aNHa/DgwT53UW9tbdXf//73MFbVd37POSkpKVFJSclR31+2bJnKyso0b948SdLKlSu1YcMGrVq1ShUVFZKk0047TZKUmZmp6dOnq6GhQeecc06v++vs7FRnZ6f3dVtbm78lAwAwoCUmJqq0tFR33HGHUlNTNXz4cFVVVSk2NlYxMTF93u8HH3yg/fv364MPPpDH41FjY6MkacyYMUGdNxrQCbFdXV2qr6/X/PnzvW2xsbEqLi5WXV2dpM/PvPT09CgxMVEdHR168cUXNXv27KPuc/HixbrnnnsCWSYAAP6xwB1bly1bpptvvlkzZsxQUlKS7rzzTjU3NyshIaHP+6ysrNRjjz3mfX3uuedKkl566SVNmTKlvyUfVUDDyb59++TxeJSenu7Tnp6erh07dkiSXC6XrrjiCkmSx+NRWVnZMZ80PH/+fDkcDu/rtrY2ZWdnB7LsgPjysuLdSy4NYyUAgGiUmJjoM4/T7Xbrnnvu8d7PZPfu3X7vs7q6WtXV1QGq8MSFfCnx6NGj9dZbb51wf5vNJpvNJqfTKafTKY/HE8TqAACwpq1bt2rHjh0qLCxUa2ur7r33XknSrFmzwlyZ/wK6lDgtLU1xcXFyuVw+7S6XSxkZGf3at91u17Zt23wm+wAAgC8cvslacXGx3G63XnnlFaWlpfXad9GiRTr55JN73Y41tzQUAnrmJD4+XhMmTFBNTY0uv/xySVJPT49qampUXl7er31z5gQAgKM799xzVV9ff8L9b7755qPO+RwyZEigyuoTv8NJR0eHdu7c6X3d1NSkxsZGpaamauTIkXI4HCotLVVBQYEKCwu1fPlyud1u7+qdvrLb7bLb7Wpra1NycogfXQ0AwACTmpqq1NTUcJfRK7/DyZYtW3yeh3N4smppaamqq6s1Z84c7d27V5WVlWppaVF+fr42bdp0xCRZf3HmBAAQKsaYcJdgSYEaN7/DyZQpU4578PLy8n5fxvkqzpwAAIItLi5O0ue3xgj3pQ0rOnjwoCRp8ODB/dpP2B78BwBApBk0aJCGDh2qvXv3avDgwYqN5RF0J8IYo4MHD2rPnj1KSUnxhry+skw44bIOACDYYmJilJmZqaamJr3//vvhLsdyUlJS+r06V7JQOOGyDgAgFOLj4/W1r31NXV1d4S7FUgYPHtzvMyaHWSacAAAQKrGxsf267Tv6xzIX05xOp3Jzc495q3sAAGB9lgkn3CEWAIDoYJlwAgAAogPhBAAARBTLhBPmnAAAEB0sE06YcwIAQHSwTDgBAADRgfucBMKCZO3+/5fD53y2Jry1AABgcZw5AQAAEYVwAgAAIoplwklErdZZkKzdCVeHuwoAAAYky4QTVusAABAdLBNOAABAdCCcAACAiEI4AQAAEYVwAgAAIgrhBAAARBTLhJOIWkp8gnIqNiinYkO4ywAAwFIsE05YSgwAQHSwTDgBAADRgXASLNxFFgCAPiGcAACAiEI4AQAAEYVwAgAAIkrYwsnBgwc1atQo3X777eEqAQAARKCwhZOFCxfqvPPOC9fhAQBAhApLOHnvvfe0Y8cOlZSUhOPwAAAggvkdTmprazVz5kxlZWUpJiZG69evP6KP0+lUTk6OEhISVFRUpM2bN/u8f/vtt2vx4sV9LhoAAAxcfocTt9utvLw8OZ3OXt9ft26dHA6Hqqqq1NDQoLy8PE2bNk179uyRJP3pT3/S2LFjNXbs2P5VDgAABqRB/n6gpKTkmJdjli1bprKyMs2bN0+StHLlSm3YsEGrVq1SRUWF3njjDa1du1ZPPPGEOjo61N3draSkJFVWVva6v87OTnV2dnpft7W1+VsyAACwkIDOOenq6lJ9fb2Ki4u/OEBsrIqLi1VXVydJWrx4sZqbm7V7924tXbpUZWVlRw0mh/snJyd7t+zs7ECWDAAAIkxAw8m+ffvk8XiUnp7u056enq6WlpY+7XP+/PlqbW31bs3NzYEoFQAARCi/L+sE0nXXXXfcPjabTTabTU6nU06nUx6PJ/iFAQCAsAnomZO0tDTFxcXJ5XL5tLtcLmVkZPRr33a7Xdu2bdObb77Zr/0AAIDIFtBwEh8frwkTJqimpsbb1tPTo5qaGk2aNKlf+3Y6ncrNzdXEiRP7WyYAAIhgfl/W6ejo0M6dO72vm5qa1NjYqNTUVI0cOVIOh0OlpaUqKChQYWGhli9fLrfb7V2901d2u112u11tbW1KTk7u174AAEDk8jucbNmyRVOnTvW+djgckqTS0lJVV1drzpw52rt3ryorK9XS0qL8/Hxt2rTpiEmy/mLOCQAA0cHvcDJlyhQZY47Zp7y8XOXl5X0uqjecOQEAIDqE7cF/AAAAvbFMOGFCLAAA0cEy4YSlxAAARAfLhBMAABAdLBNOuKwDAEB0sEw44bIOAADRIazP1okqC760/HlBa/jqAAAgwlnmzAkAAIgOlgknzDkBACA6WCacMOcEAIDoYJlwAgAAogPhBAAARBTCCQAAiCiEEwAAEFEsE05YrQMAQHSwTDhhtQ4AANGBO8SegJyKDd5/3r3k0jBWAgDAwGeZMycAACA6EE4AAEBEIZwAAICIQjgBAAARxTLhhKXEAABEB8uEE5YSAwAQHSwTTgaSLy9NBgAAvggnAAAgohBOAABARCGcAACAiEI4AQAAESXk4eTAgQMqKChQfn6+zjrrLD3yyCOhLgEAAESwkD/4LzExUbW1tRo6dKjcbrfOOussXXnllRo2bFioSwEAABEo5GdO4uLiNHToUElSZ2enjDEyxoS6DAAAEKH8Die1tbWaOXOmsrKyFBMTo/Xr1x/Rx+l0KicnRwkJCSoqKtLmzZt93j9w4IDy8vI0YsQI3XHHHUpLS+vzFwAAAAOL3+HE7XYrLy9PTqez1/fXrVsnh8OhqqoqNTQ0KC8vT9OmTdOePXu8fVJSUvTWW2+pqalJa9askcvl6vs3AAAAA4rf4aSkpET333+/rrjiil7fX7ZsmcrKyjRv3jzl5uZq5cqVGjp0qFatWnVE3/T0dOXl5emVV1456vE6OzvV1tbmswEAgIEroHNOurq6VF9fr+Li4i8OEBur4uJi1dXVSZJcLpfa29slSa2traqtrdW4ceOOus/FixcrOTnZu2VnZweyZAAAEGECGk727dsnj8ej9PR0n/b09HS1tLRIkt5//31NnjxZeXl5mjx5sn70ox/p7LPPPuo+58+fr9bWVu/W3NwcyJLDa2FmuCsAACDihHwpcWFhoRobG0+4v81mk81mk9PplNPplMfjCV5xAAAg7AJ65iQtLU1xcXFHTHB1uVzKyMjo177tdru2bdumN998s1/7AQAAkS2g4SQ+Pl4TJkxQTU2Nt62np0c1NTWaNGlSv/btdDqVm5uriRMn9rdMAAAQwfy+rNPR0aGdO3d6Xzc1NamxsVGpqakaOXKkHA6HSktLVVBQoMLCQi1fvlxut1vz5s3rV6F2u112u11tbW1KTk7u174AAEDk8jucbNmyRVOnTvW+djgckqTS0lJVV1drzpw52rt3ryorK9XS0qL8/Hxt2rTpiEmy/mLOCQAA0cHvcDJlypTj3m6+vLxc5eXlfS6qN5w5AQAgOoT82ToAAADHYplwwoRYAACig2XCCUuJAQCIDpYJJwAAIDpYJpxwWQcAgOhgmXDCZR0AAKKDZcIJAACIDoQTAAAQUSwTTphzAgBAdLBMOGHOCQAA0cEy4QQAAEQHwgkAAIgohBMAABBRCCcAACCiWCacsFoHAIDoYJlwwmodAACig2XCCQAAiA6EEwAAEFEIJwAAIKIQTgAAQEQhnAAAgIhimXDCUmIAAKKDZcIJS4kBAIgOlgknAAAgOhBOjmdBsnYnXB3uKgAAiBqEEwAAEFEIJwAAIKIQTgAAQEQhnAAAgIhCOAEAABFlULgL8JcxRpLU1tYWtGP0dB784hid5phtX37dW9ux+ri/1NbW1iaPxxO07wQAQDgd/t0+/Dt+LDHmRHpFkA8//FDZ2dnhLgMAAPRBc3OzRowYccw+lgsnPT09+uijj5SYmKiYmJiA77+trU3Z2dlqbm5WUlJSwPePzzHOocNYhwbjHBqMc+gEeqyNMWpvb1dWVpZiY489q8Ryl3ViY2OPm7gCISkpiT/8EGCcQ4exDg3GOTQY59AJ5FgnJyefUD8mxAIAgIhCOAEAABGFcPIVNptNVVVVstls4S5lQGOcQ4exDg3GOTQY59AJ51hbbkIsAAAY2DhzAgAAIgrhBAAARBTCCQAAiCiEEwAAEFEIJwAAIKJEZThxOp3KyclRQkKCioqKtHnz5mP2f+KJJ/T1r39dCQkJOvvss7Vx48YQVWpt/ozzI488osmTJ+uUU07RKaecouLi4uP+e8EX/P2bPmzt2rWKiYnR5ZdfHtwCBwh/x/nAgQOy2+3KzMyUzWbT2LFj+f+PE+DvOC9fvlzjxo3TkCFDlJ2drVtvvVWfffZZiKq1ptraWs2cOVNZWVmKiYnR+vXrj/uZl19+Wd/4xjdks9k0ZswYVVdXB69AE2XWrl1r4uPjzapVq8w777xjysrKTEpKinG5XL32f+2110xcXJz51a9+ZbZt22Z+8YtfmMGDB5u33347xJVbi7/jfPXVVxun02m2bt1qtm/fbq677jqTnJxsPvzwwxBXbj3+jvVhTU1N5rTTTjOTJ082s2bNCk2xFubvOHd2dpqCggIzffp08+qrr5qmpibz8ssvm8bGxhBXbi3+jvPq1auNzWYzq1evNk1NTeYvf/mLyczMNLfeemuIK7eWjRs3mrvuuss89dRTRpJ5+umnj9l/165dZujQocbhcJht27aZFStWmLi4OLNp06ag1Bd14aSwsNDY7Xbva4/HY7KysszixYt77T979mxz6aWX+rQVFRWZm266Kah1Wp2/4/xVhw4dMomJieaxxx4LVokDRl/G+tChQ+b88883v/3tb01paSnh5AT4O84PPfSQGT16tOnq6gpViQOCv+Nst9vNxRdf7NPmcDjMBRdcENQ6B5ITCSd33nmnGT9+vE/bnDlzzLRp04JSU1Rd1unq6lJ9fb2Ki4u9bbGxsSouLlZdXV2vn6mrq/PpL0nTpk07an/0bZy/6uDBg+ru7lZqamqwyhwQ+jrW9957r4YPH64bbrghFGVaXl/G+ZlnntGkSZNkt9uVnp6us846S4sWLZLH4wlV2ZbTl3E+//zzVV9f7730s2vXLm3cuFHTp08PSc3RItS/hZZ7KnF/7Nu3Tx6PR+np6T7t6enp2rFjR6+faWlp6bV/S0tL0Oq0ur6M81f97Gc/U1ZW1hH/Y4Cvvoz1q6++qt/97ndqbGwMQYUDQ1/GedeuXXrxxRd1zTXXaOPGjdq5c6duueUWdXd3q6qqKhRlW05fxvnqq6/Wvn37dOGFF8oYo0OHDunmm2/Wz3/+81CUHDWO9lvY1tamTz/9VEOGDAno8aLqzAmsYcmSJVq7dq2efvppJSQkhLucAaW9vV1z587VI488orS0tHCXM6D19PRo+PDhevjhhzVhwgTNmTNHd911l1auXBnu0gaUl19+WYsWLdKDDz6ohoYGPfXUU9qwYYPuu+++cJeGfoiqMydpaWmKi4uTy+XyaXe5XMrIyOj1MxkZGX71R9/G+bClS5dqyZIleuGFF3TOOecEs8wBwd+x/sc//qHdu3dr5syZ3raenh5J0qBBg/Tuu+/qjDPOCG7RFtSXv+nMzEwNHjxYcXFx3rYzzzxTLS0t6urqUnx8fFBrtqK+jPPdd9+tuXPn6gc/+IEk6eyzz5bb7daNN96ou+66S7Gx/Dd4IBzttzApKSngZ02kKDtzEh8frwkTJqimpsbb1tPTo5qaGk2aNKnXz0yaNMmnvyQ9//zzR+2Pvo2zJP3qV7/Sfffdp02bNqmgoCAUpVqev2P99a9/XW+//bYaGxu922WXXaapU6eqsbFR2dnZoSzfMvryN33BBRdo586d3vAnSX//+9+VmZlJMDmKvozzwYMHjwgghwOh4bm2ARPy38KgTLONYGvXrjU2m81UV1ebbdu2mRtvvNGkpKSYlpYWY4wxc+fONRUVFd7+r732mhk0aJBZunSp2b59u6mqqmIp8Qnwd5yXLFli4uPjzZNPPmk+/vhj79be3h6ur2AZ/o71V7Fa58T4O84ffPCBSUxMNOXl5ebdd981zz77rBk+fLi5//77w/UVLMHfca6qqjKJiYnmD3/4g9m1a5d57rnnzBlnnGFmz54drq9gCe3t7Wbr1q1m69atRpJZtmyZ2bp1q3n//feNMcZUVFSYuXPnevsfXkp8xx13mO3btxun08lS4kBbsWKFGTlypImPjzeFhYXmjTfe8L530UUXmdLSUp/+jz/+uBk7dqyJj48348ePNxs2bAhxxdbkzziPGjXKSDpiq6qqCn3hFuTv3/SXEU5OnL/j/Prrr5uioiJjs9nM6NGjzcKFC82hQ4dCXLX1+DPO3d3dZsGCBeaMM84wCQkJJjs729xyyy3mk08+CX3hFvLSSy/1+v+5h8e2tLTUXHTRRUd8Jj8/38THx5vRo0ebRx99NGj1xRjDeS8AABA5omrOCQAAiHyEEwAAEFEIJwAAIKIQTgAAQEQhnAAAgIhCOAEAABGFcAIAACIK4QQAAEQUwgkAAIgohBMAABBRCCcAACCi/H+xcsHU4qfmbgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1238\n", "item counter : 1547\n", "ratio : 0.7997416020671835\n", " ratio number predicted/items: 0.23772609819121446\n", "current epoch: 3\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1246\n", "item counter : 1246\n", "ratio : 0.9991980753809142\n", " ratio number predicted/items: 0.0\n", "current epoch: 4\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGzCAYAAAD0T7cVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA46ElEQVR4nO3de3hU1b3/8U8SyAQwF0IkFwlGoNCCmrTERBB+AqaloIi2Flo5GNAGLUlbHS8NtRJQbq0cyhFHeaTF0B4sqAXqEUrVKA+KsUggHg43pQSNxRmgQG5oEibr94dldCRcJkxm9mTer+fZj9lr1uz9nWVgPuy99t4RxhgjAAAAi4gMdgEAAABfRjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBEFSlpaWKiIjQtm3bgl0KAIsgnAAAAEshnAAAAEshnAAAAEshnABoFx9++KGmT5+uAQMGqEuXLurRo4d+8IMf6ODBg632P3nypO6++2716NFDcXFxuuOOO3T8+HGvPtu2bdPo0aOVlJSkLl266IorrtCdd94ZgE8DIJA6BbsAAB3Tu+++q7fffls//OEP1atXLx08eFBPP/20RowYod27d6tr165e/YuKipSQkKBZs2Zp3759evrpp/Xhhx9q06ZNioiI0OHDh/Wd73xHl156qYqLi5WQkKCDBw9qzZo1QfqEANoL4QRAu7jxxht12223ebWNGzdOQ4YM0Z///GdNnjzZ67Xo6GiVlZWpc+fOkqTLL79cDz30kP7nf/5HN998s95++20dP35cr7zyirKzsz3vmzNnTvt/GAABxWkdAO2iS5cunp+bm5v1r3/9S/369VNCQoK2b99+Rv9p06Z5gokk/eQnP1GnTp20YcMGSVJCQoIk6eWXX1Zzc3P7Fg8gqAgnANrFp59+qpkzZyo9PV02m01JSUm69NJLdeLECdXU1JzR/2tf+5rX+iWXXKLU1FTPHJXrr79e3//+9zV79mwlJSVp/PjxevbZZ9XY2BiIjwMggAgnANrFT3/6U82dO1cTJkzQ888/r1deeUWvvvqqevTooZaWFp+3FxERoRdffFHl5eUqKirSP//5T915550aPHiw6uvr2+ETAAgWwgmAdvHiiy8qPz9f//mf/6nbbrtN3/72tzVs2DCdOHGi1f4ffPCB13p9fb0++eQTZWRkeLVfe+21mjt3rrZt26aVK1dq165dWrVqVTt9CgDBQDgB0C6ioqJkjPFqW7Jkidxud6v9n3nmGa+5JE8//bROnTqlMWPGSJKOHz9+xvaysrIkiVM7QAfD1ToA2sVNN92kP/7xj4qPj9fAgQNVXl6u1157TT169Gi1f1NTk2644QZNmDBB+/bt01NPPaVhw4bp5ptvliStWLFCTz31lG699Vb17dtXdXV1WrZsmeLi4jR27NhAfjQA7YxwAqBd/Nd//ZeioqK0cuVKffbZZ7ruuuv02muvafTo0a32f/LJJ7Vy5UrNnDlTzc3N+tGPfqQnnnhCERERkj6fELt161atWrVKLpdL8fHxysnJ0cqVK3XFFVcE8qMBaGcR5qvHSQEAAIKIOScAAMBSCCcAAMBSCCcAAMBSgjIhNiMjQ3FxcYqMjFT37t31xhtvBKMMAABgQUG7Wuftt9/WJZdcEqzdAwAAi+K0DgAAsBSfLyXevHmzHn/8cVVUVOiTTz7R2rVrdcstt3j1cTgcevzxx+V0OpWZmaklS5YoJyfH8/oVV1yhxMRERUZG6t5779WkSZMueP8tLS06dOiQYmNjPfc/AAAA1maMUV1dndLS0hQZeZ5jI8ZHGzZsMA8//LBZs2aNkWTWrl3r9fqqVatMdHS0Wb58udm1a5cpKCgwCQkJxuVyefp8/PHHxhhjDh06ZAYOHGjee++9s+7vs88+MzU1NZ5l9+7dRhILCwsLCwtLCC7V1dXnzRoXdRO2iIiIM46c5Obm6pprrtGTTz4p6fMjHenp6frpT3+q4uLiM7bx4IMPatCgQZoyZUqr+5g1a5Zmz559Rnt1dbXi4uLaWnpIamhoUFpamiTp0KFD6tatW5ArAgDgwtTW1io9PV0nTpxQfHz8Ofv6dUJsU1OTKioqNGPGDE9bZGSk8vLyVF5eLunzL9iWlhbFxsaqvr5er7/+uiZMmHDWbc6YMUN2u92zfvrDxcXFhV04iYqK8vwcFxdHOAEAhJwLmZLh13By9OhRud1uJScne7UnJydr7969kiSXy6Vbb71VkuR2u1VQUKBrrrnmrNu02Wyy2WxyOBxyOBxnfaIpAADoGAJ+KXGfPn303nvv+fy+wsJCFRYWqra29ryHgwAAQOjy66XESUlJioqKksvl8mp3uVxKSUm5qG07HA4NHDjwnEdZAABA6PNrOImOjtbgwYNVVlbmaWtpaVFZWZmGDBlyUdsuLCzU7t279e67715smQAAwMJ8Pq1TX1+v/fv3e9arqqpUWVmpxMRE9e7dW3a7Xfn5+crOzlZOTo4WL16shoYGTZ069aIKDdqck1n/PoU0qyaw+wUAIEz5fCnxpk2bNHLkyDPa8/PzVVpaKkl68sknPTdhy8rK0hNPPKHc3Fy/FHx6zklNTU1grtaxUDhpaGjw3PK/vr6eq3UAACHDl+/vi7rPSSB9+cjJ+++/H9xwEqTAQjgBAIQqX8JJyDxbhzknAACEh5AJJwAAIDyETDgJ5KXEGcXrlVG8vt33AwAAzhQy4YTTOgAAhIeQCScAACA8hEw44Q6xAACEh4A/W6etLP1snVlfqscC90MBACCUhcyREwAAEB4IJwAAwFJCJpww5wQAgPAQMuEk2JcSc+8TAAACI2TCCQAACA+EEwAAYCmEEwAAYCmEEwAAYCkhE064WgcAgPAQMuEk2Ffr+GxWvPedYwEAwAUJmXACAADCA+EEAABYCuHkq2bF62DM7RfUlZuyAQDgf0ELJydPntTll1+uBx54IFglAAAACwpaOJk7d66uvfbaYO0eAABYVFDCyQcffKC9e/dqzJgxwdg9AACwMJ/DyebNmzVu3DilpaUpIiJC69atO6OPw+FQRkaGYmJilJubq61bt3q9/sADD2j+/PltLhoAAHRcPoeThoYGZWZmyuFwtPr66tWrZbfbVVJSou3btyszM1OjR4/W4cOHJUl/+ctf1L9/f/Xv3/+C9tfY2Kja2lqvBQAAdFydfH3DmDFjznk6ZtGiRSooKNDUqVMlSUuXLtX69eu1fPlyFRcX65133tGqVav0wgsvqL6+Xs3NzYqLi9PMmTNb3d78+fM1e/ZsX8sEAAAhyq9zTpqamlRRUaG8vLwvdhAZqby8PJWXl0v6PGxUV1fr4MGDWrhwoQoKCs4aTCRpxowZqqmp8SzV1dX+LBkAAFiMX8PJ0aNH5Xa7lZyc7NWenJwsp9PZpm3abDbFxcXpj3/8o6699lrdcMMN/igVAABYlM+ndfxpypQpwdw9AACwIL8eOUlKSlJUVJRcLpdXu8vlUkpKykVtO+Qe/AcAANrEr+EkOjpagwcPVllZmaetpaVFZWVlGjJkyEVt2+FwaODAgbrmmmsutkwAAGBhPoeT+vp6VVZWqrKyUpJUVVWlyspKffTRR5Iku92uZcuWacWKFdqzZ49+8pOfqKGhwXP1TluFypETnrcDAMDF8XnOybZt2zRy5EjPut1ulyTl5+ertLRUEydO1JEjRzRz5kw5nU5lZWVp48aNZ0ySBQAAaI3P4WTEiBEyxpyzT1FRkYqKitpcVGscDoccDofcbrdftxsws+K/9HNN8OoAAMDigvbgP1+FymkdAABwcUImnDAhFgCA8BAy4YQjJwAAhIeQCScAACA8EE4AAIClhEw4Yc4JAADhIWTCCXNOAAAIDyETTgAAQHggnAAAAEsJmXDCnBMAAMJDyIQT5pwAABAeQiacAACA8EA4aWcZxeuDXQIAACGFcAIAACyFcAIAACwlZMIJV+sAABAeQiaccLUOAADhIWTCCQAACA+EEwAAYCkBDycnTpxQdna2srKydOWVV2rZsmWBLgEAAFhYp0DvMDY2Vps3b1bXrl3V0NCgK6+8Ut/73vfUo0ePQJcSfLPi//3fmuDWAQCAhQT8yElUVJS6du0qSWpsbJQxRsaYQJcBAAAsyudwsnnzZo0bN05paWmKiIjQunXrzujjcDiUkZGhmJgY5ebmauvWrV6vnzhxQpmZmerVq5cefPBBJSUltfkDAACAjsXncNLQ0KDMzEw5HI5WX1+9erXsdrtKSkq0fft2ZWZmavTo0Tp8+LCnT0JCgt577z1VVVXpueeek8vlavsnAAAAHYrP4WTMmDGaM2eObr311lZfX7RokQoKCjR16lQNHDhQS5cuVdeuXbV8+fIz+iYnJyszM1NvvvnmWffX2Nio2tparwUAAHRcfp1z0tTUpIqKCuXl5X2xg8hI5eXlqby8XJLkcrlUV1cnSaqpqdHmzZs1YMCAs25z/vz5io+P9yzp6en+LBkAAFiMX8PJ0aNH5Xa7lZyc7NWenJwsp9MpSfrwww81fPhwZWZmavjw4frpT3+qq6666qzbnDFjhmpqarRw4UINGDBA/fr182fJAADAYgJ+KXFOTo4qKysvuL/NZpPNZtP999+v+++/X7W1tYqPj2+/AgEAQFD59chJUlKSoqKizpjg6nK5lJKSclHb5sF/AACEB7+Gk+joaA0ePFhlZWWetpaWFpWVlWnIkCEXtW0e/AcAQHjw+bROfX299u/f71mvqqpSZWWlEhMT1bt3b9ntduXn5ys7O1s5OTlavHixGhoaNHXq1Isq1OFwyOFwyO12X9R2AACAtfkcTrZt26aRI0d61u12uyQpPz9fpaWlmjhxoo4cOaKZM2fK6XQqKytLGzduPGOSrK8KCwtVWFjInBMAADo4n8PJiBEjznu7+aKiIhUVFbW5qNZw5AQAgPAQ8GfrtBVzTgAACA8hE04AAEB4CJlw0pEuJc4oXh/sEgAAsKyQCSec1gEAIDyETDgBAADhIWTCSUc6rQMAAM4uZMIJp3UAAAgPIRNOAABAeCCcAAAASyGcAAAASwmZcMKEWAAAwkPIhBMmxAIAEB5CJpwAAIDwQDixmlnxny8AAIQpwgkAALAUwgkAALCUkAknXK0DAEB4CJlwwtU6AACEh5AJJwAAIDwQTgAAgKUEPJxUV1drxIgRGjhwoK6++mq98MILgS4BAABYWKeA77BTJy1evFhZWVlyOp0aPHiwxo4dq27dugW6FAAAYEEBDyepqalKTU2VJKWkpCgpKUnHjh0jnAAAAEltOK2zefNmjRs3TmlpaYqIiNC6devO6ONwOJSRkaGYmBjl5uZq69atrW6roqJCbrdb6enpPhcOAAA6Jp/DSUNDgzIzM+VwOFp9ffXq1bLb7SopKdH27duVmZmp0aNH6/Dhw179jh07pjvuuEPPPPNM2yoHAAAdks+ndcaMGaMxY8ac9fVFixapoKBAU6dOlSQtXbpU69ev1/Lly1VcXCxJamxs1C233KLi4mINHTr0nPtrbGxUY2OjZ722ttbXkgEAQAjx69U6TU1NqqioUF5e3hc7iIxUXl6eysvLJUnGGE2ZMkWjRo3S5MmTz7vN+fPnKz4+3rNwCggAgI7Nr+Hk6NGjcrvdSk5O9mpPTk6W0+mUJG3ZskWrV6/WunXrlJWVpaysLO3cufOs25wxY4Zqamq0cOFCDRgwQP369fNnyQAAwGICfrXOsGHD1NLScsH9bTabbDab7r//ft1///2qra1VfHx8O1YIAACCya9HTpKSkhQVFSWXy+XV7nK5lJKSclHb7sgP/ssoXh/sEgAAsAy/hpPo6GgNHjxYZWVlnraWlhaVlZVpyJAhF7VtHvwHAEB48Pm0Tn19vfbv3+9Zr6qqUmVlpRITE9W7d2/Z7Xbl5+crOztbOTk5Wrx4sRoaGjxX77SVw+GQw+GQ2+2+qO0AAABr8zmcbNu2TSNHjvSs2+12SVJ+fr5KS0s1ceJEHTlyRDNnzpTT6VRWVpY2btx4xiRZXxUWFqqwsJA5JwAAdHA+h5MRI0bIGHPOPkVFRSoqKmpzUa3hyAkAAOEh4E8lbivmnAAAEB5CJpwAAIDwEDLhpCNfSgwAAL4QMuGE0zoAAISHkAknAAAgPIRMOOG0DgAA4SFkwgmndQAACA8hE04AAEB4IJwAAABLCZlwwpwTAADCQ8iEk7CdczIr/vMFAIAwETLhBAAAhAfCCQAAsBTCCQAAsBTCCQAAsJSQCSdcrQMAQHgImXAStlfrAAAQZkImnAAAgPBAOAEAAJZCOAEAAJYSlHBy6623qnv37rrtttuCsXsAAGBhQQknP//5z/WHP/whGLsGAAAWF5RwMmLECMXGxgZj1wAAwOJ8DiebN2/WuHHjlJaWpoiICK1bt+6MPg6HQxkZGYqJiVFubq62bt3qj1oBAEAY8DmcNDQ0KDMzUw6Ho9XXV69eLbvdrpKSEm3fvl2ZmZkaPXq0Dh8+3KYCGxsbVVtb67UAAICOy+dwMmbMGM2ZM0e33nprq68vWrRIBQUFmjp1qgYOHKilS5eqa9euWr58eZsKnD9/vuLj4z1Lenp6m7YDAABCg1/nnDQ1NamiokJ5eXlf7CAyUnl5eSovL2/TNmfMmKGamhrPUl1d7a9yAQCABfk1nBw9elRut1vJycle7cnJyXI6nZ71vLw8/eAHP9CGDRvUq1evcwYXm82muLg4/fGPf9S1116rG264wZ8lW1ZG8fpglwAAQFB0CsZOX3vtNZ/fU1hYqMLCQtXW1io+Pr4dqgIAAFbg1yMnSUlJioqKksvl8mp3uVxKSUm5qG3zVGIAAMKDX8NJdHS0Bg8erLKyMk9bS0uLysrKNGTIkIvaNk8lBgAgPPh8Wqe+vl779+/3rFdVVamyslKJiYnq3bu37Ha78vPzlZ2drZycHC1evFgNDQ2aOnXqRRXqcDjkcDjkdrsvajsAAMDafA4n27Zt08iRIz3rdrtdkpSfn6/S0lJNnDhRR44c0cyZM+V0OpWVlaWNGzeeMUnWV8w5AQAgPPgcTkaMGCFjzDn7FBUVqaioqM1FtYYjJwAAhIegPFunLZhzAgBAeAiZcAIAAMJDyIQTLiUGACA8hEw44bQOAADhIWTCCQAACA8hE044rQMAQHgImXDCaR0AAMJDyIQTAAAQHggnAADAUkImnDDnBACA8BAy4YQ5JwAAhIeQCScAACA8EE4AAIClEE4AAIClEE4AAIClhEw44Wqdr5ibGuwKAABoFyETTrhaBwCA8BAy4QQAAIQHwgkAALAUwgkAALAUwgkAALAUwgkAALCUTsEuwFfGGElSbW1t++yg8fPttzSe/HwfX1r37Pcsfc72vgvuc479q7ZWDQ0Nnm3UNhq522sMAADws9Pfc6e/x88lwlxILwv5+OOPlZ6eHuwyAABAG1RXV6tXr17n7BNy4aSlpUWHDh1SbGysIiIi/L792tpapaenq7q6WnFxcX7fPj7HOAcOYx0YjHNgMM6B4++xNsaorq5OaWlpiow896ySkDutExkZed7E5Q9xcXH84gcA4xw4jHVgMM6BwTgHjj/HOj4+/oL6MSEWAABYCuEEAABYCuHkK2w2m0pKSmSz2YJdSofGOAcOYx0YjHNgMM6BE8yxDrkJsQAAoGPjyAkAALAUwgkAALAUwgkAALAUwgkAALCUsAwnDodDGRkZiomJUW5urrZu3XrO/i+88IK+/vWvKyYmRldddZU2bNgQoEpDmy/jvGzZMg0fPlzdu3dX9+7dlZeXd97/L/iCr7/Tp61atUoRERG65ZZb2rfADsLXcT5x4oQKCwuVmpoqm82m/v378/fHBfB1nBcvXqwBAwaoS5cuSk9P13333afPPvssQNWGps2bN2vcuHFKS0tTRESE1q1bd973bNq0Sd/61rdks9nUr18/lZaWtl+BJsysWrXKREdHm+XLl5tdu3aZgoICk5CQYFwuV6v9t2zZYqKiosxvfvMbs3v3bvOrX/3KdO7c2ezcuTPAlYcWX8f59ttvNw6Hw+zYscPs2bPHTJkyxcTHx5uPP/44wJWHHl/H+rSqqipz2WWXmeHDh5vx48cHptgQ5us4NzY2muzsbDN27Fjz1ltvmaqqKrNp0yZTWVkZ4MpDi6/jvHLlSmOz2czKlStNVVWV+dvf/mZSU1PNfffdF+DKQ8uGDRvMww8/bNasWWMkmbVr156z/4EDB0zXrl2N3W43u3fvNkuWLDFRUVFm48aN7VJf2IWTnJwcU1hY6Fl3u90mLS3NzJ8/v9X+EyZMMDfeeKNXW25urrn77rvbtc5Q5+s4f9WpU6dMbGysWbFiRXuV2GG0ZaxPnTplhg4dan73u9+Z/Px8wskF8HWcn376adOnTx/T1NQUqBI7BF/HubCw0IwaNcqrzW63m+uuu65d6+xILiScPPTQQ2bQoEFebRMnTjSjR49ul5rC6rROU1OTKioqlJeX52mLjIxUXl6eysvLW31PeXm5V39JGj169Fn7o23j/FUnT55Uc3OzEhMT26vMDqGtY/3oo4+qZ8+euuuuuwJRZshryzi/9NJLGjJkiAoLC5WcnKwrr7xS8+bNk9vtDlTZIact4zx06FBVVFR4Tv0cOHBAGzZs0NixYwNSc7gI9HdhyD3472IcPXpUbrdbycnJXu3Jycnau3dvq+9xOp2t9nc6ne1WZ6hryzh/1S9+8QulpaWd8YcB3toy1m+99ZZ+//vfq7KyMgAVXriWlhY1NTUpJiYm2KWcoS3jfODAAb3++uuaNGmSNmzYoP3792v69Olqbm5WSUlJIMoOOW0Z59tvv11Hjx7VsGHDZIzRqVOndM899+iXv/xlIEoOG2f7LqytrdWnn36qLl26+HV/YXXkBKFhwYIFWrVqldauXWvJL6pQVldXp8mTJ2vZsmVKSkpql33MmjVLERER2rt3ryZMmKC4uDj16NFDP//5z70mKUZERKioqEgrV67UoEGDZLPZtHHjRknSP//5T915551KTk6WzWbToEGDtHz58jP2tWTJEg0aNEhdu3ZV9+7dlZ2dreeee65dPpevWlpa1LNnTz3zzDMaPHiwJk6cqIcfflhLly4NdmkdyqZNmzRv3jw99dRT2r59u9asWaP169frscceC3ZpuAhhdeQkKSlJUVFRcrlcXu0ul0spKSmtviclJcWn/mjbOJ+2cOFCLViwQK+99pquvvrq9iyzQ/B1rP/xj3/o4MGDGjdunKetpaVFktSpUyft27dPffv29UttEyZMUEZGhubPn6933nlHTzzxhI4fP64//OEPnj6vv/66nn/+eRUVFSkpKUkZGRlyuVy69tprPeHl0ksv1V//+lfdddddqq2t1b333ivp8yu8fvazn+m2227zBJ///d//1d///nfdfvvtfvkMp7Xldzo1NVWdO3dWVFSUp+0b3/iGnE6nmpqaFB0d7dcaO4K2jPMjjzyiyZMn68c//rEk6aqrrlJDQ4OmTZumhx9+WJGR/BvcH872XRgXF+f3oyaSwu9qnZycHFNUVORZd7vd5rLLLjvnhNibbrrJq23IkCFMiD0PX8fZGGN+/etfm7i4OFNeXh6IEjsMX8b6008/NTt37vRaxo8fb0aNGmV27txpGhsbL7qekpISI8ncfPPNXu3Tp083ksx7771njPl8El5kZKTZtWuXV7+77rrLpKammqNHj3q1//CHPzTx8fHm5MmTxhhjxo8ff8YEvfbk6+/0jBkzzOWXX27cbrenbfHixSY1NbXdaw1lvo7zt771LfPQQw95tT333HOmS5cu5tSpU+1aa0ehC5wQe+WVV3q1/ehHP2q3CbFhF05WrVplbDabKS0tNbt37zbTpk0zCQkJxul0GmOMmTx5sikuLvb037Jli+nUqZNZuHCh2bNnjykpKeFS4gvg6zgvWLDAREdHmxdffNF88sknnqWuri5YHyFk+DrWX+Xvq3VOh5O//e1vXu179uwxkjxfMpLMyJEjvfq0tLSYhIQEM23aNHPkyBGv5dlnnzWSzFtvveWpOz4+3mzdutVvtZ+Lr+P80UcfmdjYWFNUVGT27dtnXn75ZdOzZ08zZ86cgNQbqnwd55KSEhMbG2v+9Kc/mQMHDphXXnnF9O3b10yYMCFYHyEk1NXVmR07dpgdO3YYSWbRokVmx44d5sMPPzTGGFNcXGwmT57s6X/6UuIHH3zQ7NmzxzgcDi4l9rclS5aY3r17m+joaJOTk2Peeecdz2vXX3+9yc/P9+r//PPPm/79+5vo6GgzaNAgs379+gBXHJp8GefLL7/cSDpjKSkpCXzhIcjX3+kva69wcuDAAa/2pqYmExkZ6TnqKMnceeedXn1cLlervwdfXtasWWOMMWb37t3msssuM5JMv379zPTp0z3Bpb34Os5vv/22yc3NNTabzfTp08fMnTuXf81fAF/Gubm52cyaNcv07dvXxMTEmPT0dDN9+nRz/PjxwBceQt54441W/3ydHtv8/Hxz/fXXn/GerKwsEx0dbfr06WOeffbZdqsvwhhj/H+yCEC4mjVrlmbPnq0DBw7oiiuu8LSfOnVKNptNBQUFWrp0qSIiIlRYWKgnn3zS08fpdCo1NVX/8R//ofz8/Fa3f/XVV6tnz56SpIaGBr388svauHGj/vrXv8rlcmnmzJmaPXt2+35IAO0qrCbEAgicDz74wCuc7N+/Xy0tLcrIyDjrey699FLFxsbK7XZf0GXk3bp108SJEzVx4kQ1NTXpe9/7nubOnasZM2ZwpRcQwpjGDKBdOBwOr/UlS5ZIksaMGXPW90RFRen73/++/vznP+v//u//znj9yJEjnp//9a9/eb0WHR2tgQMHyhij5ubmiykdQJBx5ARAu6iqqtLNN9+s7373uyovL9d///d/6/bbb1dmZuY537dgwQK98cYbys3NVUFBgQYOHKhjx45p+/bteu2113Ts2DFJ0ne+8x2lpKTouuuuU3Jysvbs2aMnn3xSN954o2JjYwPxEQG0E8IJgHaxevVqzZw5U8XFxerUqZOKior0+OOPn/d9ycnJ2rp1qx599FGtWbNGTz31lHr06KFBgwbp17/+taff3XffrZUrV2rRokWqr69Xr1699LOf/Uy/+tWv2vNjAQgAJsQC8KvTE2KPHDnSbnehBdCxMecEAABYCuEEAABYSlDCSVVVlUaOHKmBAwd6noMAAAAgBWnOyfXXX685c+Zo+PDhOnbsmOLi4tSpE3NzAQBAEK7W2bVrlzp37qzhw4dLkhITEwNdAgAAsDCfw8nmzZv1+OOPq6KiQp988onWrl2rW265xauPw+HQ448/LqfTqczMTC1ZskQ5OTmSPr9r5CWXXKJx48bpn//8p2677Tb98pe/vOD9t7S06NChQ4qNjVVERISv5QMAgCAwxqiurk5paWmKjDz3rBKfw0lDQ4MyMzN155136nvf+94Zr69evVp2u11Lly5Vbm6uFi9erNGjR2vfvn3q2bOnTp06pTfffFOVlZXq2bOnvvvd7+qaa67Rt7/97Qva/6FDh5Senu5r2QAAwAKqq6vVq1evc/bxOZyMGTPmnLefXrRokQoKCjR16lRJ0tKlS7V+/XotX75cxcXFuuyyy5Sdne0JGGPHjlVlZeVZw0ljY6MaGxs966enyFRXVysuLs7X8i2loaFBaWlpkj4PXd26dQtyRQAAtI/a2lqlp6df0B2c/TrnpKmpSRUVFZoxY4anLTIyUnl5eSovL5ckXXPNNTp8+LCOHz+u+Ph4bd68WXffffdZtzl//vxWnzAaFxcX8uEkKirK83NcXBzhBADQ4V3IlAy/Xkp89OhRud1uJScne7UnJyfL6XRKkjp16qR58+bp//2//6err75aX/va13TTTTeddZszZsxQTU2NZ6murvZnyQAAwGKCcv3u+U4NfZnNZpPNZmvnigAAgFX49chJUlKSoqKi5HK5vNpdLpdSUlL8uSsAANBB+fXISXR0tAYPHqyysjLP5cUtLS0qKytTUVGRP3cFAEC7aWlpUVNTU7DLCCmdO3f2mkt5MXwOJ/X19dq/f79nvaqqSpWVlUpMTFTv3r1lt9uVn5+v7Oxs5eTkaPHixWpoaPBcvQMAgJU1NTWpqqpKLS0twS4l5CQkJCglJeWi70PmczjZtm2bRo4c6Vm32+2SpPz8fJWWlmrixIk6cuSIZs6cKafTqaysLG3cuPGMSbJWllG8XpJ0cMGNQa4EABBIxhh98sknioqKUnp6+nlvFobPGWN08uRJHT58WJKUmpp6UdvzOZyMGDFC53scT1FREadxAAAh59SpUzp58qTS0tLUtWvXYJcTUrp06SJJOnz4sHr27HlRp3iIhAAA/Jvb7Zb0+RxK+O50oGtubr6o7RBOAAD4Cp7d1jb+GjfCCQAAsBTCCQAAsJSg3CEWAIBQcvoqzkAJ96tFOXICAABadezYMU2aNElxcXFKSEjQXXfdpfr6+nbfL+EEAIAwdCF3wJ00aZJ27dqlV199VS+//LI2b96sadOmtXtthBMAADqAuro6TZo0Sd26dVNqaqp++9vfasSIEbr33nslSRkZGXrsscd0xx13KC4u7rwhY8+ePdq4caN+97vfKTc3V8OGDdOSJUu0atUqHTp0qF0/C+EEAIAOwG63a8uWLXrppZf06quv6s0339T27du9+ixcuFCZmZnasWOHHnnkkXNur7y8XAkJCcrOzva05eXlKTIyUn//+9/b5TOcxoRYAABCXF1dnVasWKHnnntON9xwgyTp2WefVVpamle/UaNG6f7777+gbTqdTvXs2dOrrVOnTkpMTJTT6fRP4WfBkRMAAELcgQMH1NzcrJycHE9bfHy8BgwY4NXvy0dBrIxwAgBAmOjWrdsF901JSfE8yO+0U6dO6dixY0pJSfF3aV4IJwAAhLg+ffqoc+fOevfddz1tNTU1ev/999u8zSFDhujEiROqqKjwtL3++utqaWlRbm7uRdV7Psw5AQAgxMXGxio/P18PPvigEhMT1bNnT5WUlCgyMrLNz7v5xje+oe9+97sqKCjQ0qVL1dzcrKKiIv3whz88Yy6LvxFOAAA4j1C4Y+uiRYt0zz336KabblJcXJweeughVVdXKyYmps3bXLlypYqKinTDDTcoMjJS3//+9/XEE0/4serWEU4AAOgAYmNjtXLlSs96Q0ODZs+e7bmfycGDB33eZmJiop577jl/lXjBCCcAAHQAO3bs0N69e5WTk6Oamho9+uijkqTx48cHuTLfMSEWAIAO4vRN1vLy8tTQ0KA333xTSUlJrfadN2+eLrnkklaXMWPGBLhybxw5uQBffhplKJx3BACEn29+85teV9aczz333KMJEya0+lqXLl38VVabEE4AAAhDiYmJSkxMDHYZreK0DgAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBSu1gEA4HxmxQd4fzWB3Z/FcOQEAAC0au7cuRo6dKi6du2qhISEgO2XcAIAQBhqamq6oD4/+MEP9JOf/CQAFX2BcAIAQAdQV1enSZMmqVu3bkpNTdVvf/tbjRgxQvfee68kKSMjQ4899pjuuOMOxcXFeR4IeC6zZ8/Wfffdp6uuuqqdq/dGOAEAoAOw2+3asmWLXnrpJb366qt68803tX37dq8+p5+9s2PHDj3yyCNBqvT8mBALAECIq6ur04oVK/Tcc8/phhtukCQ9++yzSktL8+o3atQo3X///cEo0SccOQEAIMQdOHBAzc3NysnJ8bTFx8drwIABXv2ys7MDXVqbEE4AAAgT3bp1C3YJF4RwAgBAiOvTp486d+6sd99919NWU1Oj999/P4hVtR1zTgAACHGxsbHKz8/Xgw8+qMTERPXs2VMlJSWKjIxUREREm7f70Ucf6dixY/roo4/kdrtVWVkpSerXr58uueQSP1V/JsJJG2UUr5ckHVxwY5ArAQC0uxC4Y+uiRYt0zz336KabblJcXJweeughVVdXKyYmps3bnDlzplasWOFZ/+Y3vylJeuONNzRixIiLLfmsCCfnMyteB2OkjM+eC3YlAACcVWxsrFauXOlZb2ho0OzZsz33Mzl48KDP2ywtLVVpaamfKrxwhBMAADqAHTt2aO/evcrJyVFNTY0effRRSdL48eODXJnvmBALAEAHcfoma3l5eWpoaNCbb76ppKSkVvvOmzdPl1xySavLmDFjAly5N46cAADQAXzzm99URUXFBfe/5557NGHChFZf69Kli7/KahPCCQAAYSgxMVGJiYnBLqNVnNYBAOArjDHBLiEk+WvcCCcAAPxbVFSUJKmpqSnIlYSmkydPSpI6d+58UdvhtE5bcHkxAHRInTp1UteuXXXkyBF17txZkZH8G/5CGGN08uRJHT58WAkJCZ6Q11aEEwAA/i0iIkKpqamqqqrShx9+GOxyQk5CQoJSUlIuejuEEwAAviQ6Olpf+9rXOLXjo86dO1/0EZPTCCcAAHxFZGTkRd32HRcnaCfTTp48qcsvv1wPPPBAsEoAAAAWFLRwMnfuXF177bXB2j0AALCooISTDz74QHv37g367XEBAID1+BxONm/erHHjxiktLU0RERFat27dGX0cDocyMjIUExOj3Nxcbd261ev1Bx54QPPnz29z0QAAoOPyOZw0NDQoMzNTDoej1ddXr14tu92ukpISbd++XZmZmRo9erQOHz4sSfrLX/6i/v37q3///hdXOQAA6JB8vlpnzJgx5zwds2jRIhUUFGjq1KmSpKVLl2r9+vVavny5iouL9c4772jVqlV64YUXVF9fr+bmZsXFxWnmzJmtbq+xsVGNjY2e9draWl9LBgAAIcSvc06amppUUVGhvLy8L3YQGam8vDyVl5dLkubPn6/q6modPHhQCxcuVEFBwVmDyen+8fHxniU9Pd2fJfvHrHjPklG8PtjVAAAQ0vwaTo4ePSq3263k5GSv9uTkZDmdzjZtc8aMGaqpqfEs1dXV/igVAABYVFBvwjZlypTz9rHZbLLZbO1fDAAAsAS/HjlJSkpSVFSUXC6XV7vL5fLLvfYBAEDH59dwEh0drcGDB6usrMzT1tLSorKyMg0ZMsSfuwIAAB2Uz6d16uvrtX//fs96VVWVKisrlZiYqN69e8tutys/P1/Z2dnKycnR4sWL1dDQ4Ll6BwAA4Fx8Difbtm3TyJEjPet2u12SlJ+fr9LSUk2cOFFHjhzRzJkz5XQ6lZWVpY0bN54xSRYAAKA1PoeTESNGyBhzzj5FRUUqKipqc1EAACB8Be3BfwAAAK0hnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnHzVrHgdjLk92FUAABC2CCcAAMBSCCcAAMBSOgW7gLAxK/5LP9cErw4AACyOIyftZVa8dyABAAAXhHACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXDSzjKK1we7BAAAQgrhBAAAWArhBAAAWArhBAAAWErAw0l1dbVGjBihgQMH6uqrr9YLL7wQ6BIAAICFdQr4Djt10uLFi5WVlSWn06nBgwdr7Nix6tatW6BLAQAAFhTwcJKamqrU1FRJUkpKipKSknTs2DHCCQAAkNSG0zqbN2/WuHHjlJaWpoiICK1bt+6MPg6HQxkZGYqJiVFubq62bt3a6rYqKirkdruVnp7uc+EAAKBj8jmcNDQ0KDMzUw6Ho9XXV69eLbvdrpKSEm3fvl2ZmZkaPXq0Dh8+7NXv2LFjuuOOO/TMM8+cc3+NjY2qra31WgAAQMflczgZM2aM5syZo1tvvbXV1xctWqSCggJNnTpVAwcO1NKlS9W1a1ctX77c06exsVG33HKLiouLNXTo0HPub/78+YqPj/csHGUBAKBj8+vVOk1NTaqoqFBeXt4XO4iMVF5ensrLyyVJxhhNmTJFo0aN0uTJk8+7zRkzZqimpsazVFdX+7NkAABgMX4NJ0ePHpXb7VZycrJXe3JyspxOpyRpy5YtWr16tdatW6esrCxlZWVp586dZ92mzWZTXFyc1wIAADqugF+tM2zYMLW0tAR6twAAIET49chJUlKSoqKi5HK5vNpdLpdSUlL8uSsAANBB+TWcREdHa/DgwSorK/O0tbS0qKysTEOGDPHnrgAAQAfl82md+vp67d+/37NeVVWlyspKJSYmqnfv3rLb7crPz1d2drZycnK0ePFiNTQ0aOrUqX4tHAAAdEw+h5Nt27Zp5MiRnnW73S5Jys/PV2lpqSZOnKgjR45o5syZcjqdysrK0saNG8+YJAsAANAan8PJiBEjZIw5Z5+ioiIVFRW1uSgAABC+Av5UYgAAgHMhnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnATT3NRgVwAAgOUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKV0CnYBvjLGSJJqa2vbZweNn2+/pfHk5/v40rpnv2fpc7b3fbWP/l17w5faamtr5Xa72+czAQAQZKe/t09/j59LhLmQXhby8ccfKz09PdhlAACANqiurlavXr3O2SfkwklLS4sOHTqk2NhYRURE+H37tbW1Sk9PV3V1teLi4vy+fXyOcQ4cxjowGOfAYJwDx99jbYxRXV2d0tLSFBl57lklIXdaJzIy8ryJyx/i4uL4xQ8AxjlwGOvAYJwDg3EOHH+OdXx8/AX1Y0IsAACwFMIJAACwFMLJV9hsNpWUlMhmswW7lA6NcQ4cxjowGOfAYJwDJ5hjHXITYgEAQMfGkRMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGApYRlOHA6HMjIyFBMTo9zcXG3duvWc/V944QV9/etfV0xMjK666ipt2LAhQJWGNl/GedmyZRo+fLi6d++u7t27Ky8v77z/X/AFX3+nT1u1apUiIiJ0yy23tG+BHYSv43zixAkVFhYqNTVVNptN/fv35++PC+DrOC9evFgDBgxQly5dlJ6ervvuu0+fffZZgKoNTZs3b9a4ceOUlpamiIgIrVu37rzv2bRpk771rW/JZrOpX79+Ki0tbb8CTZhZtWqViY6ONsuXLze7du0yBQUFJiEhwbhcrlb7b9myxURFRZnf/OY3Zvfu3eZXv/qV6dy5s9m5c2eAKw8tvo7z7bffbhwOh9mxY4fZs2ePmTJliomPjzcff/xxgCsPPb6O9WlVVVXmsssuM8OHDzfjx48PTLEhzNdxbmxsNNnZ2Wbs2LHmrbfeMlVVVWbTpk2msrIywJWHFl/HeeXKlcZms5mVK1eaqqoq87e//c2kpqaa++67L8CVh5YNGzaYhx9+2KxZs8ZIMmvXrj1n/wMHDpiuXbsau91udu/ebZYsWWKioqLMxo0b26W+sAsnOTk5prCw0LPudrtNWlqamT9/fqv9J0yYYG688UavttzcXHP33Xe3a52hztdx/qpTp06Z2NhYs2LFivYqscNoy1ifOnXKDB061Pzud78z+fn5hJML4Os4P/3006ZPnz6mqakpUCV2CL6Oc2FhoRk1apRXm91uN9ddd1271tmRXEg4eeihh8ygQYO82iZOnGhGjx7dLjWF1WmdpqYmVVRUKC8vz9MWGRmpvLw8lZeXt/qe8vJyr/6SNHr06LP2R9vG+atOnjyp5uZmJSYmtleZHUJbx/rRRx9Vz549dddddwWizJDXlnF+6aWXNGTIEBUWFio5OVlXXnml5s2bJ7fbHaiyQ05bxnno0KGqqKjwnPo5cOCANmzYoLFjxwak5nAR6O/CkHsq8cU4evSo3G63kpOTvdqTk5O1d+/eVt/jdDpb7e90OtutzlDXlnH+ql/84hdKS0s74w8DvLVlrN966y39/ve/V2VlZQAq7BjaMs4HDhzQ66+/rkmTJmnDhg3av3+/pk+frubmZpWUlASi7JDTlnG+/fbbdfToUQ0bNkzGGJ06dUr33HOPfvnLXwai5LBxtu/C2tpaffrpp+rSpYtf9xdWR04QGhYsWKBVq1Zp7dq1iomJCXY5HUpdXZ0mT56sZcuWKSkpKdjldGgtLS3q2bOnnnnmGQ0ePFgTJ07Uww8/rKVLlwa7tA5l06ZNmjdvnp566ilt375da9as0fr16/XYY48FuzRchLA6cpKUlKSoqCi5XC6vdpfLpZSUlFbfk5KS4lN/tG2cT1u4cKEWLFig1157TVdffXV7ltkh+DrW//jHP3Tw4EGNGzfO09bS0iJJ6tSpk/bt26e+ffu2b9EhqC2/06mpqercubOioqI8bd/4xjfkdDrV1NSk6Ojodq05FLVlnB955BFNnjxZP/7xjyVJV111lRoaGjRt2jQ9/PDDiozk3+D+cLbvwri4OL8fNZHC7MhJdHS0Bg8erLKyMk9bS0uLysrKNGTIkFbfM2TIEK/+kvTqq6+etT/aNs6S9Jvf/EaPPfaYNm7cqOzs7ECUGvJ8Heuvf/3r2rlzpyorKz3LzTffrJEjR6qyslLp6emBLD9ktOV3+rrrrtP+/fs94U+S3n//faWmphJMzqIt43zy5MkzAsjpQGh4rq3fBPy7sF2m2VrYqlWrjM1mM6WlpWb37t1m2rRpJiEhwTidTmOMMZMnTzbFxcWe/lu2bDGdOnUyCxcuNHv27DElJSVcSnwBfB3nBQsWmOjoaPPiiy+aTz75xLPU1dUF6yOEDF/H+qu4WufC+DrOH330kYmNjTVFRUVm37595uWXXzY9e/Y0c+bMCdZHCAm+jnNJSYmJjY01f/rTn8yBAwfMK6+8Yvr27WsmTJgQrI8QEurq6syOHTvMjh07jCSzaNEis2PHDvPhhx8aY4wpLi42kydP9vQ/fSnxgw8+aPbs2WMcDgeXEvvbkiVLTO/evU10dLTJyckx77zzjue166+/3uTn53v1f/75503//v1NdHS0GTRokFm/fn2AKw5Nvozz5ZdfbiSdsZSUlAS+8BDk6+/0lxFOLpyv4/z222+b3NxcY7PZTJ8+fczcuXPNqVOnAlx16PFlnJubm82sWbNM3759TUxMjElPTzfTp083x48fD3zhIeSNN95o9e/c02Obn59vrr/++jPek5WVZaKjo02fPn3Ms88+2271RRjDcS8AAGAdYTXnBAAAWB/hBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWMr/By9tZijruohLAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1244\n", "item counter : 1249\n", "ratio : 0.9952\n", " ratio number predicted/items: 0.004\n", "current epoch: 5\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1247\n", "item counter : 1459\n", "ratio : 0.8541095890410959\n", " ratio number predicted/items: 0.19726027397260273\n", "current epoch: 6\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1243\n", "item counter : 1374\n", "ratio : 0.904\n", " ratio number predicted/items: 0.12872727272727272\n", "current epoch: 7\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1250\n", "item counter : 1343\n", "ratio : 0.9300595238095238\n", " ratio number predicted/items: 0.07514880952380952\n", "current epoch: 8\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=10` reached.\n", "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "-----------------------------------------------------\n", "0 | net | SmallNet | 514 \n", "1 | sym_preprocess | SymPreprocess | 8.5 M \n", "2 | bcewll | BCEWithLogitsLoss | 0 \n", "3 | auroc | BinaryAUROC | 0 \n", "-----------------------------------------------------\n", "514 Trainable params\n", "8.5 M Non-trainable params\n", "8.5 M Total params\n", "34.014 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1244\n", "item counter : 1300\n", "ratio : 0.9561875480399693\n", " ratio number predicted/items: 0.04688700999231361\n", "current epoch: 9\n", "2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 0\n", "item counter : 0\n", "ratio : 0.0\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "83cc0980404b421bb0613ba017127319", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1253\n", "item counter : 1253\n", "ratio : 0.9992025518341308\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGzCAYAAAD0T7cVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA2E0lEQVR4nO3de3wV9Z3/8XcSyAmBXAiRXCCYgtXKxWAJifHyAzTbNChSrYUWFiPaoJL0Ylot1EpQubW6lBWPsqXF0N1YUIusK5SKUR4RjUUSYl25VErAtJoDFMjlYJOQfH9/sBw9ECAnOZc5yev5eMzjwcz5npnPfA3mzcz3OxNijDECAACwiNBAFwAAAPBFhBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAVVSUqKQkBDt3Lkz0KUAsAjCCQAAsBTCCQAAsBTCCQAAsBTCCQCfOHTokObOnasrrrhC/fr106BBg/Stb31LBw8e7LD9yZMnde+992rQoEGKjo7WnXfeqePHj7u12blzp3JychQfH69+/frpS1/6ku6++24/nA0Af+oT6AIA9Ezvvfee3nnnHX3729/W0KFDdfDgQT377LOaOHGidu/ercjISLf2hYWFio2N1cKFC7Vv3z49++yzOnTokLZt26aQkBAdPnxYX/va13TJJZdo3rx5io2N1cGDB7Vhw4YAnSEAXyGcAPCJm2++WXfccYfbtilTpigrK0u///3vNWvWLLfPwsPDVVZWpr59+0qSLr30Uj300EP6n//5H91666165513dPz4cb322mtKT093fW/RokW+PxkAfsVtHQA+0a9fP9efW1tb9Y9//EOXXXaZYmNjVVVVdU77OXPmuIKJJN1///3q06ePNm/eLEmKjY2VJL366qtqbW31bfEAAopwAsAnPvvsMy1YsEApKSmy2WyKj4/XJZdcohMnTqi+vv6c9l/+8pfd1gcMGKCkpCTXGJUJEybom9/8ph599FHFx8dr6tSpeu6559Tc3OyP0wHgR4QTAD7xve99T4sXL9a0adP0wgsv6LXXXtPWrVs1aNAgtbe3e7y/kJAQvfTSS6qoqFBhYaH+/ve/6+6779a4cePU1NTkgzMAECiEEwA+8dJLLykvL0//9m//pjvuuEP/8i//ouuvv14nTpzosP1HH33ktt7U1KRPP/1UqampbtuvueYaLV68WDt37lRpaak+/PBDrVu3zkdnASAQCCcAfCIsLEzGGLdtK1euVFtbW4ftf/WrX7mNJXn22Wd16tQp5ebmSpKOHz9+zv7Gjh0rSdzaAXoYZusA8IlbbrlF//mf/6mYmBiNHDlSFRUVev311zVo0KAO27e0tOimm27StGnTtG/fPj3zzDO6/vrrdeutt0qS1q5dq2eeeUa33XabRowYocbGRq1evVrR0dGaPHmyP08NgI8RTgD4xL//+78rLCxMpaWl+uc//6nrrrtOr7/+unJycjps//TTT6u0tFQLFixQa2urvvOd7+ipp55SSEiIpNMDYnfs2KF169bJ4XAoJiZGGRkZKi0t1Ze+9CV/nhoAHwsxZ18nBQAACCDGnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEsJuuectLe365NPPlFUVJTr+QcAAMDajDFqbGxUcnKyQkMvfG0k6MLJJ598opSUlECXAQAAuqC2tlZDhw69YJugCydRUVGSTp9cdHR0gKuB0+lUcnKypNPBsX///gGuCABgRQ0NDUpJSXH9Hr+QoAsnZ27lREdHE04sICwszPXn6OhowgkA4II6MyQjIOEkNTVV0dHRCg0N1cCBA/Xmm28GogwAAGBBAbty8s4772jAgAGBOjwAALAophIDAABL8TiclJeXa8qUKUpOTlZISIg2btx4Thu73a7U1FRFREQoMzNTO3bscPs8JCREEyZM0Pjx41VaWtrl4gEAQM/jcThxOp1KS0uT3W7v8PP169erqKhIxcXFqqqqUlpamnJycnT48GFXm+3bt6uyslKvvPKKlixZoj//+c9dP4NAWBhzegEAAF7ncTjJzc3VokWLdNttt3X4+fLly5Wfn6/Zs2dr5MiRWrVqlSIjI7VmzRpXmyFDhkiSkpKSNHnyZFVVVZ33eM3NzWpoaHBbAABAz+XVMSctLS2qrKxUdnb25wcIDVV2drYqKioknb7y0tjYKElqamrSG2+8oVGjRp13n0uXLlVMTIxr8fsD2LhKAgCAX3k1nBw9elRtbW1KSEhw256QkKC6ujpJksPh0PXXX6+0tDRdc801uvPOOzV+/Pjz7nP+/Pmqr693LbW1td4sGQAAWIzfpxIPHz5c77//fqfb22w22Ww2H1YEAACsxKtXTuLj4xUWFiaHw+G23eFwKDEx0ZuH8qnUeZuUOm9ToMsAAKBX8mo4CQ8P17hx41RWVuba1t7errKyMmVlZXnzUNZyZlwKY1MAAOg2j2/rNDU1af/+/a71mpoaVVdXKy4uTsOGDVNRUZHy8vKUnp6ujIwMrVixQk6nU7Nnz/Zq4QAAoGfyOJzs3LlTkyZNcq0XFRVJkvLy8lRSUqLp06fryJEjWrBggerq6jR27Fht2bLlnEGywebMbZ6Dy24OcCUAAPRsHoeTiRMnyhhzwTaFhYUqLCzsclEAAKD34t06AADAUggnAADAUggnAADAUggnAADAUggnvsJzTwAA6BLCCQAAsBTCSTfwiHsAALyPcAIAACyFcAIAACyFcAIAACyFcAIAACyFcAIAACzF4xf/oYu++MyThfWBqwMAAIvjygkAALAUwgkAALAUwgkAALAUwgkAALAUwomX8Uh7AAC6h3ACAAAshXASSAtj3KcYAwAAwgkAALAWwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAUwsnZFsboYMSMgB6fZ58AAHozwomP8Th7AAA8QzgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjixOh5nDwDoZQgnAcAj7QEAOD/CCQAAsBTCCQAAsBTCSTBiHAoAoAcjnAAAAEshnAAAAEshnAAAAEshnAAAAEvxezg5ceKE0tPTNXbsWI0ePVqrV6/2dwkAAMDC+vj7gFFRUSovL1dkZKScTqdGjx6t22+/XYMGDfJ3KZaROm+TDi67OdBlAABgCX6/chIWFqbIyEhJUnNzs4wxMsb4uwwAAGBRHoeT8vJyTZkyRcnJyQoJCdHGjRvPaWO325WamqqIiAhlZmZqx44dbp+fOHFCaWlpGjp0qB588EHFx8d3+QQAAEDP4nE4cTqdSktLk91u7/Dz9evXq6ioSMXFxaqqqlJaWppycnJ0+PBhV5vY2Fi9//77qqmp0fPPPy+Hw3He4zU3N6uhocFtAQAAPZfH4SQ3N1eLFi3Sbbfd1uHny5cvV35+vmbPnq2RI0dq1apVioyM1Jo1a85pm5CQoLS0NL311lvnPd7SpUsVExPjWlJSUjwtGQAABBGvjjlpaWlRZWWlsrOzPz9AaKiys7NVUVEhSXI4HGpsbJQk1dfXq7y8XFdcccV59zl//nzV19e7ltraWm+WDAAALMars3WOHj2qtrY2JSQkuG1PSEjQ3r17JUmHDh3SnDlzXANhv/e972nMmDHn3afNZpPNZvNmmQAAwML8PpU4IyND1dXV/j4sAAAIEl4NJ/Hx8QoLCztngKvD4VBiYqI3D4Uv+uIbihfWB64OAAC8wKtjTsLDwzVu3DiVlZW5trW3t6usrExZWVnePBQAAOihPL5y0tTUpP3797vWa2pqVF1drbi4OA0bNkxFRUXKy8tTenq6MjIytGLFCjmdTs2ePdurhQMAgJ7J43Cyc+dOTZo0ybVeVFQkScrLy1NJSYmmT5+uI0eOaMGCBaqrq9PYsWO1ZcuWcwbJ4sJ4pD0AoLfyOJxMnDjxoo+bLywsVGFhYZeLAgAAvZff360DP1kY4z5QFgCAIEE4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAluL3txIjQHg5IAAgSHDlBAAAWArhBAAAWArhJEikztuk1HmbAl0GAAA+RzgJYoQVAEBPRDgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjiBu4Ux7i8JBADAzwgnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnvRnPNAEAWBDhBAAAWArhBAAAWArhBAAAWArhpIdJnbcp0CUAANAthBMAAGAphBMAAGAphBMAAGAphJMejjEoAIBgQzgBAACWQjgBAACWQjjBhfGIewCAnxFOAACApRBOAACApRBOAACApRBOeiGmFwMArIxwAgAALCUg4eS2227TwIEDdccddwTi8AAAwMICEk5+8IMf6Le//W0gDg0AACwuIOFk4sSJioqKCsShAQCAxXkcTsrLyzVlyhQlJycrJCREGzduPKeN3W5XamqqIiIilJmZqR07dnijVgAA0At4HE6cTqfS0tJkt9s7/Hz9+vUqKipScXGxqqqqlJaWppycHB0+fLjbxQIAgJ6vj6dfyM3NVW5u7nk/X758ufLz8zV79mxJ0qpVq7Rp0yatWbNG8+bN87jA5uZmNTc3u9YbGho83gcAAAgeXh1z0tLSosrKSmVnZ39+gNBQZWdnq6Kiokv7XLp0qWJiYlxLSkqKt8oFAAAW5NVwcvToUbW1tSkhIcFte0JCgurq6lzr2dnZ+ta3vqXNmzdr6NChFwwu8+fPV319vWupra31ZskAAMBiPL6t4w2vv/56p9vabDbZbDYfVgMAAKzEq1dO4uPjFRYWJofD4bbd4XAoMTHRm4cCAAA9lFfDSXh4uMaNG6eysjLXtvb2dpWVlSkrK8ubh4KPden9O4uTvF8IAKDX8fi2TlNTk/bv3+9ar6mpUXV1teLi4jRs2DAVFRUpLy9P6enpysjI0IoVK+R0Ol2zdwAAAC7E43Cyc+dOTZo0ybVeVFQkScrLy1NJSYmmT5+uI0eOaMGCBaqrq9PYsWO1ZcuWcwbJAgAAdMTjcDJx4kQZYy7YprCwUIWFhV0uCgAA9F4BebcOAADA+RBOAACApRBOAACApRBOAACApRBOAACApRBOAACApRBOAACApRBOAACApRBO0Cmp8zZ59r6dhTGnFwAAPEQ4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4gWcDXQEA8DHCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCTzHG4cBAD5EOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJbSJ9AFeMoYI0lqaGjwzQGaT++/vfnk6WN8Yd113PO0Od/3Ot0myI6vhgY5nU7XfhuajdrO2o989d8JABBUzvyeOfN7/EJCTGdaWcjf/vY3paSkBLoMAADQBbW1tRo6dOgF2wRdOGlvb9cnn3yiqKgohYSEeH3/DQ0NSklJUW1traKjo72+f5xGP/sPfe0f9LN/0M/+4+2+NsaosbFRycnJCg298KiSoLutExoaetHE5Q3R0dH84PsB/ew/9LV/0M/+QT/7jzf7Oiamc08XZ0AsAACwFMIJAACwFMLJWWw2m4qLi2Wz2QJdSo9GP/sPfe0f9LN/0M/+E8i+DroBsQAAoGfjygkAALAUwgkAALAUwgkAALAUwgkAALCUXhlO7Ha7UlNTFRERoczMTO3YseOC7V988UV95StfUUREhMaMGaPNmzf7qdLg5kk/r169WjfccIMGDhyogQMHKjs7+6L/XfA5T3+mz1i3bp1CQkL0jW98w7cF9hCe9vOJEydUUFCgpKQk2Ww2XX755fz/oxM87ecVK1boiiuuUL9+/ZSSkqIHHnhA//znP/1UbXAqLy/XlClTlJycrJCQEG3cuPGi39m2bZu++tWvymaz6bLLLlNJSYnvCjS9zLp160x4eLhZs2aN+fDDD01+fr6JjY01Doejw/Zvv/22CQsLM7/4xS/M7t27zc9+9jPTt29f88EHH/i58uDiaT/PmDHD2O12s2vXLrNnzx5z1113mZiYGPO3v/3Nz5UHH0/7+oyamhozZMgQc8MNN5ipU6f6p9gg5mk/Nzc3m/T0dDN58mSzfft2U1NTY7Zt22aqq6v9XHlw8bSfS0tLjc1mM6Wlpaampsb88Y9/NElJSeaBBx7wc+XBZfPmzebhhx82GzZsMJLMyy+/fMH2Bw4cMJGRkaaoqMjs3r3brFy50oSFhZktW7b4pL5eF04yMjJMQUGBa72trc0kJyebpUuXdth+2rRp5uabb3bblpmZae69916f1hnsPO3ns506dcpERUWZtWvX+qrEHqMrfX3q1Clz7bXXml//+tcmLy+PcNIJnvbzs88+a4YPH25aWlr8VWKP4Gk/FxQUmBtvvNFtW1FRkbnuuut8WmdP0plw8tBDD5lRo0a5bZs+fbrJycnxSU296rZOS0uLKisrlZ2d7doWGhqq7OxsVVRUdPidiooKt/aSlJOTc9726Fo/n+3kyZNqbW1VXFycr8rsEbra14899pgGDx6se+65xx9lBr2u9PMrr7yirKwsFRQUKCEhQaNHj9aSJUvU1tbmr7KDTlf6+dprr1VlZaXr1s+BAwe0efNmTZ482S819xb+/l0YdC/+646jR4+qra1NCQkJbtsTEhK0d+/eDr9TV1fXYfu6ujqf1RnsutLPZ/vJT36i5OTkc/4ywF1X+nr79u36zW9+o+rqaj9U2Hnt7e1qaWlRREREoEs5R1f6+cCBA3rjjTc0c+ZMbd68Wfv379fcuXPV2tqq4uJif5QddLrSzzNmzNDRo0d1/fXXyxijU6dO6b777tNPf/pTf5Tca5zvd2FDQ4M+++wz9evXz6vH61VXThAcli1bpnXr1unll1+25C+qYNbY2KhZs2Zp9erVio+P98kxFi5cqJCQEO3du1fTpk1TdHS0Bg0apB/84AdugxRDQkJUWFio0tJSjRo1SjabTVu2bJEk/f3vf9fdd9+thIQE2Ww2jRo1SmvWrDnnWCtXrtSoUaMUGRmpgQMHKj09Xc8//7xPzstT7e3tGjx4sH71q19p3Lhxmj59uh5++GGtWrUq0KX1KNu2bdOSJUv0zDPPqKqqShs2bNCmTZv0+OOPB7o0dEOvunISHx+vsLAwORwOt+0Oh0OJiYkdficxMdGj9uhaP5/x5JNPatmyZXr99dd11VVX+bLMHsHTvv7rX/+qgwcPasqUKa5t7e3tkqQ+ffpo3759GjFihFdqmzZtmlJTU7V06VK9++67euqpp3T8+HH99re/dbV544039MILL6iwsFDx8fFKTU2Vw+HQNddc4wovl1xyif7whz/onnvuUUNDg374wx9KOj3D6/vf/77uuOMOV/D585//rD/96U+aMWOGV87hjK78TCclJalv374KCwtzbbvyyitVV1enlpYWhYeHe7XGnqAr/fzII49o1qxZ+u53vytJGjNmjJxOp+bMmaOHH35YoaH8G9wbzve7MDo62utXTST1vtk6GRkZprCw0LXe1tZmhgwZcsEBsbfccovbtqysLAbEXoSn/WyMMT//+c9NdHS0qaio8EeJPYYnff3ZZ5+ZDz74wG2ZOnWqufHGG80HH3xgmpubu11PcXGxkWRuvfVWt+1z5841ksz7779vjDk9CC80NNR8+OGHbu3uuecek5SUZI4ePeq2/dvf/raJiYkxJ0+eNMYYM3Xq1HMG6PmSpz/T8+fPN5deeqlpa2tzbVuxYoVJSkryea3BzNN+/upXv2oeeught23PP/+86devnzl16pRPa+0p1MkBsaNHj3bb9p3vfMdnA2J7XThZt26dsdlspqSkxOzevdvMmTPHxMbGmrq6OmOMMbNmzTLz5s1ztX/77bdNnz59zJNPPmn27NljiouLmUrcCZ7287Jly0x4eLh56aWXzKeffupaGhsbA3UKQcPTvj6bt2frnAknf/zjH92279mzx0hy/ZKRZCZNmuTWpr293cTGxpo5c+aYI0eOuC3PPfeckWS2b9/uqjsmJsbs2LHDa7VfiKf9/PHHH5uoqChTWFho9u3bZ1599VUzePBgs2jRIr/UG6w87efi4mITFRVlfve735kDBw6Y1157zYwYMcJMmzYtUKcQFBobG82uXbvMrl27jCSzfPlys2vXLnPo0CFjjDHz5s0zs2bNcrU/M5X4wQcfNHv27DF2u52pxN62cuVKM2zYMBMeHm4yMjLMu+++6/pswoQJJi8vz639Cy+8YC6//HITHh5uRo0aZTZt2uTnioOTJ/186aWXGknnLMXFxf4vPAh5+jP9Rb4KJwcOHHDb3tLSYkJDQ11XHSWZu+++262Nw+Ho8Ofgi8uGDRuMMcbs3r3bDBkyxEgyl112mZk7d64ruPiKp/38zjvvmMzMTGOz2czw4cPN4sWL+dd8J3jSz62trWbhwoVmxIgRJiIiwqSkpJi5c+ea48eP+7/wIPLmm292+PfrTN/m5eWZCRMmnPOdsWPHmvDwcDN8+HDz3HPP+ay+EGOM8f7NIgC91cKFC/Xoo4/qwIED+tKXvuTafurUKdlsNuXn52vVqlUKCQlRQUGBnn76aVeburo6JSUl6V//9V+Vl5fX4f6vuuoqDR48WJLkdDr16quvasuWLfrDH/4gh8OhBQsW6NFHH/XtSQLwqV41IBaA/3z00Udu4WT//v1qb29Xamrqeb9zySWXKCoqSm1tbZ2aRt6/f39Nnz5d06dPV0tLi26//XYtXrxY8+fPZ6YXEMQYxgzAJ+x2u9v6ypUrJUm5ubnn/U5YWJi++c1v6ve//73+93//95zPjxw54vrzP/7xD7fPwsPDNXLkSBlj1Nra2p3SAQQYV04A+ERNTY1uvfVWff3rX1dFRYX+67/+SzNmzFBaWtoFv7ds2TK9+eabyszMVH5+vkaOHKljx46pqqpKr7/+uo4dOyZJ+trXvqbExERdd911SkhI0J49e/T000/r5ptvVlRUlD9OEYCPEE4A+MT69eu1YMECzZs3T3369FFhYaGeeOKJi34vISFBO3bs0GOPPaYNGzbomWee0aBBgzRq1Cj9/Oc/d7W79957VVpaquXLl6upqUlDhw7V97//ff3sZz/z5WkB8AMGxALwqjMDYo8cOeKzp9AC6NkYcwIAACyFcAIAACyFcAIAACyFMScAAMBSuHICAAAsJeimEre3t+uTTz5RVFSUQkJCAl0OAADoBGOMGhsblZycrNDQC18bCbpw8sknnyglJSXQZQAAgC6ora3V0KFDL9gm6MLJmSc/1tbWKjo62u/HdzqdSk5OlnQ6KPXv39/vNQAAEGwaGhqUkpLSqSc4B004sdvtstvtamtrkyRFR0cHJJyEhYW5/hwdHU04AQDAA50ZkhF0s3UaGhoUExOj+vr6gF05GTBggCSpqamJcAIAQCd48vub2ToAAMBSCCcAAMBSgmbMCQAA/tLe3q6WlpZAlxFU+vbt6zYuszsIJwAAfEFLS4tqamrU3t4e6FKCTmxsrBITE7v9HDLCSQdS522SJB1cdnOAKwEA+JMxRp9++qnCwsKUkpJy0YeF4TRjjE6ePKnDhw9LkpKSkrq1P8IJAAD/59SpUzp58qSSk5MVGRkZ6HKCSr9+/SRJhw8f1uDBg7t1i4dICADA/znzLK3w8PAAVxKczgS61tbWbu0nIOGkpqZGkyZN0siRIzVmzBg5nc5AlAEAQId4d1vXeKvfAnJb56677tKiRYt0ww036NixY7LZbIEoAwAAWJDfw8mHH36ovn376oYbbpAkxcXF+bsEAABgYR6Hk/Lycj3xxBOqrKzUp59+qpdfflnf+MY33NrY7XY98cQTqqurU1pamlauXKmMjAxJ0kcffaQBAwZoypQp+vvf/6477rhDP/3pT71yMgAA+MKZWZz+0ttni3o85sTpdCotLU12u73Dz9evX6+ioiIVFxerqqpKaWlpysnJcU0vOnXqlN566y0988wzqqio0NatW7V169bunQUAAPC6Y8eOaebMmYqOjlZsbKzuueceNTU1+fy4HoeT3NxcLVq0SLfddluHny9fvlz5+fmaPXu2Ro4cqVWrVikyMlJr1qyRJA0ZMkTp6elKSUmRzWbT5MmTVV1dfd7jNTc3q6GhwW0BAADd05kn4M6cOVMffvihtm7dqldffVXl5eWaM2eOz2vz6mydlpYWVVZWKjs7+/MDhIYqOztbFRUVkqTx48fr8OHDOn78uNrb21VeXq4rr7zyvPtcunSpYmJiXEtKSoo3SwYAoEdobGzUzJkz1b9/fyUlJemXv/ylJk6cqB/+8IeSpNTUVD3++OO68847FR0dfdGQsWfPHm3ZskW//vWvlZmZqeuvv14rV67UunXr9Mknn/j0XLwaTo4ePaq2tjYlJCS4bU9ISFBdXZ0kqU+fPlqyZIn+3//7f7rqqqv05S9/Wbfccst59zl//nzV19e7ltraWm+WDABAj1BUVKS3335br7zyirZu3aq33npLVVVVbm2efPJJpaWladeuXXrkkUcuuL+KigrFxsYqPT3dtS07O1uhoaH605/+5JNzOCMgU4lzc3OVm5vbqbY2m002m012u112u931gBwAAHBaY2Oj1q5dq+eff1433XSTJOm5555TcnKyW7sbb7xRP/rRjzq1z7q6Og0ePNhtW58+fRQXF+e64OArXr1yEh8fr7CwMDkcDrftDodDiYmJ3dp3QUGBdu/erffee69b+wEAoKc5cOCAWltbXTNjJSkmJkZXXHGFW7svXgWxMq+Gk/DwcI0bN05lZWWube3t7SorK1NWVpY3DwUAADzUv3//TrdNTEx0zbQ949SpUzp27Fi3LzhcjMfhpKmpSdXV1a4ZNjU1NaqurtbHH38s6fQ9r9WrV2vt2rXas2eP7r//fjmdTs2ePbtbhdrtdo0cOVLjx4/v1n4AAOhphg8frr59+7rdXaivr9df/vKXLu8zKytLJ06cUGVlpWvbG2+8ofb2dmVmZnar3ovxeMzJzp07NWnSJNd6UVGRJCkvL08lJSWaPn26jhw5ogULFqiurk5jx47Vli1bzhkk66mCggIVFBSooaFBMTEx3doXAAA9SVRUlPLy8vTggw8qLi5OgwcPVnFxsUJDQ7v8vpsrr7xSX//615Wfn69Vq1aptbVVhYWF+va3v33OWBZv8zicTJw4UcaYC7YpLCxUYWFhl4sCAMBKguGJrcuXL9d9992nW265RdHR0XrooYdUW1uriIiILu+ztLRUhYWFuummmxQaGqpvfvObeuqpp7xYdccCMlunK5itAwDA+UVFRam0tNS17nQ69eijj7qeZ3Lw4EGP9xkXF6fnn3/eWyV2mlcHxPoSs3UAADi/Xbt26Xe/+53++te/qqqqSjNnzpQkTZ06NcCVeS5owgkAALiwMw9Zy87OltPp1FtvvaX4+PgO2y5ZskQDBgzocOnss8h8hds6AAD0AFdffbXbzJqLue+++zRt2rQOP+vXr5+3yuqSoAknzNYBAMB74uLiFBcXF+gyOsRtHQAAYCmEEwAAYClBE054QiwAAL1D0IQTphIDANA7BE04AQAAvUPQzNYBACBgFvp5lujCev8ez2K4cgIAADq0ePFiXXvttYqMjFRsbKzfjhs04YQBsQAAeE9LS0un2nzrW9/S/fff74eKPhc04YQBsQAAnF9jY6Nmzpyp/v37KykpSb/85S81ceJE/fCHP5Qkpaam6vHHH9edd96p6Oho1wsBL+TRRx/VAw88oDFjxvi4endBE04AAMD5FRUV6e2339Yrr7yirVu36q233lJVVZVbmzPv3tm1a5ceeeSRAFV6cQyIBQAgyDU2Nmrt2rV6/vnnddNNN0mSnnvuOSUnJ7u1u/HGG/WjH/0oECV6hCsnAAAEuQMHDqi1tVUZGRmubTExMbriiivc2qWnp/u7tC4hnAAA0Ev0798/0CV0StCEE2brAADQseHDh6tv375uk0bq6+v1l7/8JYBVdV3QjDkpKChQQUGBGhoaFBPj54fhAABgYVFRUcrLy9ODDz6ouLg4DR48WMXFxQoNDVVISEiX9/vxxx/r2LFj+vjjj9XW1qbq6mpJ0mWXXaYBAwZ4qfpzBU04AQAgYILgia3Lly/Xfffdp1tuuUXR0dF66KGHVFtbq4iIiC7vc8GCBVq7dq1r/eqrr5Ykvfnmm5o4cWJ3Sz4vwgkAAD1AVFSUSktLXetOp1OPPvqo63kmBw8e9HifJSUlKikp8VKFnUc4AQCgB9i1a5f27t2rjIwM1dfX67HHHpMkTZ06NcCVeS5oBsQCAIALO/OQtezsbDmdTr311luKj4/vsO2SJUs0YMCADpfc3Fw/V+6OKycAAPQAV199tSorKzvd/r777tO0adM6/Kxfv37eKqtLCCcAAPRCcXFxiouLC3QZHeK2DgAAZzHGBLqEoOStfguacMJD2AAAvhYWFiZJamlpCXAlwenkyZOSpL59+3ZrP0FzW4eHsAEAfK1Pnz6KjIzUkSNH1LdvX4WGBs2/4QPKGKOTJ0/q8OHDio2NdYW8rgqacAIAgK+FhIQoKSlJNTU1OnToUKDLCTqxsbFKTEzs9n4IJwAAfEF4eLi+/OUvc2vHQ3379u32FZMzCCcAAJwlNDS0W499R/dwMw0AAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFhKQGbrpKamKjo6WqGhoRo4cKDefPPNQJQBAAAsKGBTid955x0NGDAgUIcHAAAWxW2dsy2M0cGIGYGuAgCAXsvjcFJeXq4pU6YoOTlZISEh2rhx4zlt7Ha7UlNTFRERoczMTO3YscPt85CQEE2YMEHjx49XaWlpl4sHAAA9j8fhxOl0Ki0tTXa7vcPP169fr6KiIhUXF6uqqkppaWnKycnR4cOHXW22b9+uyspKvfLKK1qyZIn+/Oc/n/d4zc3NamhocFsAAEDP5XE4yc3N1aJFi3Tbbbd1+Pny5cuVn5+v2bNna+TIkVq1apUiIyO1Zs0aV5shQ4ZIkpKSkjR58mRVVVWd93hLly5VTEyMa0lJSfG0ZAAAEES8OuakpaVFlZWVys7O/vwAoaHKzs5WRUWFpNNXXhobGyVJTU1NeuONNzRq1Kjz7nP+/Pmqr693LbW1td4sGQAAWIxXZ+scPXpUbW1tSkhIcNuekJCgvXv3SpIcDofrqktbW5vy8/M1fvz48+7TZrPJZrN5s0wAAGBhfp9KPHz4cL3//vsef89ut8tut6utrc0HVQEAAKvw6m2d+Ph4hYWFyeFwuG13OBxKTEzs1r4LCgq0e/duvffee93aDwAAsDavhpPw8HCNGzdOZWVlrm3t7e0qKytTVlZWt/Ztt9s1cuTIC94CAgAAwc/j2zpNTU3av3+/a72mpkbV1dWKi4vTsGHDVFRUpLy8PKWnpysjI0MrVqyQ0+nU7Nmzu1VoQUGBCgoK1NDQoJiYmG7ty1Op8za5/vzhIxP9emwAAHobj8PJzp07NWnSJNd6UVGRJCkvL08lJSWaPn26jhw5ogULFqiurk5jx47Vli1bzhkkCwAA0BGPw8nEiRNljLlgm8LCQhUWFna5qI4wIBYAgN4haN6tw4BYAAB6h6AJJwAAoHcgnAAAAEsJmnDCVGIAAHqHoAknjDkBAKB3CJpwAgAAegfCCQAAsJSgCSeMOQEAoHcImnDCmBMAAHqHoAknAACgdyCcAAAASwmacMKYEwAAeoegCSeMOQEAoHcImnACAAB6B8IJAACwFMIJAACwFMIJAACwFMIJAACwlKAJJ0wlBgCgdwiacMJUYgAAeoegCScAAKB3IJwAAABLIZwAAABLIZwAAABLIZwAAABLIZwAAABLIZwAAABLCZpwwkPYAADoHYImnPAQNgAAeoegCScBszBGByNmBLoKAAB6DcIJAACwFMIJAACwFMIJAACwFMIJAACwFMIJAACwFMIJAACwlICFk5MnT+rSSy/Vj3/840CVAAAALChg4WTx4sW65pprAnV4AABgUQEJJx999JH27t2r3NzcQBweAABYmMfhpLy8XFOmTFFycrJCQkK0cePGc9rY7XalpqYqIiJCmZmZ2rFjh9vnP/7xj7V06dIuFw0AAHouj8OJ0+lUWlqa7HZ7h5+vX79eRUVFKi4uVlVVldLS0pSTk6PDhw9Lkv77v/9bl19+uS6//PLuVQ4AAHqkPp5+ITc394K3Y5YvX678/HzNnj1bkrRq1Spt2rRJa9as0bx58/Tuu+9q3bp1evHFF9XU1KTW1lZFR0drwYIFHe6vublZzc3NrvWGhgZPSwYAAEHEq2NOWlpaVFlZqezs7M8PEBqq7OxsVVRUSJKWLl2q2tpaHTx4UE8++aTy8/PPG0zOtI+JiXEtKSkp3iwZAABYjFfDydGjR9XW1qaEhAS37QkJCaqrq+vSPufPn6/6+nrXUltb641SAQCARXl8W8eb7rrrrou2sdlsstlsstvtstvtamtr831hAAAgYLx65SQ+Pl5hYWFyOBxu2x0OhxITE7u174KCAu3evVvvvfdet/YDAACszavhJDw8XOPGjVNZWZlrW3t7u8rKypSVleXNQwEAgB7K49s6TU1N2r9/v2u9pqZG1dXViouL07Bhw1RUVKS8vDylp6crIyNDK1askNPpdM3e6Spu6wAA0Dt4HE527typSZMmudaLiookSXl5eSopKdH06dN15MgRLViwQHV1dRo7dqy2bNlyziBZTxUUFKigoEANDQ2KiYnp1r4AAIB1eRxOJk6cKGPMBdsUFhaqsLCwy0UBAIDeK2Av/vOU3W7XyJEjNX78+ECXAgAAfChowgmzdQAA6B2CJpwAAIDeIWjCCbd1AADoHYImnHBbBwCA3iFowgkAAOgdCCcAAMBSgiacMOYEAIDeIWjCCWNOAADoHYImnAAAgN6BcAIAACyFcAIAACwlaMIJA2IBAOgdgiacMCAWAIDeIWjCCQAA6B0IJwAAwFIIJwAAwFIIJwAAwFKCJpwwWwcAgN4haMIJs3UAAOgdgiacAACA3oFwAgAALIVwAgAALIVwAgAALIVwAgAALIVwAgAALIVwAgAALCVowgkPYQMAoHcImnDCQ9gAAOgdgiacAACA3oFwAgAALIVwAgAALIVwAgAALIVwAgAALIVwAgAALIVwAgAALIVwAgAALMXv4eTEiRNKT0/X2LFjNXr0aK1evdrfJQAAAAvr4+8DRkVFqby8XJGRkXI6nRo9erRuv/12DRo0yN+lAAAAC/L7lZOwsDBFRkZKkpqbm2WMkTHG32UAAACL8jiclJeXa8qUKUpOTlZISIg2btx4Thu73a7U1FRFREQoMzNTO3bscPv8xIkTSktL09ChQ/Xggw8qPj6+yycAAAB6Fo9v6zidTqWlpenuu+/W7bfffs7n69evV1FRkVatWqXMzEytWLFCOTk52rdvnwYPHixJio2N1fvvvy+Hw6Hbb79dd9xxhxISEjo8XnNzs5qbm13r9fX1kqSGhgZPS++c5tNXcdqbT54+xhfWzz5uQ0OD2trafFMHAAA9yJnfn526W2K6QZJ5+eWX3bZlZGSYgoIC13pbW5tJTk42S5cu7XAf999/v3nxxRfPe4zi4mIjiYWFhYWFhaUHLLW1tRfNF14dENvS0qLKykrNnz/ftS00NFTZ2dmqqKiQJDkcDkVGRioqKkr19fUqLy/X/ffff959zp8/X0VFRa719vZ2HTt2TIMGDVJISIg3y5d0OtmlpKSotrZW0dHRXt8/TqOf/Ye+9g/62T/oZ//xdl8bY9TY2Kjk5OSLtvVqODl69Kja2trOuUWTkJCgvXv3SpIOHTqkOXPmuAbCfu9739OYMWPOu0+bzSabzea2LTY21ptldyg6OpoffD+gn/2HvvYP+tk/6Gf/8WZfx8TEdKqd36cSZ2RkqLq62t+HBQAAQcKrU4nj4+MVFhYmh8Phtt3hcCgxMdGbhwIAAD2UV8NJeHi4xo0bp7KyMte29vZ2lZWVKSsry5uH8hmbzabi4uJzbiXBu+hn/6Gv/YN+9g/62X8C2dch/zfrptOampq0f/9+SdLVV1+t5cuXa9KkSYqLi9OwYcO0fv165eXl6T/+4z+UkZGhFStW6IUXXtDevXvPO10YAADgDI/DybZt2zRp0qRztufl5amkpESS9PTTT+uJJ55QXV2dxo4dq6eeekqZmZleKRgAAPRsHocTAAAAX/L7u3UAAAAuhHACAAAshXACAAAspVeGk4u9NflsL774or7yla8oIiJCY8aM0ebNm/1UaXDzpJ9Xr16tG264QQMHDtTAgQOVnZ190f8u+JynP9NnrFu3TiEhIfrGN77h2wJ7CE/7+cSJEyooKFBSUpJsNpsuv/xy/v/RCZ7284oVK3TFFVeoX79+SklJ0QMPPKB//vOffqo2OJWXl2vKlClKTk5WSEiINm7ceNHvbNu2TV/96ldls9l02WWXuSbB+MRF377Tw6xbt86Eh4ebNWvWmA8//NDk5+eb2NhY43A4Omz/9ttvm7CwMPOLX/zC7N692/zsZz8zffv2NR988IGfKw8unvbzjBkzjN1uN7t27TJ79uwxd911l4mJiTF/+9vf/Fx58PG0r8+oqakxQ4YMMTfccIOZOnWqf4oNYp72c3Nzs0lPTzeTJ08227dvNzU1NWbbtm2murraz5UHF0/7ubS01NhsNlNaWmpqamrMH//4R5OUlGQeeOABP1ceXDZv3mwefvhhs2HDBiOd+xLfsx04cMBERkaaoqIis3v3brNy5UoTFhZmtmzZ4pP6el048fStydOmTTM333yz27bMzExz7733+rTOYOdpP5/t1KlTJioqyqxdu9ZXJfYYXenrU6dOmWuvvdb8+te/Nnl5eYSTTvC0n5999lkzfPhw09LS4q8SewRP+7mgoMDceOONbtuKiorMdddd59M6e5LOhJOHHnrIjBo1ym3b9OnTTU5Ojk9q6lW3dc68NTk7O9u17ey3Jp+toqLCrb0k5eTknLc9utbPZzt58qRaW1sVFxfnqzJ7hK729WOPPabBgwfrnnvu8UeZQa8r/fzKK68oKytLBQUFSkhI0OjRo7VkyRK1tbX5q+yg05V+vvbaa1VZWem69XPgwAFt3rxZkydP9kvNvYW/fxf6/cV/gdSZtyafra6ursP2dXV1Pqsz2HWln8/2k5/8RMnJyef8ZYC7rvT19u3b9Zvf/IYXcHqgK/184MABvfHGG5o5c6Y2b96s/fv3a+7cuWptbVVxcbE/yg46XennGTNm6OjRo7r++utljNGpU6d033336ac//ak/Su41zve7sKGhQZ999pn69evn1eP1qisnCA7Lli3TunXr9PLLLysiIiLQ5fQojY2NmjVrllavXq34+PhAl9Ojtbe3a/DgwfrVr36lcePGafr06Xr44Ye1atWqQJfWo2zbtk1LlizRM888o6qqKm3YsEGbNm3S448/HujS0A296spJV96anJiYyFuWPdSdt1M/+eSTWrZsmV5//XVdddVVviyzR/C0r//617/q4MGDmjJlimtbe3u7JKlPnz7at2+fRowY4duig1BXfqaTkpLUt29fhYWFubZdeeWVqqurU0tLi8LDw31aczDqSj8/8sgjmjVrlr773e9KksaMGSOn06k5c+bo4YcfVmgo/wb3hvP9LoyOjvb6VROpl1056cpbk7OystzaS9LWrVuD5i3LgdDVt1P/4he/0OOPP64tW7YoPT3dH6UGPU/7+itf+Yo++OADVVdXu5Zbb71VkyZNUnV1tVJSUvxZftDoys/0ddddp/3797vCnyT95S9/UVJSEsHkPLrSzydPnjwngJwJhIa3s3iN338X+mSYrYWtW7fO2Gw2U1JSYnbv3m3mzJljYmNjTV1dnTHGmFmzZpl58+a52r/99tumT58+5sknnzR79uwxxcXFTCXuBE/7edmyZSY8PNy89NJL5tNPP3UtjY2NgTqFoOFpX5+N2Tqd42k/f/zxxyYqKsoUFhaaffv2mVdffdUMHjzYLFq0KFCnEBQ87efi4mITFRVlfve735kDBw6Y1157zYwYMcJMmzYtUKcQFBobG82uXbvMrl27jCSzfPlys2vXLnPo0CFjjDHz5s0zs2bNcrU/M5X4wQcfNHv27DF2u52pxN62cuVKM2zYMBMeHm4yMjLMu+++6/pswoQJJi8vz639Cy+8YC6//HITHh5uRo0aZTZt2uTnioOTJ/186aWXGknnLMXFxf4vPAh5+jP9RYSTzvO0n9955x2TmZlpbDabGT58uFm8eLE5deqUn6sOPp70c2trq1m4cKEZMWKEiYiIMCkpKWbu3Lnm+PHj/i88iLz55psd/j/3TN/m5eWZCRMmnPOdsWPHmvDwcDN8+HDz3HPP+aw+3koMAAAspVeNOQEAANZHOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJby/wHXRECfwPRwNQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1230\n", "item counter : 2443\n", "ratio : 0.5032733224222586\n", " ratio number predicted/items: 0.6550736497545008\n", "current epoch: 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1240\n", "item counter : 2154\n", "ratio : 0.5754060324825986\n", " ratio number predicted/items: 0.5610208816705337\n", "current epoch: 2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1248\n", "item counter : 1397\n", "ratio : 0.8927038626609443\n", " ratio number predicted/items: 0.1223175965665236\n", "current epoch: 3\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1240\n", "item counter : 1388\n", "ratio : 0.8927285817134629\n", " ratio number predicted/items: 0.11879049676025918\n", "current epoch: 4\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1248\n", "item counter : 1418\n", "ratio : 0.879492600422833\n", " ratio number predicted/items: 0.1324876673713883\n", "current epoch: 5\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1242\n", "item counter : 1457\n", "ratio : 0.8518518518518519\n", " ratio number predicted/items: 0.16255144032921812\n", "current epoch: 6\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1236\n", "item counter : 1495\n", "ratio : 0.8262032085561497\n", " ratio number predicted/items: 0.1945187165775401\n", "current epoch: 7\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1236\n", "item counter : 1515\n", "ratio : 0.8153034300791556\n", " ratio number predicted/items: 0.2091029023746702\n", "current epoch: 8\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1240\n", "item counter : 1511\n", "ratio : 0.8201058201058201\n", " ratio number predicted/items: 0.207010582010582\n", "current epoch: 9\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1243\n", "item counter : 1467\n", "ratio : 0.8467302452316077\n", " ratio number predicted/items: 0.17506811989100818\n", "current epoch: 10\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1235\n", "item counter : 1420\n", "ratio : 0.8691062631949331\n", " ratio number predicted/items: 0.14567206192821958\n", "current epoch: 11\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1236\n", "item counter : 1402\n", "ratio : 0.8809693513898789\n", " ratio number predicted/items: 0.12972202423378476\n", "current epoch: 12\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiYAAAGzCAYAAAAbjdwrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAz4klEQVR4nO3df1xVdZ7H8fcF5SLFD5H4pRhpm+WPsCSIfjzUYsexMrMf2ugaY43mKE3FbI1OJVqaTrWum1E+shTbxdFqzG3TsRLzQRaNidK2+aMcsWiMq04JeC1A+O4fDTevgHrx/jgXXs/H4zzifO/3nvO5X9H77pzvOcdmjDECAACwgJBAFwAAANCMYAIAACyDYAIAACyDYAIAACyDYAIAACyDYAIAACyDYAIAACyDYAIAACyDYAIAACyDYAIgoAoLC2Wz2bRt27ZAlwLAAggmAADAMggmAADAMggmAADAMggmAHziyy+/1LRp09SvXz9169ZNPXr00B133KH9+/e32v/YsWO699571aNHD0VFRemuu+7Sd99959Zn27ZtGjFihOLi4tStWzddcMEFuvvuu/3waQD4S5dAFwCgY/r444/14Ycf6s4771SvXr20f/9+vfDCCxo2bJh27typiIgIt/65ubmKiYnR7NmztWfPHr3wwgv68ssvtXnzZtlsNh08eFA/+9nPdN5552nGjBmKiYnR/v37tWbNmgB9QgC+QDAB4BM33nijbr/9dre2UaNGKSsrS3/60580ceJEt9fCwsJUXFysrl27SpLOP/98Pfzww/qf//kf3Xzzzfrwww/13Xff6Z133lF6errrfXPnzvX9hwHgN5zKAeAT3bp1c/3c0NCgv//977rwwgsVExOj7du3t+g/ZcoUVyiRpF//+tfq0qWL1q9fL0mKiYmRJL311ltqaGjwbfEAAoZgAsAnvv/+e82aNUspKSmy2+2Ki4vTeeedpyNHjqi6urpF/3/6p39yWz/33HOVlJTkmpMydOhQ3XbbbZozZ47i4uI0evRoLV++XHV1df74OAD8hGACwCfuu+8+zZs3T2PHjtWrr76qd955R++++6569OihpqYmj7dns9n0+uuvq7S0VLm5ufrb3/6mu+++W0OGDNHRo0d98AkABALBBIBPvP7668rJydG//du/6fbbb9c///M/65prrtGRI0da7f/FF1+4rR89elTffPONUlNT3dqvvPJKzZs3T9u2bVNRUZE+++wzrVq1ykefAoC/EUwA+ERoaKiMMW5tixcvVmNjY6v9X3zxRbe5Iy+88IKOHz+ukSNHSpK+++67FtsbPHiwJHE6B+hAuCoHgE/cdNNN+s///E9FR0erf//+Ki0t1caNG9WjR49W+9fX1+v666/X2LFjtWfPHj3//PO65pprdPPNN0uSVqxYoeeff15jxoxR3759VVtbq6VLlyoqKko33HCDPz8aAB8imADwif/4j/9QaGioioqK9MMPP+jqq6/Wxo0bNWLEiFb7P/fccyoqKtKsWbPU0NCgX/ziF3r22Wdls9kk/Tj5devWrVq1apUcDoeio6OVkZGhoqIiXXDBBf78aAB8yGZOPjYKAAAQIMwxAQAAlkEwAQAAlhGQOSapqamKiopSSEiIunfvrvfeey8QZQAAAIsJ2OTXDz/8UOeee26gdg8AACyIUzkAAMAyPA4mJSUlGjVqlJKTk2Wz2bR27doWfQoKCpSamqrw8HBlZmZq69atbq/bbDYNHTpUV1xxhYqKitpdPAAA6Fg8PpXjdDqVlpamu+++W7feemuL11evXq28vDwtWbJEmZmZWrRokUaMGKE9e/YoPj5ekrRlyxb17NlT33zzjbKzszVo0CBdeumlZ7T/pqYmHThwQJGRka77GwAAAGszxqi2tlbJyckKCTnFcRFzFiSZN954w60tIyPDTJ8+3bXe2NhokpOTzfz581vdxr/+67+a5cuXt7mPH374wVRXV7uWnTt3GkksLCwsLCwsQbhUVlaeMlt4dfJrfX29ysrKNHPmTFdbSEiIsrOzVVpaKunHIy5NTU2KjIzU0aNHtWnTJo0dO7bNbc6fP19z5sxp0V5ZWamoqChvlg8LcTqdSk5OliQdOHBA55xzToArAgCcjZqaGqWkpCgyMvKU/bwaTA4fPqzGxkYlJCS4tSckJGj37t2SJIfDoTFjxkiSGhsbNXnyZF1xxRVtbnPmzJnKy8tzrTd/sKioKIJJBxYaGur6OSoqimACAB3E6aZh+P1y4T59+uiTTz454/52u112u92HFQEAAKvw6uXCcXFxCg0NlcPhcGt3OBxKTEz05q4AAEAH5NVgEhYWpiFDhqi4uNjV1tTUpOLiYmVlZXlzVwAAoAPy+FTO0aNHtXfvXtd6RUWFysvLFRsbq969eysvL085OTlKT09XRkaGFi1aJKfTqUmTJnm1cAAA0PF4HEy2bdum4cOHu9abJ6bm5OSosLBQ48aN06FDhzRr1ixVVVVp8ODB2rBhQ4sJsVaWOmOdJGn/ghsDXAkAAJ2Lx8Fk2LBh+vEWJm3Lzc1Vbm5uu4uylNnR//hvdWDrAACgE+BZOQAAwDIIJu0xO/qnIykAAMBrCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCbewFU6AAB4BcEEAABYBsEEAABYBsHkDDU/PwcAAPgOwQQAAFiGxw/x69D+MYF1f7iU+sPKABcDAEDnwxETX+FKHQAAPEYwAQAAlkEwAQAAlkEwAQAAlkEwAQAAlkEwAQAAlsHlwv5y4hU6s6sDVwcAABbGERMAAGAZBJOzwG3qAQDwLoIJAACwDIIJAACwDIIJAACwDIIJAACwDIJJIPGgPwAA3BBMAACAZRBMAACAZRBMAACAZRBMAACAZRBMvCh1xjruBgsAwFngIX5WwoP+AACdHEdMAACAZRBMAACAZRBMAACAZRBMAACAZRBMAACAZRBMAACAZRBMrI4H/QEAOhGCCQAAsAyCiY9xJ1gAAM4cwQQAAFgGwQQAAFgGwQQAAFgGwSQYcaUOAKCDIpgAAADLIJgAAADLIJgAAADLIJgAAADL8HswOXLkiNLT0zV48GANHDhQS5cu9XcJAcdN1wAAaF0Xf+8wMjJSJSUlioiIkNPp1MCBA3XrrbeqR48e/i6l42i+Qmd2dWDrAADgLPn9iEloaKgiIiIkSXV1dTLGyBjj7zIAAIAFeRxMSkpKNGrUKCUnJ8tms2nt2rUt+hQUFCg1NVXh4eHKzMzU1q1b3V4/cuSI0tLS1KtXLz300EOKi4tr9wcAAAAdh8fBxOl0Ki0tTQUFBa2+vnr1auXl5Sk/P1/bt29XWlqaRowYoYMHD7r6xMTE6JNPPlFFRYVWrlwph8PR5v7q6upUU1PjtgAAgI7J42AycuRIzZ07V2PGjGn19YULF2ry5MmaNGmS+vfvryVLligiIkLLli1r0TchIUFpaWl6//3329zf/PnzFR0d7VpSUlI8LRkAAAQJr84xqa+vV1lZmbKzs3/aQUiIsrOzVVpaKklyOByqra2VJFVXV6ukpET9+vVrc5szZ85UdXW1a6msrPRmyQAAwEK8elXO4cOH1djYqISEBLf2hIQE7d69W5L05ZdfasqUKa5Jr/fdd58GDRrU5jbtdrvsdrs3ywQAABbl98uFMzIyVF5e7u/dWlrqjHXav+BG726US4gBAEHIq6dy4uLiFBoa2mIyq8PhUGJiojd3BQAAOiCvBpOwsDANGTJExcXFrrampiYVFxcrKyvLm7sCAAAdkMenco4ePaq9e/e61isqKlReXq7Y2Fj17t1beXl5ysnJUXp6ujIyMrRo0SI5nU5NmjTJq4UDAICOx+Ngsm3bNg0fPty1npeXJ0nKyclRYWGhxo0bp0OHDmnWrFmqqqrS4MGDtWHDhhYTYgEAAE7mcTAZNmzYaW8hn5ubq9zc3HYXBR9ongwrMSEWAGBZfn9WDgAAQFsIJgAAwDIIJgAAwDIIJhaVOmNdoEsAAMDvCCYAAMAyCCad2exo96t1AAAIMIIJAACwDIIJAACwDIIJAACwDIIJAACwDIIJAACwDIIJAACwDIJJkPDLDdeaLx/mEmIAQIAQTAAAgGUQTAAAgGUQTHBqnNoBAPgRwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQSe40odAICPEEyCmF/uBgsAgB8RTAAAgGUQTDqQ1BnrOIoCAAhqBBMAAGAZBBMAAGAZBBMAAGAZBBOcPS4fBgB4CcEEAABYBsEEAABYBsEEAABYBsEEvsG8EwBAOxBMAACAZRBMOjjuBAsACCYEEwAAYBkEEwAAYBkEEwAAYBkEEwAAYBkEEwAAYBkEEwAAYBkEEwAAYBkEEwAAYBkEk06Im64BAKyKYAIAACyDYAIAACyDYAIAACyDYAIAACyDYAIAACyDYAIAACwjIMFkzJgx6t69u26//fZA7B6BMDv6pwUAgDYEJJjcf//9euWVVwKxawAAYGEBCSbDhg1TZGRkIHaNVlj+hmvzkgJdAQDATzwOJiUlJRo1apSSk5Nls9m0du3aFn0KCgqUmpqq8PBwZWZmauvWrd6oFQAAdHAeBxOn06m0tDQVFBS0+vrq1auVl5en/Px8bd++XWlpaRoxYoQOHjzYrgLr6upUU1PjtsD/fHJU5eQ5J8xDAYBOz+NgMnLkSM2dO1djxoxp9fWFCxdq8uTJmjRpkvr3768lS5YoIiJCy5Yta1eB8+fPV3R0tGtJSUlp13YAAID1eXWOSX19vcrKypSdnf3TDkJClJ2drdLS0nZtc+bMmaqurnYtlZWV3ioXAABYTBdvbuzw4cNqbGxUQkKCW3tCQoJ2797tWs/OztYnn3wip9OpXr166bXXXlNWVlar27Tb7bLb7d4sEwAAWJRXg8mZ2rhxYyB2CwAALM6rp3Li4uIUGhoqh8Ph1u5wOJSYmOjNXQEAgA7Iq8EkLCxMQ4YMUXFxsautqalJxcXFbZ6qAQAAaObxqZyjR49q7969rvWKigqVl5crNjZWvXv3Vl5ennJycpSenq6MjAwtWrRITqdTkyZN8mrhAACg4/E4mGzbtk3Dhw93refl5UmScnJyVFhYqHHjxunQoUOaNWuWqqqqNHjwYG3YsKHFhFgAAICTeRxMhg0bJmPMKfvk5uYqNze33UUBAIDOKSDPygEAAGgNwQStsvyD/QAAHRLBBAAAWAbBBAAAWAbBBMGHJxADQIdFMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMIHXpM5YZ91n7HBTNgAICgQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTtJu37vJ61tvx5V1duWMsAPgVwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFhGl0AX4CljjCSppqbG+xuvM64fm+qO/biPf7S51k/o11ofV21t9Dnltjvg/nXSe1pra23/zhP+fGvqjBpP/PNua9un+p04kz7efB8AwE3zd0jz93hbbOZ0PSzm66+/VkpKSqDLAAAA7VBZWalevXq1+XrQBZOmpiYdOHBAkZGRstlsXt9+TU2NUlJSVFlZqaioKK9vHz9inP2DcfYfxto/GGf/8fZYG2NUW1ur5ORkhYS0PZMk6E7lhISEnDJpeUtUVBS/9H7AOPsH4+w/jLV/MM7+482xjo4+/Z20mfwKAAAsg2ACAAAsg2ByErvdrvz8fNnt9kCX0qExzv7BOPsPY+0fjLP/BGqsg27yKwAA6Lg4YgIAACyDYAIAACyDYAIAACyDYAIAACyjUwaTgoICpaamKjw8XJmZmdq6desp+7/22mu6+OKLFR4erkGDBmn9+vV+qjS4eTLOS5cu1bXXXqvu3bure/fuys7OPu2fC37k6e9zs1WrVslms+mWW27xbYEdiKdjfeTIEU2fPl1JSUmy2+266KKL+PfjDHg6zosWLVK/fv3UrVs3paSk6MEHH9QPP/zgp2qDU0lJiUaNGqXk5GTZbDatXbv2tO/ZvHmzLr/8ctntdl144YUqLCz0TXGmk1m1apUJCwszy5YtM5999pmZPHmyiYmJMQ6Ho9X+H3zwgQkNDTVPPfWU2blzp3n00UdN165dzaeffurnyoOLp+M8fvx4U1BQYHbs2GF27dplfvnLX5ro6Gjz9ddf+7ny4OLpODerqKgwPXv2NNdee60ZPXq0f4oNcp6OdV1dnUlPTzc33HCD2bJli6moqDCbN2825eXlfq48uHg6zkVFRcZut5uioiJTUVFh3n77bZOUlGQefPBBP1ceXNavX28eeeQRs2bNGiPJvPHGG6fsv2/fPhMREWHy8vLMzp07zeLFi01oaKjZsGGD12vrdMEkIyPDTJ8+3bXe2NhokpOTzfz581vtP3bsWHPjjTe6tWVmZpp7773Xp3UGO0/H+WTHjx83kZGRZsWKFb4qsUNozzgfP37cXHXVVeall14yOTk5BJMz5OlYv/DCC6ZPnz6mvr7eXyV2CJ6O8/Tp0811113n1paXl2euvvpqn9bZkZxJMHn44YfNgAED3NrGjRtnRowY4fV6OtWpnPr6epWVlSk7O9vVFhISouzsbJWWlrb6ntLSUrf+kjRixIg2+6N943yyY8eOqaGhQbGxsb4qM+i1d5wff/xxxcfH65577vFHmR1Ce8b6zTffVFZWlqZPn66EhAQNHDhQTz75pBobG/1VdtBpzzhfddVVKisrc53u2bdvn9avX68bbrjBLzV3Fv78Lgy6h/idjcOHD6uxsVEJCQlu7QkJCdq9e3er76mqqmq1f1VVlc/qDHbtGeeT/e53v1NycnKLvwj4SXvGecuWLXr55ZdVXl7uhwrPXFNTk+rr6xUeHh7oUlrVnrHet2+fNm3apAkTJmj9+vXau3evpk2bpoaGBuXn5/uj7KDTnnEeP368Dh8+rGuuuUbGGB0/flxTp07V73//e3+U3Gm09V1YU1Oj77//Xt26dfPavjrVERMEhwULFmjVqlV64403LPtFFYxqa2s1ceJELV26VHFxcT7Zx+zZs2Wz2bR7926NHTtWUVFR6tGjh+6//363yYg2m025ubkqKirSgAEDZLfbtWHDBknS3/72N919991KSEiQ3W7XgAEDtGzZshb7Wrx4sQYMGKCIiAh1795d6enpWrlypU8+V3s0NTUpPj5eL774ooYMGaJx48bpkUce0ZIlSwJdWoeyefNmPfnkk3r++ee1fft2rVmzRuvWrdMTTzwR6NLQTp3qiElcXJxCQ0PlcDjc2h0OhxITE1t9T2Jiokf90b5xbvbMM89owYIF2rhxoy699FJflhn0PB3nv/71r9q/f79GjRrlamtqapIkdenSRXv27FHfvn29UtvYsWOVmpqq+fPn66OPPtKzzz6r7777Tq+88oqrz6ZNm/Tqq68qNzdXcXFxSk1NlcPh0JVXXukKLuedd57+/Oc/65577lFNTY0eeOABST9exfWb3/xGt99+uyv0/O///q/+8pe/aPz48V75DCdqz+90UlKSunbtqtDQUFfbJZdcoqqqKtXX1yssLMzrdQa79ozzY489pokTJ+pXv/qVJGnQoEFyOp2aMmWKHnnkEYWE8P/f3tDWd2FUVJRXj5ZI6nxX5WRkZJjc3FzXemNjo+nZs+cpJ7/edNNNbm1ZWVlMfj0NT8fZGGP+8Ic/mKioKFNaWuqPEjsET8b5+++/N59++qnbMnr0aHPdddeZTz/91NTV1Z11Pfn5+UaSufnmm93ap02bZiSZTz75xBjz42S7kJAQ89lnn7n1u+eee0xSUpI5fPiwW/udd95poqOjzbFjx4wxxowePbrFRDxf8/R3eubMmeb88883jY2NrrZFixaZpKQkn9cazDwd58svv9w8/PDDbm0rV6403bp1M8ePH/dprR2FznDy68CBA93afvGLX/hk8munCyarVq0ydrvdFBYWmp07d5opU6aYmJgYU1VVZYwxZuLEiWbGjBmu/h988IHp0qWLeeaZZ8yuXbtMfn4+lwufAU/HecGCBSYsLMy8/vrr5ptvvnEttbW1gfoIQcHTcT6Zt6/KaQ4mb7/9tlv7rl27jCTXl4skM3z4cLc+TU1NJiYmxkyZMsUcOnTIbVm+fLmRZLZs2eKqOzo62mzdutVrtZ+Op2P91VdfmcjISJObm2v27Nlj3nrrLRMfH2/mzp3rt5qDkafjnJ+fbyIjI80f//hHs2/fPvPOO++Yvn37mrFjxwbqIwSF2tpas2PHDrNjxw4jySxcuNDs2LHDfPnll8YYY2bMmGEmTpzo6t98ufBDDz1kdu3aZQoKCrhc2JsWL15sevfubcLCwkxGRob56KOPXK8NHTrU5OTkuPV/9dVXzUUXXWTCwsLMgAEDzLp16/xccXDyZJzPP/98I6nFkp+f7//Cg4ynv88n8lUw2bdvn1t7fX29CQkJcR1plGTuvvtutz4Oh6PV34ETlzVr1hhjjNm5c6fp2bOnkWQuvPBCM23aNFdo8SVPx/rDDz80mZmZxm63mz59+ph58+bxf/FnwJNxbmhoMLNnzzZ9+/Y14eHhJiUlxUybNs189913/i88iLz33nut/h1rHtucnBwzdOjQFu8ZPHiwCQsLM3369DHLly/3SW02Y4zx7skhAJ3V7NmzNWfOHO3bt08XXHCBq/348eOy2+2aPHmylixZIpvNpunTp+u5555z9amqqlJSUpL+5V/+RTk5Oa1u/9JLL1V8fLwkyel06q233tKGDRv05z//WQ6HQ7NmzdKcOXN8+yEB+FSnmvwKwD+++OILt2Cyd+9eNTU1KTU1tc33nHfeeYqMjFRjY+MZXSZ+zjnnaNy4cRo3bpzq6+t16623at68eZo5cyZXcwFBjOnKALyuoKDAbX3x4sWSpJEjR7b5ntDQUN12223605/+pP/7v/9r8fqhQ4dcP//97393ey0sLEz9+/eXMUYNDQ1nUzqAAOOICQCvq6io0M0336yf//znKi0t1X/9139p/PjxSktLO+X7FixYoPfee0+ZmZmaPHmy+vfvr2+//Vbbt2/Xxo0b9e2330qSfvaznykxMVFXX321EhIStGvXLj333HO68cYbFRkZ6Y+PCMBHCCYAvG716tWaNWuWZsyYoS5duig3N1dPP/30ad+XkJCgrVu36vHHH9eaNWv0/PPPq0ePHhowYID+8Ic/uPrde++9Kioq0sKFC3X06FH16tVLv/nNb/Too4/68mMB8AMmvwLwmubJr4cOHfLZ3WUBdGzMMQEAAJZBMAEAAJZBMAEAAJbBHBMAAGAZHDEBAACWEXSXCzc1NenAgQOKjIyUzWYLdDkAAOAMGGNUW1ur5ORkhYS0fVwk6ILJgQMHlJKSEugyAABAO1RWVqpXr15tvh50waT5ro6VlZWKiooKcDU4E06nU8nJyZJ+DJbnnHNOgCsCAPhbTU2NUlJSTnt35qALJs2nb6KioggmQSI0NNT1c1RUFMEEADqx003DYPIrAACwDIIJAACwDIIJAACwjKCbYwIAgK81NjaqoaEh0GUEla5du7rNKWwvggkAAP9gjFFVVZWOHDkS6FKCUkxMjBITE8/qPmMEk1akzlgnSdq/4MYAVwIA8KfmUBIfH6+IiAhu5HmGjDE6duyYDh48KElKSkpq97YIJgAA6MfTN82hpEePHoEuJ+h069ZNknTw4EHFx8e3+7QOk18BAJBcc0oiIiICXEnwah67s5mfQzABAOAEnL5pP2+MHcEEAABYBsEEAABYBpNfAQA4jearNf2lM18VyhETAADQqm+//VYTJkxQVFSUYmJidM899+jo0aM+3SfBBACATqi+vv60fSZMmKDPPvtM7777rt566y2VlJRoypQpPq2LYAIAQAdQW1urCRMm6JxzzlFSUpL+/d//XcOGDdMDDzwgSUpNTdUTTzyhu+66S1FRUacNGLt27dKGDRv00ksvKTMzU9dcc40WL16sVatW6cCBAz77HAQTAAA6gLy8PH3wwQd688039e677+r999/X9u3b3fo888wzSktL044dO/TYY4+dcnulpaWKiYlRenq6qy07O1shISH6y1/+4pPPIDH5FQCAoFdbW6sVK1Zo5cqVuv766yVJy5cvV3Jyslu/6667Tr/97W/PaJtVVVWKj493a+vSpYtiY2NVVVXlncJbwRETAACC3L59+9TQ0KCMjAxXW3R0tPr16+fW78SjH1ZFMAEAoJM455xzzrhvYmKi66F8zY4fP65vv/1WiYmJ3i7NhWACAECQ69Onj7p27aqPP/7Y1VZdXa3PP/+83dvMysrSkSNHVFZW5mrbtGmTmpqalJmZeVb1ngpzTAAACHKRkZHKycnRQw89pNjYWMXHxys/P18hISHtfn7NJZdcop///OeaPHmylixZooaGBuXm5urOO+9sMXfFmwgmAACcRjDciXXhwoWaOnWqbrrpJkVFRenhhx9WZWWlwsPD273NoqIi5ebm6vrrr1dISIhuu+02Pfvss16suqWABJPU1FRFRUUpJCRE3bt313vvvReIMgAA6DAiIyNVVFTkWnc6nZozZ47rfiX79+/3eJuxsbFauXKlt0o8IwE7YvLhhx/q3HPPDdTuAQDoUHbs2KHdu3crIyND1dXVevzxxyVJo0ePDnBlnmHyKwAAHUTzDdSys7PldDr1/vvvKy4urtW+Tz75pM4999xWl5EjR/q58p94fMSkpKRETz/9tMrKyvTNN9/ojTfe0C233OLWp6CgQE8//bSqqqqUlpamxYsXu11bbbPZNHToUIWEhOiBBx7QhAkTzvqDAADQmV122WVuV9CcztSpUzV27NhWX+vWrZu3yvKYx8HE6XQqLS1Nd999t2699dYWr69evVp5eXlasmSJMjMztWjRIo0YMUJ79uxx3UFuy5Yt6tmzp7755htlZ2dr0KBBuvTSS8/+0wAAgDMSGxur2NjYQJfRgsenckaOHKm5c+dqzJgxrb6+cOFCTZ48WZMmTVL//v21ZMkSRUREaNmyZa4+PXv2lCQlJSXphhtuaHEv/xPV1dWppqbGbQEAAB2TV+eY1NfXq6ysTNnZ2T/tICRE2dnZKi0tlfTjEZfa2lpJ0tGjR7Vp0yYNGDCgzW3Onz9f0dHRriUlJcWbJQMAAAvxajA5fPiwGhsblZCQ4NaekJDgeuCPw+HQNddco7S0NF155ZW66667dMUVV7S5zZkzZ6q6utq1VFZWerNkAABgIX6/XLhPnz765JNPzri/3W6X3W73YUUAAMAqvHrEJC4uTqGhoXI4HG7tDofDpw/8AQAAHYNXj5iEhYVpyJAhKi4udl1C3NTUpOLiYuXm5npzV36VOmOdpOC4JTEAwAdmR/t5f9X+3Z+FeBxMjh49qr1797rWKyoqVF5ertjYWPXu3Vt5eXnKyclRenq6MjIytGjRIjmdTk2aNMmrhQMAAN+aN2+e1q1bp/LycoWFhenIkSM+36fHwWTbtm0aPny4az0vL0+SlJOTo8LCQo0bN06HDh3SrFmzVFVVpcGDB2vDhg0tJsQCAIDAqa+vV1hY2Gn73HHHHcrKytLLL7/sl7o8DibDhg2TMeaUfXJzc4P61A0AAMGmtrZWU6dO1dq1a11PF/7v//5vDR48WIsWLVJqaqruueceffHFF1q7dq1uvfVWFRYWnnKbc+bMkaTT9vMmnpUDAEAHkJeXpw8++EBvvvmm3n33Xb3//vstbmDa/CydHTt26LHHHgtQpacWsKcLAwAA76itrdWKFSu0cuVKXX/99ZKk5cuXKzk52a3fddddp9/+9reBKPGMccQEAIAgt2/fPjU0NLg9MDc6Olr9+vVz65eenu7v0jxGMAEAoJM455xzAl3CaRFMAAAIcn369FHXrl318ccfu9qqq6v1+eefB7Cq9mGOCQAAQS4yMlI5OTl66KGHFBsbq/j4eOXn5yskJEQ2m63d2/3qq6/07bff6quvvlJjY6PKy8slSRdeeKHOPfdcL1XvjmDSTtwNFgA6kSC4E+vChQs1depU3XTTTa7LhSsrKxUeHt7ubc6aNUsrVqxwrV922WWSpPfee0/Dhg0725JbRTABAKADiIyMVFFRkWvd6XRqzpw5mjJliiRp//79Hm+zsLDQr/cwkQgmAAB0CDt27NDu3buVkZGh6upqPf7445Kk0aNHB7gyzzD59XRmR2t/+PhAVwEAwGk130AtOztbTqdT77//vuLi4lrt++STT+rcc89tdRk5cqSfK/8JR0wAAOgALrvsMpWVlZ1x/6lTp2rs2LGtvtatWzdvleUxggkAAJ1QbGysYmNjA11GC5zKAQDgBKd7UC3a5o2xI5gAACCpa9eukqRjx44FuJLg1Tx2zWPZHpzKaY/Z0dofLqX+sDLQlQAAvCQ0NFQxMTE6ePCgJCkiIuKsbk7WmRhjdOzYMR08eFAxMTEKDQ1t97YIJieaHS1J7QodzTdck7jpGgAEq8TERElyhRN4JiYmxjWG7UUwAQDgH2w2m5KSkhQfH6+GhoZAlxNUunbtelZHSpoRTAAAOEloaKhXvmThOSa/AgAAyyCYeAN3hwUAwCsIJgAAwDIIJgAAwDIIJj6UOmOd22XEAADg1AgmvsK8EwAAPEYwAQAAlkEwAQAAlkEwAQAAlsGdX/3lH8/h+fHn6sDVAQCAhXHEBAAAWAbBJAC4hBgAgNYRTAAAgGUQTAJpdrT73BMAADo5ggkAALAMggkAALAMggkAALAM7mNiJdzrBADQyXHEBAAAWAbBxAK4rwkAAD/yezA5cuSI0tPTNXjwYA0cOFBLly71dwnBhUuKAQCdiN/nmERGRqqkpEQRERFyOp0aOHCgbr31VvXo0cPfpQAAAIvx+xGT0NBQRURESJLq6upkjJExxt9lAAAAC/I4mJSUlGjUqFFKTk6WzWbT2rVrW/QpKChQamqqwsPDlZmZqa1bt7q9fuTIEaWlpalXr1566KGHFBcX1+4PAAAAOg6Pg4nT6VRaWpoKCgpafX316tXKy8tTfn6+tm/frrS0NI0YMUIHDx509YmJidEnn3yiiooKrVy5Ug6Ho/2foDNi3gkAoIPyOJiMHDlSc+fO1ZgxY1p9feHChZo8ebImTZqk/v37a8mSJYqIiNCyZcta9E1ISFBaWpref//9NvdXV1enmpoat6Uz4EodAEBn5NU5JvX19SorK1N2dvZPOwgJUXZ2tkpLSyVJDodDtbW1kqTq6mqVlJSoX79+bW5z/vz5io6Odi0pKSneLBkAAFiIV4PJ4cOH1djYqISEBLf2hIQEVVVVSZK+/PJLXXvttUpLS9O1116r++67T4MGDWpzmzNnzlR1dbVrqays9GbJAADAQvx+uXBGRobKy8vPuL/dbpfdbvddQR1B83wTbmMPAAhyXj1iEhcXp9DQ0BaTWR0OhxITE725KwAA0AF5NZiEhYVpyJAhKi4udrU1NTWpuLhYWVlZ3twVTocrdwAAQcjjYHL06FGVl5e7TsdUVFSovLxcX331lSQpLy9PS5cu1YoVK7Rr1y79+te/ltPp1KRJk7xaeGfDVToAgM7A4zkm27Zt0/Dhw13reXl5kqScnBwVFhZq3LhxOnTokGbNmqWqqioNHjxYGzZsaDEhFgAA4GQeB5Nhw4ad9hbyubm5ys3NbXdRAACgc/L7VTkIkBPnm3D1DgDAovz+ED8AAIC2EEwAAIBlEEwAAIBlEEwAAIBlEEyC2Fnf24SbsAEALIZgAgAALINgAgAALINgAgAALIMbrOEn3IQNABBgHDEBAACWQTABAACWQTDpQFJnrDv7S4gBAAgggglOjXudAAD8iGACAAAsg2ACAAAsg2ACAAAsg2ACzzHvBADgIwQTAABgGQQTAABgGQSTDo77mgAAggnBBAAAWAbBBAAAWAbBBGePq3QAAF5CMAEAAJZBMAEAAJZBMAEAAJZBMIFvMO8EANAOBJNOiHubAACsimAC/5qXFOgKAAAWRjABAACWQTBB4DAPBQBwEoIJAACwDIIJAACwDIIJuEoHAGAZBBMAAGAZXQJdAOBy4kTY2dWBqwMAEDAcMQEAAJYRkGAyZswYde/eXbfffnsgdg8AACwqIMHk/vvv1yuvvBKIXQMAAAsLSDAZNmyYIiMjA7FrAABgYR4Hk5KSEo0aNUrJycmy2Wxau3Ztiz4FBQVKTU1VeHi4MjMztXXrVm/UCgAAOjiPg4nT6VRaWpoKCgpafX316tXKy8tTfn6+tm/frrS0NI0YMUIHDx4862LRCXHbegDoVDy+XHjkyJEaOXJkm68vXLhQkydP1qRJkyRJS5Ys0bp167Rs2TLNmDHD4wLr6upUV1fnWq+pqfF4GwAAIDh4dY5JfX29ysrKlJ2d/dMOQkKUnZ2t0tLSdm1z/vz5io6Odi0pKSneKhcAAFiMV4PJ4cOH1djYqISEBLf2hIQEVVVVudazs7N1xx13aP369erVq9cpQ8vMmTNVXV3tWiorK71ZMoIRp3cAoMMKyJ1fN27ceMZ97Xa77Ha7D6sBAABW4dUjJnFxcQoNDZXD4XBrdzgcSkxM9OauAABAB+TVYBIWFqYhQ4aouLjY1dbU1KTi4mJlZWV5c1fwMZ44DAAIBI9P5Rw9elR79+51rVdUVKi8vFyxsbHq3bu38vLylJOTo/T0dGVkZGjRokVyOp2uq3QAAADa4nEw2bZtm4YPH+5az8vLkyTl5OSosLBQ48aN06FDhzRr1ixVVVVp8ODB2rBhQ4sJsQAAACfzOJgMGzZMxphT9snNzVVubm67iwIAAJ1TQJ6VAwAA0BqCCQAAsAyCCQAAsAyCCQAAsAyCCQAAsAyCCYJfa8/OObmN5+sAQFAgmAAAAMsgmAAAAMsgmAAAAMsgmAAAAMsgmOCM8LRhAIA/EEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBldAl0Aeg4mu91sn/BjQGu5Aw1P9RvdrX7+oltAAC/4ogJAACwDIIJAACwDIIJAACwDIIJAACwDIIJAACwjKC7KscYI0mqqanx/sbrjOvHprpjP+7jH22u9RP6tdbHVVsbfU657SDbv1qp5+T9q6ZGTqfTtd2aOqPG02yn1bYT/7zbep+3+pzcDwBw1pq/Q5q/x9tiM6frYTFff/21UlJSAl0GAABoh8rKSvXq1avN14MumDQ1NenAgQOKjIyUzWbz+vZramqUkpKiyspKRUVFeX37+BHj7B+Ms/8w1v7BOPuPt8faGKPa2lolJycrJKTtmSRBdyonJCTklEnLW6Kiovil9wPG2T8YZ/9hrP2DcfYfb451dHT0afsw+RUAAFgGwQQAAFgGweQkdrtd+fn5stvtgS6lQ2Oc/YNx9h/G2j8YZ/8J1FgH3eRXAADQcXHEBAAAWAbBBAAAWAbBBAAAWAbBBAAAWAbBBAAAWEanDCYFBQVKTU1VeHi4MjMztXXr1lP2f+2113TxxRcrPDxcgwYN0vr16/1UaXDzZJyXLl2qa6+9Vt27d1f37t2VnZ192j8X/MjT3+dmq1atks1m0y233OLbAjsQT8f6yJEjmj59upKSkmS323XRRRfx78cZ8HScFy1apH79+qlbt25KSUnRgw8+qB9++MFP1QankpISjRo1SsnJybLZbFq7du1p37N582ZdfvnlstvtuvDCC1VYWOib4kwns2rVKhMWFmaWLVtmPvvsMzN58mQTExNjHA5Hq/0/+OADExoaap566imzc+dO8+ijj5quXbuaTz/91M+VBxdPx3n8+PGmoKDA7Nixw+zatcv88pe/NNHR0ebrr7/2c+XBxdNxblZRUWF69uxprr32WjN69Gj/FBvkPB3ruro6k56ebm644QazZcsWU1FRYTZv3mzKy8v9XHlw8XSci4qKjN1uN0VFRaaiosK8/fbbJikpyTz44IN+rjy4rF+/3jzyyCNmzZo1RpJ54403Ttl/3759JiIiwuTl5ZmdO3eaxYsXm9DQULNhwwav19bpgklGRoaZPn26a72xsdEkJyeb+fPnt9p/7Nix5sYbb3Rry8zMNPfee69P6wx2no7zyY4fP24iIyPNihUrfFVih9CecT5+/Li56qqrzEsvvWRycnIIJmfI07F+4YUXTJ8+fUx9fb2/SuwQPB3n6dOnm+uuu86tLS8vz1x99dU+rbMjOZNg8vDDD5sBAwa4tY0bN86MGDHC6/V0qlM59fX1KisrU3Z2tqstJCRE2dnZKi0tbfU9paWlbv0lacSIEW32R/vG+WTHjh1TQ0ODYmNjfVVm0GvvOD/++OOKj4/XPffc448yO4T2jPWbb76prKwsTZ8+XQkJCRo4cKCefPJJNTY2+qvsoNOecb7qqqtUVlbmOt2zb98+rV+/XjfccINfau4s/PldGHRPFz4bhw8fVmNjoxISEtzaExIStHv37lbfU1VV1Wr/qqoqn9UZ7Nozzif73e9+p+Tk5BZ/EfCT9ozzli1b9PLLL6u8vNwPFXYc7Rnrffv2adOmTZowYYLWr1+vvXv3atq0aWpoaFB+fr4/yg467Rnn8ePH6/Dhw7rmmmtkjNHx48c1depU/f73v/dHyZ1GW9+FNTU1+v7779WtWzev7atTHTFBcFiwYIFWrVqlN954Q+Hh4YEup8Oora3VxIkTtXTpUsXFxQW6nA6vqalJ8fHxevHFFzVkyBCNGzdOjzzyiJYsWRLo0jqUzZs368knn9Tzzz+v7du3a82aNVq3bp2eeOKJQJeGdupUR0zi4uIUGhoqh8Ph1u5wOJSYmNjqexITEz3qj/aNc7NnnnlGCxYs0MaNG3XppZf6ssyg5+k4//Wvf9X+/fs1atQoV1tTU5MkqUuXLtqzZ4/69u3r26KDVHt+p5OSktS1a1eFhoa62i655BJVVVWpvr5eYWFhPq05GLVnnB977DFNnDhRv/rVryRJgwYNktPp1JQpU/TII48oJIT///aGtr4Lo6KivHq0ROpkR0zCwsI0ZMgQFRcXu9qamppUXFysrKysVt+TlZXl1l+S3n333Tb7o33jLElPPfWUnnjiCW3YsEHp6en+KDWoeTrOF198sT799FOVl5e7lptvvlnDhw9XeXm5UlJS/Fl+UGnP7/TVV1+tvXv3usKfJH3++edKSkoilLShPeN87NixFuGjOQwanlHrNX79LvT6dFqLW7VqlbHb7aawsNDs3LnTTJkyxcTExJiqqipjjDETJ040M2bMcPX/4IMPTJcuXcwzzzxjdu3aZfLz87lc+Ax4Os4LFiwwYWFh5vXXXzfffPONa6mtrQ3URwgKno7zybgq58x5OtZfffWViYyMNLm5uWbPnj3mrbfeMvHx8Wbu3LmB+ghBwdNxzs/PN5GRkeaPf/yj2bdvn3nnnXdM3759zdixYwP1EYJCbW2t2bFjh9mxY4eRZBYuXGh27NhhvvzyS2OMMTNmzDATJ0509W++XPihhx4yu3btMgUFBVwu7E2LFy82vXv3NmFhYSYjI8N89NFHrteGDh1qcnJy3Pq/+uqr5qKLLjJhYWFmwIABZt26dX6uODh5Ms7nn3++kdRiyc/P93/hQcbT3+cTEUw84+lYf/jhhyYzM9PY7XbTp08fM2/ePHP8+HE/Vx18PBnnhoYGM3v2bNO3b18THh5uUlJSzLRp08x3333n/8KDyHvvvdfqv7nNY5uTk2OGDh3a4j2DBw82YWFhpk+fPmb58uU+qc1mDMe6AACANXSqOSYAAMDaCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAy/h/cLWMgnErdxgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1241\n", "item counter : 1387\n", "ratio : 0.8940922190201729\n", " ratio number predicted/items: 0.11455331412103746\n", "current epoch: 13\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1239\n", "item counter : 1356\n", "ratio : 0.9130434782608695\n", " ratio number predicted/items: 0.09285187914517318\n", "current epoch: 14\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1247\n", "item counter : 1338\n", "ratio : 0.9312920089619119\n", " ratio number predicted/items: 0.07318894697535475\n", "current epoch: 15\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1246\n", "item counter : 1343\n", "ratio : 0.9270833333333334\n", " ratio number predicted/items: 0.07738095238095238\n", "current epoch: 16\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1238\n", "item counter : 1337\n", "ratio : 0.9252615844544095\n", " ratio number predicted/items: 0.08146487294469357\n", "current epoch: 17\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1242\n", "item counter : 1361\n", "ratio : 0.9118942731277533\n", " ratio number predicted/items: 0.09618208516886931\n", "current epoch: 18\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=20` reached.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1241\n", "item counter : 1393\n", "ratio : 0.8902439024390244\n", " ratio number predicted/items: 0.12697274031563846\n", "current epoch: 19\n" ] } ], "source": [ "prev_nets= []\n", "for i in range(3):\n", " model_checkpoint = ModelCheckpoint(monitor='ratio_number_predicted_per_items', mode='max')\n", " trainer = pl.Trainer(\n", " max_epochs=20 if i==2 else 10,\n", "# max_epochs=40,\n", " accelerator='gpu',\n", " devices=1,\n", " log_every_n_steps=1,\n", " # logger=pl.loggers.CSVLogger(save_dir=\"logs/\"),\n", " reload_dataloaders_every_n_epochs=1,\n", " logger=tensorboard,\n", " callbacks=[model_checkpoint]\n", " )\n", " print(i)\n", " model = SudokuLightning(\n", " lr=0.01,\n", " prev_nets=prev_nets,\n", " coef_0 = 10 if i==0 else 20,\n", " )\n", " _ = trainer.fit(model,)\n", "# model.below_threshold_coef=0.9\n", "# model = model.load_from_checkpoint(model_checkpoint.best_model_path)\n", "# print(model_checkpoint.best_model_path)\n", "# trainer.validate(model=model)\n", "# if trainer.logged_metrics['no_improve_counter'].item()==0:\n", " prev_nets.append((model.net, (model.threshold_abs, model.threshold_pres)))\n", " " ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['thresholds.dump']" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import joblib\n", "dump_list = []\n", "for i, (prev_net, (th_abs, th_pres) )in enumerate(prev_nets):\n", " net_name = f\"net_{i}\"\n", " torch.save(prev_net.state_dict(), net_name)\n", " dump_list.append((net_name,(th_abs, th_pres)))\n", "joblib.dump(dump_list, \"thresholds.dump\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "# trainer = pl.Trainer(\n", "# max_epochs=20,\n", "# # max_epochs=40,\n", "# accelerator='gpu',\n", "# devices=1,\n", "# log_every_n_steps=1,\n", "# # logger=pl.loggers.CSVLogger(save_dir=\"logs/\"),\n", "# reload_dataloaders_every_n_epochs=1,\n", "# logger=tensorboard,\n", "# callbacks=[model_checkpoint]\n", "# )\n", "# model = DistillationLightning(\n", "# lr=0.01,\n", "# prev_nets=prev_nets,\n", "# coef_0 = 2,\n", "# )\n", "# _ = trainer.fit(model,)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# for i in range(3):\n", "# model_checkpoint = ModelCheckpoint(monitor='no_improve_counter')\n", "# trainer = pl.Trainer(\n", "# max_epochs=20,\n", "# accelerator='gpu',\n", "# devices=1,\n", "# log_every_n_steps=1,\n", "# # logger=pl.loggers.CSVLogger(save_dir=\"logs/\"),\n", "# reload_dataloaders_every_n_epochs=1,\n", "# logger=tensorboard,\n", "# callbacks=[model_checkpoint]\n", "# )\n", "# print(i)\n", "# model = SudokuLightning(lr=0.01, prev_nets=prev_nets)\n", "# _ = trainer.fit(model,)\n", "# # model = model.load_from_checkpoint(model_checkpoint.best_model_path)\n", "# # trainer.validate(model=model)\n", "# prev_nets.append((model.net, (model.threshold_abs, model.threshold_pres)))" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model.no_improve_counter" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "len(prev_nets)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "from copy import copy\n", "\n", "def predict_from_net(x, net, th_abs, th_pres):\n", " x = model.sym_preprocess.forward(x)\n", " x = net(x)\n", " new_x = torch.empty(x.shape, device=x.device)\n", " new_x[:,0] = (x[:,0] > th_abs).float()\n", " new_x[:,1] = (x[:,1] > th_pres).float()\n", " return new_x\n", "\n", "def predict_fix_from_net(x, y, net, th_abs, th_pres):\n", " \n", " output = model.sym_preprocess.forward(x)\n", " output = net(output)\n", " new_x = torch.empty(x.shape, device=x.device)\n", " new_x[:,0] = (output[:,0] > th_abs).float()\n", " new_x[:,1] = (output[:,1] > th_pres).float()\n", " max_th_abs = output[:,0][(x[:,0]==0)&(y[:,0]==0)].max().item()\n", " max_th_pres = output[:,1][(x[:,1]==0)&(y[:,1]==0)].max().item()\n", " \n", " return new_x, max(th_abs, max_th_abs), max(th_pres, max_th_pres)\n", "\n", "\n", "def forward_from_prev_nets(x,y):\n", "\n", " for net, (th_abs, th_pres) in prev_nets:\n", " new_x = torch.zeros(x.shape, device=x.device)\n", " with torch.no_grad():\n", " sub_new_x = predict_from_net(x, net.to(x.device), th_abs, th_pres)\n", " new_x[sub_new_x==1]=1\n", " new_x[x==1]=1\n", " print(f\"errrors: {((new_x==1)&(y==0)).sum()}\")\n", " new_x[(new_x==1)&(y==0)]=0\n", " if new_x.sum(dim=(1,2))>x.sum(dim=(1,2)):\n", " break\n", " x = new_x\n", " return new_x\n", "\n", "\n", "def forward_from_prev_nets_all(x,y, prev_nets=prev_nets, raise_if_error=False, fix=False, full_loop=True):\n", " \n", " for i,(net, (th_abs, th_pres)) in enumerate(prev_nets):\n", " new_x = torch.zeros(x.shape, device=x.device)\n", " with torch.no_grad():\n", " if fix:\n", " sub_new_x, new_th_abs, new_th_pres = predict_fix_from_net(x, y, net.to(x.device), th_abs, th_pres)\n", " if (new_th_abs != th_abs) or (new_th_pres != th_pres):\n", " prev_nets[i] = (net, (new_th_abs, new_th_pres))\n", " else:\n", " sub_new_x = predict_from_net(x, net.to(x.device), th_abs, th_pres)\n", " new_x[sub_new_x==1]=1\n", " new_x[x==1]=1\n", " n_errors = ((new_x==1)&(y==0)).sum(dim=(0,2))\n", " # print(f\"errrors: {n_errors}\")\n", " if n_errors.sum()>0:\n", " print(f\"found errors : {n_errors}\")\n", " print(f\"model index : {i}\")\n", " if raise_if_error:\n", " raise ValueError\n", " new_x[(new_x==1)&(y==0)]=0\n", " if new_x.sum()> x.sum() and not full_loop:\n", " break\n", " x = new_x\n", " return new_x\n", "\n", "def fix_threshold(x,y,prev_nets, margin=0.05):\n", " x_feature = model.sym_preprocess.forward(x)\n", " new_prev_nets = []\n", " for net, (th_abs, th_pres) in prev_nets:\n", " \n", " output = net(x_feature) \n", " max_th_abs = output[:,0][(x[:,0]==0)&(y[:,0]==0)].max().item()\n", " if th_abs < max_th_abs+margin:\n", " th_abs = max_th_abs+margin\n", " max_th_pres = output[:,1][(x[:,1]==0)&(y[:,1]==0)].max().item()\n", " if th_pres < max_th_pres+margin:\n", " th_pres = max_th_pres+margin \n", " new_prev_nets.append((net, (th_abs, th_pres)))\n", " return new_prev_nets" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(234.)\n", "tensor(26.)\n" ] }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
\n" ], "text/plain": [ "" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(test_x.sum())\n", "print(test_x[:,1].sum())\n", "display_as_dataframe(test_x)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(535.)\n", "tensor(26.)\n" ] }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
\n" ], "text/plain": [ "" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "new_x = forward_from_prev_nets_all(test_x, test_y)\n", "print(new_x.sum())\n", "print(new_x[:,1].sum())\n", "display_as_dataframe(new_x)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(540.)\n", "tensor(26.)\n" ] }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
\n" ], "text/plain": [ "" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "prev_x = new_x.clone()\n", "new_x = forward_from_prev_nets_all(new_x, test_y)\n", "print(new_x.sum())\n", "print(new_x[:,1].sum())\n", "display_as_dataframe(new_x)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(540.)\n", "tensor(26.)\n" ] }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
\n" ], "text/plain": [ "" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "new_x = forward_from_prev_nets_all(new_x, test_y)\n", "print(new_x.sum())\n", "print(new_x[:,1].sum())\n", "display_as_dataframe(new_x)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "/home/seb/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/torch/nn/_reduction.py:42: UserWarning: size_average and reduce args will be deprecated, please use reduction='none' instead.\n", " warnings.warn(warning.format(ret))\n", "/home/seb/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/callbacks/model_checkpoint.py:612: UserWarning: Checkpoint directory lightning_logs/version_81/checkpoints exists and is not empty.\n", " rank_zero_warn(f\"Checkpoint directory {dirpath} exists and is not empty.\")\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "-----------------------------------------------------\n", "0 | net | SmallNet | 514 \n", "1 | sym_preprocess | SymPreprocess | 8.5 M \n", "2 | bcewll | BCEWithLogitsLoss | 0 \n", "3 | auroc | BinaryAUROC | 0 \n", "-----------------------------------------------------\n", "514 Trainable params\n", "8.5 M Non-trainable params\n", "8.5 M Total params\n", "34.014 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "/home/seb/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:430: PossibleUserWarning: The dataloader, val_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 12 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n", "/tmp/ipykernel_3278/2863678930.py:187: UserWarning: Data has no positive values, and therefore cannot be log-scaled.\n", " ax1.set_yscale('log')\n", "/tmp/ipykernel_3278/2863678930.py:193: UserWarning: Data has no positive values, and therefore cannot be log-scaled.\n", " ax2.set_yscale('log')\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 0\n", "item counter : 0\n", "ratio : 0.0\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/seb/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:430: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 12 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1241\n", "item counter : 1241\n", "ratio : 0.999194847020934\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1237\n", "item counter : 1916\n", "ratio : 0.6452790818988002\n", " ratio number predicted/items: 0.48982785602503914\n", "current epoch: 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGzCAYAAAD0T7cVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA6j0lEQVR4nO3de3RU5b3/8U8SyIRgLoRILhBMgUoLamJJE+NlGTSnaVS0tAqtHoxoQX8mvThUC7VNULm1h1JO6ShLLWJ7oKBWOR5BqkZd8RKLBGKtoC0laBQzQJXc0CQkz+8PZXRMgEwyl71n3q+1Zi32nmf2/s5jJB+e/Tx7RxljjAAAACwiOtQFAAAAfB7hBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBEBIrV27VlFRUdq+fXuoSwFgEYQTAABgKYQTAABgKYQTAABgKYQTAAHx9ttv6+abb9bEiRM1bNgwjRw5UldddZX27dvXZ/sjR47oxhtv1MiRI5WYmKhrr71WH374oVeb7du3q6SkRKmpqRo2bJi+9KUv6frrrw/CtwEQTENCXQCA8PTqq6/q5Zdf1ne/+12NGTNG+/bt0z333KOioiLt2rVL8fHxXu0rKiqUnJyshQsX6q233tI999yjt99+W88//7yioqJ04MABfeMb39Cpp56q+fPnKzk5Wfv27dOjjz4aom8IIFAIJwAC4tJLL9WVV17ptW/atGkqLCzUn//8Z82aNcvrvdjYWFVXV2vo0KGSpNNOO0233Xab/u///k+XX365Xn75ZX344Yd66qmnlJeX5/ncokWLAv9lAAQVl3UABMSwYcM8f+7q6tK///1vTZgwQcnJydqxY0ev9nPnzvUEE0n6f//v/2nIkCHasmWLJCk5OVmS9MQTT6irqyuwxQMIKcIJgID46KOPVFlZqaysLDkcDqWmpurUU0/V4cOH1dzc3Kv9l7/8Za/tU045RRkZGZ45KhdeeKG+853v6I477lBqaqquuOIKPfDAA+ro6AjG1wEQRIQTAAHxgx/8QIsXL9aMGTP00EMP6amnntLTTz+tkSNHqqenx+fjRUVF6ZFHHlFtba0qKir03nvv6frrr9eUKVPU1tYWgG8AIFQIJwAC4pFHHlFZWZl+/etf68orr9R//Md/6Pzzz9fhw4f7bP/Pf/7Ta7utrU3vv/++srOzvfafc845Wrx4sbZv365169bpjTfe0IYNGwL0LQCEAuEEQEDExMTIGOO1b9WqVeru7u6z/b333us1l+See+7R0aNHVVpaKkn68MMPex0vNzdXkri0A4QZVusACIjLLrtMf/zjH5WUlKRJkyaptrZWzzzzjEaOHNln+87OTl188cWaMWOG3nrrLd199906//zzdfnll0uSHnzwQd19992aPn26xo8fr9bWVt13331KTEzUJZdcEsyvBiDACCcAAuK///u/FRMTo3Xr1unjjz/Weeedp2eeeUYlJSV9tv/d736ndevWqbKyUl1dXfre976n3/72t4qKipL0yYTYbdu2acOGDXK73UpKSlJ+fr7WrVunL33pS8H8agACLMp8cZwUAAAghJhzAgAALIVwAgAALIVwAgAALIVwAgAALIVwAgAALIVwAgAALMV29znp6enR/v37lZCQ4Ln/AQAAsDZjjFpbW5WZmano6BOPjdgmnLhcLrlcLnV2dupf//pXqMsBAAAD0NjYqDFjxpywjW3CyTHH0lZjY6MSExNDXA3CSXt7uzIzMyVJ+/fv1/Dhw0NcEQCEj5aWFmVlZSkhIeGkbW13h9iWlhYlJSWpubmZcAK/am9v1ymnnCLpkyfiEk4AwH98+f1tmwmxLpdLkyZN0te//vVQlwIAAAKIkRPgU4ycAEDgMHICAABsi5ET4FOMnABA4ITlyEkwZc/frOz5m0NdBgAAEck24YTLOgAARAbb3OekvLxc5eXlnmEhS1n4uXoWNoeuDgAAwoBtRk5sZ2GSd2gBAAD9YptwYqnLOgQPAAACxjbhpLy8XLt27dKrr74a6lIAAEAA2WbOie0xLwUAgH6xzcgJAACIDLYJJ5aacwIAAALGNuGEOScAAEQG24STsMSqHwAAeiGcAAAASyGcnAyjGwAABBXhpJ/6ehggDwcEAMD/bBNOWK0DAEBksE04iZjVOlxGAgBEONuEEwAAEBkIJ37GPBQAAAYnZOHkyJEjOu200/STn/wkVCUAAAALClk4Wbx4sc4555xQnd4+mIMCAIgwIQkn//znP/Xmm2+qtLQ0FKcHAAAW5nM4qamp0bRp05SZmamoqCht2rSpVxuXy6Xs7GzFxcWpoKBA27Zt83r/Jz/5iZYuXTrgogEAQPjyOZy0t7crJydHLperz/c3btwop9Opqqoq7dixQzk5OSopKdGBAwckSf/7v/+r008/XaeffvrgKrcJJsgCAOCbIb5+oLS09ISXY1asWKE5c+Zo9uzZkqTVq1dr8+bNWrNmjebPn69XXnlFGzZs0MMPP6y2tjZ1dXUpMTFRlZWVfR6vo6NDHR0dnu2WlhZfSwYAADbi1zknnZ2dqqurU3Fx8WcniI5WcXGxamtrJUlLly5VY2Oj9u3bp+XLl2vOnDnHDSbH2iclJXleWVlZ/izZnpgkCwAIY34NJ4cOHVJ3d7fS0tK89qelpampqWlAx1ywYIGam5u1fPlyTZw4URMmTPBHqQAAwKJ8vqzjT9ddd91J2zgcDjkcDs2bN0/z5s1TS0uLkpIYNQAAIFz5deQkNTVVMTExcrvdXvvdbrfS09MHdWwe/AcAQGTwaziJjY3VlClTVF1d7dnX09Oj6upqFRYWDurY4fTgP1bwAABwfD5f1mlra9OePXs82w0NDaqvr1dKSorGjh0rp9OpsrIy5eXlKT8/XytXrlR7e7tn9c5AuVwuuVwudXd3D+o4Yenzk2MXNoeuDgAA/MDncLJ9+3ZNnTrVs+10OiVJZWVlWrt2rWbOnKmDBw+qsrJSTU1Nys3N1datW3tNkvVVeXm5ysvLmXMCAECY8zmcFBUVyRhzwjYVFRWqqKgYcFF9YeQEAIDIELIH//kqnOacAACA47NNOGG1DgAAkcE24YSREx9xF1kAgE3ZJpyEM5YWAwDwGcIJAACwFNuEE+acAAAQGWwTTphzAgBAZLBNOAEAAJEhpE8ltqSFSdoXJ2V/vD7UlfgXt7gHANiEbUZOIm3OCSt4AACRyjbhhDknAABEBtuEEwAAEBkIJwAAwFIIJ5GMW9wDACzINuEk0ibEAgAQqWwTTpgQCwBAZLBNOIl02fM3s7wYABARCCcAAMBSgh5ODh8+rLy8POXm5uqMM87QfffdF+wScCJMkgUAhFjQb1+fkJCgmpoaxcfHq729XWeccYa+/e1va+TIkcEuBQAAWFDQR05iYmIUHx8vSero6JAxRsaYYJcBAAAsyudwUlNTo2nTpikzM1NRUVHatGlTrzYul0vZ2dmKi4tTQUGBtm3b5vX+4cOHlZOTozFjxujWW29VamrqgL8AAAAILz6Hk/b2duXk5MjlcvX5/saNG+V0OlVVVaUdO3YoJydHJSUlOnDggKdNcnKyXnvtNTU0NGj9+vVyu90D/wYRjNU7AIBw5HM4KS0t1aJFizR9+vQ+31+xYoXmzJmj2bNna9KkSVq9erXi4+O1Zs2aXm3T0tKUk5OjF1544bjn6+joUEtLi9cLQcQEWQBAkPl1zklnZ6fq6upUXFz82Qmio1VcXKza2lpJktvtVmtrqySpublZNTU1mjhx4nGPuXTpUiUlJXleWVlZ/iwZAABYjF/DyaFDh9Td3a20tDSv/WlpaWpqapIkvf3227rggguUk5OjCy64QD/4wQ905plnHveYCxYsUHNzs5YvX66JEydqwoQJ/iwZAABYTNCXEufn56u+vr7f7R0OhxwOh+bNm6d58+appaVFSUlcZgAAIFz5deQkNTVVMTExvSa4ut1upaenD+rYPPgPAIDI4NdwEhsbqylTpqi6utqzr6enR9XV1SosLBzUsXnwX/+wggcAYHc+X9Zpa2vTnj17PNsNDQ2qr69XSkqKxo4dK6fTqbKyMuXl5Sk/P18rV65Ue3u7Zs+ePahCXS6XXC6Xuru7B3Uc+MGx1TsLm0NbBwAgLPkcTrZv366pU6d6tp1OpySprKxMa9eu1cyZM3Xw4EFVVlaqqalJubm52rp1a69Jsr4qLy9XeXk5c04AAAhzPoeToqKik95uvqKiQhUVFQMuqi+MnAAAEBmC/mydgWLOCQAAkcE24QQAAEQG24QTlhIDABAZbBNOuKwDAEBksE04wcAE5b4nxx4OyAMCAQB+YJtwwmUdAAAig23CCZd1AACIDLYJJwAAIDIQTgAAgKXYJpww5wQAgMhgm3DCnBP/4cnFAAArs004gc2wtBgAMECEEwAAYCmEEwAAYCmEEwAAYCm2CSes1gEAIDIMCXUB/VVeXq7y8nK1tLQoKYmJlrbz+cmxC5tDVwcAwPJsM3KCwGFpMQDASggnAADAUoIeThobG1VUVKRJkybprLPO0sMPPxzsEgAAgIUFfc7JkCFDtHLlSuXm5qqpqUlTpkzRJZdcouHDhwe7FAAAYEFBHznJyMhQbm6uJCk9PV2pqan64IMPgl0GToJ5KACAUPE5nNTU1GjatGnKzMxUVFSUNm3a1KuNy+VSdna24uLiVFBQoG3btvV5rLq6OnV3dysrK8vnwgEAQHjyOZy0t7crJydHLperz/c3btwop9Opqqoq7dixQzk5OSopKdGBAwe82n3wwQe69tprde+9957wfB0dHWppafF6AQCA8OVzOCktLdWiRYs0ffr0Pt9fsWKF5syZo9mzZ2vSpElavXq14uPjtWbNGk+bjo4Ofetb39L8+fN17rnnnvB8S5cuVVJSkufFKEsY4eGAAIA++HXOSWdnp+rq6lRcXPzZCaKjVVxcrNraWkmSMUbXXXedLrroIs2aNeukx1ywYIGam5s9r8bGRn+WDAAALMav4eTQoUPq7u5WWlqa1/60tDQ1NTVJkl566SVt3LhRmzZtUm5urnJzc/X6668f95gOh0OJiYn64x//qHPOOUcXX3yxP0sGAAAWE/SlxOeff756enqCfVoAAGATfh05SU1NVUxMjNxut9d+t9ut9PT0QR27vLxcu3bt0quvvjqo4wAAAGvzaziJjY3VlClTVF1d7dnX09Oj6upqFRYWDurYPJU4QjBJFgAins+Xddra2rRnzx7PdkNDg+rr65WSkqKxY8fK6XSqrKxMeXl5ys/P18qVK9Xe3q7Zs2cPqlCeShxax27Ktm/ZpSGuBAAQ7nwOJ9u3b9fUqVM9206nU5JUVlamtWvXaubMmTp48KAqKyvV1NSk3Nxcbd26tdckWQAAgL74HE6KiopkjDlhm4qKClVUVAy4qL64XC65XC51d3f79bgAAMBagv5snYFiQiwAAJHBNuGECbEAAEQG24QTRk6shycXAwACwTbhBAAARAbbhBMu6wAAEBlsE064rAMAQGSwTTgBAACRgXACv2KSLABgsGwTTphzEqF41g4ARBzbhBPmnAAAEBlsE04AAEBkIJwAAABLIZzAfpiHAgBhjXACAAAsxTbhhNU6AABEBtuEE1br4Li4zAMAYcU24QQAAEQGwgkAALCUkIST6dOna8SIEbryyitDcXoAAGBhIQknP/rRj/SHP/whFKdGkPGsHQCAr0ISToqKipSQkBCKUwMAAIvzOZzU1NRo2rRpyszMVFRUlDZt2tSrjcvlUnZ2tuLi4lRQUKBt27b5o1ag/1jBAwC25XM4aW9vV05OjlwuV5/vb9y4UU6nU1VVVdqxY4dycnJUUlKiAwcODLpYAAAQ/ob4+oHS0lKVlpYe9/0VK1Zozpw5mj17tiRp9erV2rx5s9asWaP58+f7XGBHR4c6Ojo82y0tLT4fAwAA2Idf55x0dnaqrq5OxcXFn50gOlrFxcWqra0d0DGXLl2qpKQkzysrK8tf5QIAAAvyazg5dOiQuru7lZaW5rU/LS1NTU1Nnu3i4mJdddVV2rJli8aMGXPC4LJgwQI1Nzdr+fLlmjhxoiZMmODPkhECrOABAJyIz5d1/OGZZ57pd1uHwyGHw6F58+Zp3rx5amlpUVISEx0BAAhXfh05SU1NVUxMjNxut9d+t9ut9PT0QR2bB/8BABAZ/BpOYmNjNWXKFFVXV3v29fT0qLq6WoWFhYM6Ng/+AwAgMvh8WaetrU179uzxbDc0NKi+vl4pKSkaO3asnE6nysrKlJeXp/z8fK1cuVLt7e2e1TsD5XK55HK51N3dPajjAAAAa/M5nGzfvl1Tp071bDudTklSWVmZ1q5dq5kzZ+rgwYOqrKxUU1OTcnNztXXr1l6TZH1VXl6u8vJy5pwAABDmfA4nRUVFMsacsE1FRYUqKioGXFRfGDnBoHz+brELm0NXBwDgpELybJ2BYM4JAACRwTbhhNU6AABEBtuEE0ZOAACIDLYJJwAAIDIQTgAAgKXYJpww5yR88awdAMDn2SacMOcEAIDIYJtwAgAAIgPhBAAAWIptwglzTnAy2fM3M38FAMKAbcIJc04AAIgMtgknAAAgMhBOAACApRBOAACApdgmnDAhNrL0Z2KrZSa/Lkz65AUA8AvbhBMmxAIAEBlsE04AAEBkIJwAAABLCUk4eeKJJzRx4kR9+ctf1v333x+KEgAAgEUNCfYJjx49KqfTqeeee05JSUmaMmWKpk+frpEjRwa7FAAAYEFBHznZtm2bJk+erNGjR+uUU05RaWmpnnrqqWCXAQAALMrncFJTU6Np06YpMzNTUVFR2rRpU682LpdL2dnZiouLU0FBgbZt2+Z5b//+/Ro9erRne/To0XrvvfcGVj0AAAg7PoeT9vZ25eTkyOVy9fn+xo0b5XQ6VVVVpR07dignJ0clJSU6cODAoIsFAADhz+dwUlpaqkWLFmn69Ol9vr9ixQrNmTNHs2fP1qRJk7R69WrFx8drzZo1kqTMzEyvkZL33ntPmZmZxz1fR0eHWlpavF4AACB8+XXOSWdnp+rq6lRcXPzZCaKjVVxcrNraWklSfn6+/v73v+u9995TW1ubnnzySZWUlBz3mEuXLlVSUpLnlZWV5c+SEYE8d5b94p1dF2f0btzX3V+5IywABJRfw8mhQ4fU3d2ttLQ0r/1paWlqamqSJA0ZMkS//vWvNXXqVOXm5mrevHknXKmzYMECNTc3e16NjY3+LBkAAFhM0JcSS9Lll1+uyy+/vF9tHQ6HHA6HXC6XXC6Xuru7A1wdAAAIJb+OnKSmpiomJkZut9trv9vtVnp6uj9PBQAAwpRfw0lsbKymTJmi6upqz76enh5VV1ersLBwUMfmwX8AAEQGny/rtLW1ac+ePZ7thoYG1dfXKyUlRWPHjpXT6VRZWZny8vKUn5+vlStXqr29XbNnzx5UoVzWAQAgMvgcTrZv366pU6d6tp1OpySprKxMa9eu1cyZM3Xw4EFVVlaqqalJubm52rp1a69Jsr4qLy9XeXm5WlpalJTESgkAAMKVz+GkqKhIxpgTtqmoqFBFRcWAi+rLsZGTo0ePSlLg7nfS8cl36+k48sk5PrftOe9x2hzvc/1uw/mP/7nP//f2oUZ94bgnOnb759q0tLR8Mkp3gvP3Ojb34AGA4zr29/zJMoQkRZn+tLKQd999l3udAABgU42NjRozZswJ29gunPT09Gj//v1KSEhQVFSU34/f0tKirKwsNTY2KjEx0e/Hxyfo5+Chr4ODfg4O+jl4/N3Xxhi1trYqMzNT0dEnXo8TkvucDEZ0dPRJE5c/JCYm8oMfBPRz8NDXwUE/Bwf9HDz+7Ov+zhn161JiAACAwSKcAAAASyGcfIHD4VBVVZUcDkeoSwlr9HPw0NfBQT8HB/0cPKHsa9tNiAUAAOGNkRMAAGAphBMAAGAphBMAAGAphBMAAGApERlOXC6XsrOzFRcXp4KCAm3btu2E7R9++GF95StfUVxcnM4880xt2bIlSJXamy/9fN999+mCCy7QiBEjNGLECBUXF5/0vws+4+vP9DEbNmxQVFSUvvWtbwW2wDDhaz8fPnxY5eXlysjIkMPh0Omnn87fH/3gaz+vXLlSEydO1LBhw5SVlaVbbrlFH3/8cZCqtaeamhpNmzZNmZmZioqK0qZNm076meeff15f+9rX5HA4NGHCBK1duzZwBZoIs2HDBhMbG2vWrFlj3njjDTNnzhyTnJxs3G53n+1feuklExMTY371q1+ZXbt2mZ///Odm6NCh5vXXXw9y5fbiaz9fffXVxuVymZ07d5rdu3eb6667ziQlJZl33303yJXbj699fUxDQ4MZPXq0ueCCC8wVV1wRnGJtzNd+7ujoMHl5eeaSSy4xL774omloaDDPP/+8qa+vD3Ll9uJrP69bt844HA6zbt0609DQYP7yl7+YjIwMc8sttwS5cnvZsmWLuf32282jjz5qJJnHHnvshO337t1r4uPjjdPpNLt27TKrVq0yMTExZuvWrQGpL+LCSX5+vikvL/dsd3d3m8zMTLN06dI+28+YMcNceumlXvsKCgrMjTfeGNA67c7Xfv6io0ePmoSEBPPggw8GqsSwMZC+Pnr0qDn33HPN/fffb8rKyggn/eBrP99zzz1m3LhxprOzM1glhgVf+7m8vNxcdNFFXvucTqc577zzAlpnOOlPOLntttvM5MmTvfbNnDnTlJSUBKSmiLqs09nZqbq6OhUXF3v2RUdHq7i4WLW1tX1+pra21qu9JJWUlBy3PQbWz1905MgRdXV1KSUlJVBlhoWB9vWdd96pUaNG6YYbbghGmbY3kH5+/PHHVVhYqPLycqWlpemMM87QkiVL1N3dHayybWcg/Xzuueeqrq7Oc+ln79692rJliy655JKg1Bwpgv270HYP/huMQ4cOqbu7W2lpaV7709LS9Oabb/b5maampj7bNzU1BaxOuxtIP3/RT3/6U2VmZvb6nwHeBtLXL774on7/+9+rvr4+CBX2X09Pjzo7OxUXFxfqUnoZSD/v3btXzz77rK655hpt2bJFe/bs0c0336yuri5VVVUFo2zbGUg/X3311Tp06JDOP/98GWN09OhR3XTTTfrZz34WjJIjxvF+F7a0tOijjz7SsGHD/Hq+iBo5gT0sW7ZMGzZs0GOPPWbJX1R21traqlmzZum+++5TampqQM6xcOFCRUVF6c0339SMGTOUmJiokSNH6kc/+pHXJMWoqChVVFRo3bp1mjx5shwOh7Zu3SpJeu+993T99dcrLS1NDodDkydP1po1a3qda9WqVZo8ebLi4+M1YsQI5eXlaf369QH5Xr7q6enRqFGjdO+992rKlCmaOXOmbr/9dq1evTrUpYWV559/XkuWLNHdd9+tHTt26NFHH9XmzZt11113hbo0DEJEjZykpqYqJiZGbrfba7/b7VZ6enqfn0lPT/epPQbWz8csX75cy5Yt0zPPPKOzzjorkGWGBV/7+l//+pf27dunadOmefb19PRIkoYMGaK33npL48eP90ttM2bMUHZ2tpYuXapXXnlFv/3tb/Xhhx/qD3/4g6fNs88+q4ceekgVFRVKTU1Vdna23G63zjnnHE94OfXUU/Xkk0/qhhtuUEtLi3784x9L+mSF1w9/+ENdeeWVnuDzt7/9TX/961919dVX++U7HDOQn+mMjAwNHTpUMTExnn1f/epX1dTUpM7OTsXGxvq1xnAwkH7+xS9+oVmzZun73/++JOnMM89Ue3u75s6dq9tvv13R0fwb3B+O97swMTHR76MmkiJvtU5+fr6pqKjwbHd3d5vRo0efcELsZZdd5rWvsLCQCbEn4Ws/G2PML3/5S5OYmGhqa2uDUWLY8KWvP/roI/P66697va644gpz0UUXmddff910dHQMup6qqiojyVx++eVe+2+++WYjybz22mvGmE8m4UVHR5s33njDq90NN9xgMjIyzKFDh7z2f/e73zVJSUnmyJEjxhhjrrjiil4T9ALJ15/pBQsWmNNOO810d3d79q1cudJkZGQEvFY787Wfv/a1r5nbbrvNa9/69evNsGHDzNGjRwNaa7hQPyfEnnHGGV77vve97wVsQmzEhZMNGzYYh8Nh1q5da3bt2mXmzp1rkpOTTVNTkzHGmFmzZpn58+d72r/00ktmyJAhZvny5Wb37t2mqqqKpcT94Gs/L1u2zMTGxppHHnnEvP/++55Xa2trqL6Cbfja11/k79U6x8LJX/7yF6/9u3fvNpI8v2QkmalTp3q16enpMcnJyWbu3Lnm4MGDXq8HHnjASDIvvviip+6kpCSzbds2v9V+Ir728zvvvGMSEhJMRUWFeeutt8wTTzxhRo0aZRYtWhSUeu3K136uqqoyCQkJ5k9/+pPZu3eveeqpp8z48ePNjBkzQvUVbKG1tdXs3LnT7Ny500gyK1asMDt37jRvv/22McaY+fPnm1mzZnnaH1tKfOutt5rdu3cbl8vFUmJ/W7VqlRk7dqyJjY01+fn55pVXXvG8d+GFF5qysjKv9g899JA5/fTTTWxsrJk8ebLZvHlzkCu2J1/6+bTTTjOSer2qqqqCX7gN+foz/XmBCid79+712t/Z2Wmio6M9o46SzPXXX+/Vxu129/lz8PnXo48+aowxZteuXWb06NFGkpkwYYK5+eabPcElUHzt55dfftkUFBQYh8Nhxo0bZxYvXsy/5vvBl37u6uoyCxcuNOPHjzdxcXEmKyvL3HzzzebDDz8MfuE28txzz/X5/9exvi0rKzMXXnhhr8/k5uaa2NhYM27cOPPAAw8ErL4oY4zx/8UiAJFq4cKFuuOOO7R371596Utf8uw/evSoHA6H5syZo9WrVysqKkrl5eX63e9+52nT1NSkjIwM/ed//qfKysr6PP5ZZ52lUaNGSZLa29v1xBNPaOvWrXryySfldrtVWVmpO+64I7BfEkBARdSEWADB889//tMrnOzZs0c9PT3Kzs4+7mdOPfVUJSQkqLu7u1/LyIcPH66ZM2dq5syZ6uzs1Le//W0tXrxYCxYsYKUXYGNMYwYQEC6Xy2t71apVkqTS0tLjfiYmJkbf+c539Oc//1l///vfe71/8OBBz5///e9/e70XGxurSZMmyRijrq6uwZQOIMQYOQEQEA0NDbr88sv1zW9+U7W1tfqf//kfXX311crJyTnh55YtW6bnnntOBQUFmjNnjiZNmqQPPvhAO3bs0DPPPKMPPvhAkvSNb3xD6enpOu+885SWlqbdu3frd7/7nS699FIlJCQE4ysCCBDCCYCA2LhxoyorKzV//nwNGTJEFRUV+q//+q+Tfi4tLU3btm3TnXfeqUcffVR33323Ro4cqcmTJ+uXv/ylp92NN96odevWacWKFWpra9OYMWP0wx/+UD//+c8D+bUABAETYgH41bEJsQcPHgzYXWgBhDfmnAAAAEshnAAAAEshnAAAAEthzgkAALAURk4AAICl2G4pcU9Pj/bv36+EhARFRUWFuhwAANAPxhi1trYqMzNT0dEnHhuxXTjZv3+/srKyQl0GAAAYgMbGRo0ZM+aEbWwXTo7d+bGxsVGJiYkhrgZ2197erszMTEmfBN/hw4eHuCIACE8tLS3Kysrq1x2cbRdOjl3KSUxMJJxg0GJiYjx/TkxMJJwAQID1Z0oGE2IBAIClEE4AAIClEE4AAICl2G7OCQAAgdbT06POzs5Ql2ErQ4cO9ZrHNxiEEwAAPqezs1MNDQ3q6ekJdSm2k5ycrPT09EHfh4xw0ofs+ZslSfuWXRriSgAAwWSM0fvvv6+YmBhlZWWd9GZh+IQxRkeOHNGBAwckSRkZGYM6HuEEAIBPHT16VEeOHFFmZqbi4+NDXY6tDBs2TJJ04MABjRo1alCXeIiEAAB8qru7W5IUGxsb4krs6Vig6+rqGtRxCCcAAHwBz24bGH/1G+EEAABYCuEEAABYChNiAQA4iWOrOIMl0leLMnICAAD69MEHH+iaa65RYmKikpOTdcMNN6itrS3g5yWcAAAQgfpzB9xrrrlGb7zxhp5++mk98cQTqqmp0dy5cwNeG+EEAIAw0NraqmuuuUbDhw9XRkaGfvOb36ioqEg//vGPJUnZ2dm66667dO211yoxMfGkIWP37t3aunWr7r//fhUUFOj888/XqlWrtGHDBu3fvz+g34VwAgBAGHA6nXrppZf0+OOP6+mnn9YLL7ygHTt2eLVZvny5cnJytHPnTv3iF7844fFqa2uVnJysvLw8z77i4mJFR0frr3/9a0C+wzFMiAUAwOZaW1v14IMPav369br44oslSQ888IAyMzO92l100UWaN29ev47Z1NSkUaNGee0bMmSIUlJS1NTU5J/Cj4OREwAAbG7v3r3q6upSfn6+Z19SUpImTpzo1e7zoyBWRjgBACBCDB8+vN9t09PTPQ/yO+bo0aP64IMPlJ6e7u/SvBBOAACwuXHjxmno0KF69dVXPfuam5v1j3/8Y8DHLCws1OHDh1VXV+fZ9+yzz6qnp0cFBQWDqvdkmHMCAIDNJSQkqKysTLfeeqtSUlI0atQoVVVVKTo6esDPu/nqV7+qb37zm5ozZ45Wr16trq4uVVRU6Lvf/W6vuSz+RjgBAOAk7HDH1hUrVuimm27SZZddpsTERN12221qbGxUXFzcgI+5bt06VVRU6OKLL1Z0dLS+853v6Le//a0fq+4b4QQAgDCQkJCgdevWebbb29t1xx13eO5nsm/fPp+PmZKSovXr1/urxH4LSTjJzs5WYmKioqOjNWLECD333HOhKAMAgLCxc+dOvfnmm8rPz1dzc7PuvPNOSdIVV1wR4sp8F7KRk5dfflmnnHJKqE4PAEDYWb58ud566y3FxsZqypQpeuGFF5Samtpn2yVLlmjJkiV9vnfBBRfoySefDGSpJ8RlHQAAwsDZZ5/ttbLmZG666SbNmDGjz/eGDRvmr7IGxOelxDU1NZo2bZoyMzMVFRWlTZs29WrjcrmUnZ2tuLg4FRQUaNu2bV7vR0VF6cILL9TXv/51r+tjAAAgOFJSUjRhwoQ+X6NHjw5pbT6Hk/b2duXk5MjlcvX5/saNG+V0OlVVVaUdO3YoJydHJSUlXjdyefHFF1VXV6fHH39cS5Ys0d/+9reBfwMAABBWfA4npaWlWrRokaZPn97n+ytWrNCcOXM0e/ZsTZo0SatXr1Z8fLzWrFnjaXMskWVkZOiSSy7p9WCiz+vo6FBLS4vXCwAAhC+/3iG2s7NTdXV1Ki4u/uwE0dEqLi5WbW2tpE9GXlpbWyVJbW1tevbZZzV58uTjHnPp0qVKSkryvLKysvxZMgAAsBi/hpNDhw6pu7tbaWlpXvvT0tI8TzB0u906//zzlZOTo3POOUfXXnutvv71rx/3mAsWLFBzc7Pn1djY6M+SAQCAxQR9tc64ceP02muv9bu9w+GQw+EIYEUnlz1/s+fPdrhLIAAAdubXcJKamqqYmBi53W6v/W63O+BPMAQAIGAWJgX5fM3BPZ/F+PWyzrGbvlRXV3v29fT0qLq6WoWFhf48Vchlz9/sNaICAEC4Wbx4sc4991zFx8crOTk5aOf1eeSkra1Ne/bs8Ww3NDSovr5eKSkpGjt2rJxOp8rKypSXl6f8/HytXLlS7e3tmj17tl8LBwAAA9fZ2anY2NiTtrnqqqtUWFio3//+90GqbAAjJ9u3b9fZZ5+ts88+W5LkdDp19tlnq7KyUpI0c+ZMLV++XJWVlcrNzVV9fb22bt3aa5IsAADwn9bWVl1zzTUaPny4MjIy9Jvf/EZFRUX68Y9/LOmT59rddddduvbaa5WYmOh5IOCJ3HHHHbrlllt05plnBrh6bz6PnBQVFckYc8I2FRUVqqioGHBRAADAN06nUy+99JIef/xxpaWlqbKyUjt27FBubq6nzbHBg6qqqtAV2g88WwcAAJtrbW3Vgw8+qPXr1+viiy+WJD3wwAPKzMz0anfRRRdp3rx5oSjRJ4QTP2G5MQAgVPbu3auuri7l5+d79iUlJWnixIle7fLy8oJd2oD4dbUOAACwruHDh4e6hH4hnAAAYHPjxo3T0KFD9eqrr3r2NTc36x//+EcIqxo4LusAAGBzCQkJKisr06233qqUlBSNGjVKVVVVio6OVlRU1ICP+8477+iDDz7QO++8o+7ubtXX10uSJkyYoFNOOcVP1fdGOAEA4GRscMfWFStW6KabbtJll12mxMRE3XbbbWpsbFRcXNyAj1lZWakHH3zQs33sNiLPPfecioqKBlvycRFOAAAIAwkJCVq3bp1nu729XXfccYfnfib79u3z+Zhr167V2rVr/VRh/xFOAAAIAzt37tSbb76p/Px8NTc3684775QkXXHFFSGuzHdMiA0gnr8DAAim5cuXKycnR8XFxWpvb9cLL7yg1NTUPtsuWbJEp5xySp+v0tLSIFfujZETAADCwNlnn626urp+t7/ppps0Y8aMPt8bNmyYv8oaEMIJAAARKCUlRSkpKaEuo09c1gEA4AtO9gw59M1f/UY4GYiFSdoXd/WAPso8FACwrpiYGElSZ2dniCuxpyNHjkiShg4dOqjjcFkHAIBPDRkyRPHx8Tp48KCGDh2q6Gj+Dd8fxhgdOXJEBw4cUHJysifkDRThxB8WJmnfp/e4yf54fWhrAQAMWFRUlDIyMtTQ0KC333471OXYTnJystLT0wd9HMLJyXwaPAgdABAZYmNj9eUvf5lLOz4aOnTooEdMjiGcAADwBdHR0YO67TsGh4tpgTKISbMAAEQywgkAALAULusEy8IkSeo1f+XYsuJ9yy4NSVkAAFgNIycAAMBSCCcAAMBSCCcAAMBSCCehdJwVPdziHgAQyQgnAADAUggnAADAUggnVsPN2wAAEY5wAgAALIWbsNnA5yfHcrM2AEC4Y+TE6rjMAwCIMIQTAABgKVzWsaNPn9OT/fF6LvMAAMIOIycAAMBSGDkJB5+OpEiMpgAA7I+REwAAYCmEEwAAYCmEk3C1MMnrcg8AAHZBOIE3Qg0AIMSCHk4OHz6svLw85ebm6owzztB9990X7BIAAICFBX21TkJCgmpqahQfH6/29nadccYZ+va3v62RI0cGu5TI8vnRkIXNoasDAICTCPrISUxMjOLj4yVJHR0dMsbIGBPsMo4vzG4X//nn8vTCJRwAgAX5HE5qamo0bdo0ZWZmKioqSps2berVxuVyKTs7W3FxcSooKNC2bdu83j98+LBycnI0ZswY3XrrrUpNTR3wFwAAAOHF53DS3t6unJwcuVyuPt/fuHGjnE6nqqqqtGPHDuXk5KikpEQHDhzwtElOTtZrr72mhoYGrV+/Xm63+7jn6+joUEtLi9cLg3PC0RQAAELM53BSWlqqRYsWafr06X2+v2LFCs2ZM0ezZ8/WpEmTtHr1asXHx2vNmjW92qalpSknJ0cvvPDCcc+3dOlSJSUleV5ZWVm+lowBIMAAAELFr3NOOjs7VVdXp+Li4s9OEB2t4uJi1dbWSpLcbrdaW1slSc3NzaqpqdHEiROPe8wFCxaoubnZ82psbPRnyRBBBABgLX5drXPo0CF1d3crLS3Na39aWprefPNNSdLbb7+tuXPneibC/uAHP9CZZ5553GM6HA45HA5/lgkAACws6EuJ8/PzVV9fH+zTwp+OrfBhSTIAIAD8Gk5SU1MVExPTa4Kr2+1Wenq6P0+FYPFXEOE+KwCAfvLrnJPY2FhNmTJF1dXVnn09PT2qrq5WYWGhP08FAADClM8jJ21tbdqzZ49nu6GhQfX19UpJSdHYsWPldDpVVlamvLw85efna+XKlWpvb9fs2bP9WjgAAAhPPoeT7du3a+rUqZ5tp9MpSSorK9PatWs1c+ZMHTx4UJWVlWpqalJubq62bt3aa5IswhzzUgAAA+RzOCkqKjrp7eYrKipUUVEx4KJgM8wnAQD4UdCfrQN48GwfAEAfCCcAAMBSCCcAAMBSCCcAAMBSCCfol+z5m3kGDwAgKAgnGDDCCgAgEAgnsDZW9ABAxCGcAAAASyGcwH6+OJrS1+gKIy4AYFuEEwAAYCmEE1gLIx4AEPEIJwAAwFIIJ/ArlhcDAAaLcAIAACxlSKgLAILCa3VPc+jqAACcFCMnAADAUggnAADAUggnQCCwJBoABoxwAgAALIVwAgAALIVwAgAALIVwgqDjRm0AgBMhnAAAAEshnAAAAEshnCCgbHUJZ3FG7yXALAkGgKDj9vWIXAuTpE7jn+NIJ74tPrfPB4B+Y+QEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEIWerG7UBAAKOcAL4irvGAkBAEU4AAIClEE4AAIClhCScTJ8+XSNGjNCVV14ZitMDAAALC0k4+dGPfqQ//OEPoTg1AACwuJCEk6KiIiUkJITi1AAAwOJ8Dic1NTWaNm2aMjMzFRUVpU2bNvVq43K5lJ2drbi4OBUUFGjbtm3+qBUAAEQAn8NJe3u7cnJy5HK5+nx/48aNcjqdqqqq0o4dO5STk6OSkhIdOHBg0MUicmXP38z9UAAgQgzx9QOlpaUqLS097vsrVqzQnDlzNHv2bEnS6tWrtXnzZq1Zs0bz58/3ucCOjg51dHR4tltaWnw+BgAAsA+/zjnp7OxUXV2diouLPztBdLSKi4tVW1s7oGMuXbpUSUlJnldWVpa/ygUAABbk13By6NAhdXd3Ky0tzWt/WlqampqaPNvFxcW66qqrtGXLFo0ZM+aEwWXBggVqbm72vBobG/1ZMiyKSzif4m60ACKQz5d1/OGZZ57pd1uHwyGHwxHAagAAgJX4deQkNTVVMTExcrvdXvvdbrfS09P9eSoAABCm/BpOYmNjNWXKFFVXV3v29fT0qLq6WoWFhf48FQAACFM+X9Zpa2vTnj17PNsNDQ2qr69XSkqKxo4dK6fTqbKyMuXl5Sk/P18rV65Ue3u7Z/UOAADAifgcTrZv366pU6d6tp1OpySprKxMa9eu1cyZM3Xw4EFVVlaqqalJubm52rp1a69JsgAG6NgE2YXNoa0DAALE53BSVFQkY8wJ21RUVKiiomLARQEAgMgVkmfrAAAAHA/hBAAAWArhBAgVbrAGAH0inAAAAEshnAAAAEshnMC2vvj8nez5m+39TJ5jl3m41AMgwhFOAACApRBOAACApRBOAACApRBOAACApRBOALtjEi2AMEM4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4QViz9YMAB+OL9z7hoYIAbIRwAgAALIVwAgAALIVwAgAALIVwAgAALIVwAgAALGVIqAvwlTFGktTS0hKYE3R8cvyejiOfnONz257zHqfN8T7X7zacf1Dn72+N+ty52js/29/SYdRterfx2u5rny9tTvS5/rTx5/kBIIiO/T1/7Pf4iUSZ/rSykHfffVdZWVmhLgMAAAxAY2OjxowZc8I2tgsnPT092r9/vxISEhQVFeX347e0tCgrK0uNjY1KTEz0+/HxCfo5eOjr4KCfg4N+Dh5/97UxRq2trcrMzFR09Ilnldjusk50dPRJE5c/JCYm8oMfBPRz8NDXwUE/Bwf9HDz+7OukpP7dCJIJsQAAwFIIJwAAwFIIJ1/gcDhUVVUlh8MR6lLCGv0cPPR1cNDPwUE/B08o+9p2E2IBAEB4Y+QEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYSkSGE5fLpezsbMXFxamgoEDbtm07YfuHH35YX/nKVxQXF6czzzxTW7ZsCVKl9uZLP99333264IILNGLECI0YMULFxcUn/e+Cz/j6M33Mhg0bFBUVpW9961uBLTBM+NrPhw8fVnl5uTIyMuRwOHT66afz90c/+NrPK1eu1MSJEzVs2DBlZWXplltu0ccffxykau2ppqZG06ZNU2ZmpqKiorRp06aTfub555/X1772NTkcDk2YMEFr164NXIEmwmzYsMHExsaaNWvWmDfeeMPMmTPHJCcnG7fb3Wf7l156ycTExJhf/epXZteuXebnP/+5GTp0qHn99deDXLm9+NrPV199tXG5XGbnzp1m9+7d5rrrrjNJSUnm3XffDXLl9uNrXx/T0NBgRo8ebS644AJzxRVXBKdYG/O1nzs6OkxeXp655JJLzIsvvmgaGhrM888/b+rr64Ncub342s/r1q0zDofDrFu3zjQ0NJi//OUvJiMjw9xyyy1BrtxetmzZYm6//Xbz6KOPGknmscceO2H7vXv3mvj4eON0Os2uXbvMqlWrTExMjNm6dWtA6ou4cJKfn2/Ky8s9293d3SYzM9MsXbq0z/YzZswwl156qde+goICc+ONNwa0TrvztZ+/6OjRoyYhIcE8+OCDgSoxbAykr48ePWrOPfdcc//995uysjLCST/42s/33HOPGTdunOns7AxWiWHB134uLy83F110kdc+p9NpzjvvvIDWGU76E05uu+02M3nyZK99M2fONCUlJQGpKaIu63R2dqqurk7FxcWefdHR0SouLlZtbW2fn6mtrfVqL0klJSXHbY+B9fMXHTlyRF1dXUpJSQlUmWFhoH195513atSoUbrhhhuCUabtDaSfH3/8cRUWFqq8vFxpaWk644wztGTJEnV3dwerbNsZSD+fe+65qqur81z62bt3r7Zs2aJLLrkkKDVHimD/LrTdU4kH49ChQ+ru7lZaWprX/rS0NL355pt9fqapqanP9k1NTQGr0+4G0s9f9NOf/lSZmZm9/meAt4H09Ysvvqjf//73qq+vD0KF4WEg/bx37149++yzuuaaa7Rlyxbt2bNHN998s7q6ulRVVRWMsm1nIP189dVX69ChQzr//PNljNHRo0d100036Wc/+1kwSo4Yx/td2NLSoo8++kjDhg3z6/kiauQE9rBs2TJt2LBBjz32mOLi4kJdTlhpbW3VrFmzdN999yk1NTXU5YS1np4ejRo1Svfee6+mTJmimTNn6vbbb9fq1atDXVpYef7557VkyRLdfffd2rFjhx599FFt3rxZd911V6hLwyBE1MhJamqqYmJi5Ha7vfa73W6lp6f3+Zn09HSf2mNg/XzM8uXLtWzZMj3zzDM666yzAllmWPC1r//1r39p3759mjZtmmdfT0+PJGnIkCF66623NH78+MAWbUMD+ZnOyMjQ0KFDFRMT49n31a9+VU1NTers7FRsbGxAa7ajgfTzL37xC82aNUvf//73JUlnnnmm2tvbNXfuXN1+++2Kjubf4P5wvN+FiYmJfh81kSJs5CQ2NlZTpkxRdXW1Z19PT4+qq6tVWFjY52cKCwu92kvS008/fdz2GFg/S9KvfvUr3XXXXdq6davy8vKCUart+drXX/nKV/T666+rvr7e87r88ss1depU1dfXKysrK5jl28ZAfqbPO+887dmzxxP+JOkf//iHMjIyCCbHMZB+PnLkSK8AciwQGp5r6zdB/10YkGm2FrZhwwbjcDjM2rVrza5du8zcuXNNcnKyaWpqMsYYM2vWLDN//nxP+5deeskMGTLELF++3OzevdtUVVWxlLgffO3nZcuWmdjYWPPII4+Y999/3/NqbW0N1VewDV/7+otYrdM/vvbzO++8YxISEkxFRYV56623zBNPPGFGjRplFi1aFKqvYAu+9nNVVZVJSEgwf/rTn8zevXvNU089ZcaPH29mzJgRqq9gC62trWbnzp1m586dRpJZsWKF2blzp3n77beNMcbMnz/fzJo1y9P+2FLiW2+91ezevdu4XC6WEvvbqlWrzNixY01sbKzJz883r7zyiue9Cy+80JSVlXm1f+ihh8zpp59uYmNjzeTJk83mzZuDXLE9+dLPp512mpHU61VVVRX8wm3I15/pzyOc9J+v/fzyyy+bgoIC43A4zLhx48zixYvN0aNHg1y1/fjSz11dXWbhwoVm/PjxJi4uzmRlZZmbb77ZfPjhh8Ev3Eaee+65Pv/OPda3ZWVl5sILL+z1mdzcXBMbG2vGjRtnHnjggYDVF2UM414AAMA6ImrOCQAAsD7CCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsJT/D/SCuPbBroFYAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1239\n", "item counter : 1744\n", "ratio : 0.710028653295129\n", " ratio number predicted/items: 0.39140401146131804\n", "current epoch: 2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1239\n", "item counter : 1607\n", "ratio : 0.7705223880597015\n", " ratio number predicted/items: 0.2916666666666667\n", "current epoch: 3\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1241\n", "item counter : 1515\n", "ratio : 0.8186015831134564\n", " ratio number predicted/items: 0.20976253298153033\n", "current epoch: 4\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1247\n", "item counter : 1436\n", "ratio : 0.8677800974251914\n", " ratio number predicted/items: 0.14474599860821155\n", "current epoch: 5\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1245\n", "item counter : 1462\n", "ratio : 0.8509911141490089\n", " ratio number predicted/items: 0.1674641148325359\n", "current epoch: 6\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1239\n", "item counter : 1611\n", "ratio : 0.7686104218362283\n", " ratio number predicted/items: 0.2698511166253102\n", "current epoch: 7\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1227\n", "item counter : 1863\n", "ratio : 0.6582618025751072\n", " ratio number predicted/items: 0.44206008583690987\n", "current epoch: 8\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiYAAAGzCAYAAAAbjdwrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA1yElEQVR4nO3dfXRU1b3/8c8kkAnBPBBiniSYgldaHhpa0qTxYQGaWwqKiLXQwsUULegP0lbTpYVaCShPtV7KLY2ySsXovaFgLbK8QqkSZUU0LSUh1itgSwkaixmgShIGTUKyf3/YjAxJIDPMw5mZ92utWeXs2XPOd3YD+bjPPufYjDFGAAAAFhAV7AIAAAC6EEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEwABFV5eblsNpv27dsX7FIAWADBBAAAWAbBBAAAWAbBBAAAWAbBBIBfvPvuu1qwYIFGjBihAQMGaPDgwfrmN7+po0eP9tj/zJkzuvvuuzV48GAlJCTojjvu0EcffeTWZ9++fZo0aZJSUlI0YMAAfe5zn9Odd94ZgG8DIFD6BbsAAOHpz3/+s9544w1961vf0pAhQ3T06FE98cQTmjBhgg4cOKC4uDi3/sXFxUpKStLSpUv1zjvv6IknntC7776r3bt3y2az6fjx4/ra176myy+/XIsWLVJSUpKOHj2qrVu3BukbAvAHggkAv7jpppt0++23u7VNnTpVBQUF+t3vfqc5c+a4vRcTE6PKykr1799fknTllVfqgQce0P/+7//qlltu0RtvvKGPPvpIL730knJzc12fW758uf+/DICA4VQOAL8YMGCA68/t7e365z//qauuukpJSUmqra3t1n/+/PmuUCJJ/+///T/169dPO3bskCQlJSVJkl588UW1t7f7t3gAQUMwAeAXH3/8sZYsWaKsrCzZ7XalpKTo8ssv16lTp9TU1NSt/7/927+5bV922WXKyMhwrUkZP368vvGNb2jZsmVKSUnRtGnT9NRTT6m1tTUQXwdAgBBMAPjF9773Pa1YsUIzZszQs88+q5deekkvv/yyBg8erM7OTo/3Z7PZ9Nxzz6m6ulrFxcX6xz/+oTvvvFPjxo3T6dOn/fANAAQDwQSAXzz33HMqKirSf/7nf+r222/Xv//7v+u6667TqVOneuz/t7/9zW379OnT+uCDD5Sdne3W/tWvflUrVqzQvn37VFFRobffflubN2/207cAEGgEEwB+ER0dLWOMW9u6devU0dHRY/9f/epXbmtHnnjiCZ09e1aTJ0+WJH300Ufd9jd27FhJ4nQOEEa4KgeAX9x888367//+byUmJmrkyJGqrq7Wrl27NHjw4B77t7W16cYbb9SMGTP0zjvv6PHHH9d1112nW265RZL09NNP6/HHH9f06dM1fPhwtbS0aMOGDUpISNCUKVMC+dUA+BHBBIBf/Nd//Zeio6NVUVGhTz75RNdee6127dqlSZMm9dj/l7/8pSoqKrRkyRK1t7fr29/+tn7xi1/IZrNJ+nTx6969e7V582Y5HA4lJiYqLy9PFRUV+tznPhfIrwbAj2zm/LlRAACAIGGNCQAAsAyCCQAAsAyCCQAAsAyCCQAAsAyCCQAAsAyCCQAAsIyg3MckOztbCQkJioqK0qBBg/Tqq6/2+bOdnZ06duyY4uPjXfc3AAAA1maMUUtLizIzMxUV1fu8SNBusPbGG2/osssu8/hzx44dU1ZWlh8qAgAA/tbQ0KAhQ4b0+n7I3fk1Pj5e0qdfLCEhIcjVANbkdDqVmZkp6dMwP3DgwCBXBCDSNTc3Kysry/V7vDceB5Oqqir97Gc/U01NjT744AM9//zzuvXWW936lJWV6Wc/+5kaGxuVk5OjdevWKS8vz/W+zWbT+PHjFRUVpXvvvVezZ8/u8/G7Tt8kJCQQTIBeREdHu/6ckJBAMAFgGRdbhuHx4len06mcnByVlZX1+P6WLVtUUlKi0tJS1dbWKicnR5MmTdLx48ddffbs2aOamhq98MILWrlypf7yl7/0erzW1lY1Nze7vQAAQHjyOJhMnjxZy5cv1/Tp03t8f82aNZo3b57mzp2rkSNHav369YqLi9PGjRtdfa644gpJUkZGhqZMmaLa2tpej7dq1SolJia6XqwvAQAgfPn0cuG2tjbV1NSosLDwswNERamwsFDV1dWSPp1xaWlpkSSdPn1ar7zyikaNGtXrPhcvXqympibXq6GhwZclAwAAC/Hp4teTJ0+qo6NDaWlpbu1paWk6dOiQJMnhcLhmWzo6OjRv3jx95Stf6XWfdrtddrvdl2UCAACLCvhVOcOGDdObb74Z6MN6JHvRdknS0dU3BbkSAAAii09P5aSkpCg6OloOh8Ot3eFwKD093ZeHAgAAYcinwSQmJkbjxo1TZWWlq62zs1OVlZUqKCjw5aEAAEAY8vhUzunTp3X48GHXdn19verq6pScnKyhQ4eqpKRERUVFys3NVV5entauXSun06m5c+f6tHAAABB+PA4m+/bt08SJE13bJSUlkqSioiKVl5dr5syZOnHihJYsWaLGxkaNHTtWO3fu7LYgFgAA4HweB5MJEybIGHPBPsXFxSouLva6KMtbmviv/20Kbh0AAIQZn64xiVhLEz8LKwAAwGsEEwAAYBkEE39hFgUAAI8RTC6GgAEAQMAQTAAAgGUE/Jb0EevcWReu5gEAoEfMmPRR1/NzAACA/xBMAACAZRBMgomFtQAAuCGYAAAAyyCYXALWnQAA4FsEEwAAYBlcLmwlXFIMAIhwzJgAAADLIJgAAADLIJhYHZcUAwAiCMHEh7IXbedKHQAALgHBBAAAWAbBBAAAWAbBJBSx7gQAEKYIJgAAwDIIJgAAwDIIJn4WkKt0OLUDAAgTBBMAAGAZPCvnXP+adTgaK2V/sinIxQAAEHmYMQlXnN4BAIQgggkAALAMgkkQcNt6AAB6RjABAACWweLXSHHuepOlTcGrAwCAC2DGBAAAWAbBBAAAWAbBJJJxSTEAwGIIJgAAwDIIJhbA5cMAAHyKq3LwGa7cAQAEGTMmAADAMggmAADAMggmuDCu3AEABBDBxKJYEAsAiEQEEwAAYBkEE3iO0zsAAD8hmAAAAMsgmODSMYMCAPARggkAALAMgkmI4CodAEAkIJjAPzi9AwDwAsEEAABYRsCDyalTp5Sbm6uxY8dq9OjR2rBhQ6BLAAAAFhXwpwvHx8erqqpKcXFxcjqdGj16tG677TYNHjw40KUgkHhyMQCgDwI+YxIdHa24uDhJUmtrq4wxMsYEuoywwIJYAEC48TiYVFVVaerUqcrMzJTNZtO2bdu69SkrK1N2drZiY2OVn5+vvXv3ur1/6tQp5eTkaMiQIbr//vuVkpLi9RcAAADhw+Ng4nQ6lZOTo7Kysh7f37Jli0pKSlRaWqra2lrl5ORo0qRJOn78uKtPUlKS3nzzTdXX12vTpk1yOBzefwOELq7cAQCcx+NgMnnyZC1fvlzTp0/v8f01a9Zo3rx5mjt3rkaOHKn169crLi5OGzdu7NY3LS1NOTk5eu2113o9Xmtrq5qbm91eAAAgPPl0jUlbW5tqampUWFj42QGiolRYWKjq6mpJksPhUEtLiySpqalJVVVVGjFiRK/7XLVqlRITE12vrKwsX5YcVrIXbQ/tdSddMyjMogBAxPJpMDl58qQ6OjqUlpbm1p6WlqbGxkZJ0rvvvqvrr79eOTk5uv766/W9731PY8aM6XWfixcvVlNTk+vV0NDgy5IBAICFBPxy4by8PNXV1fW5v91ul91u919BAADAMnw6Y5KSkqLo6Ohui1kdDofS09N9eShECk7tAEBE8WkwiYmJ0bhx41RZWelq6+zsVGVlpQoKCnx5KPRRSK85AQBEHI9P5Zw+fVqHDx92bdfX16uurk7JyckaOnSoSkpKVFRUpNzcXOXl5Wnt2rVyOp2aO3euTwsHAADhx+Ngsm/fPk2cONG1XVJSIkkqKipSeXm5Zs6cqRMnTmjJkiVqbGzU2LFjtXPnzm4LYgGvdZ3a4db2ABB2PA4mEyZMuOgt5IuLi1VcXOx1UYBHCCoAEDYC/qwcAACA3hBMAACAZRBMAACAZRBMIlBEXELM/U8AICQRTBAZCCoAEBIIJgAAwDIIJoiMUzsAgJBAMAEAAJZBMEHkYt0JAFgOwQQ94vQOACAYCCYAAMAyCCbAhXC6BwACyuOH+AFh69wAwgMBASAomDEBAACWQTBBn7AYFgAQCJzKATzR0+merjZO/wDAJWPGBAAAWAbBBAAAWAbBBAAAWAbBBF5jQewFnH//E+6HAgB9QjABAACWQTABAACWQTABAACWQTABAACWQTABAACWQTCBz2Qv2s6VOp7gSh0A6IZb0gNWwdONAYAZEwAAYB3MmAChhFkVAGGOGRP4FWtOLhHrUABEGIIJAACwDIIJAACwDIIJAACwDIIJAACwDIIJAq4vC2JZNAsAkYlgAoQ6rtwBEEYIJgg6ZkcAAF0IJgAAwDIIJkA4WpER7AoAwCsEEwAAYBkEE4QE1qEAQGQgmAAAAMsgmCBkMYsCAOGHYAIAACyDYAIAACyjX7ALABAAXXeGXdp08T4X6wcAfsSMCQAAsAyCCQAAsIygBJPp06dr0KBBuv3224NxeACSdw//6/oMDw0E4CdBCSY/+MEP9MwzzwTj0AA8QQgBEGBBCSYTJkxQfHx8MA4NAAAszONgUlVVpalTpyozM1M2m03btm3r1qesrEzZ2dmKjY1Vfn6+9u7d64taAQBAmPM4mDidTuXk5KisrKzH97ds2aKSkhKVlpaqtrZWOTk5mjRpko4fP37JxQIAgPDm8X1MJk+erMmTJ/f6/po1azRv3jzNnTtXkrR+/Xpt375dGzdu1KJFizwusLW1Va2tra7t5uZmj/cBAABCg0/XmLS1tammpkaFhYWfHSAqSoWFhaqurvZqn6tWrVJiYqLrlZWV5atyAVgJV/wAkI+DycmTJ9XR0aG0tDS39rS0NDU2Nrq2CwsL9c1vflM7duzQkCFDLhhaFi9erKamJteroaHBlyUjjPBQvyDpS5ggcADoo6Dckn7Xrl197mu322W32/1YDQAAsAqfzpikpKQoOjpaDofDrd3hcCg9Pd2XhwJgZcyQAPCST4NJTEyMxo0bp8rKSldbZ2enKisrVVBQ4MtDAQCAMOTxqZzTp0/r8OHDru36+nrV1dUpOTlZQ4cOVUlJiYqKipSbm6u8vDytXbtWTqfTdZUOAPRZX56KDCCseBxM9u3bp4kTJ7q2S0pKJElFRUUqLy/XzJkzdeLECS1ZskSNjY0aO3asdu7c2W1BLAAAwPk8DiYTJkyQMeaCfYqLi1VcXOx1UYCvZC/arqOrb4rY44edc9etMIsChKWgPCsHAACgJwQTRJTsRdv7dL8T7okSAFy5A6AHBBMAAGAZBBMAAGAZBBNEPE7bAIB1EEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEwAAIBlEEyAPvDVg//6+hBBBMD5DxHs6aGC/nzQIA8xBHpEMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJbRL9gFALi47EXbdXT1TcEuw5q6blK2tOnS+nhyrHP3df6+e+rjyb7P/Yyv6gZCCDMmAADAMggmAADAMggmAADAMggmAADAMggmAADAMggmAADAMkLucmFjjCSpubnZ9ztvNa4/drae+fQY/2pzbZ/Tr6c+rtp66XPBfXP8Sz5+IGtUb8fy8Pjn7+eC+75AH9e2JOc5/Zqbm9XRQx9Pju9Rnwt9LlDHP1+wa+xLTX05PhDCuv597Po93hubuVgPi3n//feVlZUV7DIAAIAXGhoaNGTIkF7fD7lg0tnZqWPHjik+Pl42m83n+29ublZWVpYaGhqUkJDg8/3jU4xzYDDOgcNYBwbjHDi+HmtjjFpaWpSZmamoqN5XkoTcqZyoqKgLJi1fSUhI4Ic+ABjnwGCcA4exDgzGOXB8OdaJiYkX7cPiVwAAYBkEEwAAYBkEk/PY7XaVlpbKbrcHu5SwxjgHBuMcOIx1YDDOgROssQ65xa8AACB8MWMCAAAsg2ACAAAsg2ACAAAsg2ACAAAsIyKDSVlZmbKzsxUbG6v8/Hzt3bv3gv1/+9vf6vOf/7xiY2M1ZswY7dixI0CVhjZPxnnDhg26/vrrNWjQIA0aNEiFhYUX/f8Fn/L057nL5s2bZbPZdOutt/q3wDDi6VifOnVKCxcuVEZGhux2u66++mr+/egDT8d57dq1GjFihAYMGKCsrCzdd999+uSTTwJUbWiqqqrS1KlTlZmZKZvNpm3btl30M7t379aXv/xl2e12XXXVVSovL/dPcSbCbN682cTExJiNGzeat99+28ybN88kJSUZh8PRY//XX3/dREdHm0cffdQcOHDA/OQnPzH9+/c3b731VoArDy2ejvOsWbNMWVmZ2b9/vzl48KD5zne+YxITE837778f4MpDi6fj3KW+vt5cccUV5vrrrzfTpk0LTLEhztOxbm1tNbm5uWbKlClmz549pr6+3uzevdvU1dUFuPLQ4uk4V1RUGLvdbioqKkx9fb35wx/+YDIyMsx9990X4MpDy44dO8yDDz5otm7daiSZ559//oL9jxw5YuLi4kxJSYk5cOCAWbdunYmOjjY7d+70eW0RF0zy8vLMwoULXdsdHR0mMzPTrFq1qsf+M2bMMDfddJNbW35+vrn77rv9Wmeo83Scz3f27FkTHx9vnn76aX+VGBa8GeezZ8+aa665xvz61782RUVFBJM+8nSsn3jiCTNs2DDT1tYWqBLDgqfjvHDhQnPDDTe4tZWUlJhrr73Wr3WGk74EkwceeMCMGjXKrW3mzJlm0qRJPq8nok7ltLW1qaamRoWFha62qKgoFRYWqrq6usfPVFdXu/WXpEmTJvXaH96N8/nOnDmj9vZ2JScn+6vMkOftOD/88MNKTU3VXXfdFYgyw4I3Y/3CCy+ooKBACxcuVFpamkaPHq2VK1eqo6MjUGWHHG/G+ZprrlFNTY3rdM+RI0e0Y8cOTZkyJSA1R4pA/i4MuYf4XYqTJ0+qo6NDaWlpbu1paWk6dOhQj59pbGzssX9jY6Pf6gx13ozz+X70ox8pMzOz218EfMabcd6zZ4+efPJJ1dXVBaDCvuvs7FRbW5tiY2ODXUqPvBnrI0eO6JVXXtHs2bO1Y8cOHT58WAsWLFB7e7tKS0sDUXbI8WacZ82apZMnT+q6666TMUZnz57VPffcox//+MeBKDli9Pa7sLm5WR9//LEGDBjgs2NF1IwJQsPq1au1efNmPf/885b9RRWKWlpaNGfOHG3YsEEpKSl+OcbSpUtls9l06NAhzZgxQwkJCRo8eLB+8IMfuC1GtNlsKi4uVkVFhUaNGiW73a6dO3dKkv7xj3/ozjvvVFpamux2u0aNGqWNGzd2O9a6des0atQoxcXFadCgQcrNzdWmTZv88r280dnZqdTUVP3qV7/SuHHjNHPmTD344INav359sEsLK7t379bKlSv1+OOPq7a2Vlu3btX27dv1yCOPBLs0eCmiZkxSUlIUHR0th8Ph1u5wOJSent7jZ9LT0z3qD+/Guctjjz2m1atXa9euXfriF7/ozzJDnqfj/Pe//11Hjx7V1KlTXW2dnZ2SpH79+umdd97R8OHDfVLbjBkzlJ2drVWrVumPf/yjfvGLX+ijjz7SM8884+rzyiuv6Nlnn1VxcbFSUlKUnZ0th8Ohr371q67gcvnll+v3v/+97rrrLjU3N+vee++V9OlVXN///vd1++23u0LPX/7yF/3pT3/SrFmzfPIdzuXNz3RGRob69++v6OhoV9sXvvAFNTY2qq2tTTExMT6vM9R5M84PPfSQ5syZo+9+97uSpDFjxsjpdGr+/Pl68MEHFRXFf3/7Qm+/CxMSEnw6WyIp8q7KycvLM8XFxa7tjo4Oc8UVV1xw8evNN9/s1lZQUMDi14vwdJyNMeanP/2pSUhIMNXV1YEoMSx4Ms4ff/yxeeutt9xe06ZNMzfccIN56623TGtr6yXXU1paaiSZW265xa19wYIFRpJ58803jTGfLraLiooyb7/9tlu/u+66y2RkZJiTJ0+6tX/rW98yiYmJ5syZM8YYY6ZNm9ZtIZ6/efozvXjxYnPllVeajo4OV9vatWtNRkaG32sNZZ6O85e//GXzwAMPuLVt2rTJDBgwwJw9e9avtYYL9XHx6+jRo93avv3tb/tl8WvEBZPNmzcbu91uysvLzYEDB8z8+fNNUlKSaWxsNMYYM2fOHLNo0SJX/9dff93069fPPPbYY+bgwYOmtLSUy4X7wNNxXr16tYmJiTHPPfec+eCDD1yvlpaWYH2FkODpOJ/P11fldAWTP/zhD27tBw8eNJJcv1wkmYkTJ7r16ezsNElJSWb+/PnmxIkTbq+nnnrKSDJ79uxx1Z2YmGj27t3rs9ovxtOxfu+990x8fLwpLi4277zzjnnxxRdNamqqWb58ecBqDkWejnNpaamJj483v/nNb8yRI0fMSy+9ZIYPH25mzJgRrK8QElpaWsz+/fvN/v37jSSzZs0as3//fvPuu+8aY4xZtGiRmTNnjqt/1+XC999/vzl48KApKyvjcmFfWrdunRk6dKiJiYkxeXl55o9//KPrvfHjx5uioiK3/s8++6y5+uqrTUxMjBk1apTZvn17gCsOTZ6M85VXXmkkdXuVlpYGvvAQ4+nP87n8FUyOHDni1t7W1maioqJcM42SzJ133unWx+Fw9PgzcO5r69atxhhjDhw4YK644gojyVx11VVmwYIFrtDiT56O9RtvvGHy8/ON3W43w4YNMytWrOC/4vvAk3Fub283S5cuNcOHDzexsbEmKyvLLFiwwHz00UeBLzyEvPrqqz3+Hesa26KiIjN+/Phunxk7dqyJiYkxw4YNM0899ZRfarMZY4xvTw4BiFRLly7VsmXLdOTIEX3uc59ztZ89e1Z2u13z5s3T+vXrZbPZtHDhQv3yl7909WlsbFRGRob+4z/+Q0VFRT3u/4tf/KJSU1MlSU6nUy+++KJ27typ3//+93I4HFqyZImWLVvm3y8JwK8iavErgMD429/+5hZMDh8+rM7OTmVnZ/f6mcsvv1zx8fHq6Ojo02XiAwcO1MyZMzVz5ky1tbXptttu04oVK7R48WKu5gJCGMuVAfhcWVmZ2/a6deskSZMnT+71M9HR0frGN76h3/3ud/q///u/bu+fOHHC9ed//vOfbu/FxMRo5MiRMsaovb39UkoHEGTMmADwufr6et1yyy36+te/rurqav3P//yPZs2apZycnAt+bvXq1Xr11VeVn5+vefPmaeTIkfrwww9VW1urXbt26cMPP5Qkfe1rX1N6erquvfZapaWl6eDBg/rlL3+pm266SfHx8YH4igD8hGACwOe2bNmiJUuWaNGiRerXr5+Ki4v1s5/97KKfS0tL0969e/Xwww9r69atevzxxzV48GCNGjVKP/3pT1397r77blVUVGjNmjU6ffq0hgwZou9///v6yU9+4s+vBSAAWPwKwGe6Fr+eOHHCb3eXBRDeWGMCAAAsg2ACAAAsg2ACAAAsgzUmAADAMpgxAQAAlhFylwt3dnbq2LFjio+Pl81mC3Y5AACgD4wxamlpUWZmpqKiep8XCblgcuzYMWVlZQW7DAAA4IWGhgYNGTKk1/dDLph03dWxoaFBCQkJQa4GgNPpVGZmpqRP/8Nh4MCBQa4IgBU1NzcrKyvrondnDrlg0nX6JiEhgWACWEB0dLTrzwkJCQQTABd0sWUYLH4FAACWQTABAACWQTABAACWEXJrTAAA8LeOjg61t7cHu4yQ0r9/f7c1Z94imAAA8C/GGDU2NurUqVPBLiUkJSUlKT09/ZLuM0Yw6UH2ou2SpKOrbwpyJQCAQOoKJampqYqLi+NGnn1kjNGZM2d0/PhxSVJGRobX+yKYAACgT0/fdIWSwYMHB7uckDNgwABJ0vHjx5Wamur1aR0WvwIAILnWlMTFxQW5ktDVNXaXsj6HYAIAwDk4feM9X4wdwQQAAFgGwQQAAFgGi18BALiIrqs1AyWSrwplxgQAAPToww8/1OzZs5WQkKCkpCTdddddOn36tF+PSTABACACtbW1XbTP7Nmz9fbbb+vll1/Wiy++qKqqKs2fP9+vdRFMAAAIAy0tLZo9e7YGDhyojIwM/fznP9eECRN07733SpKys7P1yCOP6I477lBCQsJFA8bBgwe1c+dO/frXv1Z+fr6uu+46rVu3Tps3b9axY8f89j0IJgAAhIGSkhK9/vrreuGFF/Tyyy/rtddeU21trVufxx57TDk5Odq/f78eeuihC+6vurpaSUlJys3NdbUVFhYqKipKf/rTn/zyHSQWvwIAEPJaWlr09NNPa9OmTbrxxhslSU899ZQyMzPd+t1www364Q9/2Kd9NjY2KjU11a2tX79+Sk5OVmNjo28K7wEzJgAAhLgjR46ovb1deXl5rrbExESNGDHCrd+5sx9WRTABACBCDBw4sM9909PTXQ/l63L27Fl9+OGHSk9P93VpLgQTAABC3LBhw9S/f3/9+c9/drU1NTXpr3/9q9f7LCgo0KlTp1RTU+Nqe+WVV9TZ2an8/PxLqvdCWGMCAECIi4+PV1FRke6//34lJycrNTVVpaWlioqK8vr5NV/4whf09a9/XfPmzdP69evV3t6u4uJifetb3+q2dsWXCCYAAFxEKNyJdc2aNbrnnnt08803KyEhQQ888IAaGhoUGxvr9T4rKipUXFysG2+8UVFRUfrGN76hX/ziFz6sujuCCQAAYSA+Pl4VFRWubafTqWXLlrnuV3L06FGP95mcnKxNmzb5qsQ+IZgAABAG9u/fr0OHDikvL09NTU16+OGHJUnTpk0LcmWeYfErAABhousGaoWFhXI6nXrttdeUkpLSY9+VK1fqsssu6/E1efLkAFf+GWZMAAAIA1/60pfcrqC5mHvuuUczZszo8b0BAwb4qiyPBSWYZGdnKyEhQVFRURo0aJBeffXVYJQBAEDESk5OVnJycrDL6CZoMyZvvPGGLrvssmAdHgAAWBBrTAAAgGV4HEyqqqo0depUZWZmymazadu2bd36lJWVKTs7W7GxscrPz9fevXvd3rfZbBo/fry+8pWvuF3aBAAAIpvHwcTpdConJ0dlZWU9vr9lyxaVlJSotLRUtbW1ysnJ0aRJk9zut79nzx7V1NTohRde0MqVK/WXv/zF+28AAADChsfBZPLkyVq+fLmmT5/e4/tr1qzRvHnzNHfuXI0cOVLr169XXFycNm7c6OpzxRVXSJIyMjI0ZcoU1dbW9nq81tZWNTc3u70AAEB48uni17a2NtXU1Gjx4sWutqioKBUWFqq6ulrSpzMunZ2dio+P1+nTp/XKK6/0ermSJK1atUrLli3zZZkey160XVJo3JIYAOAHSxMDfLymwB7PQny6+PXkyZPq6OhQWlqaW3taWpoaGxslSQ6HQ9ddd51ycnL01a9+VXfccYe+8pWv9LrPxYsXq6mpyfVqaGjwZckAAKAXK1as0DXXXKO4uDglJSUF5JgBv1x42LBhevPNN/vc3263y263+7EiAAAiT1tbm2JiYi7a55vf/KYKCgr05JNPBqQun86YpKSkKDo6Wg6Hw63d4XAoPT3dl4cKuuxF212neAAACLaWlhbNnj1bAwcOVEZGhn7+859rwoQJuvfeeyV9enPTRx55RHfccYcSEhJcD/e7kGXLlum+++7TmDFj/Fz9Z3waTGJiYjRu3DhVVla62jo7O1VZWamCggJfHgoAAJyjpKREr7/+ul544QW9/PLLeu2117pdXNL1LJ39+/froYceClKlF+bxqZzTp0/r8OHDru36+nrV1dUpOTlZQ4cOVUlJiYqKipSbm6u8vDytXbtWTqdTc+fO9WnhAADgUy0tLXr66ae1adMm3XjjjZKkp556SpmZmW79brjhBv3whz8MRol95nEw2bdvnyZOnOjaLikpkSQVFRWpvLxcM2fO1IkTJ7RkyRI1NjZq7Nix2rlzZ7cFsQAAwDeOHDmi9vZ25eXludoSExM1YsQIt365ubmBLs1jHgeTCRMmyBhzwT7FxcUqLi72uqhQdO56Ey4rBgBY0cCBA4NdwkXxrBwAAELcsGHD1L9/f/35z392tTU1Nemvf/1rEKvyTtCeLgwAAHwjPj5eRUVFuv/++5WcnKzU1FSVlpYqKipKNpvN6/2+9957+vDDD/Xee++po6NDdXV1kqSrrrpKl112mY+qd0cwAQDgYkLgTqxr1qzRPffco5tvvlkJCQl64IEH1NDQoNjYWK/3uWTJEj399NOu7S996UuSpFdffVUTJky41JJ7RDABACAMxMfHq6KiwrXtdDq1bNky1/1Kjh496vE+y8vLVV5e7qMK+4Zg4kc8YwcAECj79+/XoUOHlJeXp6amJj388MOSpGnTpgW5Ms+w+BUAgDDRdQO1wsJCOZ1Ovfbaa0pJSemx78qVK3XZZZf1+Jo8eXKAK/8MMyYAAISBL33pS6qpqelz/3vuuUczZszo8b0BAwb4qiyPEUwAAIhAycnJSk5ODnYZ3XAqBwCAc1zsJqLonS/GjhmTAOLusABgXf3795cknTlzJqinMkLZmTNnJH02lt4gmAAAICk6OlpJSUk6fvy4JCkuLu6Sbk4WSYwxOnPmjI4fP66kpCRFR0d7vS+CiTeWJuporJT9yaZgVwIA8KH09HRJcoUTeCYpKck1ht4imPgCQQUAwoLNZlNGRoZSU1PV3t4e7HJCSv/+/S9ppqQLwSTIuAkbAFhPdHS0T37JwnNclXMxSxN1NHZW4D4HAEAEI5gAAADL4FROoPxrHYrEWhQAAHrDjIkFZS/a7nbPEwAAIgXBBAAAWAbBJJhYIAsAgBuCCQAAsAwWv1rJ0kRJ6nazNu51AgCIFMyYAAAAyyCYWB3rUAAAEYRgEqK4pBgAEI4IJqGIWRQAQJgimAAAAMvgqpxw8K+rebqu5OHqHQBAqGLGBAAAWAYzJufq5T4iIelf30VLm4JbBwAAHiCYRIquoCIRVgAAlsWpnDDHJcUAgFBCMIlkSxPdZ1IAAAgygkkEYhYFAGBVrDHBZ1iHAgAIMmZMAACAZRBMcOFTO6xDAQAEUMCDyalTp5Sbm6uxY8dq9OjR2rBhQ6BLwKUirAAA/CTga0zi4+NVVVWluLg4OZ1OjR49WrfddpsGDx4c6FIAAIDFBHzGJDo6WnFxcZKk1tZWGWNkjAl0GbgIrtwBAASDx8GkqqpKU6dOVWZmpmw2m7Zt29atT1lZmbKzsxUbG6v8/Hzt3bvX7f1Tp04pJydHQ4YM0f3336+UlBSvvwAsgFM7AAAf8TiYOJ1O5eTkqKysrMf3t2zZopKSEpWWlqq2tlY5OTmaNGmSjh8/7uqTlJSkN998U/X19dq0aZMcDkevx2ttbVVzc7PbCyGAsAIA8ILHwWTy5Mlavny5pk+f3uP7a9as0bx58zR37lyNHDlS69evV1xcnDZu3Nitb1pamnJycvTaa6/1erxVq1YpMTHR9crKyvK0ZPjAJZ/a6QoqhBUAwAX4dI1JW1ubampqVFhY+NkBoqJUWFio6upqSZLD4VBLS4skqampSVVVVRoxYkSv+1y8eLGamppcr4aGBl+WDAAALMSnV+WcPHlSHR0dSktLc2tPS0vToUOHJEnvvvuu5s+f71r0+r3vfU9jxozpdZ92u112u92XZcIqumZPuMssAOBfAn65cF5enurq6gJ9WPhB9qLtOrr6JrdtSW5tHuGW+AAQ8Xx6KiclJUXR0dHdFrM6HA6lp6f78lAAACAM+TSYxMTEaNy4caqsrHS1dXZ2qrKyUgUFBb48FCIFC2YBIKJ4fCrn9OnTOnz4sGu7vr5edXV1Sk5O1tChQ1VSUqKioiLl5uYqLy9Pa9euldPp1Ny5c31aOAAACD8eB5N9+/Zp4sSJru2SkhJJUlFRkcrLyzVz5kydOHFCS5YsUWNjo8aOHaudO3d2WxALeI1FswAQtjwOJhMmTLjoLeSLi4tVXFzsdVEIH+cvkPULggoAhI2APysH4Dk8AIDeEEwQnlg0CwAhiWCCoAvIDApBBQBCAsEEAABYBsEEkYtZFACwnIDfkh6wLG6JDwBBx4wJcCHMqgBAQBFMYElcUgwAkYlTOYAnON0DAH7FjAlCQk8zKMyqAED4IZgA/tCXtSmsXwGAbggmwKUK1RBixZoARDzWmABW0dP6lb48oNBXDzH09vgA4EMEE4SNgDzJONiCvfg22McHEPY4lQOEo/NP03DaBkCIIJgAAADLIJgA8D9mbAD0EWtMAFyaFRnd27xZtNuX9SuscQHCHsEEEaXrpmxhv0g2knkbXrgCCbAETuUgrHF3WEjiVBIQQggmAKwrFAJFKNQIhBCCCYDQ5s9gQOgAAo41JgAikzdrSligC/gdMyaIeKxDAQDrIJgAgBVw2giQRDABesQsCvyOIAL0iGACAAAsg2AC9AEzKLgkzI4AfUYwAQAAlsHlwgAQKrgUGRGAGRMAAGAZzJgAQDhhVgUhjhkTAAhlLKxFmCGYAAAAyyCYAAAAyyCYAAAAywhKMJk+fboGDRqk22+/PRiHB4DQwPoRRKCgBJMf/OAHeuaZZ4JxaAAAYGFBCSYTJkxQfHx8MA4NAJCYjYFleRxMqqqqNHXqVGVmZspms2nbtm3d+pSVlSk7O1uxsbHKz8/X3r17fVErYGk8TwcALp3HwcTpdConJ0dlZWU9vr9lyxaVlJSotLRUtbW1ysnJ0aRJk3T8+HGvCmxtbVVzc7PbC7ACggjCHrMqCAKPg8nkyZO1fPlyTZ8+vcf316xZo3nz5mnu3LkaOXKk1q9fr7i4OG3cuNGrAletWqXExETXKysry6v9AMFAeAEAz/h0jUlbW5tqampUWFj42QGiolRYWKjq6mqv9rl48WI1NTW5Xg0NDb4qFwAAWIxPn5Vz8uRJdXR0KC0tza09LS1Nhw4dcm0XFhbqzTfflNPp1JAhQ/Tb3/5WBQUFPe7TbrfLbrf7skwAAGBRQXmI365du4JxWAAAYHE+PZWTkpKi6OhoORwOt3aHw6H09HRfHgoA0FcsYkUI8WkwiYmJ0bhx41RZWelq6+zsVGVlZa+nagAAALp4fCrn9OnTOnz4sGu7vr5edXV1Sk5O1tChQ1VSUqKioiLl5uYqLy9Pa9euldPp1Ny5c31aOAAACD8eB5N9+/Zp4sSJru2SkhJJUlFRkcrLyzVz5kydOHFCS5YsUWNjo8aOHaudO3d2WxALAABwPo+DyYQJE2SMuWCf4uJiFRcXe10UEOmyF23X0dU3BbsMRJKuNShLm4JbByJeUJ6VAwAA0BOCCRBA2Yu2++xusNxVFkA4IpgAAADLIJgAAADLIJgAAADLIJgAAADLIJgAAADLIJgAAADLIJgAAADLIJgAQebP+5F4u2/ukYIedT2l+EJPKu5LH+ACCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCZAmOjLvUeyF23nHiXwLe5ZAh8jmAAAAMsgmAAAAMsgmAAAAMsgmAAAAMsgmAAAAMvoF+wCPGWMkSQ1Nzf7fuetxvXHztYznx7jX22u7XP69dTHVVsvfS64b45/yccPhRq9Ob7O268vj9+XfffUp6vNeU5bc3OzOjo6ev/cuX9v+7Bvv/W50OcCUWOkHR/QZ7+3u36P98ZmLtbDYt5//31lZWUFuwwAAOCFhoYGDRkypNf3Qy6YdHZ26tixY4qPj5fNZvP5/pubm5WVlaWGhgYlJCT4fP/4FOMcGIxz4DDWgcE4B46vx9oYo5aWFmVmZioqqveVJCF3KicqKuqCSctXEhIS+KEPAMY5MBjnwGGsA4NxDhxfjnVi4sVvxsfiVwAAYBkEEwAAYBkEk/PY7XaVlpbKbrcHu5SwxjgHBuMcOIx1YDDOgROssQ65xa8AACB8MWMCAAAsg2ACAAAsg2ACAAAsg2ACAAAsg2ACAAAsIyKDSVlZmbKzsxUbG6v8/Hzt3bv3gv1/+9vf6vOf/7xiY2M1ZswY7dixI0CVhjZPxnnDhg26/vrrNWjQIA0aNEiFhYUX/f8Fn/L057nL5s2bZbPZdOutt/q3wDDi6VifOnVKCxcuVEZGhux2u66++mr+/egDT8d57dq1GjFihAYMGKCsrCzdd999+uSTTwJUbWiqqqrS1KlTlZmZKZvNpm3btl30M7t379aXv/xl2e12XXXVVSovL/dPcSbCbN682cTExJiNGzeat99+28ybN88kJSUZh8PRY//XX3/dREdHm0cffdQcOHDA/OQnPzH9+/c3b731VoArDy2ejvOsWbNMWVmZ2b9/vzl48KD5zne+YxITE837778f4MpDi6fj3KW+vt5cccUV5vrrrzfTpk0LTLEhztOxbm1tNbm5uWbKlClmz549pr6+3uzevdvU1dUFuPLQ4uk4V1RUGLvdbioqKkx9fb35wx/+YDIyMsx9990X4MpDy44dO8yDDz5otm7daiSZ559//oL9jxw5YuLi4kxJSYk5cOCAWbdunYmOjjY7d+70eW0RF0zy8vLMwoULXdsdHR0mMzPTrFq1qsf+M2bMMDfddJNbW35+vrn77rv9Wmeo83Scz3f27FkTHx9vnn76aX+VGBa8GeezZ8+aa665xvz61782RUVFBJM+8nSsn3jiCTNs2DDT1tYWqBLDgqfjvHDhQnPDDTe4tZWUlJhrr73Wr3WGk74EkwceeMCMGjXKrW3mzJlm0qRJPq8nok7ltLW1qaamRoWFha62qKgoFRYWqrq6usfPVFdXu/WXpEmTJvXaH96N8/nOnDmj9vZ2JScn+6vMkOftOD/88MNKTU3VXXfdFYgyw4I3Y/3CCy+ooKBACxcuVFpamkaPHq2VK1eqo6MjUGWHHG/G+ZprrlFNTY3rdM+RI0e0Y8cOTZkyJSA1R4pA/i4MuacLX4qTJ0+qo6NDaWlpbu1paWk6dOhQj59pbGzssX9jY6Pf6gx13ozz+X70ox8pMzOz218EfMabcd6zZ4+efPJJ1dXVBaDC8OHNWB85ckSvvPKKZs+erR07dujw4cNasGCB2tvbVVpaGoiyQ4434zxr1iydPHlS1113nYwxOnv2rO655x79+Mc/DkTJEaO334XNzc36+OOPNWDAAJ8dK6JmTBAaVq9erc2bN+v5559XbGxssMsJGy0tLZozZ442bNiglJSUYJcT9jo7O5Wamqpf/epXGjdunGbOnKkHH3xQ69evD3ZpYWX37t1auXKlHn/8cdXW1mrr1q3avn27HnnkkWCXBi9F1IxJSkqKoqOj5XA43NodDofS09N7/Ex6erpH/eHdOHd57LHHtHr1au3atUtf/OIX/VlmyPN0nP/+97/r6NGjmjp1qquts7NTktSvXz+98847Gj58uH+LDlHe/ExnZGSof//+io6OdrV94QtfUGNjo9ra2hQTE+PXmkORN+P80EMPac6cOfrud78rSRozZoycTqfmz5+vBx98UFFR/Pe3L/T2uzAhIcGnsyVShM2YxMTEaNy4caqsrHS1dXZ2qrKyUgUFBT1+pqCgwK2/JL388su99od34yxJjz76qB555BHt3LlTubm5gSg1pHk6zp///Of11ltvqa6uzvW65ZZbNHHiRNXV1SkrKyuQ5YcUb36mr732Wh0+fNgV/iTpr3/9qzIyMgglvfBmnM+cOdMtfHSFQcMzan0moL8Lfb6c1uI2b95s7Ha7KS8vNwcOHDDz5883SUlJprGx0RhjzJw5c8yiRYtc/V9//XXTr18/89hjj5mDBw+a0tJSLhfuA0/HefXq1SYmJsY899xz5oMPPnC9WlpagvUVQoKn43w+rsrpO0/H+r333jPx8fGmuLjYvPPOO+bFF180qampZvny5cH6CiHB03EuLS018fHx5je/+Y05cuSIeemll8zw4cPNjBkzgvUVQkJLS4vZv3+/2b9/v5Fk1qxZY/bv32/effddY4wxixYtMnPmzHH177pc+P777zcHDx40ZWVlXC7sS+vWrTNDhw41MTExJi8vz/zxj390vTd+/HhTVFTk1v/ZZ581V199tYmJiTGjRo0y27dvD3DFocmTcb7yyiuNpG6v0tLSwBceYjz9eT4XwcQzno71G2+8YfLz843dbjfDhg0zK1asMGfPng1w1aHHk3Fub283S5cuNcOHDzexsbEmKyvLLFiwwHz00UeBLzyEvPrqqz3+m9s1tkVFRWb8+PHdPjN27FgTExNjhg0bZp566im/1GYzhrkuAABgDRG1xgQAAFgbwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFjG/wcPdnCD63jalgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=10` reached.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1238\n", "item counter : 2324\n", "ratio : 0.5324731182795699\n", " ratio number predicted/items: 0.7445161290322581\n", "current epoch: 9\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "-----------------------------------------------------\n", "0 | net | SmallNet | 514 \n", "1 | sym_preprocess | SymPreprocess | 8.5 M \n", "2 | bcewll | BCEWithLogitsLoss | 0 \n", "3 | auroc | BinaryAUROC | 0 \n", "-----------------------------------------------------\n", "514 Trainable params\n", "8.5 M Non-trainable params\n", "8.5 M Total params\n", "34.014 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGzCAYAAAD0T7cVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAvhklEQVR4nO3de3RU5b3/8c8kkAkkmcQQSTIQjKCiQQUFkuJlCZLTFBUo1YKFgylakBJO1bikUJSAcqtHKUccZamF4DmxqBRZHkREEBaKUQoEj8pFMQEjmAAVchmU3J7fH/6YOhKQCXPZk7xfa81a7Gee2fs7Xwfnw76NzRhjBAAAYBERoS4AAADghwgnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAEKqsLBQNptN27ZtC3UpACyCcAIAACyFcAIAACyFcAIAACyFcAIgIA4cOKBJkyapZ8+e6tChgzp16qRf//rX2r9/f7PzT5w4oXvvvVedOnWSw+HQXXfdpWPHjnnN2bZtm3JycpSUlKQOHTro4osv1t133x2EdwMgmNqFugAArdM//vEPvf/++7rzzjvVtWtX7d+/X88++6wGDhyoXbt2qWPHjl7zJ0+erISEBM2cOVN79+7Vs88+qwMHDmjTpk2y2Ww6fPiwfv7zn+vCCy/U1KlTlZCQoP3792vlypUheocAAoVwAiAgbr31Vt1xxx1eY0OHDtWAAQP097//XWPHjvV6LioqShs2bFD79u0lSRdddJGmTJmi//3f/9WwYcP0/vvv69ixY1q3bp369evned3s2bMD/2YABBWHdQAERIcOHTx/rq+v1z//+U9dcsklSkhI0I4dO06bP2HCBE8wkaTf//73ateundasWSNJSkhIkCStXr1a9fX1gS0eQEgRTgAExLfffqsZM2YoLS1NdrtdSUlJuvDCC3X8+HFVVVWdNv/SSy/1Wo6NjVVqaqrnHJWbbrpJt99+u2bNmqWkpCQNHz5cS5cu1cmTJ4PxdgAEEeEEQED8x3/8h+bMmaORI0fqlVde0bp16/T222+rU6dOampq8nl9NptNK1asUHFxsSZPnqyDBw/q7rvvVt++fVVbWxuAdwAgVAgnAAJixYoVys3N1ZNPPqk77rhD//Zv/6YbbrhBx48fb3b+559/7rVcW1urr7/+Wunp6V7jP/vZzzRnzhxt27ZNRUVF+vTTT7V8+fIAvQsAoUA4ARAQkZGRMsZ4jS1atEiNjY3Nzn/uuee8ziV59tln1dDQoCFDhkiSjh07dtr6+vTpI0kc2gFaGa7WARAQt912m/77v/9b8fHxysjIUHFxsdavX69OnTo1O7+urk6DBw/WyJEjtXfvXj3zzDO64YYbNGzYMEnSsmXL9Mwzz2jEiBHq0aOHampq9Pzzz8vhcOiWW24J5lsDEGCEEwAB8V//9V+KjIxUUVGRvvvuO11//fVav369cnJymp3/9NNPq6ioSDNmzFB9fb1+85vf6KmnnpLNZpP0/QmxW7du1fLly1VZWan4+HhlZmaqqKhIF198cTDfGoAAs5kf7ycFAAAIIc45AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlhJ29zlpamrSoUOHFBcX57n/AQAAsDZjjGpqauR0OhURcfZ9I2EXTg4dOqS0tLRQlwEAAFqgvLxcXbt2PeucsAsncXFxkr5/cw6Hw6/rdrvdcjqdkr4PQTExMX5dPwAAbVV1dbXS0tI83+NnE5JwMmLECG3atEmDBw/WihUrfHrtqUM5DofD7+EkMjLS82eHw0E4AQDAz87llIyQnBB733336cUXXwzFpgEAgMWFJJwMHDjwnHbrAACAtsfncLJ582YNHTpUTqdTNptNq1atOm2Oy+VSenq6oqOjlZWVpa1bt/qjVgAA0Ab4HE7cbrd69+4tl8vV7PMvv/yy8vPzVVBQoB07dqh3797KycnR4cOHW1TgyZMnVV1d7fUAAACtl8/hZMiQIZo9e7ZGjBjR7PMLFizQ+PHjNW7cOGVkZGjx4sXq2LGjlixZ0qIC582bp/j4eM+Dy4gBAGjd/HrOSV1dnbZv367s7Ox/bSAiQtnZ2SouLm7ROqdNm6aqqirPo7y83F/lAgAAC/LrpcRHjx5VY2OjkpOTvcaTk5O1Z88ez3J2drY++ugjud1ude3aVa+++qoGDBjQ7Drtdrvsdrs/ywQAABYWkvucrF+/PhSbBQAAYcCvh3WSkpIUGRmpyspKr/HKykqlpKT4c1MAAKCV8ms4iYqKUt++fbVhwwbPWFNTkzZs2HDGwzYAAAA/5PNhndraWu3bt8+zXFZWpp07dyoxMVHdunVTfn6+cnNz1a9fP2VmZmrhwoVyu90aN26cXwsHAACtk8/hZNu2bRo0aJBnOT8/X5KUm5urwsJCjRo1SkeOHNGMGTNUUVGhPn36aO3ataedJOsrl8sll8ulxsbG81oPAACwNpsxxoS6CF9UV1crPj5eVVVVAflV4tjYWEnf7yHih/8AAPAPX76/Q/LbOgAAAGdCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJYSNuHE5XIpIyND/fv3D3UpAAAggLjPyQ9wnxMAAAKD+5wAAICwRTgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWEjbhhJuwAQDQNnATth/gJmwAAAQGN2EDAABhi3ACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAsJWzCCXeIBQCgbeAOsT/AHWIBAAgM7hALAADCFuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYStiEE35bBwCAtoHf1vkBflsHAIDA4Ld1AABA2CKcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASwmbcOJyuZSRkaH+/fuHuhQAABBANmOMCXURvvDlJ5d95Xa7FRsbK0mqra1VTEyMX9cPAEBb5cv3d9jsOQEAAG0D4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFhK2IQTl8uljIwM9e/fP9SlAACAALIZY0yoi/BFdXW14uPjVVVVJYfD4dd1u91uxcbGSpJqa2sVExPj1/UDANBW+fL9HTZ7TgAAQNtAOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJYSNuHE5XIpIyND/fv3D3UpAAAggGzGGBPqInxRXV2t+Ph4VVVVyeFw+HXdbrdbsbGxkqTa2lrFxMT4df0AALRVvnx/h82eEwAA0DYQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKWEJJysXr1aPXv21KWXXqoXXnghFCUAAACLahfsDTY0NCg/P18bN25UfHy8+vbtqxEjRqhTp07BLgUAAFhQ0PecbN26Vb169VKXLl0UGxurIUOGaN26dcEuAwAAWJTP4WTz5s0aOnSonE6nbDabVq1addocl8ul9PR0RUdHKysrS1u3bvU8d+jQIXXp0sWz3KVLFx08eLBl1QMAgFbH53DidrvVu3dvuVyuZp9/+eWXlZ+fr4KCAu3YsUO9e/dWTk6ODh8+fN7FAgCA1s/ncDJkyBDNnj1bI0aMaPb5BQsWaPz48Ro3bpwyMjK0ePFidezYUUuWLJEkOZ1Orz0lBw8elNPpPOP2Tp48qerqaq8HAABovfx6zkldXZ22b9+u7Ozsf20gIkLZ2dkqLi6WJGVmZuqTTz7RwYMHVVtbqzfffFM5OTlnXOe8efMUHx/veaSlpfmzZAAAYDF+DSdHjx5VY2OjkpOTvcaTk5NVUVEhSWrXrp2efPJJDRo0SH369NGDDz541it1pk2bpqqqKs+jvLzcnyUDAACLCfqlxJI0bNgwDRs27Jzm2u122e32AFcEAACswq97TpKSkhQZGanKykqv8crKSqWkpPhzUwAAoJXyaziJiopS3759tWHDBs9YU1OTNmzYoAEDBvhzUwAAoJXy+bBObW2t9u3b51kuKyvTzp07lZiYqG7duik/P1+5ubnq16+fMjMztXDhQrndbo0bN86vhQMAgNbJ53Cybds2DRo0yLOcn58vScrNzVVhYaFGjRqlI0eOaMaMGaqoqFCfPn20du3a006SBQAAaI7NGGNCXcS5cLlccrlcamho0Oeff67y8nI5HA6/bsPtdnvuuXLo0CHFxMT4df0AALRV1dXVSktL0/HjxxUfH3/WuWETTk756quvuNcJAABhqry8XF27dj3rnLALJ01NTTp06JDi4uJks9n8vv5TyS4Qe2bwL/Q5eOh1cNDn4KDPwePvXhtjVFNTI6fTqYiIs1+PE5L7nJyPiIiIn0xc/uBwOPjgBwF9Dh56HRz0OTjoc/D4s9c/dTjnFL9eSgwAAHC+CCcAAMBSCCc/YrfbVVBQwC3zA4w+Bw+9Dg76HBz0OXhC2euwOyEWAAC0buw5AQAAlkI4AQAAlkI4AQAAlkI4AQAAltImw4nL5VJ6erqio6OVlZWlrVu3nnX+q6++qssvv1zR0dG66qqrtGbNmiBVGt586fPzzz+vG2+8URdccIEuuOACZWdn/+R/F3zP18/zKcuXL5fNZtMvf/nLwBbYivja6+PHjysvL0+pqamy2+267LLL+P/HOfC1zwsXLlTPnj3VoUMHpaWl6YEHHtB3330XpGrD0+bNmzV06FA5nU7ZbDatWrXqJ1+zadMmXXvttbLb7brkkktUWFgYuAJNG7N8+XITFRVllixZYj799FMzfvx4k5CQYCorK5udv2XLFhMZGWkef/xxs2vXLvPwww+b9u3bm48//jjIlYcXX/s8evRo43K5TElJidm9e7f57W9/a+Lj481XX30V5MrDi699PqWsrMx06dLF3HjjjWb48OHBKTbM+drrkydPmn79+plbbrnFvPfee6asrMxs2rTJ7Ny5M8iVhxdf+1xUVGTsdrspKioyZWVl5q233jKpqanmgQceCHLl4WXNmjVm+vTpZuXKlUaSee211846v7S01HTs2NHk5+ebXbt2mUWLFpnIyEizdu3agNTX5sJJZmamycvL8yw3NjYap9Np5s2b1+z8kSNHmltvvdVrLCsry9x7770BrTPc+drnH2toaDBxcXFm2bJlgSqxVWhJnxsaGsx1111nXnjhBZObm0s4OUe+9vrZZ5813bt3N3V1dcEqsVXwtc95eXnm5ptv9hrLz883119/fUDrbE3OJZxMmTLF9OrVy2ts1KhRJicnJyA1tanDOnV1ddq+fbuys7M9YxEREcrOzlZxcXGzrykuLvaaL0k5OTlnnI+W9fnHTpw4ofr6eiUmJgaqzLDX0j4/+uij6ty5s+65555glNkqtKTXr7/+ugYMGKC8vDwlJyfryiuv1Ny5c9XY2BisssNOS/p83XXXafv27Z5DP6WlpVqzZo1uueWWoNTcVgT7uzDsfvjvfBw9elSNjY1KTk72Gk9OTtaePXuafU1FRUWz8ysqKgJWZ7hrSZ9/7I9//KOcTudpfxnwLy3p83vvvae//vWv2rlzZxAq9E1TU5Pq6uoUHR0d6lJO05Jel5aW6p133tGYMWO0Zs0a7du3T5MmTVJ9fb0KCgqCUXbYaUmfR48eraNHj+qGG26QMUYNDQ2aOHGi/vSnPwWj5DbjTN+F1dXV+vbbb9WhQwe/bq9N7TlBeJg/f76WL1+u1157zZJfVOGqpqZGY8eO1fPPP6+kpKSAbWfmzJmy2Wzas2ePRo4cKYfDoU6dOum+++7zOknRZrNp8uTJKioqUq9evWS327V27VpJ0sGDB3X33XcrOTlZdrtdvXr10pIlS07b1qJFi9SrVy917NhRF1xwgfr166eXXnopYO/NF01NTercubOee+459e3bV6NGjdL06dO1ePHiUJfWqmzatElz587VM888ox07dmjlypV644039Nhjj4W6NJyHNrXnJCkpSZGRkaqsrPQar6ysVEpKSrOvSUlJ8Wk+WtbnU5544gnNnz9f69ev19VXXx3IMsOer33+4osvtH//fg0dOtQz1tTUJElq166d9u7dqx49evitvpEjRyo9PV3z5s3TBx98oKeeekrHjh3Tiy++6Jnzzjvv6JVXXtHkyZOVlJSk9PR0VVZW6mc/+5knvFx44YV68803dc8996i6ulr333+/pO+v8PrDH/6gO+64wxN8/u///k8ffvihRo8e7bf3IbXsM52amqr27dsrMjLSM3bFFVeooqJCdXV1ioqK8muNrUFL+vzII49o7Nix+t3vfidJuuqqq+R2uzVhwgRNnz5dERH8G9wfzvRd6HA4/L7XRFLbu1onMzPTTJ482bPc2NhounTpctYTYm+77TavsQEDBnBC7E/wtc/GGPPnP//ZOBwOU1xcHIwSWwVf+vztt9+ajz/+2OsxfPhwc/PNN5uPP/7YnDx50i81FRQUGElm2LBhXuOTJk0yksxHH31kjPn+JLyIiAjz6aefes275557TGpqqjl69KjX+J133mni4+PNiRMnjDHGDB8+/LQT9ALJ18/0tGnTzEUXXWQaGxs9YwsXLjSpqakBrzWc+drna6+91kyZMsVr7KWXXjIdOnQwDQ0NAa21tdA5nhB75ZVXeo395je/CdgJsW0unCxfvtzY7XZTWFhodu3aZSZMmGASEhJMRUWFMcaYsWPHmqlTp3rmb9myxbRr18488cQTZvfu3aagoIBLic+Br32eP3++iYqKMitWrDBff/2151FTUxOqtxAWfO3zjwXiap1T4eStt97yGt+9e7eR5PmSkWQGDRrkNaepqckkJCSYCRMmmCNHjng9li5daiSZ9957z1N7fHy82bp1q1/rPxNfe/3ll1+auLg4M3nyZLN3716zevVq07lzZzN79uyg1BuufO1zQUGBiYuLM3/7299MaWmpWbdunenRo4cZOXJkqN5CWKipqTElJSWmpKTESDILFiwwJSUl5sCBA8YYY6ZOnWrGjh3rmX/qUuKHHnrI7N6927hcLi4l9rdFixaZbt26maioKJOZmWk++OADz3M33XSTyc3N9Zr/yiuvmMsuu8xERUWZXr16mTfeeCPIFYcnX/p80UUXGUmnPQoKCoJfeJjx9fP8Q4EMJ6WlpV7jdXV1JiIiwrPXUZK5++67veZUVlY2+zn44WPlypXGGGN27dplunTpYiSZSy65xEyaNMkTXALF116///77Jisry9jtdtO9e3czZ84c/jV/Dnzpc319vZk5c6bp0aOHiY6ONmlpaWbSpEnm2LFjwS88jGzcuLHZv1+nepubm2tuuumm017Tp08fExUVZbp3726WLl0asPpsxhjj/4NFANqqmTNnatasWSotLdXFF1/sGW9oaJDdbtf48eO1ePFi2Ww25eXl6emnn/bMqaioUGpqqv793/9dubm5za7/6quvVufOnSVJbrdbq1ev1tq1a/Xmm2+qsrJSM2bM0KxZswL7JgEEVJs6IRZA8Hz++ede4WTfvn1qampSenr6GV9z4YUXKi4uTo2Njed0GXlMTIxGjRqlUaNGqa6uTr/61a80Z84cTZs2jSu9gDDGacwAAsLlcnktL1q0SJI0ZMiQM74mMjJSt99+u/7+97/rk08+Oe35I0eOeP78z3/+0+u5qKgoZWRkyBij+vr68ykdQIix5wRAQJSVlWnYsGH6xS9+oeLiYv3P//yPRo8erd69e5/1dfPnz9fGjRuVlZWl8ePHKyMjQ99884127Nih9evX65tvvpEk/fznP1dKSoquv/56JScna/fu3Xr66ad16623Ki4uLhhvEUCAEE4ABMTLL7+sGTNmaOrUqWrXrp0mT56s//zP//zJ1yUnJ2vr1q169NFHtXLlSj3zzDPq1KmTevXqpT//+c+eeffee6+Kioq0YMEC1dbWqmvXrvrDH/6ghx9+OJBvC0AQcEIsAL86dULskSNHAnonWgCtF+ecAAAASyGcAAAASyGcAAAAS+GcEwAAYCnsOQEAAJYSdpcSNzU16dChQ4qLi5PNZgt1OQAA4BwYY1RTUyOn06mIiLPvGwm7cHLo0CGlpaWFugwAANAC5eXl6tq161nnhF04OXXnx/LycjkcDr+u2+12y+l0Svo+BMXExPh1/QAAtFXV1dVKS0s7pzs4hyScjBgxQps2bdLgwYO1YsUKn1576lCOw+HweziJjIz0/NnhcBBOAADws3M5JSMkJ8Ted999evHFF0OxaQAAYHEhCScDBw7kh7kAAECzfA4nmzdv1tChQ+V0OmWz2bRq1arT5rhcLqWnpys6OlpZWVnaunWrP2oFAABtgM/nnLjdbvXu3Vt33323fvWrX532/Msvv6z8/HwtXrxYWVlZWrhwoXJycrR371517tzZL0UDABBITU1NqqurC3UZYaV9+/Ze526eD5/DyZAhQzRkyJAzPr9gwQKNHz9e48aNkyQtXrxYb7zxhpYsWaKpU6f6XODJkyd18uRJz3J1dbXP6wAA4FzV1dWprKxMTU1NoS4l7CQkJCglJeW870Pm16t16urqtH37dk2bNs0zFhERoezsbBUXF7donfPmzdOsWbP8VSIAAGdkjNHXX3+tyMhIpaWl/eTNwvA9Y4xOnDihw4cPS5JSU1PPa31+DSdHjx5VY2OjkpOTvcaTk5O1Z88ez3J2drY++ugjud1ude3aVa+++qoGDBjQ7DqnTZum/Px8z/Kp66QBAPC3hoYGnThxQk6nUx07dgx1OWGlQ4cOkqTDhw+rc+fO53WIJyT3OVm/fv05z7Xb7bLb7QGsBgCA7zU2NkqSoqKiQlxJeDoV6Orr688rnPh1f1VSUpIiIyNVWVnpNV5ZWamUlBR/bgoAgIDht9taxl9982s4iYqKUt++fbVhwwbPWFNTkzZs2HDGwzYAAAA/5PNhndraWu3bt8+zXFZWpp07dyoxMVHdunVTfn6+cnNz1a9fP2VmZmrhwoVyu92eq3cAAADOxudwsm3bNg0aNMizfOpk1dzcXBUWFmrUqFE6cuSIZsyYoYqKCvXp00dr16497SRZAADCRfrUN4K6vf3zbw3q9qzG58M6AwcOlDHmtEdhYaFnzuTJk3XgwAGdPHlSH374obKyss67UJfLpYyMDPXv3/+81wUAAH7aN998ozFjxsjhcCghIUH33HOPamtrA77dsLmAOy8vT7t27dI//vGPUJcCAEDYO5c74I4ZM0affvqp3n77ba1evVqbN2/WhAkTAl5b2IQTAABwZjU1NRozZoxiYmKUmpqqv/zlLxo4cKDuv/9+SVJ6eroee+wx3XXXXXI4HD8ZMnbv3q21a9fqhRdeUFZWlm644QYtWrRIy5cv16FDhwL6XggnAAC0Avn5+dqyZYtef/11vf3223r33Xe1Y8cOrzlPPPGEevfurZKSEj3yyCNnXV9xcbESEhLUr18/z1h2drYiIiL04YcfBuQ9nBKSm7ABAAD/qamp0bJly/TSSy9p8ODBkqSlS5fK6XR6zbv55pv14IMPntM6KyoqTvvB3nbt2ikxMVEVFRX+KfwM2HMCAECYKy0tVX19vTIzMz1j8fHx6tmzp9e8H+4FsTLCCQAAbURMTMw5z01JSfH8kN8pDQ0N+uabbwJ+13fCCQAAYa579+5q37691xWtVVVV+uyzz1q8zgEDBuj48ePavn27Z+ydd95RU1OTX24RcjZhc86Jy+WSy+Xy/CgTAAD4XlxcnHJzc/XQQw8pMTFRnTt3VkFBgSIiIlr8ezdXXHGFfvGLX2j8+PFavHix6uvrNXnyZN15552nncvib2ETTvLy8pSXl6fq6mrFx8eHuhwAQBsSDndsXbBggSZOnKjbbrtNDodDU6ZMUXl5uaKjo1u8zqKiIk2ePFmDBw9WRESEbr/9dj311FN+rLp5YRNOAADAmcXFxamoqMiz7Ha7NWvWLM/9TPbv3+/zOhMTE/XSSy/5q8RzRjgBAKAVKCkp0Z49e5SZmamqqio9+uijkqThw4eHuDLfcUIsAACtxKmbrGVnZ8vtduvdd99VUlJSs3Pnzp2r2NjYZh9DhgwJcuXe2HMCAEArcM0113hdWfNTJk6cqJEjRzb7XIcOHfxVVosQTgAAaIMSExOVmJgY6jKaxWEdAABgKYQTAABgKWETTlwulzIyMtS/f/9QlwIAAAIobMJJXl6edu3a5XVrXgAA0PqETTgBAABtA1frAADwU2YG+WdTZlYFd3sWw54TAADQrDlz5ui6665Tx44dlZCQELTtEk4AAGiD6urqzmnOr3/9a/3+978PQkX/QjgBAKAVqKmp0ZgxYxQTE6PU1FT95S9/0cCBA3X//fdLktLT0/XYY4/prrvuksPh8Pwg4NnMmjVLDzzwgK666qoAV++NcAIAQCuQn5+vLVu26PXXX9fbb7+td999Vzt27PCac+q3d0pKSvTII4+EqNKfxgmxAACEuZqaGi1btkwvvfSSBg8eLElaunSpnE6n17ybb75ZDz74YChK9Al7TgAACHOlpaWqr69XZmamZyw+Pl49e/b0mtevX79gl9YiYRNOuEMsAADnJyYmJtQlnJOwCSfcIRYAgOZ1795d7du39/qOrKqq0meffRbCqlqOc04AAAhzcXFxys3N1UMPPaTExER17txZBQUFioiIkM1ma/F6v/zyS33zzTf68ssv1djYqJ07d0qSLrnkEsXGxvqp+tMRTgAA+ClhcMfWBQsWaOLEibrtttvkcDg0ZcoUlZeXKzo6usXrnDFjhpYtW+ZZvuaaayRJGzdu1MCBA8+35DMinAAA0ArExcWpqKjIs+x2uzVr1izP/Uz279/v8zoLCwtVWFjopwrPHeEEAIBWoKSkRHv27FFmZqaqqqr06KOPSpKGDx8e4sp8FzYnxAIAgLM7dZO17Oxsud1uvfvuu0pKSmp27ty5cxUbG9vsY8iQIUGu3Bt7TgAAaAWuueYabd++/ZznT5w4USNHjmz2uQ4dOvirrBYhnAAA0AYlJiYqMTEx1GU0i8M6AAD8iDEm1CWEJX/1jXACAMD/FxkZKUmqq6sLcSXh6cSJE5Kk9u3bn9d6OKwDAMD/165dO3Xs2FFHjhxR+/btFRHBv+HPhTFGJ06c0OHDh5WQkOAJeS0VNuHE5XLJ5XKpsbEx1KUAAFopm82m1NRUlZWV6cCBA6EuJ+wkJCQoJSXlvNdjM2F2YK26ulrx8fGqqqqSw+Hw67rdbrfndry1tbVh8wNJAAD/ampq4tCOj9q3b3/WPSa+fH+HzZ4TAACCJSIi4rxu+47zw8E0AABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKWETTlwulzIyMtS/f/9QlwIAAALIZowxoS7CF7785LKv3G63YmNjJUm1tbWKiYnx6/oBAGirfPn+Dps9JwAAoG0gnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEsJm3DicrmUkZGh/v37h7oUAAAQQDZjjAl1Eb6orq5WfHy8qqqq5HA4/Lput9ut2NhYSVJtba1iYmL8un4AANoqX76/w2bPCQAAaBsIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFLCJpy4XC5lZGSof//+oS4FAAAEkM0YY0JdhC+qq6sVHx+vqqoqORwOv67b7XYrNjZWklRbW6uYmBi/rh8AgLbKl+/vsNlzAgAA2gbCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsJSQhJPVq1erZ8+euvTSS/XCCy+EogQAAGBR7YK9wYaGBuXn52vjxo2Kj49X3759NWLECHXq1CnYpQAAAAsK+p6TrVu3qlevXurSpYtiY2M1ZMgQrVu3LthlAAAAi/I5nGzevFlDhw6V0+mUzWbTqlWrTpvjcrmUnp6u6OhoZWVlaevWrZ7nDh06pC5duniWu3TpooMHD7asegAA0Or4HE7cbrd69+4tl8vV7PMvv/yy8vPzVVBQoB07dqh3797KycnR4cOHz7tYAADQ+vkcToYMGaLZs2drxIgRzT6/YMECjR8/XuPGjVNGRoYWL16sjh07asmSJZIkp9Pptafk4MGDcjqdZ9zeyZMnVV1d7fUAAACtl1/POamrq9P27duVnZ39rw1ERCg7O1vFxcWSpMzMTH3yySc6ePCgamtr9eabbyonJ+eM65w3b57i4+M9j7S0NH+WDAAALMav4eTo0aNqbGxUcnKy13hycrIqKiokSe3atdOTTz6pQYMGqU+fPnrwwQfPeqXOtGnTVFVV5XmUl5f7s2QAAGAxQb+UWJKGDRumYcOGndNcu90uu90e4IoAAIBV+HXPSVJSkiIjI1VZWek1XllZqZSUFH9uCgAAtFJ+DSdRUVHq27evNmzY4BlramrShg0bNGDAAH9uCgAAtFI+H9apra3Vvn37PMtlZWXauXOnEhMT1a1bN+Xn5ys3N1f9+vVTZmamFi5cKLfbrXHjxvm1cAAA0Dr5HE62bdumQYMGeZbz8/MlSbm5uSosLNSoUaN05MgRzZgxQxUVFerTp4/Wrl172kmyLWWMkaSAXFLsdrs9f66urlZjY6PftwEAQFt06nv71Pf42djMucyyAJfLJZfLpbq6On3xxRehLgcAALRAeXm5unbtetY5YRNOTmlqatKhQ4cUFxcnm83m9/VXV1crLS1N5eXlcjgcfl8/vkefg4deBwd9Dg76HDz+7rUxRjU1NXI6nYqIOPspryG5lPh8RERE/GTi8geHw8EHPwjoc/DQ6+Cgz8FBn4PHn72Oj48/p3lB/1ViAACAsyGcAAAASyGc/IjdbldBQQF3pQ0w+hw89Do46HNw0OfgCWWvw+6EWAAA0Lqx5wQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFhKmwwnLpdL6enpio6OVlZWlrZu3XrW+a+++qouv/xyRUdH66qrrtKaNWuCVGl486XPzz//vG688UZdcMEFuuCCC5Sdnf2T/13wPV8/z6csX75cNptNv/zlLwNbYCvia6+PHz+uvLw8paamym6367LLLuP/H+fA1z4vXLhQPXv2VIcOHZSWlqYHHnhA3333XZCqDU+bN2/W0KFD5XQ6ZbPZtGrVqp98zaZNm3TttdfKbrfrkksuUWFhYeAKNG3M8uXLTVRUlFmyZIn59NNPzfjx401CQoKprKxsdv6WLVtMZGSkefzxx82uXbvMww8/bNq3b28+/vjjIFceXnzt8+jRo43L5TIlJSVm9+7d5re//a2Jj483X331VZArDy++9vmUsrIy06VLF3PjjTea4cOHB6fYMOdrr0+ePGn69etnbrnlFvPee++ZsrIys2nTJrNz584gVx5efO1zUVGRsdvtpqioyJSVlZm33nrLpKammgceeCDIlYeXNWvWmOnTp5uVK1caSea111476/zS0lLTsWNHk5+fb3bt2mUWLVpkIiMjzdq1awNSX5sLJ5mZmSYvL8+z3NjYaJxOp5k3b16z80eOHGluvfVWr7GsrCxz7733BrTOcOdrn3+soaHBxMXFmWXLlgWqxFahJX1uaGgw1113nXnhhRdMbm4u4eQc+drrZ5991nTv3t3U1dUFq8RWwdc+5+XlmZtvvtlrLD8/31x//fUBrbM1OZdwMmXKFNOrVy+vsVGjRpmcnJyA1NSmDuvU1dVp+/btys7O9oxFREQoOztbxcXFzb6muLjYa74k5eTknHE+WtbnHztx4oTq6+uVmJgYqDLDXkv7/Oijj6pz58665557glFmq9CSXr/++usaMGCA8vLylJycrCuvvFJz585VY2NjsMoOOy3p83XXXaft27d7Dv2UlpZqzZo1uuWWW4JSc1sR7O/CsPtV4vNx9OhRNTY2Kjk52Ws8OTlZe/bsafY1FRUVzc6vqKgIWJ3hriV9/rE//vGPcjqdp/1lwL+0pM/vvfee/vrXv2rnzp1BqLD1aEmvS0tL9c4772jMmDFas2aN9u3bp0mTJqm+vl4FBQXBKDvstKTPo0eP1tGjR3XDDTfIGKOGhgZNnDhRf/rTn4JRcptxpu/C6upqffvtt+rQoYNft9em9pwgPMyfP1/Lly/Xa6+9pujo6FCX02rU1NRo7Nixev7555WUlBTqclq9pqYmde7cWc8995z69u2rUaNGafr06Vq8eHGoS2tVNm3apLlz5+qZZ57Rjh07tHLlSr3xxht67LHHQl0azkOb2nOSlJSkyMhIVVZWeo1XVlYqJSWl2dekpKT4NB8t6/MpTzzxhObPn6/169fr6quvDmSZYc/XPn/xxRfav3+/hg4d6hlramqSJLVr10579+5Vjx49Alt0mGrJZzo1NVXt27dXZGSkZ+yKK65QRUWF6urqFBUVFdCaw1FL+vzII49o7Nix+t3vfidJuuqqq+R2uzVhwgRNnz5dERH8G9wfzvRd6HA4/L7XRGpje06ioqLUt29fbdiwwTPW1NSkDRs2aMCAAc2+ZsCAAV7zJentt98+43y0rM+S9Pjjj+uxxx7T2rVr1a9fv2CUGtZ87fPll1+ujz/+WDt37vQ8hg0bpkGDBmnnzp1KS0sLZvlhpSWf6euvv1779u3zBEBJ+uyzz5SamkowOYOW9PnEiROnBZBTgdDwu7Z+E/TvwoCcZmthy5cvN3a73RQWFppdu3aZCRMmmISEBFNRUWGMMWbs2LFm6tSpnvlbtmwx7dq1M0888YTZvXu3KSgo4FLic+Brn+fPn2+ioqLMihUrzNdff+151NTUhOothAVf+/xjXK1z7nzt9Zdffmni4uLM5MmTzd69e83q1atN586dzezZs0P1FsKCr30uKCgwcXFx5m9/+5spLS0169atMz169DAjR44M1VsICzU1NaakpMSUlJQYSWbBggWmpKTEHDhwwBhjzNSpU83YsWM9809dSvzQQw+Z3bt3G5fLxaXE/rZo0SLTrVs3ExUVZTIzM80HH3zgee6mm24yubm5XvNfeeUVc9lll5moqCjTq1cv88YbbwS54vDkS58vuugiI+m0R0FBQfALDzO+fp5/iHDiG197/f7775usrCxjt9tN9+7dzZw5c0xDQ0OQqw4/vvS5vr7ezJw50/To0cNER0ebtLQ0M2nSJHPs2LHgFx5GNm7c2Oz/c0/1Njc319x0002nvaZPnz4mKirKdO/e3SxdujRg9dmMYb8XAACwjjZ1zgkAALA+wgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALCU/we+u8gvAS4lhQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 0\n", "item counter : 0\n", "ratio : 0.0\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1241\n", "item counter : 1241\n", "ratio : 0.999194847020934\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1240\n", "item counter : 1250\n", "ratio : 0.991207034372502\n", " ratio number predicted/items: 0.011990407673860911\n", "current epoch: 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGzCAYAAAD0T7cVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAz40lEQVR4nO3de1xVdb7/8TegbMS4iMRNMdLGSjMoCaL0lxaTaZnZRRs9RtZojTIztefUYE2g5W3K43gyykc1anMOjlZjnk46dqF8WEZjojSdvJQjFqWgjgq4La7f3x8NO3eisnFf1obX8/FYj1jf/d1rfdY3dL9d67vWDjLGGAEAAFhEsL8LAAAAOBHhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBIBfLV++XEFBQdqyZYu/SwFgEYQTAABgKYQTAABgKYQTAABgKYQTAF7x5Zdfatq0abrwwgvVrVs39ezZU3fccYf27t3bav/jx4/rvvvuU8+ePRUZGam77rpLR44ccemzZcsWjRgxQrGxserWrZvOP/983XPPPT44GgC+1MXfBQDomD7++GN9+OGHuvPOO9W7d2/t3btXzz33nIYNG6bt27crPDzcpX9ubq6io6M1c+ZM7dq1S88995y+/PJLbdiwQUFBQTpw4ICuv/56nXvuucrLy1N0dLT27t2r1atX++kIAXgL4QSAV9x44426/fbbXdpGjx6trKws/eUvf9GkSZNcXgsNDVVxcbG6du0qSTrvvPP08MMP63//9391880368MPP9SRI0f01ltvKT093fm+2bNne/9gAPgUl3UAeEW3bt2cPzc0NOif//ynLrjgAkVHR2vr1q0n9Z86daozmEjSL37xC3Xp0kXr1q2TJEVHR0uS3njjDTU0NHi3eAB+RTgB4BXffvut8vPzlZycLJvNptjYWJ177rk6evSoqqurT+r/k5/8xGX9nHPOUWJionOOyjXXXKPbbrtNs2bNUmxsrMaMGaNly5aprq7OF4cDwIcIJwC84pe//KXmzJmjcePG6eWXX9Zbb72lt99+Wz179lRzc7Pb2wsKCtKrr76qkpIS5ebm6ptvvtE999yjwYMH69ixY144AgD+QjgB4BWvvvqqcnJy9B//8R+6/fbb9dOf/lRDhgzR0aNHW+3/xRdfuKwfO3ZM+/fvV0pKikv7lVdeqTlz5mjLli0qKirSZ599ppUrV3rpKAD4A+EEgFeEhITIGOPStnjxYjU1NbXa//nnn3eZS/Lcc8+psbFRI0eOlCQdOXLkpO2lpaVJEpd2gA6Gu3UAeMVNN92k//qv/1JUVJQGDBigkpISvfPOO+rZs2er/evr63Xddddp3Lhx2rVrl5599lkNGTJEN998syTppZde0rPPPquxY8eqX79+qq2t1QsvvKDIyEiNGjXKl4cGwMsIJwC84j//8z8VEhKioqIifffdd7r66qv1zjvvaMSIEa32f+aZZ1RUVKT8/Hw1NDToZz/7mZ5++mkFBQVJ+n5C7ObNm7Vy5UpVVVUpKipKGRkZKioq0vnnn+/LQwPgZUHmx+dJAQAA/Ig5JwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIC7jknzc3N2rdvnyIiIpzPPwAAANZmjFFtba2SkpIUHHz6cyN+CScpKSmKjIxUcHCwevTooffee6/N7923b5+Sk5O9WB0AAPCWiooK9e7d+7R9/Hbm5MMPP9Q555zj9vsiIiIkfX9wkZGRni6rQ3A4HEpKSpL0fZjr3r27nysCAHR2NTU1Sk5Odn6On07AXdZpuZQTGRlJODmFkJAQ58+RkZGEEwCAZbRlSobbE2I3btyo0aNHKykpSUFBQVqzZs1JfQoLC5WSkqKwsDBlZmZq8+bNJxV2zTXX6IorrlBRUZG7JQAAgA7M7XDicDiUmpqqwsLCVl9ftWqV7Ha7CgoKtHXrVqWmpmrEiBE6cOCAs88HH3yg0tJSvf7665o7d67+/ve/t/8IAABAh+J2OBk5cqRmz56tsWPHtvr6woULNWXKFE2ePFkDBgzQkiVLFB4erqVLlzr79OrVS5KUmJioUaNGaevWrafcX11dnWpqalwWAADQcXn0OSf19fUqLS1Vdnb2DzsIDlZ2drZKSkokfX/mpba2VpJ07Ngxvfvuuxo4cOAptzlv3jxFRUU5F+7UAQCgY/NoODl06JCampoUHx/v0h4fH6/KykpJUlVVlYYMGaLU1FRdeeWVuuuuu3TFFVeccpszZsxQdXW1c6moqPBkyWc2M+r75UxtAADAI3x+t07fvn31ySeftLm/zWaTzWbzYkUAAMBKPHrmJDY2ViEhIaqqqnJpr6qqUkJCgid3BQAAOiiPhpPQ0FANHjxYxcXFzrbm5mYVFxcrKyvLk7vyqpS8tUrJW+vvMgAA6JTcvqxz7Ngx7d6927leXl6usrIyxcTEqE+fPrLb7crJyVF6eroyMjK0aNEiORwOTZ482aOFAwCAjsntcLJlyxYNHz7cuW632yVJOTk5Wr58ucaPH6+DBw8qPz9flZWVSktL0/r160+aJAsAANAat8PJsGHDZIw5bZ/c3Fzl5ua2uygAANB5Bdx361jSibcVz6z2Xx0AAHQAHp0QCwAAcLYIJwAAwFIIJ23E7cUAAPgG4QQAAFgK4QQAAFgK4QQAAFgK4cRb+OZiAADahXACAAAshXACAAAshXACAAAshXByFnjuCQAAnkc4AQAAlkI4AQAAlkI4AQAAlkI4AQAAltLF3wV0Gic+kG1mtf/qAADA4jhz8mMzo7Q3bIK/qwAAoNMinAAAAEshnAAAAEshnAAAAEshnAAAAEshnHgYj7QHAODsEE4AAIClEE4AAIClEE4AAIClEE4AAIClEE78aWaU62PtAQAA4QQAAFgL4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4cTLeJw9AADuIZwAAABLIZwAAABLIZwAAABLIZwAAABLIZwAAABLIZwAAABLIZwAAABLIZxYDd9UDADo5AgnAADAUggnAADAUggnAADAUggnfsD37QAAcGqEEwAAYCmEEwAAYCk+DydHjx5Venq60tLSdMkll+iFF17wdQkAAMDCuvh6hxEREdq4caPCw8PlcDh0ySWX6NZbb1XPnj19XQoAALAgn585CQkJUXh4uCSprq5OxhgZY3xdBgAAsCi3w8nGjRs1evRoJSUlKSgoSGvWrDmpT2FhoVJSUhQWFqbMzExt3rzZ5fWjR48qNTVVvXv31kMPPaTY2Nh2HwAAAOhY3A4nDodDqampKiwsbPX1VatWyW63q6CgQFu3blVqaqpGjBihAwcOOPtER0frk08+UXl5uVasWKGqqqr2HwEAAOhQ3A4nI0eO1OzZszV27NhWX1+4cKGmTJmiyZMna8CAAVqyZInCw8O1dOnSk/rGx8crNTVV77///in3V1dXp5qaGpelU+G7dgAAnYxH55zU19ertLRU2dnZP+wgOFjZ2dkqKSmRJFVVVam2tlaSVF1drY0bN+rCCy885TbnzZunqKgo55KcnOzJkgEAgMV4NJwcOnRITU1Nio+Pd2mPj49XZWWlJOnLL7/U0KFDlZqaqqFDh+qXv/ylBg0adMptzpgxQ9XV1c6loqLCkyUDAACL8fmtxBkZGSorK2tzf5vNJpvN5r2CAACApXj0zElsbKxCQkJOmuBaVVWlhIQET+4KAAB0UB4NJ6GhoRo8eLCKi4udbc3NzSouLlZWVpYndwUAADooty/rHDt2TLt373aul5eXq6ysTDExMerTp4/sdrtycnKUnp6ujIwMLVq0SA6HQ5MnT/Zo4Z1ay907M6v9WwcAAF7gdjjZsmWLhg8f7ly32+2SpJycHC1fvlzjx4/XwYMHlZ+fr8rKSqWlpWn9+vUnTZLFD1Ly1mrv/Bv9XQYAAJbgdjgZNmzYGR83n5ubq9zc3HYXBQAAOi+ff7cOAADA6RBOAACApRBOAACApfj8IWzwghO/e4c7eAAAAY4zJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFKYENtZMGkWABAgOHMCAAAshXDSmc2Mcj2jAgCABRBO4IrAAgDwM8IJAACwFMIJTq+1MymcXQEAeBHhBAAAWArhBAAAWArhxKJS8tb6u4S2a7nMw6UeAIAHEE4AAIClEE7gHZxJAQC0E+EEAABYCuEEAABYCl/8B99o7YsHW9r4IkIAwAk4cwIAACyFcAIAACyFcAIAACyFcAJr4RZkAOj0CCewNsIKAHQ6hBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMEHibJAkCHRjgBAACWQjhB4ONMCgB0KIQTAABgKYQTAABgKYSTAJGSt1YpeWv9XQYAAF5HOAEAAJZCOAEAAJZCOEHHxB08ABCwCCcAAMBSuvi7AMAnTjyLMrPaf3UAAM6IMyfovLj0AwCWRDgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACW4pdwMnbsWPXo0UO33367P3YPAAAszC/h5Ne//rX+9Kc/+WPXwKm13FrM7cUA4Fd+CSfDhg1TRESEP3YNAAAszu1wsnHjRo0ePVpJSUkKCgrSmjVrTupTWFiolJQUhYWFKTMzU5s3b/ZErQAAoBNwO5w4HA6lpqaqsLCw1ddXrVolu92ugoICbd26VampqRoxYoQOHDjQrgLr6upUU1PjsgAAgI7L7XAycuRIzZ49W2PHjm319YULF2rKlCmaPHmyBgwYoCVLlig8PFxLly5tV4Hz5s1TVFSUc0lOTm7XdgAAQGDw6JyT+vp6lZaWKjs7+4cdBAcrOztbJSUl7drmjBkzVF1d7VwqKio8VS4AALAgj34r8aFDh9TU1KT4+HiX9vj4eO3cudO5np2drU8++UQOh0O9e/fWK6+8oqysrFa3abPZZLPZPFkmAACwMI+Gk7Z65513/LFbAAAQADx6WSc2NlYhISGqqqpyaa+qqlJCQoIndwUAADooj4aT0NBQDR48WMXFxc625uZmFRcXn/KyDQAAwIncvqxz7Ngx7d6927leXl6usrIyxcTEqE+fPrLb7crJyVF6eroyMjK0aNEiORwOTZ482aOFAwCAjsntcLJlyxYNHz7cuW632yVJOTk5Wr58ucaPH6+DBw8qPz9flZWVSktL0/r160+aJAsAANAat8PJsGHDZIw5bZ/c3Fzl5ua2uygAANB5+eW7dQAAAE6FcAIAACyFcAIAACyFcBLAUvLW+ruEjm9m1PcLAMBnCCcAAMBSCCcAAMBSCCcAAMBSCCcAAMBSCCcAAMBSCCcAAMBSCCcAAMBSCCcAAMBSCCcAAMBSCCeAu3hqLAB4FeEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEE8Bce5gYArSKcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAAS+ni7wLcZYyRJNXU1HhnB3Xfb7+57vj3+zhh3bnfU/Q51fva3McD+1dNjRwOxwmrNWpqajqpz4n70olj+eM2d/qc7n2+2L+/amwvT20HAAJAy+dcy+f46QSZtvSykK+//lrJycn+LgMAALRDRUWFevfufdo+ARdOmpubtW/fPkVERCgoKMjj26+pqVFycrIqKioUGRnp8e3je4yz7zDWvsE4+wbj7DueHmtjjGpra5WUlKTg4NPPKgm4yzrBwcFnTFyeEBkZyS++DzDOvsNY+wbj7BuMs+94cqyjotr2VGwmxAIAAEshnAAAAEshnPyIzWZTQUGBbDabv0vp0Bhn32GsfYNx9g3G2Xf8OdYBNyEWAAB0bJw5AQAAlkI4AQAAlkI4AQAAlkI4AQAAltIpw0lhYaFSUlIUFhamzMxMbd68+bT9X3nlFV100UUKCwvToEGDtG7dOh9VGtjcGecXXnhBQ4cOVY8ePdSjRw9lZ2ef8f8LfuDu73SLlStXKigoSLfccot3C+wg3B3no0ePavr06UpMTJTNZlP//v35+6MN3B3nRYsW6cILL1S3bt2UnJysBx98UN99952Pqg1MGzdu1OjRo5WUlKSgoCCtWbPmjO/ZsGGDLr/8ctlsNl1wwQVavny59wo0nczKlStNaGioWbp0qfnss8/MlClTTHR0tKmqqmq1/6ZNm0xISIh58sknzfbt283vfvc707VrV/Ppp5/6uPLA4u44T5gwwRQWFppt27aZHTt2mLvvvttERUWZr7/+2seVBx53x7pFeXm56dWrlxk6dKgZM2aMb4oNYO6Oc11dnUlPTzejRo0yH3zwgSkvLzcbNmwwZWVlPq48sLg7zkVFRcZms5mioiJTXl5u3nzzTZOYmGgefPBBH1ceWNatW2ceffRRs3r1aiPJvPbaa6ftv2fPHhMeHm7sdrvZvn27Wbx4sQkJCTHr16/3Sn2dLpxkZGSY6dOnO9ebmppMUlKSmTdvXqv9x40bZ2688UaXtszMTHPfffd5tc5A5+44/1hjY6OJiIgwL730krdK7DDaM9aNjY3mqquuMi+++KLJyckhnLSBu+P83HPPmb59+5r6+npfldghuDvO06dPN9dee61Lm91uN1dffbVX6+xI2hJOHn74YTNw4ECXtvHjx5sRI0Z4paZOdVmnvr5epaWlys7OdrYFBwcrOztbJSUlrb6npKTEpb8kjRgx4pT90b5x/rHjx4+roaFBMTEx3iqzQ2jvWD/++OOKi4vTvffe64syA157xvn1119XVlaWpk+frvj4eF1yySWaO3eumpqafFV2wGnPOF911VUqLS11XvrZs2eP1q1bp1GjRvmk5s7C15+FAffFf2fj0KFDampqUnx8vEt7fHy8du7c2ep7KisrW+1fWVnptToDXXvG+cd++9vfKikp6aQ/DHDVnrH+4IMP9Mc//lFlZWU+qLDtmpubVV9fr7CwMH+XcpL2jPOePXv07rvvauLEiVq3bp12796tadOmqaGhQQUFBb4oO+C0Z5wnTJigQ4cOaciQITLGqLGxUffff78eeeQRX5TcaZzqs7CmpkbffvutunXr5tH9daozJwgM8+fP18qVK/Xaa69Z8oMqkNXW1mrSpEl64YUXFBsb65V9zJw5U0FBQdq5c6fGjRunyMhI9ezZU7/+9a9dJikGBQUpNzdXRUVFGjhwoGw2m9avXy9J+uabb3TPPfcoPj5eNptNAwcO1NKlS0/a1+LFizVw4ECFh4erR48eSk9P14oVK7xyXO5qbm5WXFycnn/+eQ0ePFjjx4/Xo48+qiVLlvi7tA5lw4YNmjt3rp599llt3bpVq1ev1tq1a/XEE0/4uzSchU515iQ2NlYhISGqqqpyaa+qqlJCQkKr70lISHCrP9o3zi0WLFig+fPn65133tGll17qzTI7BHfH+h//+If27t2r0aNHO9uam5slSV26dNGuXbvUr18/j9Q2btw4paSkaN68efroo4/09NNP68iRI/rTn/7k7PPuu+/q5ZdfVm5urmJjY5WSkqKqqipdeeWVzvBy7rnn6q9//avuvfde1dTU6IEHHpD0/R1ev/rVr3T77bc7g8/f//53/e1vf9OECRM8cgwt2vM7nZiYqK5duyokJMTZdvHFF6uyslL19fUKDQ31aI0dQXvG+bHHHtOkSZP085//XJI0aNAgORwOTZ06VY8++qiCg/k3uCec6rMwMjLS42dNJHW+u3UyMjJMbm6uc72pqcn06tXrtBNib7rpJpe2rKwsJsSegbvjbIwxv//9701kZKQpKSnxRYkdhjtj/e2335pPP/3UZRkzZoy59tprzaeffmrq6urOup6CggIjydx8880u7dOmTTOSzCeffGKM+X4SXnBwsPnss89c+t17770mMTHRHDp0yKX9zjvvNFFRUeb48ePGGGPGjBlz0gQ9b3L3d3rGjBnmvPPOM01NTc62RYsWmcTERK/XGsjcHefLL7/cPPzwwy5tK1asMN26dTONjY1erbWjUBsnxF5yySUubT/72c+8NiG204WTlStXGpvNZpYvX262b99upk6daqKjo01lZaUxxphJkyaZvLw8Z/9NmzaZLl26mAULFpgdO3aYgoICbiVuA3fHef78+SY0NNS8+uqrZv/+/c6ltrbWX4cQMNwd6x/z9N06LeHkzTffdGnfsWOHkeT8kJFkhg8f7tKnubnZREdHm6lTp5qDBw+6LMuWLTOSzAcffOCsOyoqymzevNljtZ+Ou+P81VdfmYiICJObm2t27dpl3njjDRMXF2dmz57tk3oDlbvjXFBQYCIiIsyf//xns2fPHvPWW2+Zfv36mXHjxvnrEAJCbW2t2bZtm9m2bZuRZBYuXGi2bdtmvvzyS2OMMXl5eWbSpEnO/i23Ej/00ENmx44dprCwkFuJPW3x4sWmT58+JjQ01GRkZJiPPvrI+do111xjcnJyXPq//PLLpn///iY0NNQMHDjQrF271scVByZ3xvm8884zkk5aCgoKfF94AHL3d/pE3gone/bscWmvr683wcHBzrOOksw999zj0qeqqqrV34MTl9WrVxtjjNm+fbvp1auXkWQuuOACM23aNGdw8RZ3x/nDDz80mZmZxmazmb59+5o5c+bwr/k2cGecGxoazMyZM02/fv1MWFiYSU5ONtOmTTNHjhzxfeEB5L333mv1z1fL2Obk5JhrrrnmpPekpaWZ0NBQ07dvX7Ns2TKv1RdkjDGev1gEoLOaOXOmZs2apT179uj88893tjc2Nspms2nKlClasmSJgoKCNH36dD3zzDPOPpWVlUpMTNS//du/KScnp9XtX3rppYqLi5MkORwOvfHGG1q/fr3++te/qqqqSvn5+Zo1a5Z3DxKAV3WqCbEAfOeLL75wCSe7d+9Wc3OzUlJSTvmec889VxEREWpqamrTbeTdu3fX+PHjNX78eNXX1+vWW2/VnDlzNGPGDO70AgIY05gBeEVhYaHL+uLFiyVJI0eOPOV7QkJCdNttt+kvf/mL/u///u+k1w8ePOj8+Z///KfLa6GhoRowYICMMWpoaDib0gH4GWdOAHhFeXm5br75Zt1www0qKSnRf//3f2vChAlKTU097fvmz5+v9957T5mZmZoyZYoGDBigw4cPa+vWrXrnnXd0+PBhSdL111+vhIQEXX311YqPj9eOHTv0zDPP6MYbb1RERIQvDhGAlxBOAHjFqlWrlJ+fr7y8PHXp0kW5ubl66qmnzvi++Ph4bd68WY8//rhWr16tZ599Vj179tTAgQP1+9//3tnvvvvuU1FRkRYuXKhjx46pd+/e+tWvfqXf/e533jwsAD7AhFgAHtUyIfbgwYNeewotgI6NOScAAMBSCCcAAMBSCCcAAMBSmHMCAAAshTMnAADAUgLuVuLm5mbt27dPERERCgoK8nc5AACgDYwxqq2tVVJSkoKDT39uJODCyb59+5ScnOzvMgAAQDtUVFSod+/ep+0TcOGk5cmPFRUVioyM9HM11uBwOJSUlCTp+/DWvXt3P1cEAICrmpoaJScnt+kJzgEXTlou5URGRhJO/iUkJMT5c2RkJOEEAGBZbZmS4ZcJseXl5Ro+fLgGDBigQYMGyeFw+KMMAABgQX45c3L33Xdr9uzZGjp0qA4fPiybzeaPMgAAgAX5PJx89tln6tq1q4YOHSpJiomJ8XUJAADAwtwOJxs3btRTTz2l0tJS7d+/X6+99ppuueUWlz6FhYV66qmnVFlZqdTUVC1evFgZGRmSpC+++ELnnHOORo8erW+++Ua33367HnnkEY8cDAAAntDc3Kz6+np/lxFQunbt6jIH8my4HU4cDodSU1N1zz336NZbbz3p9VWrVslut2vJkiXKzMzUokWLNGLECO3atUtxcXFqbGzU+++/r7KyMsXFxemGG27QFVdcoZ/+9Ket7q+urk51dXXO9ZqaGndLBgCgzerr61VeXq7m5mZ/lxJwoqOjlZCQcNbPIXM7nIwcOVIjR4485esLFy7UlClTNHnyZEnSkiVLtHbtWi1dulR5eXnq1auX0tPTnc8qGTVqlMrKyk4ZTubNm6dZs2a5W+ZZSclbK0naO/9Gn+4XAOBfxhjt379fISEhSk5OPuPDwvA9Y4yOHz+uAwcOSJISExPPansenXNSX1+v0tJSzZgxw9kWHBys7OxslZSUSJKuuOIKHThwQEeOHFFUVJQ2btyo++6775TbnDFjhux2u3O95T5pAAA8rbGxUcePH1dSUpLCw8P9XU5A6datmyTpwIEDiouLO6tLPB4NJ4cOHVJTU5Pi4+Nd2uPj47Vz587vd9ili+bOnav/9//+n4wxuv7663XTTTedcps2m427eQAAPtHU1CRJCg0N9XMlgakl0DU0NFgnnLTVmS4NAQDgT3x3W/t4atw8ejEtNjZWISEhqqqqcmmvqqpSQkKCJ3cFAAA6KI+Gk9DQUA0ePFjFxcXOtubmZhUXFysrK8uTuwIAAB2U25d1jh07pt27dzvXy8vLVVZWppiYGPXp00d2u105OTlKT09XRkaGFi1aJIfD4bx7BwCAQNNyF6evdPa7Rd0+c7JlyxZddtlluuyyyyRJdrtdl112mfLz8yVJ48eP14IFC5Sfn6+0tDSVlZVp/fr1J02SBQAA1nb48GFNnDhRkZGRio6O1r333qtjx455fb9unzkZNmyYjDGn7ZObm6vc3Nx2FwUAALyrvr7+jHclTZw4Ufv379fbb7+thoYGTZ48WVOnTtWKFSu8WhtPlwEAoAOora3VxIkT1b17dyUmJuoPf/iDhg0bpgceeECSlJKSoieeeEJ33XWXIiMjNXXq1NNub8eOHVq/fr1efPFFZWZmasiQIVq8eLFWrlypffv2efVYCCcAAHQAdrtdmzZt0uuvv663335b77//vrZu3erSZ8GCBUpNTdW2bdv02GOPnXZ7JSUlio6OVnp6urMtOztbwcHB+tvf/uaVY2jhl+ecAAAAz6mtrdVLL72kFStW6LrrrpMkLVu2TElJSS79rr32Wv3mN79p0zYrKysVFxfn0talSxfFxMSosrLSM4WfAmdOAAAIcHv27FFDQ4MyMjKcbVFRUbrwwgtd+p14FsTKCCcAAHQS3bt3b3PfhIQE5xf5tWhsbNThw4e9/mBVwgkAAAGub9++6tq1qz7++GNnW3V1tT7//PN2bzMrK0tHjx5VaWmps+3dd99Vc3OzMjMzz6reM2HOCQAAAS4iIkI5OTl66KGHFBMTo7i4OBUUFCg4OLjd33dz8cUX64YbbtCUKVO0ZMkSNTQ0KDc3V3feeedJc1k8jXACAMAZBMITWxcuXKj7779fN910kyIjI/Xwww+roqJCYWFh7d5mUVGRcnNzdd111yk4OFi33Xabnn76aQ9W3TrCCQAAHUBERISKioqc6w6HQ7NmzXI+z2Tv3r1ubzMmJsbrD1xrDeEEAIAOYNu2bdq5c6cyMjJUXV2txx9/XJI0ZswYP1fmPibEAgDQQbQ8ZC07O1sOh0Pvv/++YmNjW+07d+5cnXPOOa0uI0eO9HHlrjhzAgBAB3DZZZe53FlzJvfff7/GjRvX6mvdunXzVFntQjgBAKATiomJUUxMjL/LaBWXdQAAgKVw5qQNUvLWOn8OhNvJAAAIZJw5AQAAlkI4AQAAlkI4AQAAlsKcEwAAzmRmlI/3V+3b/VkMZ04AAECr5syZo6uuukrh4eGKjo722X4JJ+2UkrfW5S4eAAACSX19fZv63HHHHfrFL37hg4p+QDgBAKADqK2t1cSJE9W9e3clJibqD3/4g4YNG6YHHnhAkpSSkqInnnhCd911lyIjI51fCHg6s2bN0oMPPqhBgwZ5uXpXhBMAADoAu92uTZs26fXXX9fbb7+t999/X1u3bnXp0/LdO9u2bdNjjz3mp0rPjAmxAAAEuNraWr300ktasWKFrrvuOknSsmXLlJSU5NLv2muv1W9+8xt/lOgWzpwAABDg9uzZo4aGBmVkZDjboqKidOGFF7r0S09P93Vp7UI4AQCgk+jevbu/S2gTwgkAAAGub9++6tq1qz7++GNnW3V1tT7//HM/VtV+zDkBACDARUREKCcnRw899JBiYmIUFxengoICBQcHKygoqN3b/eqrr3T48GF99dVXampqUllZmSTpggsu0DnnnOOh6k9GOAEA4EwC4ImtCxcu1P3336+bbrpJkZGRevjhh1VRUaGwsLB2bzM/P18vvfSSc/2yyy6TJL333nsaNmzY2ZZ8SoQTAAA6gIiICBUVFTnXHQ6HZs2a5Xyeyd69e93e5vLly7V8+XIPVdh2hBMAADqAbdu2aefOncrIyFB1dbUef/xxSdKYMWP8XJn7mBB7JjOjtDdswhnbWh5nzyPtAQD+0vKQtezsbDkcDr3//vuKjY1tte/cuXN1zjnntLqMHDnSx5W74swJAAAdwGWXXabS0tI297///vs1bty4Vl/r1q2bp8pqF8IJAACdUExMjGJiYvxdRqu4rAMAwI8YY/xdQkDy1LgRTgAA+JeQkBBJUn19vZ8rCUzHjx+XJHXt2vWstsNlHQAA/qVLly4KDw/XwYMH1bVrVwUH82/4tjDG6Pjx4zpw4ICio6OdIa+9CCeeMDNKe//1jJuU71b4txYAQLsFBQUpMTFR5eXl+vLLL/1dTsCJjo5WQkLCWW+HcAIAwAlCQ0P1k5/8hEs7buratetZnzFp4bdwcvz4cV188cW64447tGDBAn+VAQDASYKDg8/qse84O367mDZnzhxdeeWV/to9AACwKL+Eky+++EI7d+70+xPoAACA9bgdTjZu3KjRo0crKSlJQUFBWrNmzUl9CgsLlZKSorCwMGVmZmrz5s0ur//7v/+75s2b1+6iA8LMKGlmFI+zBwDATW6HE4fDodTUVBUWFrb6+qpVq2S321VQUKCtW7cqNTVVI0aM0IEDByRJ//M//6P+/furf//+Z1c5AADokNyeEDty5MjTXo5ZuHChpkyZosmTJ0uSlixZorVr12rp0qXKy8vTRx99pJUrV+qVV17RsWPH1NDQoMjISOXn57e6vbq6OtXV1TnXa2pq3C0ZAAAEEI/OOamvr1dpaamys7N/2EFwsLKzs1VSUiJJmjdvnioqKrR3714tWLBAU6ZMOWUwaekfFRXlXJKTkz1ZMgAAsBiPhpNDhw6pqalJ8fHxLu3x8fGqrKxs1zZnzJih6upq51JRUeGJUgEAgEX59SFsd9999xn72Gw22Ww27xcDAAAswaNnTmJjYxUSEqKqqiqX9qqqKo88zhYAAHR8Hg0noaGhGjx4sIqLi51tzc3NKi4uVlZWlid3BQAAOii3L+scO3ZMu3fvdq6Xl5errKxMMTEx6tOnj+x2u3JycpSenq6MjAwtWrRIDofDefcOAADA6bgdTrZs2aLhw4c71+12uyQpJydHy5cv1/jx43Xw4EHl5+ersrJSaWlpWr9+/UmTZDudmVEn/FztvzoAALA4t8PJsGHDZIw5bZ/c3Fzl5ua2uyi/mhmlvWFSyncr/F0JAACdkt+++A8AAKA1hBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBM/SMlb6+8SAACwLMIJAACwFMIJAACwFMIJAACwFMIJAACwFMIJAACwFMIJAACwFMIJAACwFMIJAACwFMKJP82M+n4BAABOhBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMAAGAphBMLSMlb6+8SAACwDMIJAACwFMIJAACwFMIJAACwFMIJAACwFMIJAACwFMIJAACwFMIJAACwFJ+Hk4qKCg0bNkwDBgzQpZdeqldeecXXJQAAAAvr4vMddumiRYsWKS0tTZWVlRo8eLBGjRql7t27+7oUAABgQT4PJ4mJiUpMTJQkJSQkKDY2VocPHyactJgZ9a//Vvu3DgAA/MTtyzobN27U6NGjlZSUpKCgIK1Zs+akPoWFhUpJSVFYWJgyMzO1efPmVrdVWlqqpqYmJScnu104AADomNwOJw6HQ6mpqSosLGz19VWrVslut6ugoEBbt25VamqqRowYoQMHDrj0O3z4sO666y49//zzp91fXV2dampqXJbOgO/bAQB0Vm6Hk5EjR2r27NkaO3Zsq68vXLhQU6ZM0eTJkzVgwAAtWbJE4eHhWrp0qbNPXV2dbrnlFuXl5emqq6467f7mzZunqKgo58JZFgAAOjaP3q1TX1+v0tJSZWdn/7CD4GBlZ2erpKREkmSM0d13361rr71WkyZNOuM2Z8yYoerqaudSUVHhyZIBAIDFeDScHDp0SE1NTYqPj3dpj4+PV2VlpSRp06ZNWrVqldasWaO0tDSlpaXp008/PeU2bTabIiMjXRYAANBx+fxunSFDhqi5udnXuwUAAAHCo2dOYmNjFRISoqqqKpf2qqoqJSQkeHJXAACgg/JoOAkNDdXgwYNVXFzsbGtublZxcbGysrI8uSsAANBBuX1Z59ixY9q9e7dzvby8XGVlZYqJiVGfPn1kt9uVk5Oj9PR0ZWRkaNGiRXI4HJo8ebJHCwcAAB2T2+Fky5YtGj58uHPdbrdLknJycrR8+XKNHz9eBw8eVH5+viorK5WWlqb169efNEkWAACgNW6Hk2HDhskYc9o+ubm5ys3NbXdRAACg8/L5txIDAACcDuEEAABYCuEEAABYCuEEAABYis+fEAv3nfgNxXvn3+jHSgAA8D7OnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnASolLy1Sslb6+8yAADwOMIJAACwFMIJAACwFMIJAACwFMIJAACwFMIJAACwlC7+LsBdxhhJUk1NjXd2UPf99pvrjn+/jxPWnfs9RZ9Tva/NfVrb/wn7du7/R/U4HA6X15uamjwxEgAAeEzL51fL5/jpBJm29LKQr7/+WsnJyf4uAwAAtENFRYV69+592j4BF06am5u1b98+RUREKCgoyOPbr6mpUXJysioqKhQZGenx7eN7jLPvMNa+wTj7BuPsO54ea2OMamtrlZSUpODg088qCbjLOsHBwWdMXJ4QGRnJL74PMM6+w1j7BuPsG4yz73hyrKOiotrUjwmxAADAUggnAADAUggnP2Kz2VRQUCCbzebvUjo0xtl3GGvfYJx9g3H2HX+OdcBNiAUAAB0bZ04AAIClEE4AAIClEE4AAIClEE4AAIClEE4AAICldMpwUlhYqJSUFIWFhSkzM1ObN28+bf9XXnlFF110kcLCwjRo0CCtW7fOR5UGNnfG+YUXXtDQoUPVo0cP9ejRQ9nZ2Wf8/4IfuPs73WLlypUKCgrSLbfc4t0COwh3x/no0aOaPn26EhMTZbPZ1L9/f/7+aAN3x3nRokW68MIL1a1bNyUnJ+vBBx/Ud99956NqA9PGjRs1evRoJSUlKSgoSGvWrDnjezZs2KDLL79cNptNF1xwgZYvX+69Ak0ns3LlShMaGmqWLl1qPvvsMzNlyhQTHR1tqqqqWu2/adMmExISYp588kmzfft287vf/c507drVfPrppz6uPLC4O84TJkwwhYWFZtu2bWbHjh3m7rvvNlFRUebrr7/2ceWBx92xblFeXm569eplhg4dasaMGeObYgOYu+NcV1dn0tPTzahRo8wHH3xgysvLzYYNG0xZWZmPKw8s7o5zUVGRsdlspqioyJSXl5s333zTJCYmmgcffNDHlQeWdevWmUcffdSsXr3aSDKvvfbaafvv2bPHhIeHG7vdbrZv324WL15sQkJCzPr1671SX6cLJxkZGWb69OnO9aamJpOUlGTmzZvXav9x48aZG2+80aUtMzPT3HfffV6tM9C5O84/1tjYaCIiIsxLL73krRI7jPaMdWNjo7nqqqvMiy++aHJycggnbeDuOD/33HOmb9++pr6+3lcldgjujvP06dPNtdde69Jmt9vN1Vdf7dU6O5K2hJOHH37YDBw40KVt/PjxZsSIEV6pqVNd1qmvr1dpaamys7OdbcHBwcrOzlZJSUmr7ykpKXHpL0kjRow4ZX+0b5x/7Pjx42poaFBMTIy3yuwQ2jvWjz/+uOLi4nTvvff6osyA155xfv3115WVlaXp06crPj5el1xyiebOnaumpiZflR1w2jPOV111lUpLS52Xfvbs2aN169Zp1KhRPqm5s/D1Z2HAfSvx2Th06JCampoUHx/v0h4fH6+dO3e2+p7KyspW+1dWVnqtzkDXnnH+sd/+9rdKSko66Q8DXLVnrD/44AP98Y9/VFlZmQ8q7BjaM8579uzRu+++q4kTJ2rdunXavXu3pk2bpoaGBhUUFPii7IDTnnGeMGGCDh06pCFDhsgYo8bGRt1///165JFHfFFyp3Gqz8Kamhp9++236tatm0f316nOnCAwzJ8/XytXrtRrr72msLAwf5fTodTW1mrSpEl64YUXFBsb6+9yOrTm5mbFxcXp+eef1+DBgzV+/Hg9+uijWrJkib9L61A2bNiguXPn6tlnn9XWrVu1evVqrV27Vk888YS/S8NZ6FRnTmJjYxUSEqKqqiqX9qqqKiUkJLT6noSEBLf6o33j3GLBggWaP3++3nnnHV166aXeLLNDcHes//GPf2jv3r0aPXq0s625uVmS1KVLF+3atUv9+vXzbtEBqD2/04mJieratatCQkKcbRdffLEqKytVX1+v0NBQr9YciNozzo899pgmTZqkn//855KkQYMGyeFwaOrUqXr00UcVHMy/wT3hVJ+FkZGRHj9rInWyMyehoaEaPHiwiouLnW3Nzc0qLi5WVlZWq+/Jyspy6S9Jb7/99in7o33jLElPPvmknnjiCa1fv17p6em+KDXguTvWF110kT799FOVlZU5l5tvvlnDhw9XWVmZkpOTfVl+wGjP7/TVV1+t3bt3O8OfJH3++edKTEwkmJxCe8b5+PHjJwWQlkBo+F5bj/H5Z6FXptla2MqVK43NZjPLly8327dvN1OnTjXR0dGmsrLSGGPMpEmTTF5enrP/pk2bTJcuXcyCBQvMjh07TEFBAbcSt4G74zx//nwTGhpqXn31VbN//37nUltb669DCBjujvWPcbdO27g7zl999ZWJiIgwubm5ZteuXeaNN94wcXFxZvbs2f46hIDg7jgXFBSYiIgI8+c//9ns2bPHvPXWW6Zfv35m3Lhx/jqEgFBbW2u2bdtmtm3bZiSZhQsXmm3btpkvv/zSGGNMXl6emTRpkrN/y63EDz30kNmxY4cpLCzkVmJPW7x4senTp48JDQ01GRkZ5qOPPnK+ds0115icnByX/i+//LLp37+/CQ0NNQMHDjRr1671ccWByZ1xPu+884ykk5aCggLfFx6A3P2dPhHhpO3cHecPP/zQZGZmGpvNZvr27WvmzJljGhsbfVx14HFnnBsaGszMmTNNv379TFhYmElOTjbTpk0zR44c8X3hAeS9995r9e/clrHNyckx11xzzUnvSUtLM6GhoaZv375m2bJlXqsvyBjOewEAAOvoVHNOAACA9RFOAACApRBOAACApRBOAACApRBOAACApRBOAACApRBOAACApRBOAACApRBOAACApRBOAACApRBOAACApfx/1uZjXII2lyEAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1230\n", "item counter : 1996\n", "ratio : 0.6159238858287431\n", " ratio number predicted/items: 1.1832749123685529\n", "current epoch: 2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1240\n", "item counter : 2019\n", "ratio : 0.6138613861386139\n", " ratio number predicted/items: 1.3925742574257425\n", "current epoch: 3\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1234\n", "item counter : 2037\n", "ratio : 0.60549558390579\n", " ratio number predicted/items: 1.5500490677134446\n", "current epoch: 4\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1239\n", "item counter : 2104\n", "ratio : 0.5885985748218527\n", " ratio number predicted/items: 1.8498812351543943\n", "current epoch: 5\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1233\n", "item counter : 2172\n", "ratio : 0.5674183156925909\n", " ratio number predicted/items: 1.9829728485964104\n", "current epoch: 6\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1233\n", "item counter : 2215\n", "ratio : 0.5564079422382672\n", " ratio number predicted/items: 2.046028880866426\n", "current epoch: 7\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1235\n", "item counter : 2242\n", "ratio : 0.5506018724921979\n", " ratio number predicted/items: 2.0789121711992866\n", "current epoch: 8\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiYAAAGzCAYAAAAbjdwrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA1BUlEQVR4nO3dfVyUdb7/8feAMkhxIxJ3iZF2srwJS4Lo5qcWZ10tc+1GWzvGWqt5lLaNfdjqtomVd9vpeDwZ5SPLqHNwtW3N40nXSsoHWbQmSHVSK1csWmPULQGxAOH7+6OYGgVlcG6umXk9H4955Fzznev7mW/gvP1e3+u6bMYYIwAAAAsI83cBAAAA7QgmAADAMggmAADAMggmAADAMggmAADAMggmAADAMggmAADAMggmAADAMggmAADAMggmAPyquLhYNptNO3bs8HcpACyAYAIAACyDYAIAACyDYAIAACyDYALAKz777DPNnDlTAwcOVK9evdSnTx/deuut2r9/f4ftjx07prvvvlt9+vRRTEyM7rjjDn399dcubXbs2KHRo0crISFBvXr10vnnn68777zTB58GgK/08HcBAILTe++9p3feeUe33Xab+vbtq/379+upp57SyJEjtWvXLkVFRbm0z8/PV1xcnObPn6+PP/5YTz31lD777DNt3bpVNptNBw8e1E9+8hOdc845mjNnjuLi4rR//36tW7fOT58QgDcQTAB4xfXXX69bbrnFZdu4ceOUk5OjP//5z5oyZYrLaxERESotLVXPnj0lSeedd57uv/9+/e///q9uvPFGvfPOO/r666/12muvKTMz0/m+BQsWeP/DAPAZDuUA8IpevXo5/9zS0qJ//OMfuuCCCxQXF6fKysqT2k+fPt0ZSiTpX//1X9WjRw9t2rRJkhQXFydJeuWVV9TS0uLd4gH4DcEEgFd88803mjdvntLS0mS325WQkKBzzjlHR44cUV1d3Unt/+mf/snl+dlnn62UlBTnmpQRI0bo5ptv1kMPPaSEhASNHz9ezz33nJqamnzxcQD4CMEEgFfcc889WrhwoSZOnKgXX3xRr732ml5//XX16dNHbW1tbu/PZrPppZdeUnl5ufLz8/X3v/9dd955p4YPH66jR4964RMA8AeCCQCveOmll5SXl6d///d/1y233KJ//ud/1tVXX60jR4502P7TTz91eX706FF9+eWXSk9Pd9l+xRVXaOHChdqxY4dKSkr00Ucfac2aNV76FAB8jWACwCvCw8NljHHZtnz5crW2tnbY/umnn3ZZO/LUU0/p+PHjGjNmjCTp66+/Pml/w4YNkyQO5wBBhLNyAHjFDTfcoP/6r/9SbGysBg0apPLycm3ZskV9+vTpsH1zc7Ouu+46TZw4UR9//LGefPJJXX311brxxhslSc8//7yefPJJTZgwQQMGDFBDQ4NWrlypmJgYjR071pcfDYAXEUwAeMV//ud/Kjw8XCUlJfr222911VVXacuWLRo9enSH7Z944gmVlJRo3rx5amlp0c9//nM9/vjjstlskr5b/Lp9+3atWbNGDodDsbGxysrKUklJic4//3xffjQAXmQzJ86NAgAA+AlrTAAAgGUQTAAAgGUQTAAAgGUQTAAAgGUQTAAAgGUQTAAAgGUE3HVM2tradODAAUVHRzuvbwAAAKzNGKOGhgalpqYqLKzzeZGACyYHDhxQWlqav8sAAADdUFNTo759+3b6esAFk+joaEnffbCYmBg/V4PTaWxsVGpqqqTvQuVZZ53l54oAAP5QX1+vtLQ05/d4Z/wSTNLT0xUTE6OwsDD17t1bb775Zpff2374JiYmhmASAMLDw51/jomJIZgAQIg73TIMv82YvPPOOzr77LP91T0AALAgzsoBAACW4XYwKSsr07hx45Samiqbzab169ef1KaoqEjp6emKjIxUdna2tm/f7vK6zWbTiBEjdPnll6ukpKTbxQMAgODidjBpbGxURkaGioqKOnx97dq1KigoUGFhoSorK5WRkaHRo0fr4MGDzjbbtm1TRUWFNmzYoEWLFumDDz7o/icAAABBw+1gMmbMGC1YsEATJkzo8PWlS5dq2rRpmjp1qgYNGqQVK1YoKipKq1atcrY599xzJUkpKSkaO3asKisrO+2vqalJ9fX1Lg9vS5+zUelzNnq9HwAA4Mqja0yam5tVUVGh3NzcHzoIC1Nubq7Ky8slfTfj0tDQIEk6evSo3njjDQ0ePLjTfS5evFixsbHOB9cwAQAgeHk0mBw+fFitra1KSkpy2Z6UlKTa2lpJksPh0NVXX62MjAxdccUVuuOOO3T55Zd3us+5c+eqrq7O+aipqfFkyQAAwEJ8frpw//799f7773e5vd1ul91u92JFpzE/9vv/1vmvBgAAQoRHZ0wSEhIUHh4uh8Phst3hcCg5OdmTXfnX/NgfAgsAAPAYjwaTiIgIDR8+XKWlpc5tbW1tKi0tVU5Ojie7AgAAQcjtQzlHjx7V3r17nc+rq6tVVVWl+Ph49evXTwUFBcrLy1NmZqaysrK0bNkyNTY2aurUqR4tHAAABB+3g8mOHTs0atQo5/OCggJJUl5enoqLizVp0iQdOnRI8+bNU21trYYNG6bNmzeftCAWAADgRG4Hk5EjR8oYc8o2+fn5ys/P73ZRAAAgNHGvHE9gMSwAAB5BMAEAAJZBMAEAAJZBMAEAAJZBMOkibuoHAID3+fyS9Jb2/QLW/ZFS+rer/VwMAAChhxkTb+FMHQAA3EYwAQAAlkEwAQAAlkEwAQAAlkEwAQAAlkEwAQAAlkEwAQAAlkEwOQNuXXSt/fRhTiEGAKBTBBMAAGAZBBMAAGAZBBMAAGAZBBMAAGAZBBMAAGAZBBMAAGAZBBN/4vRhAABcEEwAAIBlEEwAAIBlEEw8KH3ORveuBgsAAFwQTAAAgGUQTAAAgGUQTAAAgGX08HcB+JEfnzo8v85/dQAA4CfMmAAAAMsgmAAAAMsgmAAAAMsgmAAAAMsgmAAAAMsgmAAAAMsgmHjZGV+injsQAwBCCMEEAABYBsEEAABYBsEEAABYBsEEAABYBsEkELEgFgAQpAgmAADAMggmAADAMggmAADAMggmAADAMggmfnDGV4MFACBIEUwAAIBlEEyCAacPAwCChM+DyZEjR5SZmalhw4ZpyJAhWrlypa9LAAAAFtXD1x1GR0errKxMUVFRamxs1JAhQ3TTTTepT58+vi4FAABYjM9nTMLDwxUVFSVJampqkjFGxhhflwEAACzI7WBSVlamcePGKTU1VTabTevXrz+pTVFRkdLT0xUZGans7Gxt377d5fUjR44oIyNDffv21ezZs5WQkNDtDwAAAIKH28GksbFRGRkZKioq6vD1tWvXqqCgQIWFhaqsrFRGRoZGjx6tgwcPOtvExcXp/fffV3V1tVavXi2Hw9H9TwAAAIKG28FkzJgxWrBggSZMmNDh60uXLtW0adM0depUDRo0SCtWrFBUVJRWrVp1UtukpCRlZGTorbfe6rS/pqYm1dfXuzzQBZypAwAIQB5dY9Lc3KyKigrl5ub+0EFYmHJzc1VeXi5JcjgcamhokCTV1dWprKxMAwcO7HSfixcvVmxsrPORlpbmyZItgQuuAQDwHY8Gk8OHD6u1tVVJSUku25OSklRbWytJ+uyzz3TNNdcoIyND11xzje655x4NHTq0033OnTtXdXV1zkdNTY0nSwYAABbi89OFs7KyVFVV1eX2drtddrvdewUBAADL8OiMSUJCgsLDw09azOpwOJScnOzJrgAAQBDyaDCJiIjQ8OHDVVpa6tzW1tam0tJS5eTkeLIrAAAQhNw+lHP06FHt3bvX+by6ulpVVVWKj49Xv379VFBQoLy8PGVmZiorK0vLli1TY2Ojpk6d6tHCAQBA8HE7mOzYsUOjRo1yPi8oKJAk5eXlqbi4WJMmTdKhQ4c0b9481dbWatiwYdq8efNJC2LhYz8+dXh+nf/qAADgFNwOJiNHjjztJeTz8/OVn5/f7aIAAEBo8vm9cgAAADpDMLEoLroGAAhFBBMAAGAZBJNQxv10AAAWQzABAACWQTABAACWQTABAACWQTABAACWQTABAACWQTABAACWQTAJEFxwDQAQCggmAADAMty+iR+CGHcgBgD4GTMmAADAMggmAADAMggmAIDu89Q9t7qyH+7vFRIIJgAAayKIhCSCCQCg4xDgy9kQ4HuclQMAwcTfZ9f5uv/2/tr76kr//h4jnBIzJgHMJxdd4186QODz9MxHoM2i8PdYQCGYAEAg40sXQYZDOQAQKDx5COLEQyChjvGwDGZMAACAZRBMAADoyImHyThs5hMEEwDwBy4oBnSIYAIAnfFleCCEAJJY/AoAXcc1MnAiFs16HMEkiLRf12T/kuu92xG/iADQMYLpGeNQDgB4G4dpgC4jmAQ5n1wdFrAST16dFIDPEUwAQCLMABZBMAEQmggigCURTABYl6dO1yWEAAGDYAIAgDcRjN3C6cI4c5w+DE/gNEsAYsYEAABYCDMmAAIHsypA0GPGBID3cYwdQBcRTAB4HkEEQDdxKAdA13V0KIXFz4B7OCR5SsyYAKGK638AsCCCSQji/jlBhvAAIIgQTIBgFAhhJRBqBOBzBBMAAGAZBBMAAGAZnJUD72ifop99wL91WNmJZ7N4c6V+V86c4UwBABbAjAlgZazDABBi/BJMJkyYoN69e+uWW27xR/cAAMCi/BJM7r33Xr3wwgv+6BrwDWY6AKBb/BJMRo4cqejoaH90DQCA9fCPGSe3g0lZWZnGjRun1NRU2Ww2rV+//qQ2RUVFSk9PV2RkpLKzs7V9+3ZP1IpAtzDlhAWWIfSL6KnP2r6fUBk3ACHH7WDS2NiojIwMFRUVdfj62rVrVVBQoMLCQlVWViojI0OjR4/WwYMHz7hY+A5Xh3UDQQEAPMbt04XHjBmjMWPGdPr60qVLNW3aNE2dOlWStGLFCm3cuFGrVq3SnDlz3C6wqalJTU1Nzuf19fVu7wMAAAQGj64xaW5uVkVFhXJzc3/oICxMubm5Ki8v79Y+Fy9erNjYWOcjLS3NU+UilHAoBQACgkeDyeHDh9Xa2qqkpCSX7UlJSaqtrXU+z83N1a233qpNmzapb9++pwwtc+fOVV1dnfNRU1PjyZJhdYQAAAgpfrny65YtW7rc1m63y263e7EaAABgFR6dMUlISFB4eLgcDofLdofDoeTkZE92BfgGMzYA4FMeDSYREREaPny4SktLndva2tpUWlqqnJwcT3YFD7LMGTieXL/Rnf2wfgQA/M7tQzlHjx7V3r17nc+rq6tVVVWl+Ph49evXTwUFBcrLy1NmZqaysrK0bNkyNTY2Os/SAQAA6IzbwWTHjh0aNWqU83lBQYEkKS8vT8XFxZo0aZIOHTqkefPmqba2VsOGDdPmzZtPWhAL+F1X7rgLAPApt4PJyJEjZYw5ZZv8/Hzl5+d3uygAABCa/HKvHAAAgI4QTBD4WLAKAEGDYAIAACyDYAIAACyDYIJus8z1TwAgGIXoYWqCCQAAsAyCCQAAsAyCCQAAsAyCCQJPiB53BYBQQDABAACWQTABAACWQTABAACWQTABAACWQTCBx6TP2chF1wAAZ4RgAgAALINgAgAALINgAgAALINgAgAALINgAgAALINgAgAALINgAgAALINgAgAALINggi7hwmkA4Gchcmd1ggkAALAMggkAALAMggkAALAMggkAALAMggkAALAMggkAALCMHv4uwF3GGElSfX2953feZJx/bGs69l0f329zPv9Ru47aOGvrpM0p9x2E/Tf+6P9TfZNRq5F0wn5Oet7Rth///+7sfZ5qc6r3+aJG+j+z/gOhRvrn99hT/QeQ9u+Q9u/xztjM6VpYzBdffKG0tDR/lwEAALqhpqZGffv27fT1gAsmbW1tOnDggKKjo2Wz2Ty+//r6eqWlpammpkYxMTEe3z++wzj7BuPsO4y1bzDOvuPpsTbGqKGhQampqQoL63wlScAdygkLCztl0vKUmJgYfuh9gHH2DcbZdxhr32CcfceTYx0be/or17L4FQAAWAbBBAAAWAbB5AR2u12FhYWy2+3+LiWoMc6+wTj7DmPtG4yz7/hrrANu8SsAAAhezJgAAADLIJgAAADLIJgAAADLIJgAAADLCMlgUlRUpPT0dEVGRio7O1vbt28/Zfs//elPuuiiixQZGamhQ4dq06ZNPqo0sLkzzitXrtQ111yj3r17q3fv3srNzT3t/xd8x92f53Zr1qyRzWbTz372M+8WGETcHesjR45o1qxZSklJkd1u14UXXsjfH13g7jgvW7ZMAwcOVK9evZSWlqb77rtP3377rY+qDUxlZWUaN26cUlNTZbPZtH79+tO+Z+vWrbrssstkt9t1wQUXqLi42DvFmRCzZs0aExERYVatWmU++ugjM23aNBMXF2ccDkeH7d9++20THh5uHn30UbNr1y7z+9//3vTs2dN8+OGHPq48sLg7zpMnTzZFRUVm586dZvfu3eYXv/iFiY2NNV988YWPKw8s7o5zu+rqanPuueeaa665xowfP943xQY4d8e6qanJZGZmmrFjx5pt27aZ6upqs3XrVlNVVeXjygOLu+NcUlJi7Ha7KSkpMdXV1ebVV181KSkp5r777vNx5YFl06ZN5oEHHjDr1q0zkszLL798yvb79u0zUVFRpqCgwOzatcssX77chIeHm82bN3u8tpALJllZWWbWrFnO562trSY1NdUsXry4w/YTJ040119/vcu27Oxsc/fdd3u1zkDn7jif6Pjx4yY6Oto8//zz3ioxKHRnnI8fP26uvPJK88wzz5i8vDyCSRe5O9ZPPfWU6d+/v2lubvZViUHB3XGeNWuWufbaa122FRQUmKuuusqrdQaTrgST+++/3wwePNhl26RJk8zo0aM9Xk9IHcppbm5WRUWFcnNzndvCwsKUm5ur8vLyDt9TXl7u0l6SRo8e3Wl7dG+cT3Ts2DG1tLQoPj7eW2UGvO6O88MPP6zExETdddddvigzKHRnrDds2KCcnBzNmjVLSUlJGjJkiBYtWqTW1lZflR1wujPOV155pSoqKpyHe/bt26dNmzZp7NixPqk5VPjyuzDgbuJ3Jg4fPqzW1lYlJSW5bE9KStKePXs6fE9tbW2H7Wtra71WZ6Drzjif6Le//a1SU1NP+kXAD7ozztu2bdOzzz6rqqoqH1TYdW1tbWpublZkZKS/S+lQd8Z63759euONN3T77bdr06ZN2rt3r2bOnKmWlhYVFhb6ouyA051xnjx5sg4fPqyrr75axhgdP35cM2bM0O9+9ztflBwyOvsurK+v1zfffKNevXp5rK+QmjFBYFiyZInWrFmjl19+2bJfVIGooaFBU6ZM0cqVK5WQkOCVPubPny+bzaY9e/Zo4sSJiomJUZ8+fXTvvfe6LEa02WzKz89XSUmJBg8eLLvdrs2bN0uS/v73v+vOO+9UUlKS7Ha7Bg8erFWrVp3U1/LlyzV48GBFRUWpd+/eyszM1OrVq73yubqjra1NiYmJevrppzV8+HBNmjRJDzzwgFasWOHv0oLK1q1btWjRIj355JOqrKzUunXrtHHjRj3yyCP+Lg3dFFIzJgkJCQoPD5fD4XDZ7nA4lJyc3OF7kpOT3WqP7o1zu8cee0xLlizRli1bdMkll3izzIDn7jj/7W9/0/79+zVu3Djntra2NklSjx499PHHH2vAgAEeqW3ixIlKT0/X4sWL9e677+rxxx/X119/rRdeeMHZ5o033tCLL76o/Px8JSQkKD09XQ6HQ1dccYUzuJxzzjn6y1/+orvuukv19fX69a9/Lem7s7h+9atf6ZZbbnGGng8++EB//etfNXnyZI98hh/rzs90SkqKevbsqfDwcOe2iy++WLW1tWpublZERITH6wx03RnnBx98UFOmTNEvf/lLSdLQoUPV2Nio6dOn64EHHlBYGP/+9oTOvgtjYmI8OlsiKfTOysnKyjL5+fnO562trebcc8895eLXG264wWVbTk4Oi19Pw91xNsaYP/zhDyYmJsaUl5f7osSg4M44f/PNN+bDDz90eYwfP95ce+215sMPPzRNTU1nXE9hYaGRZG688UaX7TNnzjSSzPvvv2+M+W6xXVhYmPnoo49c2t11110mJSXFHD582GX7bbfdZmJjY82xY8eMMcaMHz/+pIV43ubuz/TcuXPNeeedZ1pbW53bli1bZlJSUrxeayBzd5wvu+wyc//997tsW716tenVq5c5fvy4V2sNFuri4tchQ4a4bPv5z3/ulcWvIRdM1qxZY+x2uykuLja7du0y06dPN3Fxcaa2ttYYY8yUKVPMnDlznO3ffvtt06NHD/PYY4+Z3bt3m8LCQk4X7gJ3x3nJkiUmIiLCvPTSS+bLL790PhoaGvz1EQKCu+N8Ik+fldMeTF599VWX7bt37zaSnF8uksyoUaNc2rS1tZm4uDgzffp0c+jQIZfHc889ZySZbdu2OeuOjY0127dv91jtp+PuWH/++ecmOjra5Ofnm48//ti88sorJjEx0SxYsMBnNQcid8e5sLDQREdHmz/+8Y9m37595rXXXjMDBgwwEydO9NdHCAgNDQ1m586dZufOnUaSWbp0qdm5c6f57LPPjDHGzJkzx0yZMsXZvv104dmzZ5vdu3eboqIiThf2pOXLl5t+/fqZiIgIk5WVZd59913nayNGjDB5eXku7V988UVz4YUXmoiICDN48GCzceNGH1ccmNwZ5/POO89IOulRWFjo+8IDjLs/zz/mrWCyb98+l+3Nzc0mLCzMOdMoydx5550ubRwOR4c/Az9+rFu3zhhjzK5du8y5555rJJkLLrjAzJw50xlavMndsX7nnXdMdna2sdvtpn///mbhwoX8K74L3BnnlpYWM3/+fDNgwAATGRlp0tLSzMyZM83XX3/t+8IDyJtvvtnh71j72Obl5ZkRI0ac9J5hw4aZiIgI079/f/Pcc895pTabMcZ49uAQgFA1f/58PfTQQ9q3b5/OP/985/bjx4/Lbrdr2rRpWrFihWw2m2bNmqUnnnjC2aa2tlYpKSn6l3/5F+Xl5XW4/0suuUSJiYmSpMbGRr3yyivavHmz/vKXv8jhcGjevHl66KGHvPshAXhVSC1+BeAbn376qUsw2bt3r9ra2pSent7pe8455xxFR0ertbW1S6eJn3XWWZo0aZImTZqk5uZm3XTTTVq4cKHmzp3L2VxAAGO5MgCPKyoqcnm+fPlySdKYMWM6fU94eLhuvvlm/fnPf9b//d//nfT6oUOHnH/+xz/+4fJaRESEBg0aJGOMWlpazqR0AH7GjAkAj6uurtaNN96on/70pyovL9d///d/a/LkycrIyDjl+5YsWaI333xT2dnZmjZtmgYNGqSvvvpKlZWV2rJli7766itJ0k9+8hMlJyfrqquuUlJSknbv3q0nnnhC119/vaKjo33xEQF4CcEEgMetXbtW8+bN05w5c9SjRw/l5+fr3/7t3077vqSkJG3fvl0PP/yw1q1bpyeffFJ9+vTR4MGD9Yc//MHZ7u6771ZJSYmWLl2qo0ePqm/fvvrVr36l3//+9978WAB8gMWvADymffHroUOHvHZ1WQDBjTUmAADAMggmAADAMggmAADAMlhjAgAALIMZEwAAYBkBd7pwW1ubDhw4oOjoaNlsNn+XAwAAusAYo4aGBqWmpiosrPN5kYALJgcOHFBaWpq/ywAAAN1QU1Ojvn37dvp6wAWT9qs61tTUKCYmxs/VAL7X2Nio1NRUSd8F9bPOOsvPFQHA6dXX1ystLe20V2cOuGDSfvgmJiaGYIKQFB4e7vxzTEwMwQRAQDndMgwWvwIAAMsgmAAAAMsgmAAAAMsIuDUmAAB4W2trq1paWvxdRkDp2bOnyxq47iKYAADwPWOMamtrdeTIEX+XEpDi4uKUnJx8RtcZI5h0IH3ORknS/iXX+7kSAIAvtYeSxMRERUVFcSHPLjLG6NixYzp48KAkKSUlpdv7IpgAAKDvDt+0h5I+ffr4u5yA06tXL0nSwYMHlZiY2O3DOix+BQBAcq4piYqK8nMlgat97M5kfQ7BBACAH+HwTfd5YuwIJgAAwDIIJgAAwDJY/AoAwGm0n63pK6F8VigzJgAAoENfffWVbr/9dsXExCguLk533XWXjh496tU+CSYAAISg5ubm07a5/fbb9dFHH+n111/XK6+8orKyMk2fPt2rdRFMAAAIAg0NDbr99tt11llnKSUlRf/xH/+hkSNH6te//rUkKT09XY888ojuuOMOxcTEnDZg7N69W5s3b9Yzzzyj7OxsXX311Vq+fLnWrFmjAwcOeO1zEEwAAAgCBQUFevvtt7Vhwwa9/vrreuutt1RZWenS5rHHHlNGRoZ27typBx988JT7Ky8vV1xcnDIzM53bcnNzFRYWpr/+9a9e+QwSi18BAAh4DQ0Nev7557V69Wpdd911kqTnnntOqampLu2uvfZa/eY3v+nSPmtra5WYmOiyrUePHoqPj1dtba1nCu8AMyYAAAS4ffv2qaWlRVlZWc5tsbGxGjhwoEu7H89+WBXBBACAEHHWWWd1uW1ycrLzpnztjh8/rq+++krJycmeLs2JYAIAQIDr37+/evbsqffee8+5ra6uTp988km395mTk6MjR46ooqLCue2NN95QW1ubsrOzz6jeU2GNCQAAAS46Olp5eXmaPXu24uPjlZiYqMLCQoWFhXX7/jUXX3yxfvrTn2ratGlasWKFWlpalJ+fr9tuu+2ktSueRDABAOA0AuFKrEuXLtWMGTN0ww03KCYmRvfff79qamoUGRnZ7X2WlJQoPz9f1113ncLCwnTzzTfr8ccf92DVJyOYAAAQBKKjo1VSUuJ83tjYqIceesh5vZL9+/e7vc/4+HitXr3aUyV2CcEEAIAgsHPnTu3Zs0dZWVmqq6vTww8/LEkaP368nytzD4tfAQAIEu0XUMvNzVVjY6PeeustJSQkdNh20aJFOvvsszt8jBkzxseV/4AZEwAAgsCll17qcgbN6cyYMUMTJ07s8LVevXp5qiy3EUwAAAhB8fHxio+P93cZJ/FLMElPT1dMTIzCwsLUu3dvvfnmm/4oAwAAWIzfZkzeeecdnX322f7qHgAAWBCLX7sgfc5Gpc/Z6O8yAAAIem4Hk7KyMo0bN06pqamy2Wxav379SW2KioqUnp6uyMhIZWdna/v27S6v22w2jRgxQpdffrnLOdcAACC0uR1MGhsblZGRoaKiog5fX7t2rQoKClRYWKjKykplZGRo9OjRLjcC2rZtmyoqKrRhwwYtWrRIH3zwQaf9NTU1qb6+3uUBAACCk9trTMaMGXPK85uXLl2qadOmaerUqZKkFStWaOPGjVq1apXmzJkjSTr33HMlSSkpKRo7dqwqKyt1ySWXdLi/xYsX66GHHnK3TAAAPGd+rI/7q/Ntfxbi0TUmzc3NqqioUG5u7g8dhIUpNzdX5eXlkr6bcWloaJAkHT16VG+88YYGDx7c6T7nzp2ruro656OmpsaTJQMAgE4sXLhQV155paKiohQXF+eTPj16Vs7hw4fV2tqqpKQkl+1JSUnas2ePJMnhcGjChAmSpNbWVk2bNk2XX355p/u02+2y2+2eLBMAgJDX3NysiIiI07a59dZblZOTo2effdYndfn8dOH+/fvr/fff93W3AAAEtYaGBs2YMUPr16933l34f/7nfzRs2DAtW7ZM6enpuuuuu/Tpp59q/fr1uummm1RcXHzKfbYvpThdO0/y6KGchIQEhYeHy+FwuGx3OBxKTk72ZFcAAOBHCgoK9Pbbb2vDhg16/fXX9dZbb6mystKlTfu9dHbu3KkHH3zQT5WemkeDSUREhIYPH67S0lLntra2NpWWlionJ8eTXQEAgO81NDTo+eef12OPPabrrrtOQ4YM0XPPPafW1laXdtdee61+85vfaMCAARowYICfqj01tw/lHD16VHv37nU+r66uVlVVleLj49WvXz8VFBQoLy9PmZmZysrK0rJly9TY2Og8SwcAAHjWvn371NLSoqysLOe22NhYDRw40KVdZmamr0tzm9vBZMeOHRo1apTzeUFBgSQpLy9PxcXFmjRpkg4dOqR58+aptrZWw4YN0+bNm09aEAsAAHzrrLPO8ncJp+V2MBk5cqSMMadsk5+fr/z8/G4XFQjaL1G/f8n1fq4EABDq+vfvr549e+q9995Tv379JEl1dXX65JNP9P/+3//zc3Xu8dtN/AAAgGdER0crLy9Ps2fPVnx8vBITE1VYWKiwsDDZbLZu7/fzzz/XV199pc8//1ytra2qqqqSJF1wwQVeuxEvwQQAgNMJgCuxLl26VDNmzNANN9zgPF24pqZGkZGR3d7nvHnz9PzzzzufX3rppZKkN998UyNHjjzTkjtEMDmd+bHaHymlf7va35UAANCp6OholxvjNjY26qGHHtL06dMlSfv373d7n8XFxT69holEMAEAICjs3LlTe/bsUVZWlurq6vTwww9LksaPH+/nytzj0euYAAAA/2m/gFpubq4aGxv11ltvKSEhocO2ixYt0tlnn93h41Q36/U2ZkwAAAgCl156qSoqKrrcfsaMGZo4cWKHr/Xq1ctTZbmNYAIAQAiKj49XfHy8v8s4CYdyumN+rPZHTvZ3FQAALzjdtbrQOU+MHcEEAABJPXv2lCQdO3bMz5UErvaxax/L7uBQjoe0XwlW4mqwABCIwsPDFRcXp4MHD0qSoqKizujiZKHEGKNjx47p4MGDiouLU3h4eLf3RTABAOB7ycnJkuQMJ3BPXFyccwy7i2ACAMD3bDabUlJSlJiYqJaWFn+XE1B69ux5RjMl7QgmPzY/VpK40isAhLjw8HCPfMnCfSx+9QTO0gEAwCMIJgAAwDIIJgAAwDIIJgAAwDIIJl6UPmejy/VNAADAqRFMvIUFsQAAuI1gAgAALINgAgAALINgAgAALIMrv/rK91eVlb67qiw3+gMA4GTMmAAAAMsgmAAAAMsgmPjT/FiXQzwAAIQ6ggkAALAMggkAALAMgokFOC9b335oh8M7AIAQRTABAACWQTABAACWQTCxOg7tAABCCMHEopzrTgAACCEEk0DELAoAIEgRTAAAgGUQTIIBMygAgCDh82By5MgRZWZmatiwYRoyZIhWrlzp6xIAAIBF9fB1h9HR0SorK1NUVJQaGxs1ZMgQ3XTTTerTp4+vSwko6XM2av+S6/1dBgAAXuXzGZPw8HBFRUVJkpqammSMkTHG12UEPw7vAAACkNvBpKysTOPGjVNqaqpsNpvWr19/UpuioiKlp6crMjJS2dnZ2r59u8vrR44cUUZGhvr27avZs2crISGh2x8glLl1SjGXuwcABAC3g0ljY6MyMjJUVFTU4etr165VQUGBCgsLVVlZqYyMDI0ePVoHDx50tomLi9P777+v6upqrV69Wg6Ho9P+mpqaVF9f7/IAAADBye1gMmbMGC1YsEATJkzo8PWlS5dq2rRpmjp1qgYNGqQVK1YoKipKq1atOqltUlKSMjIy9NZbb3Xa3+LFixUbG+t8pKWluVsyAAAIEB5dY9Lc3KyKigrl5ub+0EFYmHJzc1VeXi5JcjgcamhokCTV1dWprKxMAwcO7HSfc+fOVV1dnfNRU1PjyZJDG4d2AAAW49Gzcg4fPqzW1lYlJSW5bE9KStKePXskSZ999pmmT5/uXPR6zz33aOjQoZ3u0263y263e7JMAABgUT4/XTgrK0tVVVW+7jYktC+G7fZpxT+ePZlf54GKAABwj0cP5SQkJCg8PPykxawOh0PJycme7AoAAAQhjwaTiIgIDR8+XKWlpc5tbW1tKi0tVU5Ojie7AgAAQcjtQzlHjx7V3r17nc+rq6tVVVWl+Ph49evXTwUFBcrLy1NmZqaysrK0bNkyNTY2aurUqR4tHAAABB+3g8mOHTs0atQo5/OCggJJUl5enoqLizVp0iQdOnRI8+bNU21trYYNG6bNmzeftCAWAaJ93QlrTgAAPuB2MBk5cuRpLyGfn5+v/Pz8bhcFiyOsAAC8xOf3ygEAAOgMwSTIuXU/HQAA/IxgEoIIKwAAqyKYAAAAyyCYAAAAyyCY4MxxM0AAgIcQTOCdNSeEFQBAN/j8Jn4IUdwgEADQBcyYwH+YVQEAnIBgAgAALINgAgAALINggg5xETYAgD8QTAAAgGVwVg6sgzN3ACDkMWMCAAAsg2ACAAAsg2ACa+NaJwAQUggmAADAMggm6BJOHwYA+ALBBAAAWAbBBAAAWAbBBIHnxAWxLJAFgKBBMEG3WXrdCeEFAAISwQShi7ACAJZDMAEAAJZBMAEAAJZBMIHHpM/ZaO11JwAAyyOYAAAAyyCYAAAAyyCYAAAAy+jh7wIAy3C57kmd/+oAgBDGjAkAALAMggm8KuDP0uEibADgUwQTAABgGQQTAABgGQQT+FzAH94BAHiNX4LJhAkT1Lt3b91yyy3+6B4AAFiUX4LJvffeqxdeeMEfXQMAAAvzSzAZOXKkoqOj/dE1AACwMLeDSVlZmcaNG6fU1FTZbDatX7/+pDZFRUVKT09XZGSksrOztX37dk/UCgQuTjsGgC5xO5g0NjYqIyNDRUVFHb6+du1aFRQUqLCwUJWVlcrIyNDo0aN18ODBMy4WAAAEN7eDyZgxY7RgwQJNmDChw9eXLl2qadOmaerUqRo0aJBWrFihqKgorVq1qlsFNjU1qb6+3uWB4BJQZ+m0z3ycbvaDGRIA6BaPrjFpbm5WRUWFcnNzf+ggLEy5ubkqLy/v1j4XL16s2NhY5yMtLc1T5QIAAIvxaDA5fPiwWltblZSU5LI9KSlJtbW1zue5ubm69dZbtWnTJvXt2/eUoWXu3Lmqq6tzPmpqajxZMnDmmB0BAI/xy92Ft2zZ0uW2drtddrvdi9UAAACr8OiMSUJCgsLDw+VwOFy2OxwOJScne7IrAAAQhDwaTCIiIjR8+HCVlpY6t7W1tam0tFQ5OTme7AoAAAQhtw/lHD16VHv37nU+r66uVlVVleLj49WvXz8VFBQoLy9PmZmZysrK0rJly9TY2KipU6d6tHAAABB83A4mO3bs0KhRo5zPCwoKJEl5eXkqLi7WpEmTdOjQIc2bN0+1tbUaNmyYNm/efNKCWAAAgBO5HUxGjhwpY8wp2+Tn5ys/P7/bRQEAgNDkl3vlAAAAdIRgAgAALINgAkvy1mXq0+dsDKxL4ANAiCGYAAAAyyCYAAAAyyCYIGAF/CGZ7++x4/wcXb1zMQAEMYIJAACwDIIJAACwDIIJAACwDIIJQp4316oE/DoYAPAxggkAALAMggkAALAMggkAALAMggkAALAMggkAALAMggkAALAMggkAALAMggkCAtcD+d78WGlhir+rAACvIZgAAADLIJgAAADLIJgAAADLIJgAAADLIJgAAADL6OHvAtxljJEk1dfXe37nTcb5x7amY9/18f025/MfteuojbO2Ttqcct/0f0b968c/Eyduc7PGE9930vNTtXGzxlP2f6Imo8Zm86Nm9Wptbe24LQBYSPvf4e3f452xmdO1sJgvvvhCaWlp/i4DAAB0Q01Njfr27dvp6wEXTNra2nTgwAFFR0fLZrN5fP/19fVKS0tTTU2NYmJiPL5/fIdx9g3G2XcYa99gnH3H02NtjFFDQ4NSU1MVFtb5SpKAO5QTFhZ2yqTlKTExMfzQ+wDj7BuMs+8w1r7BOPuOJ8c6Njb2tG1Y/AoAACyDYAIAACyDYHICu92uwsJC2e12f5cS1Bhn32CcfYex9g3G2Xf8NdYBt/gVAAAEL2ZMAACAZRBMAACAZRBMAACAZRBMAACAZRBMAACAZYRkMCkqKlJ6eroiIyOVnZ2t7du3n7L9n/70J1100UWKjIzU0KFDtWnTJh9VGtjcGeeVK1fqmmuuUe/evdW7d2/l5uae9v8LvuPuz3O7NWvWyGaz6Wc/+5l3Cwwi7o71kSNHNGvWLKWkpMhut+vCCy/k748ucHecly1bpoEDB6pXr15KS0vTfffdp2+//dZH1QamsrIyjRs3TqmpqbLZbFq/fv1p37N161ZddtllstvtuuCCC1RcXOyd4kyIWbNmjYmIiDCrVq0yH330kZk2bZqJi4szDoejw/Zvv/22CQ8PN48++qjZtWuX+f3vf2969uxpPvzwQx9XHljcHefJkyeboqIis3PnTrN7927zi1/8wsTGxpovvvjCx5UHFnfHuV11dbU599xzzTXXXGPGjx/vm2IDnLtj3dTUZDIzM83YsWPNtm3bTHV1tdm6daupqqryceWBxd1xLikpMXa73ZSUlJjq6mrz6quvmpSUFHPffff5uPLAsmnTJvPAAw+YdevWGUnm5ZdfPmX7ffv2maioKFNQUGB27dplli9fbsLDw83mzZs9XlvIBZOsrCwza9Ys5/PW1laTmppqFi9e3GH7iRMnmuuvv95lW3Z2trn77ru9Wmegc3ecT3T8+HETHR1tnn/+eW+VGBS6M87Hjx83V155pXnmmWdMXl4ewaSL3B3rp556yvTv3980Nzf7qsSg4O44z5o1y1x77bUu2woKCsxVV13l1TqDSVeCyf33328GDx7ssm3SpElm9OjRHq8npA7lNDc3q6KiQrm5uc5tYWFhys3NVXl5eYfvKS8vd2kvSaNHj+60Pbo3zic6duyYWlpaFB8f760yA153x/nhhx9WYmKi7rrrLl+UGRS6M9YbNmxQTk6OZs2apaSkJA0ZMkSLFi1Sa2urr8oOON0Z5yuvvFIVFRXOwz379u3Tpk2bNHbsWJ/UHCp8+V0YcHcXPhOHDx9Wa2urkpKSXLYnJSVpz549Hb6ntra2w/a1tbVeqzPQdWecT/Tb3/5WqampJ/0i4AfdGedt27bp2WefVVVVlQ8qDB7dGet9+/bpjTfe0O23365NmzZp7969mjlzplpaWlRYWOiLsgNOd8Z58uTJOnz4sK6++moZY3T8+HHNmDFDv/vd73xRcsjo7Luwvr5e33zzjXr16uWxvkJqxgSBYcmSJVqzZo1efvllRUZG+rucoNHQ0KApU6Zo5cqVSkhI8Hc5Qa+trU2JiYl6+umnNXz4cE2aNEkPPPCAVqxY4e/SgsrWrVu1aNEiPfnkk6qsrNS6deu0ceNGPfLII/4uDd0UUjMmCQkJCg8Pl8PhcNnucDiUnJzc4XuSk5Pdao/ujXO7xx57TEuWLNGWLVt0ySWXeLPMgOfuOP/tb3/T/v37NW7cOOe2trY2SVKPHj308ccfa8CAAd4tOkB152c6JSVFPXv2VHh4uHPbxRdfrNraWjU3NysiIsKrNQei7ozzgw8+qClTpuiXv/ylJGno0KFqbGzU9OnT9cADDygsjH9/e0Jn34UxMTEenS2RQmzGJCIiQsOHD1dpaalzW1tbm0pLS5WTk9Phe3JyclzaS9Lrr7/eaXt0b5wl6dFHH9UjjzyizZs3KzMz0xelBjR3x/miiy7Shx9+qKqqKufjxhtv1KhRo1RVVaW0tDRflh9QuvMzfdVVV2nv3r3O8CdJn3zyiVJSUgglnejOOB87duyk8NEeBg33qPUYn34Xenw5rcWtWbPG2O12U1xcbHbt2mWmT59u4uLiTG1trTHGmClTppg5c+Y427/99tumR48e5rHHHjO7d+82hYWFnC7cBe6O85IlS0xERIR56aWXzJdfful8NDQ0+OsjBAR3x/lEnJXTde6O9eeff26io6NNfn6++fjjj80rr7xiEhMTzYIFC/z1EQKCu+NcWFhooqOjzR//+Eezb98+89prr5kBAwaYiRMn+usjBISGhgazc+dOs3PnTiPJLF261OzcudN89tlnxhhj5syZY6ZMmeJs33668OzZs83u3btNUVERpwt70vLly02/fv1MRESEycrKMu+++67ztREjRpi8vDyX9i+++KK58MILTUREhBk8eLDZuHGjjysOTO6M83nnnWcknfQoLCz0feEBxt2f5x8jmLjH3bF+5513THZ2trHb7aZ///5m4cKF5vjx4z6uOvC4M84tLS1m/vz5ZsCAASYyMtKkpaWZmTNnmq+//tr3hQeQN998s8O/c9vHNi8vz4wYMeKk9wwbNsxERESY/v37m+eee84rtdmMYa4LAABYQ0itMQEAANZGMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJbx/wHjN5JQ0XZd2AAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=10` reached.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1235\n", "item counter : 2253\n", "ratio : 0.5479148181011535\n", " ratio number predicted/items: 2.0940550133096716\n", "current epoch: 9\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "-----------------------------------------------------\n", "0 | net | SmallNet | 514 \n", "1 | sym_preprocess | SymPreprocess | 8.5 M \n", "2 | bcewll | BCEWithLogitsLoss | 0 \n", "3 | auroc | BinaryAUROC | 0 \n", "-----------------------------------------------------\n", "514 Trainable params\n", "8.5 M Non-trainable params\n", "8.5 M Total params\n", "34.014 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 0\n", "item counter : 0\n", "ratio : 0.0\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1232\n", "item counter : 1232\n", "ratio : 0.9991889699918897\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1232\n", "item counter : 1232\n", "ratio : 0.9991889699918897\n", " ratio number predicted/items: 0.0\n", "current epoch: 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1234\n", "item counter : 1637\n", "ratio : 0.7533577533577533\n", " ratio number predicted/items: 0.3076923076923077\n", "current epoch: 2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1230\n", "item counter : 1408\n", "ratio : 0.872959545777147\n", " ratio number predicted/items: 0.1547196593328602\n", "current epoch: 3\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1235\n", "item counter : 1309\n", "ratio : 0.9427480916030534\n", " ratio number predicted/items: 0.061068702290076333\n", "current epoch: 4\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiYAAAGzCAYAAAAbjdwrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAz/0lEQVR4nO3dfXRU1b3/8c8kkAnBPBBiniSYgldaAYMSE6OwAM0tBUWqVWjxYooWtBBbTRc0FCWg8tBeL+UWo6yiGHpvKFiLLK+hVImyIpqWEoj1Jw8tJWisZoAqeRg0Ccn+/aEZGZIAE+bhzOT9WmvW4uzZc853NpF8PGeffWzGGCMAAAALCAt0AQAAAB0IJgAAwDIIJgAAwDIIJgAAwDIIJgAAwDIIJgAAwDIIJgAAwDIIJgAAwDIIJgAAwDIIJgACqqSkRDabTXv27Al0KQAsgGACAAAsg2ACAAAsg2ACAAAsg2ACwCfef/99zZ07V8OGDVO/fv00cOBA3XXXXTp69GiX/U+dOqX7779fAwcOVExMjO655x59+umnbn327NmjiRMnKiEhQf369dPXvvY13XvvvX74NgD8pU+gCwAQmv7yl7/o7bff1ne/+10NGjRIR48e1TPPPKPx48dr//79ioqKcuufn5+vuLg4LVmyRIcOHdIzzzyj999/Xzt37pTNZtOxY8f0zW9+U5deeqkKCwsVFxeno0ePasuWLQH6hgB8gWACwCduueUW3XnnnW5tU6ZMUU5Ojn7/+99r5syZbu9FRESovLxcffv2lSRdfvnlWrBggf7v//5Pt912m95++219+umnevXVV5WZmen63BNPPOH7LwPAb7iUA8An+vXr5/pza2ur/vWvf+mKK65QXFyc9u7d26n/nDlzXKFEkn74wx+qT58+2rZtmyQpLi5OkvTKK6+otbXVt8UDCBiCCQCf+Oyzz7R48WKlpaXJbrcrISFBl156qU6ePKn6+vpO/f/t3/7NbfuSSy5RSkqKa07KuHHj9J3vfEdLly5VQkKCpk6dqueff17Nzc3++DoA/IRgAsAnHnzwQS1btkzTpk3TCy+8oFdffVWvvfaaBg4cqPb2do/3Z7PZ9OKLL6qyslL5+fn65z//qXvvvVejR49WU1OTD74BgEAgmADwiRdffFF5eXn6r//6L915553693//d40ZM0YnT57ssv/f//53t+2mpiZ9/PHHSk9Pd2u//vrrtWzZMu3Zs0elpaV67733tGnTJh99CwD+RjAB4BPh4eEyxri1rVmzRm1tbV32//Wvf+02d+SZZ57R6dOnNWnSJEnSp59+2ml/o0aNkiQu5wAhhLtyAPjErbfeqv/5n/9RbGysrrrqKlVWVmrHjh0aOHBgl/1bWlp08803a9q0aTp06JCefvppjRkzRrfddpskacOGDXr66ad1++23a+jQoWpsbNS6desUExOjyZMn+/OrAfAhggkAn/jv//5vhYeHq7S0VJ9//rluvPFG7dixQxMnTuyy/1NPPaXS0lItXrxYra2t+t73vqdf/epXstlskr6Y/Lp7925t2rRJDodDsbGxysrKUmlpqb72ta/586sB8CGbOfvcKAAAQIAwxwQAAFhGQC7lpKenKyYmRmFhYRowYIDeeOONQJQBAAAsJmBzTN5++21dcsklgTo8AACwIC7lAAAAy/A4mFRUVGjKlClKTU2VzWbT1q1bO/UpLi5Wenq6IiMjlZ2drd27d7u9b7PZNG7cOF133XUqLS3tcfEAACC0eBxMnE6nMjIyVFxc3OX7mzdvVkFBgYqKirR3715lZGRo4sSJOnbsmKvPrl27VFVVpZdfflnLly/XX//6155/AwAAEDIu6nZhm82ml156Sd/+9rddbdnZ2bruuuv01FNPSZLa29uVlpamBx98UIWFhZ32MX/+fA0fPlzf//73uzxGc3Oz26qO7e3t+uSTTzRw4EDX+gYAAMDajDFqbGxUamqqwsK6Py/i1cmvLS0tqqqq0sKFC11tYWFhys3NVWVlpaQvzri0t7crOjpaTU1Nev311zVt2rRu97lixQotXbrUm2UCAIAAqa2t1aBBg7p936vB5MSJE2pra1NSUpJbe1JSkg4ePChJcjgcuv322yVJbW1tmj17tq677rpu97lw4UIVFBS4tuvr6zV48GDV1tYqJibGm+UDF83pdCo1NVWS9NFHH6l///4BrggArKGhoUFpaWmKjo4+Zz+/3y48ZMgQvfPOOxfc3263y263d2qPiYkhmMBywsPDXX+OiYkhmADAWc43DcOrtwsnJCQoPDxcDofDrd3hcCg5OdmbhwIAACHIq8EkIiJCo0ePVnl5uautvb1d5eXlysnJ8eahAABACPL4Uk5TU5MOHz7s2q6pqVF1dbXi4+M1ePBgFRQUKC8vT5mZmcrKytLq1avldDo1a9YsrxYOAABCj8fBZM+ePZowYYJru2Nial5enkpKSjR9+nQdP35cixcvVl1dnUaNGqXt27d3mhALAABwtotaxyQQGhoaFBsbq/r6ep9Nfk0vLJMkHV15i7Qk9ovGJfU+ORZCi9PpdD0DqqmpicmvAPClC/39zbNyAACAZRBMAACAZRBMAACAZRBMemJJ7FdzTwAAgNcQTAAAgGUQTAAAgGUQTAAAgGUQTAAAgGUQTAAAgGUQTAAAgGUQTLyB24cBAPAKgskF6nh+DgAA8B2CCQAAsAyCCQAAsIw+gS7AUr6cJ3I0Ukr/fGOAiwEAoPfhjAkAALAMggkAALAMgomvcAsxAAAeI5gAAADLIJgAAADLIJgAAADLIJgAAADLIJgAAADLIJhcBJ6fAwCAd7Hyq7+ceevwkvrA1QEAgIVxxgQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwSSQeNAfAABuCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCZelF5YxvNzAAC4CDwrx0p4ng4AoJfjjAkAALAMggkAALAMggkAALAMggkAALAMggkAALAMgonV8TwdAEAvQjABAACWQTABAACWQTABAACWQTDxMZaoBwDgwhFMAACAZRBMghF36gAAQhTBBAAAWIbfg8nJkyeVmZmpUaNGacSIEVq3bp2/SwAAABbVx98HjI6OVkVFhaKiouR0OjVixAjdcccdGjhwoL9LAQAAFuP3Mybh4eGKioqSJDU3N8sYI2OMv8sILcw5AQCECI+DSUVFhaZMmaLU1FTZbDZt3bq1U5/i4mKlp6crMjJS2dnZ2r17t9v7J0+eVEZGhgYNGqT58+crISGhx18AAACEDo+DidPpVEZGhoqLi7t8f/PmzSooKFBRUZH27t2rjIwMTZw4UceOHXP1iYuL0zvvvKOamhpt3LhRDoej598gCLG2CQAAXfM4mEyaNElPPPGEbr/99i7fX7VqlWbPnq1Zs2bpqquu0tq1axUVFaX169d36puUlKSMjAy9+eab3R6vublZDQ0Nbi8AABCavDrHpKWlRVVVVcrNzf3qAGFhys3NVWVlpSTJ4XCosbFRklRfX6+KigoNGzas232uWLFCsbGxrldaWpo3SwYAABbi1WBy4sQJtbW1KSkpya09KSlJdXV1kqT3339fY8eOVUZGhsaOHasHH3xQI0eO7HafCxcuVH19vetVW1vrzZJDFxNiAQBByO+3C2dlZam6uvqC+9vtdtntdt8VBAAALMOrZ0wSEhIUHh7eaTKrw+FQcnKyNw8FAABCkFeDSUREhEaPHq3y8nJXW3t7u8rLy5WTk+PNQwEAgBDk8aWcpqYmHT582LVdU1Oj6upqxcfHa/DgwSooKFBeXp4yMzOVlZWl1atXy+l0atasWV4tHAAAhB6Pg8mePXs0YcIE13ZBQYEkKS8vTyUlJZo+fbqOHz+uxYsXq66uTqNGjdL27ds7TYjFV9ILy3R05S2+PciZE2GX1Pv2WAAA9JDHwWT8+PHnXUI+Pz9f+fn5PS4KAAD0Tn5/Vg4AAEB3CCYAAMAyCCYAAMAyCCa9GavDAgAshmACAAAsg2ACAAAsg2BiUemFZYEuAQAAv/P7Q/xgYSzCBgAIMM6YAAAAyyCYAAAAyyCY4Ny4pRgA4EcEEwAAYBkEEwAAYBkEEwAAYBkEkyDBuiYAgN6AYAIAACyDYALPcacOAMBHCCYAAMAyCCYAAMAyCCYAAMAyCCZBjDt1AAChhmCCi8dkWACAlxBMAACAZRBM4BucRQEA9ADBBAAAWAbBBAAAWAbBBAAAWAbBJISkF5ZxCzEAIKgRTAAAgGUQTAAAgGX0CXQB6CXOvHV4SX3g6gAAWBpnTAAAgGUQTAAAgGUQTAAAgGUQTAAAgGUQTEIc65oAAIIJwQQAAFgGwQSBwxOIAQBnIZj0QlzeAQBYFcEEAABYBsEEAABYBsEEAABYBsEEAABYBg/xg3XwoD8A6PU4YwIAACyDYAJrY60TAOhVCCZgXRMAgGUQTAAAgGUQTNAlzqIAAAKBYAIAACwjIMHk9ttv14ABA3TnnXcG4vAAAMCiAhJMfvzjH+s3v/lNIA4NAAAsLCDBZPz48YqOjg7EoREKuIUYAEKWx8GkoqJCU6ZMUWpqqmw2m7Zu3dqpT3FxsdLT0xUZGans7Gzt3r3bG7UCXSOoAEDI8DiYOJ1OZWRkqLi4uMv3N2/erIKCAhUVFWnv3r3KyMjQxIkTdezYsYsuFgAAhDaPn5UzadIkTZo0qdv3V61apdmzZ2vWrFmSpLVr16qsrEzr169XYWGhxwU2NzerubnZtd3Q0ODxPgAAQHDw6hyTlpYWVVVVKTc396sDhIUpNzdXlZWVPdrnihUrFBsb63qlpaV5q1x4gHVNAAD+4NVgcuLECbW1tSkpKcmtPSkpSXV1da7t3Nxc3XXXXdq2bZsGDRp0ztCycOFC1dfXu161tbXeLBkAAFiIx5dyvGHHjh0X3Ndut8tut/uwGgAAYBVePWOSkJCg8PBwORwOt3aHw6Hk5GRvHgoAAIQgrwaTiIgIjR49WuXl5a629vZ2lZeXKycnx5uHAgAAIcjjYNLU1KTq6mpVV1dLkmpqalRdXa0PPvhAklRQUKB169Zpw4YNOnDggH74wx/K6XS67tJB6GBCLADA2zyeY7Jnzx5NmDDBtV1QUCBJysvLU0lJiaZPn67jx49r8eLFqqur06hRo7R9+/ZOE2IBAADO5nEwGT9+vIwx5+yTn5+v/Pz8HheF4NRxBuXoylvc2s7cDpiOlWGX1Ae2DgDAOQXkWTkAAABdIZgAAADLIJgAAADLIJgAAADLIJgAAADLCMiS9IAlddy5I3H3DgAECGdMAACAZRBMAACAZRBMAACAZRBMEJqWxLrPGQEABAWCCQAAsAyCCQAAsAyCCQAAsAyCCQAAsAyCCfwuvbDsnNsX8hm/YRItAPgVwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQhI2CrwwIAvIZgAgAALINgAgAALINgAgAALINgAgAALINgAgAALINgAgAALKNPoAvwlDFGktTQ0OD9nTcb1x/bm099cYwv21zbZ/Trqo+rtm76nHPfHP+rv4vujnXm31MP+uhcPzfnOP45P3cGp9N5xi4a1NbWdkGfA4BQ1/Hvc8fv8e7YzPl6WMyHH36otLS0QJcBAAB6oLa2VoMGDer2/aALJu3t7froo48UHR0tm83m9f03NDQoLS1NtbW1iomJ8fr+8QXG2T8YZ/9hrP2DcfYfb4+1MUaNjY1KTU1VWFj3M0mC7lJOWFjYOZOWt8TExPBD7weMs38wzv7DWPsH4+w/3hzr2NjY8/Zh8isAALAMggkAALAMgslZ7Ha7ioqKZLfbA11KSGOc/YNx9h/G2j8YZ/8J1FgH3eRXAAAQujhjAgAALINgAgAALINgAgAALINgAgAALKNXBpPi4mKlp6crMjJS2dnZ2r179zn7/+53v9PXv/51RUZGauTIkdq2bZufKg1unozzunXrNHbsWA0YMEADBgxQbm7uef9e8AVPf547bNq0STabTd/+9rd9W2AI8XSsT548qXnz5iklJUV2u11XXnkl/35cAE/HefXq1Ro2bJj69euntLQ0Pfzww/r888/9VG1wqqio0JQpU5SamiqbzaatW7ee9zM7d+7UtddeK7vdriuuuEIlJSW+Kc70Mps2bTIRERFm/fr15r333jOzZ882cXFxxuFwdNn/rbfeMuHh4eYXv/iF2b9/v3nkkUdM3759zbvvvuvnyoOLp+M8Y8YMU1xcbPbt22cOHDhgvv/975vY2Fjz4Ycf+rny4OLpOHeoqakxl112mRk7dqyZOnWqf4oNcp6OdXNzs8nMzDSTJ082u3btMjU1NWbnzp2murraz5UHF0/HubS01NjtdlNaWmpqamrMH//4R5OSkmIefvhhP1ceXLZt22YWLVpktmzZYiSZl1566Zz9jxw5YqKiokxBQYHZv3+/WbNmjQkPDzfbt2/3em29LphkZWWZefPmubbb2tpMamqqWbFiRZf9p02bZm655Ra3tuzsbHP//ff7tM5g5+k4n+306dMmOjrabNiwwVclhoSejPPp06fNDTfcYJ599lmTl5dHMLlAno71M888Y4YMGWJaWlr8VWJI8HSc582bZ2666Sa3toKCAnPjjTf6tM5QciHBZMGCBWb48OFubdOnTzcTJ070ej296lJOS0uLqqqqlJub62oLCwtTbm6uKisru/xMZWWlW39JmjhxYrf90bNxPtupU6fU2tqq+Ph4X5UZ9Ho6zo899pgSExN13333+aPMkNCTsX755ZeVk5OjefPmKSkpSSNGjNDy5cvV1tbmr7KDTk/G+YYbblBVVZXrcs+RI0e0bds2TZ482S819xb+/F0YdA/xuxgnTpxQW1ubkpKS3NqTkpJ08ODBLj9TV1fXZf+6ujqf1RnsejLOZ/vpT3+q1NTUTv8h4Cs9Geddu3bpueeeU3V1tR8qvHDt7e1qaWlRZGRkoEvpUk/G+siRI3r99dd19913a9u2bTp8+LDmzp2r1tZWFRUV+aPsoNOTcZ4xY4ZOnDihMWPGyBij06dP64EHHtDPfvYzf5Tca3T3u7ChoUGfffaZ+vXr57Vj9aozJggOK1eu1KZNm/TSSy9Z9hdVMGpsbNTMmTO1bt06JSQk+OQYS5Yskc1m08GDBzVt2jTFxMRo4MCB+vGPf+w2GdFmsyk/P1+lpaUaPny47Ha7tm/fLkn65z//qXvvvVdJSUmy2+0aPny41q9f3+lYa9as0fDhwxUVFaUBAwYoMzNTGzdu9Mn36on29nYlJibq17/+tUaPHq3p06dr0aJFWrt2baBLCyk7d+7U8uXL9fTTT2vv3r3asmWLysrK9Pjjjwe6NPRQrzpjkpCQoPDwcDkcDrd2h8Oh5OTkLj+TnJzsUX/0bJw7PPnkk1q5cqV27Nihq6++2pdlBj1Px/kf//iHjh49qilTprja2tvbJUl9+vTRoUOHNHToUK/UNm3aNKWnp2vFihX605/+pF/96lf69NNP9Zvf/MbV5/XXX9cLL7yg/Px8JSQkKD09XQ6HQ9dff70ruFx66aX6wx/+oPvuu08NDQ166KGHJH1xF9ePfvQj3Xnnna7Q89e//lV//vOfNWPGDK98hzP15Gc6JSVFffv2VXh4uKvtG9/4hurq6tTS0qKIiAiv1xnsejLOjz76qGbOnKkf/OAHkqSRI0fK6XRqzpw5WrRokcLC+P9vb+jud2FMTIxXz5ZI6n135WRlZZn8/HzXdltbm7nsssvOOfn11ltvdWvLyclh8ut5eDrOxhjz85//3MTExJjKykp/lBgSPBnnzz77zLz77rtur6lTp5qbbrrJvPvuu6a5ufmi6ykqKjKSzG233ebWPnfuXCPJvPPOO8aYLybbhYWFmffee8+t33333WdSUlLMiRMn3Nq/+93vmtjYWHPq1CljjDFTp07tNBHP1zz9mV64cKG5/PLLTVtbm6tt9erVJiUlxee1BjNPx/naa681CxYscGvbuHGj6devnzl9+rRPaw0VusDJryNGjHBr+973vueTya+9Lphs2rTJ2O12U1JSYvbv32/mzJlj4uLiTF1dnTHGmJkzZ5rCwkJX/7feesv06dPHPPnkk+bAgQOmqKiI24UvgKfjvHLlShMREWFefPFF8/HHH7tejY2NgfoKQcHTcT6bt+/K6Qgmf/zjH93aDxw4YCS5frlIMhMmTHDr097ebuLi4sycOXPM8ePH3V7PP/+8kWR27drlqjs2Ntbs3r3ba7Wfj6dj/cEHH5jo6GiTn59vDh06ZF555RWTmJhonnjiCb/VHIw8HeeioiITHR1tfvvb35ojR46YV1991QwdOtRMmzYtUF8hKDQ2Npp9+/aZffv2GUlm1apVZt++feb99983xhhTWFhoZs6c6erfcbvw/PnzzYEDB0xxcTG3C3vTmjVrzODBg01ERITJysoyf/rTn1zvjRs3zuTl5bn1f+GFF8yVV15pIiIizPDhw01ZWZmfKw5Onozz5ZdfbiR1ehUVFfm/8CDj6c/zmXwVTI4cOeLW3tLSYsLCwlxnGiWZe++9162Pw+Ho8mfgzNeWLVuMMcbs37/fXHbZZUaSueKKK8zcuXNdocWXPB3rt99+22RnZxu73W6GDBlili1bxv/FXwBPxrm1tdUsWbLEDB061ERGRpq0tDQzd+5c8+mnn/q/8CDyxhtvdPnfWMfY5uXlmXHjxnX6zKhRo0xERIQZMmSIef75531Sm80YY7x7cQhAb7VkyRItXbpUR44c0de+9jVX++nTp2W32zV79mytXbtWNptN8+bN01NPPeXqU1dXp5SUFP3Hf/yH8vLyutz/1VdfrcTEREmS0+nUK6+8ou3bt+sPf/iDHA6HFi9erKVLl/r2SwLwqV41+RWAf/z97393CyaHDx9We3u70tPTu/3MpZdequjoaLW1tV3QbeL9+/fX9OnTNX36dLW0tOiOO+7QsmXLtHDhQu7mAoIY05UBeF1xcbHb9po1ayRJkyZN6vYz4eHh+s53vqPf//73+n//7/91ev/48eOuP//rX/9yey8iIkJXXXWVjDFqbW29mNIBBBhnTAB4XU1NjW677TZ961vfUmVlpf73f/9XM2bMUEZGxjk/t3LlSr3xxhvKzs7W7NmzddVVV+mTTz7R3r17tWPHDn3yySeSpG9+85tKTk7WjTfeqKSkJB04cEBPPfWUbrnlFkVHR/vjKwLwEYIJAK/bvHmzFi9erMLCQvXp00f5+fn6z//8z/N+LikpSbt379Zjjz2mLVu26Omnn9bAgQM1fPhw/fznP3f1u//++1VaWqpVq1apqalJgwYN0o9+9CM98sgjvvxaAPyAya8AvKZj8uvx48d9trosgNDGHBMAAGAZBBMAAGAZBBMAAGAZzDEBAACWwRkTAABgGUF3u3B7e7s++ugjRUdHy2azBbocAABwAYwxamxsVGpqqsLCuj8vEnTB5KOPPlJaWlqgywAAAD1QW1urQYMGdft+0AWTjlUda2trFRMTE+BqcDan06nU1FRJX4TI/v37B7giAIAVNDQ0KC0t7byrMwddMOm4fBMTE0MwsaDw8HDXn2NiYggmAAA355uGweRXAABgGQQTAABgGQQTAABgGUE3xwQAAF9ra2tTa2troMsIKn379nWbZ9hTBBMAAL5kjFFdXZ1OnjwZ6FKCUlxcnJKTky9qnTGCSRfSC8skSUdX3hLgSgAA/tQRShITExUVFcVCnhfIGKNTp07p2LFjkqSUlJQe74tgAgCAvrh80xFKBg4cGOhygk6/fv0kSceOHVNiYmKPL+sw+RUAAMk1pyQqKirAlQSvjrG7mPk5BBMAAM7A5Zue88bYEUwAAIBlEEwAAIBlMPkVAIDz6Lhb0196812hnDEBAABd+uSTT3T33XcrJiZGcXFxuu+++9TU1OTTYxJMAADohVpaWs7b5+6779Z7772n1157Ta+88ooqKio0Z84cn9ZFMAEAIAQ0Njbq7rvvVv/+/ZWSkqJf/vKXGj9+vB566CFJUnp6uh5//HHdc889iomJOW/AOHDggLZv365nn31W2dnZGjNmjNasWaNNmzbpo48+8tn3IJgAABACCgoK9NZbb+nll1/Wa6+9pjfffFN79+516/Pkk08qIyND+/bt06OPPnrO/VVWViouLk6ZmZmuttzcXIWFhenPf/6zT76DxORXAACCXmNjozZs2KCNGzfq5ptvliQ9//zzSk1Ndet300036Sc/+ckF7bOurk6JiYlubX369FF8fLzq6uq8U3gXOGMCAECQO3LkiFpbW5WVleVqi42N1bBhw9z6nXn2w6oIJgAA9BL9+/e/4L7Jycmuh/J1OH36tD755BMlJyd7uzQXggkAAEFuyJAh6tu3r/7yl7+42urr6/W3v/2tx/vMycnRyZMnVVVV5Wp7/fXX1d7eruzs7Iuq91yYYwIAQJCLjo5WXl6e5s+fr/j4eCUmJqqoqEhhYWE9fn7NN77xDX3rW9/S7NmztXbtWrW2tio/P1/f/e53O81d8aaABJP09HTFxMQoLCxMAwYM0BtvvBGIMgAAuCDBsBLrqlWr9MADD+jWW29VTEyMFixYoNraWkVGRvZ4n6WlpcrPz9fNN9+ssLAwfec739GvfvUrL1bdWcDOmLz99tu65JJLAnV4AABCSnR0tEpLS13bTqdTS5cuda1XcvToUY/3GR8fr40bN3qrxAvCpRwAAELAvn37dPDgQWVlZam+vl6PPfaYJGnq1KkBrswzHk9+raio0JQpU5SamiqbzaatW7d26lNcXKz09HRFRkYqOztbu3fvdnvfZrNp3Lhxuu6669zSHQAA6LmOBdRyc3PldDr15ptvKiEhocu+y5cv1yWXXNLla9KkSX6u/CsenzFxOp3KyMjQvffeqzvuuKPT+5s3b1ZBQYHWrl2r7OxsrV69WhMnTtShQ4dcC7Xs2rVLl112mT7++GPl5uZq5MiRuvrqqy/+2wAA0Etdc801bnfQnM8DDzygadOmdflev379vFWWxzwOJpMmTTpnklq1apVmz56tWbNmSZLWrl2rsrIyrV+/XoWFhZKkyy67TJKUkpKiyZMna+/evd0Gk+bmZjU3N7u2GxoaPC0ZAACcJT4+XvHx8YEuoxOvrmPS0tKiqqoq5ebmfnWAsDDl5uaqsrJS0hdnXBobGyVJTU1Nev311zV8+PBu97lixQrFxsa6Xmlpad4sGQAAWIhXg8mJEyfU1tampKQkt/akpCTXuvoOh0NjxoxRRkaGrr/+et1zzz267rrrut3nwoULVV9f73rV1tZ6s2QAAGAhfr8rZ8iQIXrnnXcuuL/dbpfdbvdhRQAAwCq8esYkISFB4eHhcjgcbu0Oh8On6+oDAIDQ4NVgEhERodGjR6u8vNzV1t7ervLycuXk5HjzUAAAIAR5fCmnqalJhw8fdm3X1NSourpa8fHxGjx4sAoKCpSXl6fMzExlZWVp9erVcjqdrrt0glF6YZmk4FiSGADgA0ti/Xy8ev8ez0I8DiZ79uzRhAkTXNsFBQWSpLy8PJWUlGj69Ok6fvy4Fi9erLq6Oo0aNUrbt2/vNCEWAABY27Jly1RWVqbq6mpFRETo5MmTPj+mx8Fk/PjxMsacs09+fr7y8/N7XBQAAPCtlpYWRUREnLfPXXfdpZycHD333HN+qcurc0wAAEBgNDY26u6771b//v2VkpKiX/7ylxo/frweeughSVJ6eroef/xx3XPPPYqJiXE93O9cli5dqocfflgjR470cfVfIZgAABACCgoK9NZbb+nll1/Wa6+9pjfffFN79+5169PxLJ19+/bp0UcfDVCl58bThQEACHKNjY3asGGDNm7cqJtvvlmS9Pzzzys1NdWt30033aSf/OQngSjxgnHGBACAIHfkyBG1trYqKyvL1RYbG6thw4a59cvMzPR3aR4jmAAA0Ev0798/0CWcF8Gkh9ILy1zrmwAAEEhDhgxR37599Ze//MXVVl9fr7/97W8BrKpnmGMCAECQi46OVl5enubPn6/4+HglJiaqqKhIYWFhstlsPd7vBx98oE8++UQffPCB2traVF1dLUm64oordMkll3ipencEEwAAzicIVmJdtWqVHnjgAd16662KiYnRggULVFtbq8jIyB7vc/HixdqwYYNr+5prrpEkvfHGGxo/fvzFltwlggkAACEgOjpapaWlrm2n06mlS5e61is5evSox/ssKSlRSUmJlyq8MAQTAABCwL59+3Tw4EFlZWWpvr5ejz32mCRp6tSpAa7MM0x+BQAgRHQsoJabmyun06k333xTCQkJXfZdvny5Lrnkki5fkyZN8nPlX+GMCQAAIeCaa65RVVXVBfd/4IEHNG3atC7f69evn7fK8hjB5HyWxOpopJT++cZAVwIAgNfEx8crPj4+0GV0wqUcAADOYIwJdAlByxtjxxkTLzlzsbWjK28JYCUAgJ7o27evJOnUqVMBvZQRzE6dOiXpq7HsCYJJT3B5BwBCTnh4uOLi4nTs2DFJUlRU1EUtTtabGGN06tQpHTt2THFxcQoPD+/xvggmAAB8KTk5WZJc4QSeiYuLc41hTxFMAAD4ks1mU0pKihITE9Xa2hrocoJK3759L+pMSQeCiTdwaQcAQkp4eLhXfsnCcwSTMy2JlSRCBgAAAcLtwgAAwDIIJgAAwDIIJj6UXljmtr4JAAA4N4KJryyJ1dHIGYGuAgCAoEIwAQAAlkEwAQAAlkEwAQAAlsE6Jv7y5RopX/y5PnB1AABgYZwxAQAAlkEwAQAAlkEwCQDWNgEAoGsEk0BaEus+9wQAgF6OYAIAACyDYAIAACyDYAIAACyDYAIAACyDYAIAACyDYGIBrtuHO+7S4U4dAEAvRTABAACW4fdgcvLkSWVmZmrUqFEaMWKE1q1b5+8SAACARfn9IX7R0dGqqKhQVFSUnE6nRowYoTvuuEMDBw70dykAAMBi/H7GJDw8XFFRUZKk5uZmGWNkjPF3GcGDOScAgF7E42BSUVGhKVOmKDU1VTabTVu3bu3Up7i4WOnp6YqMjFR2drZ2797t9v7JkyeVkZGhQYMGaf78+UpISOjxFwAAAKHD42DidDqVkZGh4uLiLt/fvHmzCgoKVFRUpL179yojI0MTJ07UsWPHXH3i4uL0zjvvqKamRhs3bpTD4ej2eM3NzWpoaHB7AQCA0ORxMJk0aZKeeOIJ3X777V2+v2rVKs2ePVuzZs3SVVddpbVr1yoqKkrr16/v1DcpKUkZGRl68803uz3eihUrFBsb63qlpaV5WjIAAAgSXp1j0tLSoqqqKuXm5n51gLAw5ebmqrKyUpLkcDjU2NgoSaqvr1dFRYWGDRvW7T4XLlyo+vp616u2ttabJVuWa20TAAB6Ea/elXPixAm1tbUpKSnJrT0pKUkHDx6UJL3//vuaM2eOa9Lrgw8+qJEjR3a7T7vdLrvd7s0yg1/HZNgl9YGtAwAAL/P77cJZWVmqrq7292EBAEAQ8OqlnISEBIWHh3eazOpwOJScnOzNQwEAgBDk1WASERGh0aNHq7y83NXW3t6u8vJy5eTkePNQAAAgBHl8KaepqUmHDx92bdfU1Ki6ulrx8fEaPHiwCgoKlJeXp8zMTGVlZWn16tVyOp2aNWuWVwvHGZhzAgAIER4Hkz179mjChAmu7YKCAklSXl6eSkpKNH36dB0/flyLFy9WXV2dRo0ape3bt3eaEAsAAHA2j4PJ+PHjz7uEfH5+vvLz83tcFDpLLyzT0ZW3BLoMAAB8yu/PygEAAOgOwQQAAFgGwSRU8VRiAEAQIpgAAADLIJgAAADLIJgAAADLIJgAAADLIJgEsfTCskCXAACAV/n96cIIkDPv0GHpegCARXHGBAAAWAbBBAAAWAbBpDdjETYAgMUQTAAAgGUQTAAAgGUQTAAAgGUQTAAAgGUQTEJIemEZi64BAIIaC6zhKyzCBgAIMM6YAAAAyyCYAAAAyyCYAAAAyyCYAAAAyyCYAAAAyyCYAAAAyyCYhLiLXteEB/0BAPyIYAIAACyDYAIAACyDYAIAACyDYAIAACyDYALPMSEWAOAjBBMAAGAZBBMAAGAZBBNcPC7tAAC8hGDSC130omsAAPgIwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFhGQILJ7bffrgEDBujOO+8MxOEBAIBFBSSY/PjHP9ZvfvObQBwaAABYWECCyfjx4xUdHR2IQwMAAAvzOJhUVFRoypQpSk1Nlc1m09atWzv1KS4uVnp6uiIjI5Wdna3du3d7o1YEm2Upga4AABBkPA4mTqdTGRkZKi4u7vL9zZs3q6CgQEVFRdq7d68yMjI0ceJEHTt27KKLBQAAoa2Ppx+YNGmSJk2a1O37q1at0uzZszVr1ixJ0tq1a1VWVqb169ersLDQ4wKbm5vV3Nzs2m5oaPB4HwAAIDh4dY5JS0uLqqqqlJub+9UBwsKUm5urysrKHu1zxYoVio2Ndb3S0tK8VS4AALAYrwaTEydOqK2tTUlJSW7tSUlJqqurc23n5ubqrrvu0rZt2zRo0KBzhpaFCxeqvr7e9aqtrfVmyZCfnp3T8aA/HvYHADgHjy/leMOOHTsuuK/dbpfdbvdhNQAAwCq8esYkISFB4eHhcjgcbu0Oh0PJycnePBQAAAhBXg0mERERGj16tMrLy11t7e3tKi8vV05OjjcPBQAAQpDHl3Kampp0+PBh13ZNTY2qq6sVHx+vwYMHq6CgQHl5ecrMzFRWVpZWr14tp9PpuksHAACgOx4Hkz179mjChAmu7YKCAklSXl6eSkpKNH36dB0/flyLFy9WXV2dRo0ape3bt3eaEAsAAHA2j4PJ+PHjZYw5Z5/8/Hzl5+f3uCgAANA7BeRZOQAAAF0hmAAAAMsgmAAAAMsgmAAAAMsgmAAAAMsgmKBLfnl+DgAAZyGYAAAAyyCYAAAAyyCYAAAAyyCYAAAAyyCYIHCWxH7xAgDgSwQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTXJCuHurn9Qf9daxrcubaJqx1AgC9CsEEAABYBsEEAABYBsEEAABYBsEEAABYBsEEAABYRp9AF+ApY4wkqaGhwfs7bzauP7Y3n/riGF+2ubbP6NdVH1dt3fQ5576D/PhqaJDT6XTto6HZqO2sz3T0c2vzpA8AICh1/A7p+D3eHZs5Xw+L+fDDD5WWlhboMgAAQA/U1tZq0KBB3b4fdMGkvb1dH330kaKjo2Wz2by+/4aGBqWlpam2tlYxMTFe3z++wDj7B+PsP4y1fzDO/uPtsTbGqLGxUampqQoL634mSdBdygkLCztn0vKWmJgYfuj9gHH2D8bZfxhr/2Cc/cebYx0be/4FM5n8CgAALINgAgAALINgcha73a6ioiLZ7fZAlxLSGGf/YJz9h7H2D8bZfwI11kE3+RUAAIQuzpgAAADLIJgAAADLIJgAAADLIJgAAADLIJgAAADL6JXBpLi4WOnp6YqMjFR2drZ27959zv6/+93v9PWvf12RkZEaOXKktm3b5qdKg5sn47xu3TqNHTtWAwYM0IABA5Sbm3vevxd8wdOf5w6bNm2SzWbTt7/9bd8WGEI8HeuTJ09q3rx5SklJkd1u15VXXsm/HxfA03FevXq1hg0bpn79+iktLU0PP/ywPv/8cz9VG5wqKio0ZcoUpaamymazaevWref9zM6dO3XttdfKbrfriiuuUElJiW+KM73Mpk2bTEREhFm/fr157733zOzZs01cXJxxOBxd9n/rrbdMeHi4+cUvfmH2799vHnnkEdO3b1/z7rvv+rny4OLpOM+YMcMUFxebffv2mQMHDpjvf//7JjY21nz44Yd+rjy4eDrOHWpqasxll11mxo4da6ZOneqfYoOcp2Pd3NxsMjMzzeTJk82uXbtMTU2N2blzp6murvZz5cHF03EuLS01drvdlJaWmpqaGvPHP/7RpKSkmIcfftjPlQeXbdu2mUWLFpktW7YYSeall146Z/8jR46YqKgoU1BQYPbv32/WrFljwsPDzfbt271eW68LJllZWWbevHmu7ba2NpOammpWrFjRZf9p06aZW265xa0tOzvb3H///T6tM9h5Os5nO336tImOjjYbNmzwVYkhoSfjfPr0aXPDDTeYZ5991uTl5RFMLpCnY/3MM8+YIUOGmJaWFn+VGBI8Hed58+aZm266ya2toKDA3HjjjT6tM5RcSDBZsGCBGT58uFvb9OnTzcSJE71eT6+6lNPS0qKqqirl5ua62sLCwpSbm6vKysouP1NZWenWX5ImTpzYbX/0bJzPdurUKbW2tio+Pt5XZQa9no7zY489psTERN13333+KDMk9GSsX375ZeXk5GjevHlKSkrSiBEjtHz5crW1tfmr7KDTk3G+4YYbVFVV5brcc+TIEW3btk2TJ0/2S829hT9/Fwbd04UvxokTJ9TW1qakpCS39qSkJB08eLDLz9TV1XXZv66uzmd1BruejPPZfvrTnyo1NbXTfwj4Sk/GedeuXXruuedUXV3thwpDR0/G+siRI3r99dd19913a9u2bTp8+LDmzp2r1tZWFRUV+aPsoNOTcZ4xY4ZOnDihMWPGyBij06dP64EHHtDPfvYzf5Tca3T3u7ChoUGfffaZ+vXr57Vj9aozJggOK1eu1KZNm/TSSy8pMjIy0OWEjMbGRs2cOVPr1q1TQkJCoMsJee3t7UpMTNSvf/1rjR49WtOnT9eiRYu0du3aQJcWUnbu3Knly5fr6aef1t69e7VlyxaVlZXp8ccfD3Rp6KFedcYkISFB4eHhcjgcbu0Oh0PJycldfiY5Odmj/ujZOHd48skntXLlSu3YsUNXX321L8sMep6O8z/+8Q8dPXpUU6ZMcbW1t7dLkvr06aNDhw5p6NChvi06SPXkZzolJUV9+/ZVeHi4q+0b3/iG6urq1NLSooiICJ/WHIx6Ms6PPvqoZs6cqR/84AeSpJEjR8rpdGrOnDlatGiRwsL4/29v6O53YUxMjFfPlki97IxJRESERo8erfLycldbe3u7ysvLlZOT0+VncnJy3PpL0muvvdZtf/RsnCXpF7/4hR5//HFt375dmZmZ/ig1qHk6zl//+tf17rvvqrq62vW67bbbNGHCBFVXVystLc2f5QeVnvxM33jjjTp8+LAr/EnS3/72N6WkpBBKutGTcT516lSn8NERBg3PqPUav/4u9Pp0WovbtGmTsdvtpqSkxOzfv9/MmTPHxMXFmbq6OmOMMTNnzjSFhYWu/m+99Zbp06ePefLJJ82BAwdMUVERtwtfAE/HeeXKlSYiIsK8+OKL5uOPP3a9GhsbA/UVgoKn43w27sq5cJ6O9QcffGCio6NNfn6+OXTokHnllVdMYmKieeKJJwL1FYKCp+NcVFRkoqOjzW9/+1tz5MgR8+qrr5qhQ4eaadOmBeorBIXGxkazb98+s2/fPiPJrFq1yuzbt8+8//77xhhjCgsLzcyZM139O24Xnj9/vjlw4IApLi7mdmFvWrNmjRk8eLCJiIgwWVlZ5k9/+pPrvXHjxpm8vDy3/i+88IK58sorTUREhBk+fLgpKyvzc8XByZNxvvzyy42kTq+ioiL/Fx5kPP15PhPBxDOejvXbb79tsrOzjd1uN0OGDDHLli0zp0+f9nPVwceTcW5tbTVLliwxQ4cONZGRkSYtLc3MnTvXfPrpp/4vPIi88cYbXf6b2zG2eXl5Zty4cZ0+M2rUKBMREWGGDBlinn/+eZ/UZjOGc10AAMAaetUcEwAAYG0EEwAAYBkEEwAAYBkEEwAAYBkEEwAAYBkEEwAAYBkEEwAAYBkEEwAAYBkEEwAAYBkEEwAAYBkEEwAAYBn/H+h2zUMiIKOxAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1232\n", "item counter : 1270\n", "ratio : 0.969315499606609\n", " ratio number predicted/items: 0.03225806451612903\n", "current epoch: 5\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1236\n", "item counter : 1257\n", "ratio : 0.9825119236883942\n", " ratio number predicted/items: 0.018282988871224166\n", "current epoch: 6\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1240\n", "item counter : 1258\n", "ratio : 0.9849086576648134\n", " ratio number predicted/items: 0.015885623510722795\n", "current epoch: 7\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1233\n", "item counter : 1247\n", "ratio : 0.9879807692307693\n", " ratio number predicted/items: 0.01201923076923077\n", "current epoch: 8\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1239\n", "item counter : 1262\n", "ratio : 0.9809976247030879\n", " ratio number predicted/items: 0.018210609659540775\n", "current epoch: 9\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1236\n", "item counter : 1274\n", "ratio : 0.9694117647058823\n", " ratio number predicted/items: 0.03215686274509804\n", "current epoch: 10\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1234\n", "item counter : 1274\n", "ratio : 0.967843137254902\n", " ratio number predicted/items: 0.03607843137254902\n", "current epoch: 11\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1233\n", "item counter : 1300\n", "ratio : 0.9477325134511914\n", " ratio number predicted/items: 0.05995388162951576\n", "current epoch: 12\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1233\n", "item counter : 1329\n", "ratio : 0.9270676691729324\n", " ratio number predicted/items: 0.09323308270676692\n", "current epoch: 13\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1230\n", "item counter : 1379\n", "ratio : 0.8913043478260869\n", " ratio number predicted/items: 0.15\n", "current epoch: 14\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1235\n", "item counter : 1610\n", "ratio : 0.7666045934202359\n", " ratio number predicted/items: 0.38423339540657975\n", "current epoch: 15\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1232\n", "item counter : 1995\n", "ratio : 0.6172344689378757\n", " ratio number predicted/items: 0.811122244488978\n", "current epoch: 16\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1227\n", "item counter : 2116\n", "ratio : 0.5795937647614549\n", " ratio number predicted/items: 1.0354274917335853\n", "current epoch: 17\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1230\n", "item counter : 2399\n", "ratio : 0.5125\n", " ratio number predicted/items: 1.5420833333333333\n", "current epoch: 18\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=20` reached.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 1229\n", "item counter : 2736\n", "ratio : 0.44903178662769455\n", " ratio number predicted/items: 2.000365363536719\n", "current epoch: 19\n" ] } ], "source": [ "for i in range(3):\n", " model_checkpoint = ModelCheckpoint(monitor='ratio_number_predicted_per_items', mode='max')\n", " trainer = pl.Trainer(\n", " max_epochs=20 if i==2 else 10,\n", "# max_epochs=40,\n", " accelerator='gpu',\n", " devices=1,\n", " log_every_n_steps=1,\n", " # logger=pl.loggers.CSVLogger(save_dir=\"logs/\"),\n", " reload_dataloaders_every_n_epochs=1,\n", " logger=tensorboard,\n", " callbacks=[model_checkpoint]\n", " )\n", " print(i)\n", " model = SudokuLightning(\n", " lr=0.01,\n", " prev_nets=prev_nets,\n", " coef_0 = 10 if i==0 else 20,\n", " )\n", " _ = trainer.fit(model,)\n", "# model.below_threshold_coef=0.9\n", "# model = model.load_from_checkpoint(model_checkpoint.best_model_path)\n", "# print(model_checkpoint.best_model_path)\n", "# trainer.validate(model=model)\n", "# if trainer.logged_metrics['no_improve_counter'].item()==0:\n", " prev_nets.append((model.net, (model.threshold_abs, model.threshold_pres)))" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(234.)\n", "tensor(26.)\n" ] }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
\n" ], "text/plain": [ "" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(test_x.sum())\n", "print(test_x[:,1].sum())\n", "display_as_dataframe(test_x)" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(557.)\n", "tensor(28.)\n" ] }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
\n" ], "text/plain": [ "" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "new_x = forward_from_prev_nets_all(test_x, test_y)\n", "print(new_x.sum())\n", "print(new_x[:,1].sum())\n", "display_as_dataframe(new_x)" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(565.)\n", "tensor(30.)\n" ] }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
\n" ], "text/plain": [ "" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "prev_x = new_x.clone()\n", "new_x = forward_from_prev_nets_all(new_x, test_y)\n", "print(new_x.sum())\n", "print(new_x[:,1].sum())\n", "display_as_dataframe(new_x)" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(570.)\n", "tensor(30.)\n" ] }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
\n" ], "text/plain": [ "" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "new_x = forward_from_prev_nets_all(new_x, test_y)\n", "print(new_x.sum())\n", "print(new_x[:,1].sum())\n", "display_as_dataframe(new_x)" ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(570.)\n", "tensor(30.)\n" ] }, { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
123123123123123123123123123
456456456456456456456456456
789789789789789789789789789
\n" ], "text/plain": [ "" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "new_x = forward_from_prev_nets_all(new_x, test_y)\n", "print(new_x.sum())\n", "print(new_x[:,1].sum())\n", "display_as_dataframe(new_x)" ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([[1., 1., 0.],\n", " [1., 1., 1.],\n", " [1., 1., 0.]])" ] }, "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ "new_x.reshape((2,9,9,9))[0,6:,6:,7]" ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor([[[1.0000, 0.0000, 0.0000],\n", " [1.0000, 1.0000, 1.0000],\n", " [1.0000, 1.0000, 1.0000]],\n", "\n", " [[0.8750, 1.0000, 0.7500],\n", " [0.8750, 0.8750, 0.6250],\n", " [0.8750, 0.8750, 0.6250]],\n", "\n", " [[0.7500, 0.8750, 0.8750],\n", " [0.8750, 0.8750, 0.8750],\n", " [0.8750, 0.8750, 0.8750]],\n", "\n", " [[0.7500, 0.8750, 0.8750],\n", " [0.7500, 0.7500, 0.7500],\n", " [0.7500, 0.7500, 0.7500]],\n", "\n", " [[0.8333, 0.8333, 0.8333],\n", " [1.0000, 1.0000, 1.0000],\n", " [0.8333, 0.8333, 0.8333]],\n", "\n", " [[0.8333, 0.8333, 0.8333],\n", " [0.8333, 0.8333, 0.8333],\n", " [1.0000, 1.0000, 1.0000]],\n", "\n", " [[1.0000, 0.8333, 0.8333],\n", " [1.0000, 0.8333, 0.8333],\n", " [1.0000, 0.8333, 0.8333]],\n", "\n", " [[0.6667, 0.6667, 1.0000],\n", " [0.6667, 0.6667, 1.0000],\n", " [0.6667, 0.6667, 1.0000]],\n", "\n", " [[0.7500, 0.7500, 0.7500],\n", " [0.6250, 0.8750, 0.6250],\n", " [0.6250, 0.6250, 0.8750]],\n", "\n", " [[0.7656, 0.7969, 0.6406],\n", " [0.7812, 0.7812, 0.6562],\n", " [0.7812, 0.8125, 0.6250]],\n", "\n", " [[0.7344, 0.7344, 0.7344],\n", " [0.7656, 0.7344, 0.7656],\n", " [0.7812, 0.7812, 0.7500]],\n", "\n", " [[0.7188, 0.7188, 0.7188],\n", " [0.7344, 0.7031, 0.7344],\n", " [0.7344, 0.7344, 0.7031]],\n", "\n", " [[0.8125, 0.8125, 0.8125],\n", " [0.7708, 0.7708, 0.7708],\n", " [0.7917, 0.7917, 0.7917]],\n", "\n", " [[0.7500, 0.7500, 0.7500],\n", " [0.7500, 0.7500, 0.7500],\n", " [0.7083, 0.7083, 0.7083]],\n", "\n", " [[0.6667, 0.7083, 0.7917],\n", " [0.6667, 0.7083, 0.7917],\n", " [0.6667, 0.7083, 0.7917]],\n", "\n", " [[0.7500, 0.7083, 0.8333],\n", " [0.7500, 0.7083, 0.8333],\n", " [0.7500, 0.7083, 0.8333]],\n", "\n", " [[0.0000, 0.0000, 0.0000],\n", " [0.0000, 0.0000, 0.0000],\n", " [0.0000, 0.0000, 0.0000]],\n", "\n", " [[0.1250, 0.0000, 0.0000],\n", " [0.1250, 0.0000, 0.0000],\n", " [0.1250, 0.0000, 0.0000]],\n", "\n", " [[0.0000, 0.0000, 0.0000],\n", " [0.1250, 0.1250, 0.1250],\n", " [0.1250, 0.1250, 0.1250]],\n", "\n", " [[0.0000, 0.0000, 0.0000],\n", " [0.0000, 0.0000, 0.0000],\n", " [0.0000, 0.0000, 0.0000]],\n", "\n", " [[0.1667, 0.1667, 0.1667],\n", " [0.0000, 0.0000, 0.0000],\n", " [0.1667, 0.1667, 0.1667]],\n", "\n", " [[0.1667, 0.1667, 0.1667],\n", " [0.1667, 0.1667, 0.1667],\n", " [0.0000, 0.0000, 0.0000]],\n", "\n", " [[0.0000, 0.1667, 0.1667],\n", " [0.0000, 0.1667, 0.1667],\n", " [0.0000, 0.1667, 0.1667]],\n", "\n", " [[0.0000, 0.0000, 0.0000],\n", " [0.0000, 0.0000, 0.0000],\n", " [0.0000, 0.0000, 0.0000]],\n", "\n", " [[0.0000, 0.0000, 0.0000],\n", " [0.0000, 0.1250, 0.0000],\n", " [0.0000, 0.0000, 0.1250]],\n", "\n", " [[0.0469, 0.0625, 0.0312],\n", " [0.0469, 0.0469, 0.0312],\n", " [0.0469, 0.0625, 0.0156]],\n", "\n", " [[0.0469, 0.0469, 0.0469],\n", " [0.0469, 0.0312, 0.0469],\n", " [0.0469, 0.0469, 0.0312]],\n", "\n", " [[0.0312, 0.0312, 0.0312],\n", " [0.0312, 0.0156, 0.0312],\n", " [0.0312, 0.0312, 0.0156]],\n", "\n", " [[0.0417, 0.0417, 0.0417],\n", " [0.0625, 0.0625, 0.0625],\n", " [0.0625, 0.0625, 0.0625]],\n", "\n", " [[0.0417, 0.0417, 0.0417],\n", " [0.0417, 0.0417, 0.0417],\n", " [0.0417, 0.0417, 0.0417]],\n", "\n", " [[0.0208, 0.0417, 0.0208],\n", " [0.0208, 0.0417, 0.0208],\n", " [0.0208, 0.0417, 0.0208]],\n", "\n", " [[0.0625, 0.0417, 0.1042],\n", " [0.0625, 0.0417, 0.1042],\n", " [0.0625, 0.0417, 0.1042]]])" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model.sym_preprocess(new_x).reshape(32,9,9,9)[:,:3,6:,7]" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "/home/seb/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/torch/nn/_reduction.py:42: UserWarning: size_average and reduce args will be deprecated, please use reduction='none' instead.\n", " warnings.warn(warning.format(ret))\n", "/home/seb/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/callbacks/model_checkpoint.py:612: UserWarning: Checkpoint directory lightning_logs/version_81/checkpoints exists and is not empty.\n", " rank_zero_warn(f\"Checkpoint directory {dirpath} exists and is not empty.\")\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "-----------------------------------------------------\n", "0 | net | SmallNet | 514 \n", "1 | sym_preprocess | SymPreprocess | 8.5 M \n", "2 | bcewll | BCEWithLogitsLoss | 0 \n", "3 | auroc | BinaryAUROC | 0 \n", "-----------------------------------------------------\n", "514 Trainable params\n", "8.5 M Non-trainable params\n", "8.5 M Total params\n", "34.014 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "/home/seb/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:430: PossibleUserWarning: The dataloader, val_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 12 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n", "/tmp/ipykernel_3278/2863678930.py:187: UserWarning: Data has no positive values, and therefore cannot be log-scaled.\n", " ax1.set_yscale('log')\n", "/tmp/ipykernel_3278/2863678930.py:193: UserWarning: Data has no positive values, and therefore cannot be log-scaled.\n", " ax2.set_yscale('log')\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 0\n", "item counter : 0\n", "ratio : 0.0\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/seb/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:430: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 12 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n", " rank_zero_warn(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4c65b4fd391c4abdb5c461d1900985ad", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 848\n", "item counter : 851\n", "ratio : 0.9953051643192489\n", " ratio number predicted/items: 0.004694835680751174\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 849\n", "item counter : 862\n", "ratio : 0.9837775202780996\n", " ratio number predicted/items: 0.03244495944380069\n", "current epoch: 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 847\n", "item counter : 858\n", "ratio : 0.9860302677532014\n", " ratio number predicted/items: 0.012805587892898719\n", "current epoch: 2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 845\n", "item counter : 852\n", "ratio : 0.9906213364595545\n", " ratio number predicted/items: 0.008206330597889801\n", "current epoch: 3\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 847\n", "item counter : 849\n", "ratio : 0.9964705882352941\n", " ratio number predicted/items: 0.002352941176470588\n", "current epoch: 4\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 848\n", "item counter : 854\n", "ratio : 0.991812865497076\n", " ratio number predicted/items: 0.007017543859649123\n", "current epoch: 5\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 848\n", "item counter : 850\n", "ratio : 0.9964747356051704\n", " ratio number predicted/items: 0.0023501762632197414\n", "current epoch: 6\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 849\n", "item counter : 851\n", "ratio : 0.9964788732394366\n", " ratio number predicted/items: 0.002347417840375587\n", "current epoch: 7\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 848\n", "item counter : 849\n", "ratio : 0.9976470588235294\n", " ratio number predicted/items: 0.001176470588235294\n", "current epoch: 8\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=10` reached.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 846\n", "item counter : 848\n", "ratio : 0.9964664310954063\n", " ratio number predicted/items: 0.002355712603062426\n", "current epoch: 9\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "-----------------------------------------------------\n", "0 | net | SmallNet | 514 \n", "1 | sym_preprocess | SymPreprocess | 8.5 M \n", "2 | bcewll | BCEWithLogitsLoss | 0 \n", "3 | auroc | BinaryAUROC | 0 \n", "-----------------------------------------------------\n", "514 Trainable params\n", "8.5 M Non-trainable params\n", "8.5 M Total params\n", "34.014 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 0\n", "item counter : 0\n", "ratio : 0.0\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b7b930ecc82e405a865686cf97b835a1", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 842\n", "item counter : 861\n", "ratio : 0.9767981438515081\n", " ratio number predicted/items: 0.031322505800464036\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGzCAYAAAD0T7cVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA3EklEQVR4nO3de3QV5b3G8ScJZIdgLoRILhJMwUrLxaQlJsbLMmhOaVBErEIrByPaoCVpq9tqQ60EVIS2HMop3cqSFmN7oKAWOR6hVImyohgLBOLxyKWlBIzFbKBIEoImIXnPH5atkXDZyb7MZH8/a82Sefc7M7/9Gs3DzDszYcYYIwAAAIsID3YBAAAAn0c4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4ARBU5eXlCgsL07Zt24JdCgCLIJwAAABLIZwAAABLIZwAAABLIZwA8IsDBw5o5syZGj58uPr166eBAwfqtttu0/79+7vsf+LECd1zzz0aOHCgYmNjdccdd+ijjz7q1Gfbtm0aN26cEhMT1a9fP33pS1/SXXfdFYBvAyCQ+gS7AAC909atW/XWW2/p29/+tgYPHqz9+/frqaeeUl5ennbu3Kno6OhO/UtKShQfH685c+Zoz549euqpp3TgwAFt2rRJYWFhOnTokL7xjW/owgsvVGlpqeLj47V//36tWbMmSN8QgL8QTgD4xQ033KBbb721U9uECROUm5urP/7xj5o2bVqnzyIjI1VRUaG+fftKki6++GI99NBD+p//+R/ddNNNeuutt/TRRx/plVdeUVZWlme7xx9/3P9fBkBAcVkHgF/069fP8+e2tjb985//1CWXXKL4+Hht3779tP4zZszwBBNJ+t73vqc+ffpo/fr1kqT4+HhJ0ssvv6y2tjb/Fg8gqAgnAPzi448/1uzZs5WWliaHw6HExERdeOGFOnbsmBoaGk7r/+Uvf7nT+gUXXKCUlBTPHJVrr71W3/rWtzR37lwlJiZq4sSJeuaZZ9TS0hKIrwMggAgnAPzi+9//vubNm6fJkyfrueee0yuvvKJXX31VAwcOVEdHh9f7CwsL0wsvvKCqqiqVlJToH//4h+666y6NGTNGx48f98M3ABAshBMAfvHCCy+osLBQ//Ef/6Fbb71V//Zv/6arr75ax44d67L/3/72t07rx48f14cffqj09PRO7VdccYXmzZunbdu2acWKFXrvvfe0atUqP30LAMFAOAHgFxERETLGdGpbsmSJ2tvbu+z/9NNPd5pL8tRTT+nkyZMqKCiQJH300Uen7S8zM1OSuLQD9DLcrQPAL2688Ub9/ve/V1xcnEaMGKGqqipt3LhRAwcO7LJ/a2urrr/+ek2ePFl79uzRk08+qauvvlo33XSTJOnZZ5/Vk08+qUmTJmnYsGFqamrSsmXLFBsbq/HjxwfyqwHwM8IJAL/4z//8T0VERGjFihX65JNPdNVVV2njxo0aN25cl/1//etfa8WKFZo9e7ba2tr0ne98R7/61a8UFhYm6dMJsVu2bNGqVavkdrsVFxen7OxsrVixQl/60pcC+dUA+FmY+eJ5UgAAgCBizgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAU2z3npKOjQwcPHlRMTIzn+QcAAMDajDFqampSamqqwsPPfm7EduHk4MGDSktLC3YZAACgG+rq6jR48OCz9rFNOHG5XHK5XDp58qSkT79cbGxskKuyp+bmZqWmpkr6NOz1798/yBUBAHq7xsZGpaWlKSYm5px9bfeE2MbGRsXFxamhoYFw0k3Nzc264IILJH365lfCCQDA37z5/c2EWAAAYCm2CScul0sjRozQ5ZdfHuxSAACAH3FZJwRxWQcAEGhc1gEAALZlm3ASyMs66aXrlF66zu/HAQAAp7NNOCkuLtbOnTu1devWYJcCAAD8yDbhBAAAhAbbhBPu1gEAIDTYJpxwWQcAgNBgm3ACAABCA+EEAABYCuEEAABYim3CCRNiAQAIDbYJJ0yIBQAgNNgmnAAAgNBAOAEAAJZCODmXOXGfLgAAICAIJwAAwFJsE064WwcAgNBgm3DC3ToAAIQG24QTAAAQGggn3cEkWQAA/IZwAgAALIVwAgAALCVo4eTEiRO6+OKL9aMf/ShYJXRtTpz2R90e7CoAAAhZQQsn8+bN0xVXXBGsw3stvXSd0kvXBbsMAAB6vaCEk7/97W/avXu3CgoKgnF4AABgYV6Hk8rKSk2YMEGpqakKCwvT2rVrT+vjcrmUnp6uqKgo5eTkaMuWLZ0+/9GPfqT58+d3u2jLOXX3DnfwAADQY16Hk+bmZmVkZMjlcnX5+erVq+V0OlVWVqbt27crIyND48aN06FDhyRJ//3f/61LL71Ul1566Xkdr6WlRY2NjZ0WAADQe/XxdoOCgoKzXo5ZtGiRioqKNH36dEnS0qVLtW7dOi1fvlylpaV6++23tWrVKj3//PM6fvy42traFBsbq9mzZ3e5v/nz52vu3LnelgkAAGzKp3NOWltbVV1drfz8/M8OEB6u/Px8VVVVSfo0bNTV1Wn//v1auHChioqKzhhMJGnWrFlqaGjwLHV1db4sGQAAWIxPw8mRI0fU3t6upKSkTu1JSUmqr6/v1j4dDodiY2P1+9//XldccYWuv/56X5QKAAAsyuvLOr505513nnff4uJiFRcXq7GxUXFxTDwFAKC38umZk8TEREVERMjtdndqd7vdSk5O7tG+XS6XRowYocsvv7xH+wEAANbm03ASGRmpMWPGqKKiwtPW0dGhiooK5ebm9mjfxcXF2rlzp7Zu3drTMgODW4sBAOgWry/rHD9+XHv37vWs19bWqqamRgkJCRoyZIicTqcKCwuVlZWl7OxsLV68WM3NzZ67d7rL5XLJ5XKpvb29R/sBAADW5nU42bZtm8aOHetZdzqdkqTCwkKVl5drypQpOnz4sGbPnq36+nplZmZqw4YNp02S9RZzTgAACA1eh5O8vDwZY87ap6SkRCUlJd0uqiucOQEAIDQE7cV/3rLdnBMAANAttgknVsRbigEA8D3bhBNuJQYAIDTYJpxwWQcAgNAQ1CfEhpTPP/NkTkPw6gAAwOJsc+YEAACEBtuEE+acAAAQGmwTTphzAgBAaLBNOAEAAKGBcAIAACzFNuGEOScAAIQG24QT5pwAABAabBNOAABAaCCcBNOcuM4PZwMAAIQTX+NlgAAA9AzhBAAAWIptwgl36wAAEBpsE064WwcAgNBgm3ACAABCA+EEAABYCuEEAABYCuHEanj2CQAgxAU8nBw7dkxZWVnKzMzUqFGjtGzZskCXAAAALKxPoA8YExOjyspKRUdHq7m5WaNGjdItt9yigQMHBroUAABgQQE/cxIREaHo6GhJUktLi4wxMsYEugwAAGBRXoeTyspKTZgwQampqQoLC9PatWtP6+NyuZSenq6oqCjl5ORoy5YtnT4/duyYMjIyNHjwYD344INKTEzs9hewOh5nDwCAd7wOJ83NzcrIyJDL5ery89WrV8vpdKqsrEzbt29XRkaGxo0bp0OHDnn6xMfH65133lFtba1Wrlwpt9t9xuO1tLSosbGx0wIAAHovr8NJQUGBHn/8cU2aNKnLzxctWqSioiJNnz5dI0aM0NKlSxUdHa3ly5ef1jcpKUkZGRl64403zni8+fPnKy4uzrOkpaV5WzIAALARn845aW1tVXV1tfLz8z87QHi48vPzVVVVJUlyu91qamqSJDU0NKiyslLDhw8/4z5nzZqlhoYGz1JXV+fLkgEAgMX49G6dI0eOqL29XUlJSZ3ak5KStHv3bknSgQMHNGPGDM9E2O9///saPXr0GffpcDjkcDjkcrnkcrnU3t7uy5IBAIDFBPxW4uzsbNXU1Hi9XXFxsYqLi9XY2Ki4OB5SBgBAb+XTyzqJiYmKiIg4bYKr2+1WcnJyj/btcrk0YsQIXX755T3aj+3wxFgAQIjxaTiJjIzUmDFjVFFR4Wnr6OhQRUWFcnNze7Tv4uJi7dy5U1u3bu1pmQAAwMK8vqxz/Phx7d2717NeW1urmpoaJSQkaMiQIXI6nSosLFRWVpays7O1ePFiNTc3a/r06T0qlDknAACEBq/DybZt2zR27FjPutPplCQVFhaqvLxcU6ZM0eHDhzV79mzV19crMzNTGzZsOG2SrLeYcwIAQGjwOpzk5eWd83HzJSUlKikp6XZRXeHMCQAAoSHg79bpLuacAAAQGmwTTgAAQGiwTTjpTbcS8zJAAADOzDbhhMs6AACEBtuEEwAAEBoIJ3bEU2MBAL2YbcJJb5pzAgAAzsw24YQ5JwAAhAbbhBMAABAaCCcAAMBSbBNOmHMCAEBosE04Yc4JAAChwTbhpDfjibEAAHyGcAIAACyFcAIAACyFcAIAACylT7ALgA98/lH2cxqCVwcAAD5gmzMn3EoMAEBosE044VZiAABCg23CCQAACA2EEwAAYCmEEwAAYCkBDyd1dXXKy8vTiBEjdNlll+n5558PdAkAAMDCAn4rcZ8+fbR48WJlZmaqvr5eY8aM0fjx49W/f/9AlwIAACwo4OEkJSVFKSkpkqTk5GQlJibq6NGjhBMAACCpG5d1KisrNWHCBKWmpiosLExr1649rY/L5VJ6erqioqKUk5OjLVu2dLmv6upqtbe3Ky0tzevCezteBggACFVeh5Pm5mZlZGTI5XJ1+fnq1avldDpVVlam7du3KyMjQ+PGjdOhQ4c69Tt69KjuuOMOPf30092rHAAA9EpeX9YpKChQQUHBGT9ftGiRioqKNH36dEnS0qVLtW7dOi1fvlylpaWSpJaWFt18880qLS3VlVdeedbjtbS0qKWlxbPe2NjobckAAMBGfHq3Tmtrq6qrq5Wfn//ZAcLDlZ+fr6qqKkmSMUZ33nmnrrvuOk2bNu2c+5w/f77i4uI8C5eAAADo3XwaTo4cOaL29nYlJSV1ak9KSlJ9fb0kafPmzVq9erXWrl2rzMxMZWZm6t133z3jPmfNmqWGhgYtXLhQw4cP1yWXXOLLkgEAgMUE/G6dq6++Wh0dHefd3+FwyOFw6IEHHtADDzygxsZGxcXFnXtDAABgSz49c5KYmKiIiAi53e5O7W63W8nJyT3aN28lBgAgNPg0nERGRmrMmDGqqKjwtHV0dKiiokK5ubk92jdvJQYAIDR4fVnn+PHj2rt3r2e9trZWNTU1SkhI0JAhQ+R0OlVYWKisrCxlZ2dr8eLFam5u9ty9010ul0sul0vt7e092g8AALA2r8PJtm3bNHbsWM+60+mUJBUWFqq8vFxTpkzR4cOHNXv2bNXX1yszM1MbNmw4bZKst4qLi1VcXMycEwAAejmvw0leXp6MMWftU1JSopKSkm4XhdOdemLs/gU3BLkSAAD8K+BvJe4uJsQCABAabBNOmBDrpTlxny4AANiMbcIJAAAIDbYJJ1zWAQAgNNgmnHBZBwCA0GCbcAIAAEKDbcIJl3UAAAgNtgknXNYBACA02CacAACA0EA4AQAAlkI4AQAAlmKbcMKEWAAAQoNtwgkTYgEACA22CScAACA09Al2AQiQz78E8MGDwasDAIBz4MwJAACwFMIJAACwFNuEE+7WOV166bpglwAAgM/ZJpxwtw4AAKHBNuEEAACEBsIJAACwFMIJAACwFMIJAACwlKCEk0mTJmnAgAG69dZbg3H4Xo07eAAAdheUcPLDH/5Qv/vd74JxaAAAYHFBCSd5eXmKiYkJxqEBAIDFeR1OKisrNWHCBKWmpiosLExr1649rY/L5VJ6erqioqKUk5OjLVu2+KJWAAAQArwOJ83NzcrIyJDL5ery89WrV8vpdKqsrEzbt29XRkaGxo0bp0OHDnWrwJaWFjU2NnZaAABA7+V1OCkoKNDjjz+uSZMmdfn5okWLVFRUpOnTp2vEiBFaunSpoqOjtXz58m4VOH/+fMXFxXmWtLS0bu0HAADYg0/nnLS2tqq6ulr5+fmfHSA8XPn5+aqqqurWPmfNmqWGhgbPUldX56tyAQCABfk0nBw5ckTt7e1KSkrq1J6UlKT6+nrPen5+vm677TatX79egwcPPmtwcTgcio2N1e9//3tdccUVuv76631ZMualBLsCAAA66ROMg27cuNHrbYqLi1VcXKzGxkbFxcX5oSoAAGAFPj1zkpiYqIiICLnd7k7tbrdbycnJPdq3y+XSiBEjdPnll/doPwAAwNp8Gk4iIyM1ZswYVVRUeNo6OjpUUVGh3NzcHu27uLhYO3fu1NatW3taJgAAsDCvL+scP35ce/fu9azX1taqpqZGCQkJGjJkiJxOpwoLC5WVlaXs7GwtXrxYzc3Nmj59eo8Kdblccrlcam9v79F+AACAtXkdTrZt26axY8d61p1OpySpsLBQ5eXlmjJlig4fPqzZs2ervr5emZmZ2rBhw2mTZL3FnBMAAEKD1+EkLy9Pxpiz9ikpKVFJSUm3i+oKZ04AAAgNQXm3Tncw5wQAgNBgm3ACAABCg23CCbcSAwAQGmwTTrisAwBAaLBNOAEAAKGBcAIAACzFNuGEOScAAIQG24QT5pwAABAabBNOAABAaCCcAAAAS7FNOGHOSfekl64LdgkAAHjFNuGEOScAAIQG24QTAAAQGggnAADAUggnAADAUggnAADAUmwTTrhbBwCA0NAn2AWcr+LiYhUXF6uhoUHx8fFqbGz0z4FajCSpo+XEp8f43Lqk09o+v36m7c67T4CO3/y5sWtsMWr311gCAPAvp37PGWPO0VMKM+fTy0I++OADpaWlBbsMAADQDXV1dRo8ePBZ+9gunHR0dOjgwYOKiYlRWFiYz/ff2NiotLQ01dXVKTY21uf7x6cY58BhrAODcQ4MxjlwfD3Wxhg1NTUpNTVV4eFnn1Vim8s6p4SHh58zcflCbGwsP/gBwDgHDmMdGIxzYDDOgePLsY6LizuvfraZEAsAAEID4QQAAFgK4eQLHA6HysrK5HA4gl1Kr8Y4Bw5jHRiMc2AwzoETzLG23YRYAADQu3HmBAAAWArhBAAAWArhBAAAWArhBAAAWEpIhhOXy6X09HRFRUUpJydHW7ZsOWv/559/Xl/5ylcUFRWl0aNHa/369QGq1N68Gedly5bpmmuu0YABAzRgwADl5+ef898LPuPtz/Qpq1atUlhYmG6++Wb/FthLeDvOx44dU3FxsVJSUuRwOHTppZfy/4/z4O04L168WMOHD1e/fv2Ulpam+++/X5988kmAqrWnyspKTZgwQampqQoLC9PatWvPuc2mTZv09a9/XQ6HQ5dcconKy8v9V6AJMatWrTKRkZFm+fLl5r333jNFRUUmPj7euN3uLvtv3rzZREREmJ///Odm586d5qc//anp27eveffddwNcub14O8633367cblcZseOHWbXrl3mzjvvNHFxceaDDz4IcOX24+1Yn1JbW2suuugic80115iJEycGplgb83acW1paTFZWlhk/frx58803TW1trdm0aZOpqakJcOX24u04r1ixwjgcDrNixQpTW1tr/vznP5uUlBRz//33B7hye1m/fr15+OGHzZo1a4wk8+KLL561/759+0x0dLRxOp1m586dZsmSJSYiIsJs2LDBL/WFXDjJzs42xcXFnvX29naTmppq5s+f32X/yZMnmxtuuKFTW05Ojrnnnnv8WqfdeTvOX3Ty5EkTExNjnn32WX+V2Gt0Z6xPnjxprrzySvOb3/zGFBYWEk7Og7fj/NRTT5mhQ4ea1tbWQJXYK3g7zsXFxea6667r1OZ0Os1VV13l1zp7k/MJJw899JAZOXJkp7YpU6aYcePG+aWmkLqs09raqurqauXn53vawsPDlZ+fr6qqqi63qaqq6tRfksaNG3fG/ujeOH/RiRMn1NbWpoSEBH+V2St0d6wfffRRDRo0SHfffXcgyrS97ozzSy+9pNzcXBUXFyspKUmjRo3SE088ofb29kCVbTvdGecrr7xS1dXVnks/+/bt0/r16zV+/PiA1BwqAv270HYv/uuJI0eOqL29XUlJSZ3ak5KStHv37i63qa+v77J/fX293+q0u+6M8xf9+Mc/Vmpq6mn/MaCz7oz1m2++qd/+9reqqakJQIXnr6OjQ62trYqKigp2Kafpzjjv27dPr732mqZOnar169dr7969mjlzptra2lRWVhaIsm2nO+N8++2368iRI7r66qtljNHJkyd177336ic/+UkgSg4ZZ/pd2NjYqI8//lj9+vXz6fFC6swJ7GHBggVatWqVXnzxRUv+orKzpqYmTZs2TcuWLVNiYqJfjjFnzhyFhYVp9+7dmjx5smJjYzVw4ED98Ic/7DRJMSwsTCUlJVqxYoVGjhwph8OhDRs2SJL+8Y9/6K677lJSUpIcDodGjhyp5cuXn3asJUuWaOTIkYqOjtaAAQOUlZWllStX+uV7eaujo0ODBg3S008/rTFjxmjKlCl6+OGHtXTp0mCX1qts2rRJTzzxhJ588klt375da9as0bp16/TYY48FuzT0QEidOUlMTFRERITcbnendrfbreTk5C63SU5O9qo/ujfOpyxcuFALFizQxo0bddlll/mzzF7B27H++9//rv3792vChAmeto6ODklSnz59tGfPHg0bNswntU2ePFnp6emaP3++3n77bf3qV7/SRx99pN/97neePq+99pqee+45lZSUKDExUenp6XK73briiis84eXCCy/Un/70J919991qbGzUfffdJ+nTO7x+8IMf6NZbb/UEn//93//VX/7yF91+++0++Q6ndOdnOiUlRX379lVERISn7atf/arq6+vV2tqqyMhIn9bYG3RnnB955BFNmzZN3/3udyVJo0ePVnNzs2bMmKGHH35Y4eH8HdwXzvS7MDY21udnTSSF3t062dnZpqSkxLPe3t5uLrroorNOiL3xxhs7teXm5jIh9hy8HWdjjPnZz35mYmNjTVVVVSBK7DW8GeuPP/7YvPvuu52WiRMnmuuuu868++67pqWlpcf1lJWVGUnmpptu6tQ+c+ZMI8m88847xphPJ+GFh4eb9957r1O/u+++26SkpJgjR450av/2t79t4uLizIkTJ4wxxkycOPG0CXr+5O3P9KxZs8zFF19s2tvbPW2LFy82KSkpfq/Vzrwd569//evmoYce6tS2cuVK069fP3Py5Em/1tpb6DwnxI4aNapT23e+8x2/TYgNuXCyatUq43A4THl5udm5c6eZMWOGiY+PN/X19cYYY6ZNm2ZKS0s9/Tdv3mz69OljFi5caHbt2mXKysq4lfg8eDvOCxYsMJGRkeaFF14wH374oWdpamoK1lewDW/H+ot8fbfOqXDy5z//uVP7rl27jCTPLxlJZuzYsZ36dHR0mPj4eDNjxgxz+PDhTsszzzxjJJk333zTU3dcXJzZsmWLz2o/G2/H+f333zcxMTGmpKTE7Nmzx7z88stm0KBB5vHHHw9IvXbl7TiXlZWZmJgY84c//MHs27fPvPLKK2bYsGFm8uTJwfoKttDU1GR27NhhduzYYSSZRYsWmR07dpgDBw4YY4wpLS0106ZN8/Q/dSvxgw8+aHbt2mVcLhe3EvvakiVLzJAhQ0xkZKTJzs42b7/9tueza6+91hQWFnbq/9xzz5lLL73UREZGmpEjR5p169YFuGJ78macL774YiPptKWsrCzwhduQtz/Tn+evcLJv375O7a2trSY8PNxz1lGSueuuuzr1cbvdXf4cfH5Zs2aNMcaYnTt3mosuushIMpdccomZOXOmJ7j4i7fj/NZbb5mcnBzjcDjM0KFDzbx58/jb/HnwZpzb2trMnDlzzLBhw0xUVJRJS0szM2fONB999FHgC7eR119/vcv/vk6NbWFhobn22mtP2yYzM9NERkaaoUOHmmeeecZv9YUZY4zvLxYBCFVz5szR3LlztW/fPn3pS1/ytJ88eVIOh0NFRUVaunSpwsLCVFxcrF//+teePvX19UpJSdG///u/q7CwsMv9X3bZZRo0aJAkqbm5WS+//LI2bNigP/3pT3K73Zo9e7bmzp3r3y8JwK9CakIsgMD529/+1imc7N27Vx0dHUpPTz/jNhdeeKFiYmLU3t5+XreR9+/fX1OmTNGUKVPU2tqqW265RfPmzdOsWbO40wuwMaYxA/ALl8vVaX3JkiWSpIKCgjNuExERoW9961v64x//qP/7v/877fPDhw97/vzPf/6z02eRkZEaMWKEjDFqa2vrSekAgowzJwD8ora2VjfddJO++c1vqqqqSv/1X/+l22+/XRkZGWfdbsGCBXr99deVk5OjoqIijRgxQkePHtX27du1ceNGHT16VJL0jW98Q8nJybrqqquUlJSkXbt26de//rVuuOEGxcTEBOIrAvATwgkAv1i9erVmz56t0tJS9enTRyUlJfrFL35xzu2SkpK0ZcsWPfroo1qzZo2efPJJDRw4UCNHjtTPfvYzT7977rlHK1as0KJFi3T8+HENHjxYP/jBD/TTn/7Un18LQAAwIRaAT52aEHv48GG/PYUWQO/GnBMAAGAphBMAAGAphBMAAGApzDkBAACWwpkTAABgKba7lbijo0MHDx5UTEyMwsLCgl0OAAA4D8YYNTU1KTU1VeHhZz83YrtwcvDgQaWlpQW7DAAA0A11dXUaPHjwWfvYLpycevJjXV2dYmNjg1xNYDQ3Nys1NVXSp+Gsf//+Qa4IAADvNDY2Ki0t7bye4Gy7cHLqUk5sbGzIhJOIiAjPn2NjYwknAADbOp8pGUyIBQAAlkI4AQAAlkI4AQAAlmK7OScAAPhbR0eHWltbg12GrfTt27fTHMmeIJwAAPA5ra2tqq2tVUdHR7BLsZ34+HglJyf3+DlkhJMupJeukyTtX3BDkCsBAASSMUYffvihIiIilJaWds6HheFTxhidOHFChw4dkiSlpKT0aH+EEwAA/uXkyZM6ceKEUlNTFR0dHexybKVfv36SpEOHDmnQoEE9usRDJAQA4F/a29slSZGRkUGuxJ5OBbq2trYe7YdwAgDAF/Dutu7x1bgRTgAAgKUQTgAAgKUwIRYAgHM4dRdnoIT63aKcOQEAAF06evSopk6dqtjYWMXHx+vuu+/W8ePH/X5cwgkAACHofJ6AO3XqVL333nt69dVX9fLLL6uyslIzZszwe22EEwAAeoGmpiZNnTpV/fv3V0pKin75y18qLy9P9913nyQpPT1djz32mO644w7FxsaeM2Ts2rVLGzZs0G9+8xvl5OTo6quv1pIlS7Rq1SodPHjQr9+FcAIAQC/gdDq1efNmvfTSS3r11Vf1xhtvaPv27Z36LFy4UBkZGdqxY4ceeeSRs+6vqqpK8fHxysrK8rTl5+crPDxcf/nLX/zyHU5hQiwAADbX1NSkZ599VitXrtT1118vSXrmmWeUmpraqd91112nBx544Lz2WV9fr0GDBnVq69OnjxISElRfX++bws+AMycAANjcvn371NbWpuzsbE9bXFychg8f3qnf58+CWFlQzpykp6crNjZW4eHhGjBggF5//fVglAEAQEjp37//efdNTk72vMjvlJMnT+ro0aNKTk72dWmdBO3MyVtvvaWamhqCCQAAPTR06FD17dtXW7du9bQ1NDTor3/9a7f3mZubq2PHjqm6utrT9tprr6mjo0M5OTk9qvdcmHMCAIDNxcTEqLCwUA8++KASEhI0aNAglZWVKTw8vNvvu/nqV7+qb37zmyoqKtLSpUvV1tamkpISffvb3z5tLouveR1OKisr9Ytf/ELV1dX68MMP9eKLL+rmm2/u1MflcukXv/iF6uvrlZGRoSVLlnS6DhYWFqZrr71W4eHhuu+++zR16tQefxEAAPzFDk9sXbRoke69917deOONio2N1UMPPaS6ujpFRUV1e58rVqxQSUmJrr/+eoWHh+tb3/qWfvWrX/mw6q55HU6am5uVkZGhu+66S7fccstpn69evVpOp1NLly5VTk6OFi9erHHjxmnPnj2eWb9vvvmmLrroIn344YfKz8/X6NGjddlll/X82wAAEKJiYmK0YsUKz3pzc7Pmzp3reZ7J/v37vd5nQkKCVq5c6asSz5vX4aSgoEAFBQVn/HzRokUqKirS9OnTJUlLly7VunXrtHz5cpWWlkqSLrroIklSSkqKxo8fr+3bt58xnLS0tKilpcWz3tjY6G3JAAD0ejt27NDu3buVnZ2thoYGPfroo5KkiRMnBrky7/l0Qmxra6uqq6uVn5//2QHCw5Wfn6+qqipJnya5pqYmSdLx48f12muvaeTIkWfc5/z58xUXF+dZ0tLSfFkyAAC9xqmHrOXn56u5uVlvvPGGEhMTu+z7xBNP6IILLuhyOdtJiEDw6YTYI0eOqL29XUlJSZ3ak5KStHv3bkmS2+3WpEmTJEnt7e0qKirS5ZdffsZ9zpo1S06n07Pe2NhIQAEA4Au+9rWvdbqz5lzuvfdeTZ48ucvP+vXr56uyuiXgd+sMHTpU77zzznn3dzgccjgcfqwIAIDQk5CQoISEhGCX0SWfXtZJTExURESE3G53p3a32+33B7YAAIDewafhJDIyUmPGjFFFRYWnraOjQxUVFcrNzfXloQAAQC/l9WWd48ePa+/evZ712tpa1dTUKCEhQUOGDJHT6VRhYaGysrKUnZ2txYsXq7m52XP3DgAAwNl4HU62bdumsWPHetZPTVYtLCxUeXm5pkyZosOHD2v27Nmqr69XZmamNmzYcNokWQAAgK54HU7y8vJkjDlrn5KSEpWUlHS7KAAAELp4tw4AAOcyJy7Ax2sI7PEsJmhvJQYAANY2b948XXnllYqOjlZ8fHzAjks4AQAgBLW2tp5Xn9tuu03f+973AlDRZwgnAAD0Ak1NTZo6dar69++vlJQU/fKXv1ReXp7uu+8+SVJ6eroee+wx3XHHHYqNjfW8EPBs5s6dq/vvv1+jR4/2c/WdEU7OQ3rpOs8CAIAVOZ1Obd68WS+99JJeffVVvfHGG9q+fXunPqfevbNjxw498sgjQar03JgQCwCAzTU1NenZZ5/VypUrdf3110uSnnnmGaWmpnbqd9111+mBBx4IRole4cwJAAA2t2/fPrW1tSk7O9vTFhcXp+HDh3fql5WVFejSuoVwAgBAiOjfv3+wSzgvhBMAAGxu6NCh6tu3r7Zu3eppa2ho0F//+tcgVtV9zDkBAMDmYmJiVFhYqAcffFAJCQkaNGiQysrKFB4errCwsG7v9/3339fRo0f1/vvvq729XTU1NZKkSy65RBdccIGPqj8d4QQAgHOxwRNbFy1apHvvvVc33nijYmNj9dBDD6murk5RUVHd3ufs2bP17LPPeta/9rWvSZJef/115eXl9bTkMyKcAADQC8TExGjFihWe9ebmZs2dO9fzPJP9+/d7vc/y8nKVl5f7qMLzRzgBAKAX2LFjh3bv3q3s7Gw1NDTo0UcflSRNnDgxyJV5jwmxAAD0Eqcespafn6/m5ma98cYbSkxM7LLvE088oQsuuKDLpaCgIMCVd8aZk2469bTY/QtuCHIlAAB8Oh+kurr6vPvfe++9mjx5cpef9evXz1dldQvhBACAEJSQkKCEhIRgl9ElLusAAPAFxphgl2BLvho3wgkAAP8SEREhSWptbQ1yJfZ04sQJSVLfvn17tB8u65zLnDjtj5LSP1kZ7EoAAH7Wp08fRUdH6/Dhw+rbt6/Cw/k7/PkwxujEiRM6dOiQ4uPjPSGvuwgnAAD8S1hYmFJSUlRbW6sDBw4EuxzbiY+PV3Jyco/3QzgBAOBzIiMj9eUvf5lLO17q27dvj8+YnEI46Q4u9QBArxYeHt6jx76jZ7iYBgAALIVwAgAALIXLOj5y6omxEk+NBQCgJwgn/jInTtKn81IIKwAAnD/CiS/8a4KsxCRZAAB6ijknAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnXzQnTvujbg/YsU49SRYAAHyKcAIAACyFcGIBn39pIAAAoY5wAgAALIVwAgAALCXg4eTYsWPKyspSZmamRo0apWXLlgW6BAAAYGF9An3AmJgYVVZWKjo6Ws3NzRo1apRuueUWDRw4MNClBNbn78qZ0xC8OgAAsLiAnzmJiIhQdHS0JKmlpUXGGBljAl0GAACwKK/DSWVlpSZMmKDU1FSFhYVp7dq1p/VxuVxKT09XVFSUcnJytGXLlk6fHzt2TBkZGRo8eLAefPBBJSYmdvsL9Do8+wQAEOK8DifNzc3KyMiQy+Xq8vPVq1fL6XSqrKxM27dvV0ZGhsaNG6dDhw55+sTHx+udd95RbW2tVq5cKbfbfcbjtbS0qLGxsdNid9w6DADAmXkdTgoKCvT4449r0qRJXX6+aNEiFRUVafr06RoxYoSWLl2q6OhoLV++/LS+SUlJysjI0BtvvHHG482fP19xcXGeJS0tzduSAQCAjfh0zklra6uqq6uVn5//2QHCw5Wfn6+qqipJktvtVlNTkySpoaFBlZWVGj58+Bn3OWvWLDU0NHiWuro6X5YMAAAsxqd36xw5ckTt7e1KSkrq1J6UlKTdu3dLkg4cOKAZM2Z4JsJ+//vf1+jRo8+4T4fDIYfD4csyAQCAhQX8VuLs7GzV1NQE+rAAAMAmfHpZJzExUREREadNcHW73UpOTvbloQAAQC/l03ASGRmpMWPGqKKiwtPW0dGhiooK5ebm+vJQvR539AAAQpXXl3WOHz+uvXv3etZra2tVU1OjhIQEDRkyRE6nU4WFhcrKylJ2drYWL16s5uZmTZ8+3aeFAwCA3snrcLJt2zaNHTvWs+50OiVJhYWFKi8v15QpU3T48GHNnj1b9fX1yszM1IYNG06bJAsAANAVr8NJXl7eOR83X1JSopKSkm4XBQAAQlfA360DAABwNoQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKUEJJ5MmTdKAAQN06623BuPwAADAwoISTn74wx/qd7/7XTAODQAALC4o4SQvL08xMTHBODQAALA4r8NJZWWlJkyYoNTUVIWFhWnt2rWn9XG5XEpPT1dUVJRycnK0ZcsWX9QKAABCgNfhpLm5WRkZGXK5XF1+vnr1ajmdTpWVlWn79u3KyMjQuHHjdOjQoR4XG5LmxEnzUoJdBQAAAdPH2w0KCgpUUFBwxs8XLVqkoqIiTZ8+XZK0dOlSrVu3TsuXL1dpaanXBba0tKilpcWz3tjY6PU+AACAffh0zklra6uqq6uVn5//2QHCw5Wfn6+qqqpu7XP+/PmKi4vzLGlpab4qFwAAWJBPw8mRI0fU3t6upKSkTu1JSUmqr6/3rOfn5+u2227T+vXrNXjw4LMGl1mzZqmhocGz1NXV+bJkAABgMV5f1vGFjRs3nndfh8Mhh8Phx2oAAICV+PTMSWJioiIiIuR2uzu1u91uJScn+/JQAACgl/JpOImMjNSYMWNUUVHhaevo6FBFRYVyc3N9eSgAANBLeX1Z5/jx49q7d69nvba2VjU1NUpISNCQIUPkdDpVWFiorKwsZWdna/HixWpubvbcvQMAAHA2XoeTbdu2aezYsZ51p9MpSSosLFR5ebmmTJmiw4cPa/bs2aqvr1dmZqY2bNhw2iRZ9MCcuH/9syG4dQAA4Adeh5O8vDwZY87ap6SkRCUlJd0uCgAAhK6gvFsHAADgTAgnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUvoEuwD4wJy4z/25IXh1AADgA5w5AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlmK7u3WMMZKkxsZG/xyg5dP9d7Sc+PQYn1v3HPcMfc603Xn3OcPxm1s/27axsVHtp/b1hW06tQEAYCGnfs+d+j1+NmHmfHpZyAcffKC0tLRglwEAALqhrq5OgwcPPmsf24WTjo4OHTx4UDExMQoLC/P5/hsbG5WWlqa6ujrFxsb6fP/4FOMcOIx1YDDOgcE4B46vx9oYo6amJqWmpio8/OyzSmx3WSc8PPycicsXYmNj+cEPAMY5cBjrwGCcA4NxDhxfjnVcXNy5O4kJsQAAwGIIJwAAwFIIJ1/gcDhUVlYmh8MR7FJ6NcY5cBjrwGCcA4NxDpxgjrXtJsQCAIDejTMnAADAUggnAADAUggnAADAUggnAADAUggnAADAUkIynLhcLqWnpysqKko5OTnasmXLWfs///zz+spXvqKoqCiNHj1a69evD1Cl9ubNOC9btkzXXHONBgwYoAEDBig/P/+c/17wGW9/pk9ZtWqVwsLCdPPNN/u3wF7C23E+duyYiouLlZKSIofDoUsvvZT/f5wHb8d58eLFGj58uPr166e0tDTdf//9+uSTTwJUrT1VVlZqwoQJSk1NVVhYmNauXXvObTZt2qSvf/3rcjgcuuSSS1ReXu6/Ak2IWbVqlYmMjDTLly837733nikqKjLx8fHG7XZ32X/z5s0mIiLC/PznPzc7d+40P/3pT03fvn3Nu+++G+DK7cXbcb799tuNy+UyO3bsMLt27TJ33nmniYuLMx988EGAK7cfb8f6lNraWnPRRReZa665xkycODEwxdqYt+Pc0tJisrKyzPjx482bb75pamtrzaZNm0xNTU2AK7cXb8d5xYoVxuFwmBUrVpja2lrz5z//2aSkpJj7778/wJXby/r1683DDz9s1qxZYySZF1988az99+3bZ6Kjo43T6TQ7d+40S5YsMREREWbDhg1+qS/kwkl2drYpLi72rLe3t5vU1FQzf/78LvtPnjzZ3HDDDZ3acnJyzD333OPXOu3O23H+opMnT5qYmBjz7LPP+qvEXqM7Y33y5Elz5ZVXmt/85jemsLCQcHIevB3np556ygwdOtS0trYGqsRewdtxLi4uNtddd12nNqfTaa666iq/1tmbnE84eeihh8zIkSM7tU2ZMsWMGzfOLzWF1GWd1tZWVVdXKz8/39MWHh6u/Px8VVVVdblNVVVVp/6SNG7cuDP2R/fG+YtOnDihtrY2JSQk+KvMXqG7Y/3oo49q0KBBuvvuuwNRpu11Z5xfeukl5ebmqri4WElJSRo1apSeeOIJtbe3B6ps2+nOOF955ZWqrq72XPrZt2+f1q9fr/Hjxwek5lAR6N+FtnsrcU8cOXJE7e3tSkpK6tSelJSk3bt3d7lNfX19l/3r6+v9VqfddWecv+jHP/6xUlNTT/uPAZ11Z6zffPNN/fa3v1VNTU0AKuwdujPO+/bt02uvvaapU6dq/fr12rt3r2bOnKm2tjaVlZUFomzb6c4433777Tpy5IiuvvpqGWN08uRJ3XvvvfrJT34SiJJDxpl+FzY2Nurjjz9Wv379fHq8kDpzAntYsGCBVq1apRdffFFRUVHBLqdXaWpq0rRp07Rs2TIlJiYGu5xeraOjQ4MGDdLTTz+tMWPGaMqUKXr44Ye1dOnSYJfWq2zatElPPPGEnnzySW3fvl1r1qzRunXr9NhjjwW7NPRASJ05SUxMVEREhNxud6d2t9ut5OTkLrdJTk72qj+6N86nLFy4UAsWLNDGjRt12WWX+bPMXsHbsf773/+u/fv3a8KECZ62jo4OSVKfPn20Z88eDRs2zL9F21B3fqZTUlLUt29fRUREeNq++tWvqr6+Xq2trYqMjPRrzXbUnXF+5JFHNG3aNH33u9+VJI0ePVrNzc2aMWOGHn74YYWH83dwXzjT78LY2FifnzWRQuzMSWRkpMaMGaOKigpPW0dHhyoqKpSbm9vlNrm5uZ36S9Krr756xv7o3jhL0s9//nM99thj2rBhg7KysgJRqu15O9Zf+cpX9O6776qmpsaz3HTTTRo7dqxqamqUlpYWyPJtozs/01dddZX27t3rCX+S9Ne//lUpKSkEkzPozjifOHHitAByKhAa3mvrMwH/XeiXabYWtmrVKuNwOEx5ebnZuXOnmTFjhomPjzf19fXGGGOmTZtmSktLPf03b95s+vTpYxYuXGh27dplysrKuJX4PHg7zgsWLDCRkZHmhRdeMB9++KFnaWpqCtZXsA1vx/qLuFvn/Hg7zu+//76JiYkxJSUlZs+ePebll182gwYNMo8//niwvoIteDvOZWVlJiYmxvzhD38w+/btM6+88ooZNmyYmTx5crC+gi00NTWZHTt2mB07dhhJZtGiRWbHjh3mwIEDxhhjSktLzbRp0zz9T91K/OCDD5pdu3YZl8vFrcS+tmTJEjNkyBATGRlpsrOzzdtvv+357NprrzWFhYWd+j/33HPm0ksvNZGRkWbkyJFm3bp1Aa7YnrwZ54svvthIOm0pKysLfOE25O3P9OcRTs6ft+P81ltvmZycHONwOMzQoUPNvHnzzMmTJwNctf14M85tbW1mzpw5ZtiwYSYqKsqkpaWZmTNnmo8++ijwhdvI66+/3uX/c0+NbWFhobn22mtP2yYzM9NERkaaoUOHmmeeecZv9YUZw3kvAABgHSE15wQAAFgf4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFjK/wPDpziyNysgMgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 839\n", "item counter : 874\n", "ratio : 0.9588571428571429\n", " ratio number predicted/items: 0.07771428571428571\n", "current epoch: 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 846\n", "item counter : 865\n", "ratio : 0.976905311778291\n", " ratio number predicted/items: 0.03348729792147806\n", "current epoch: 2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 846\n", "item counter : 887\n", "ratio : 0.9527027027027027\n", " ratio number predicted/items: 0.06644144144144144\n", "current epoch: 3\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 845\n", "item counter : 927\n", "ratio : 0.9105603448275862\n", " ratio number predicted/items: 0.11422413793103449\n", "current epoch: 4\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 845\n", "item counter : 937\n", "ratio : 0.9008528784648188\n", " ratio number predicted/items: 0.1162046908315565\n", "current epoch: 5\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 845\n", "item counter : 951\n", "ratio : 0.8876050420168067\n", " ratio number predicted/items: 0.13130252100840337\n", "current epoch: 6\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 845\n", "item counter : 853\n", "ratio : 0.9894613583138173\n", " ratio number predicted/items: 0.00936768149882904\n", "current epoch: 7\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 845\n", "item counter : 897\n", "ratio : 0.9409799554565702\n", " ratio number predicted/items: 0.0645879732739421\n", "current epoch: 8\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=10` reached.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 845\n", "item counter : 854\n", "ratio : 0.9883040935672515\n", " ratio number predicted/items: 0.011695906432748537\n", "current epoch: 9\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "-----------------------------------------------------\n", "0 | net | SmallNet | 514 \n", "1 | sym_preprocess | SymPreprocess | 8.5 M \n", "2 | bcewll | BCEWithLogitsLoss | 0 \n", "3 | auroc | BinaryAUROC | 0 \n", "-----------------------------------------------------\n", "514 Trainable params\n", "8.5 M Non-trainable params\n", "8.5 M Total params\n", "34.014 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGzCAYAAAD0T7cVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAvhklEQVR4nO3de3RU5b3/8c8kkAkkmcQQSTIQjKCiQQUFkuJlCZLTFBUo1YKFgylakBJO1bikUJSAcqtHKUccZamF4DmxqBRZHkREEBaKUQoEj8pFMQEjmAAVchmU3J7fH/6YOhKQCXPZk7xfa81a7Gee2fs7Xwfnw76NzRhjBAAAYBERoS4AAADghwgnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAADAUggnAEKqsLBQNptN27ZtC3UpACyCcAIAACyFcAIAACyFcAIAACyFcAIgIA4cOKBJkyapZ8+e6tChgzp16qRf//rX2r9/f7PzT5w4oXvvvVedOnWSw+HQXXfdpWPHjnnN2bZtm3JycpSUlKQOHTro4osv1t133x2EdwMgmNqFugAArdM//vEPvf/++7rzzjvVtWtX7d+/X88++6wGDhyoXbt2qWPHjl7zJ0+erISEBM2cOVN79+7Vs88+qwMHDmjTpk2y2Ww6fPiwfv7zn+vCCy/U1KlTlZCQoP3792vlypUheocAAoVwAiAgbr31Vt1xxx1eY0OHDtWAAQP097//XWPHjvV6LioqShs2bFD79u0lSRdddJGmTJmi//3f/9WwYcP0/vvv69ixY1q3bp369evned3s2bMD/2YABBWHdQAERIcOHTx/rq+v1z//+U9dcsklSkhI0I4dO06bP2HCBE8wkaTf//73ateundasWSNJSkhIkCStXr1a9fX1gS0eQEgRTgAExLfffqsZM2YoLS1NdrtdSUlJuvDCC3X8+HFVVVWdNv/SSy/1Wo6NjVVqaqrnHJWbbrpJt99+u2bNmqWkpCQNHz5cS5cu1cmTJ4PxdgAEEeEEQED8x3/8h+bMmaORI0fqlVde0bp16/T222+rU6dOampq8nl9NptNK1asUHFxsSZPnqyDBw/q7rvvVt++fVVbWxuAdwAgVAgnAAJixYoVys3N1ZNPPqk77rhD//Zv/6YbbrhBx48fb3b+559/7rVcW1urr7/+Wunp6V7jP/vZzzRnzhxt27ZNRUVF+vTTT7V8+fIAvQsAoUA4ARAQkZGRMsZ4jS1atEiNjY3Nzn/uuee8ziV59tln1dDQoCFDhkiSjh07dtr6+vTpI0kc2gFaGa7WARAQt912m/77v/9b8fHxysjIUHFxsdavX69OnTo1O7+urk6DBw/WyJEjtXfvXj3zzDO64YYbNGzYMEnSsmXL9Mwzz2jEiBHq0aOHampq9Pzzz8vhcOiWW24J5lsDEGCEEwAB8V//9V+KjIxUUVGRvvvuO11//fVav369cnJymp3/9NNPq6ioSDNmzFB9fb1+85vf6KmnnpLNZpP0/QmxW7du1fLly1VZWan4+HhlZmaqqKhIF198cTDfGoAAs5kf7ycFAAAIIc45AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlkI4AQAAlhJ29zlpamrSoUOHFBcX57n/AQAAsDZjjGpqauR0OhURcfZ9I2EXTg4dOqS0tLRQlwEAAFqgvLxcXbt2PeucsAsncXFxkr5/cw6Hw6/rdrvdcjqdkr4PQTExMX5dPwAAbVV1dbXS0tI83+NnE5JwMmLECG3atEmDBw/WihUrfHrtqUM5DofD7+EkMjLS82eHw0E4AQDAz87llIyQnBB733336cUXXwzFpgEAgMWFJJwMHDjwnHbrAACAtsfncLJ582YNHTpUTqdTNptNq1atOm2Oy+VSenq6oqOjlZWVpa1bt/qjVgAA0Ab4HE7cbrd69+4tl8vV7PMvv/yy8vPzVVBQoB07dqh3797KycnR4cOHW1TgyZMnVV1d7fUAAACtl8/hZMiQIZo9e7ZGjBjR7PMLFizQ+PHjNW7cOGVkZGjx4sXq2LGjlixZ0qIC582bp/j4eM+Dy4gBAGjd/HrOSV1dnbZv367s7Ox/bSAiQtnZ2SouLm7ROqdNm6aqqirPo7y83F/lAgAAC/LrpcRHjx5VY2OjkpOTvcaTk5O1Z88ez3J2drY++ugjud1ude3aVa+++qoGDBjQ7Drtdrvsdrs/ywQAABYWkvucrF+/PhSbBQAAYcCvh3WSkpIUGRmpyspKr/HKykqlpKT4c1MAAKCV8ms4iYqKUt++fbVhwwbPWFNTkzZs2HDGwzYAAAA/5PNhndraWu3bt8+zXFZWpp07dyoxMVHdunVTfn6+cnNz1a9fP2VmZmrhwoVyu90aN26cXwsHAACtk8/hZNu2bRo0aJBnOT8/X5KUm5urwsJCjRo1SkeOHNGMGTNUUVGhPn36aO3ataedJOsrl8sll8ulxsbG81oPAACwNpsxxoS6CF9UV1crPj5eVVVVAflV4tjYWEnf7yHih/8AAPAPX76/Q/LbOgAAAGdCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJYSNuHE5XIpIyND/fv3D3UpAAAggLjPyQ9wnxMAAAKD+5wAAICwRTgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWEjbhhJuwAQDQNnATth/gJmwAAAQGN2EDAABhi3ACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAshXACAAAsJWzCCXeIBQCgbeAOsT/AHWIBAAgM7hALAADCFuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYCuEEAABYStiEE35bBwCAtoHf1vkBflsHAIDA4Ld1AABA2CKcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASyGcAAAASwmbcOJyuZSRkaH+/fuHuhQAABBANmOMCXURvvDlJ5d95Xa7FRsbK0mqra1VTEyMX9cPAEBb5cv3d9jsOQEAAG0D4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFhK2IQTl8uljIwM9e/fP9SlAACAALIZY0yoi/BFdXW14uPjVVVVJYfD4dd1u91uxcbGSpJqa2sVExPj1/UDANBW+fL9HTZ7TgAAQNtAOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJZCOAEAAJYSNuHE5XIpIyND/fv3D3UpAAAggGzGGBPqInxRXV2t+Ph4VVVVyeFw+HXdbrdbsbGxkqTa2lrFxMT4df0AALRVvnx/h82eEwAA0DYQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKUQTgAAgKWEJJysXr1aPXv21KWXXqoXXnghFCUAAACLahfsDTY0NCg/P18bN25UfHy8+vbtqxEjRqhTp07BLgUAAFhQ0PecbN26Vb169VKXLl0UGxurIUOGaN26dcEuAwAAWJTP4WTz5s0aOnSonE6nbDabVq1addocl8ul9PR0RUdHKysrS1u3bvU8d+jQIXXp0sWz3KVLFx08eLBl1QMAgFbH53DidrvVu3dvuVyuZp9/+eWXlZ+fr4KCAu3YsUO9e/dWTk6ODh8+fN7FAgCA1s/ncDJkyBDNnj1bI0aMaPb5BQsWaPz48Ro3bpwyMjK0ePFidezYUUuWLJEkOZ1Orz0lBw8elNPpPOP2Tp48qerqaq8HAABovfx6zkldXZ22b9+u7Ozsf20gIkLZ2dkqLi6WJGVmZuqTTz7RwYMHVVtbqzfffFM5OTlnXOe8efMUHx/veaSlpfmzZAAAYDF+DSdHjx5VY2OjkpOTvcaTk5NVUVEhSWrXrp2efPJJDRo0SH369NGDDz541it1pk2bpqqqKs+jvLzcnyUDAACLCfqlxJI0bNgwDRs27Jzm2u122e32AFcEAACswq97TpKSkhQZGanKykqv8crKSqWkpPhzUwAAoJXyaziJiopS3759tWHDBs9YU1OTNmzYoAEDBvhzUwAAoJXy+bBObW2t9u3b51kuKyvTzp07lZiYqG7duik/P1+5ubnq16+fMjMztXDhQrndbo0bN86vhQMAgNbJ53Cybds2DRo0yLOcn58vScrNzVVhYaFGjRqlI0eOaMaMGaqoqFCfPn20du3a006SBQAAaI7NGGNCXcS5cLlccrlcamho0Oeff67y8nI5HA6/bsPtdnvuuXLo0CHFxMT4df0AALRV1dXVSktL0/HjxxUfH3/WuWETTk756quvuNcJAABhqry8XF27dj3rnLALJ01NTTp06JDi4uJks9n8vv5TyS4Qe2bwL/Q5eOh1cNDn4KDPwePvXhtjVFNTI6fTqYiIs1+PE5L7nJyPiIiIn0xc/uBwOPjgBwF9Dh56HRz0OTjoc/D4s9c/dTjnFL9eSgwAAHC+CCcAAMBSCCc/YrfbVVBQwC3zA4w+Bw+9Dg76HBz0OXhC2euwOyEWAAC0buw5AQAAlkI4AQAAlkI4AQAAlkI4AQAAltImw4nL5VJ6erqio6OVlZWlrVu3nnX+q6++qssvv1zR0dG66qqrtGbNmiBVGt586fPzzz+vG2+8URdccIEuuOACZWdn/+R/F3zP18/zKcuXL5fNZtMvf/nLwBbYivja6+PHjysvL0+pqamy2+267LLL+P/HOfC1zwsXLlTPnj3VoUMHpaWl6YEHHtB3330XpGrD0+bNmzV06FA5nU7ZbDatWrXqJ1+zadMmXXvttbLb7brkkktUWFgYuAJNG7N8+XITFRVllixZYj799FMzfvx4k5CQYCorK5udv2XLFhMZGWkef/xxs2vXLvPwww+b9u3bm48//jjIlYcXX/s8evRo43K5TElJidm9e7f57W9/a+Lj481XX30V5MrDi699PqWsrMx06dLF3HjjjWb48OHBKTbM+drrkydPmn79+plbbrnFvPfee6asrMxs2rTJ7Ny5M8iVhxdf+1xUVGTsdrspKioyZWVl5q233jKpqanmgQceCHLl4WXNmjVm+vTpZuXKlUaSee211846v7S01HTs2NHk5+ebXbt2mUWLFpnIyEizdu3agNTX5sJJZmamycvL8yw3NjYap9Np5s2b1+z8kSNHmltvvdVrLCsry9x7770BrTPc+drnH2toaDBxcXFm2bJlgSqxVWhJnxsaGsx1111nXnjhBZObm0s4OUe+9vrZZ5813bt3N3V1dcEqsVXwtc95eXnm5ptv9hrLz883119/fUDrbE3OJZxMmTLF9OrVy2ts1KhRJicnJyA1tanDOnV1ddq+fbuys7M9YxEREcrOzlZxcXGzrykuLvaaL0k5OTlnnI+W9fnHTpw4ofr6eiUmJgaqzLDX0j4/+uij6ty5s+65555glNkqtKTXr7/+ugYMGKC8vDwlJyfryiuv1Ny5c9XY2BisssNOS/p83XXXafv27Z5DP6WlpVqzZo1uueWWoNTcVgT7uzDsfvjvfBw9elSNjY1KTk72Gk9OTtaePXuafU1FRUWz8ysqKgJWZ7hrSZ9/7I9//KOcTudpfxnwLy3p83vvvae//vWv2rlzZxAq9E1TU5Pq6uoUHR0d6lJO05Jel5aW6p133tGYMWO0Zs0a7du3T5MmTVJ9fb0KCgqCUXbYaUmfR48eraNHj+qGG26QMUYNDQ2aOHGi/vSnPwWj5DbjTN+F1dXV+vbbb9WhQwe/bq9N7TlBeJg/f76WL1+u1157zZJfVOGqpqZGY8eO1fPPP6+kpKSAbWfmzJmy2Wzas2ePRo4cKYfDoU6dOum+++7zOknRZrNp8uTJKioqUq9evWS327V27VpJ0sGDB3X33XcrOTlZdrtdvXr10pIlS07b1qJFi9SrVy917NhRF1xwgfr166eXXnopYO/NF01NTercubOee+459e3bV6NGjdL06dO1ePHiUJfWqmzatElz587VM888ox07dmjlypV644039Nhjj4W6NJyHNrXnJCkpSZGRkaqsrPQar6ysVEpKSrOvSUlJ8Wk+WtbnU5544gnNnz9f69ev19VXXx3IMsOer33+4osvtH//fg0dOtQz1tTUJElq166d9u7dqx49evitvpEjRyo9PV3z5s3TBx98oKeeekrHjh3Tiy++6Jnzzjvv6JVXXtHkyZOVlJSk9PR0VVZW6mc/+5knvFx44YV68803dc8996i6ulr333+/pO+v8PrDH/6gO+64wxN8/u///k8ffvihRo8e7bf3IbXsM52amqr27dsrMjLSM3bFFVeooqJCdXV1ioqK8muNrUFL+vzII49o7Nix+t3vfidJuuqqq+R2uzVhwgRNnz5dERH8G9wfzvRd6HA4/L7XRFLbu1onMzPTTJ482bPc2NhounTpctYTYm+77TavsQEDBnBC7E/wtc/GGPPnP//ZOBwOU1xcHIwSWwVf+vztt9+ajz/+2OsxfPhwc/PNN5uPP/7YnDx50i81FRQUGElm2LBhXuOTJk0yksxHH31kjPn+JLyIiAjz6aefes275557TGpqqjl69KjX+J133mni4+PNiRMnjDHGDB8+/LQT9ALJ18/0tGnTzEUXXWQaGxs9YwsXLjSpqakBrzWc+drna6+91kyZMsVr7KWXXjIdOnQwDQ0NAa21tdA5nhB75ZVXeo395je/CdgJsW0unCxfvtzY7XZTWFhodu3aZSZMmGASEhJMRUWFMcaYsWPHmqlTp3rmb9myxbRr18488cQTZvfu3aagoIBLic+Br32eP3++iYqKMitWrDBff/2151FTUxOqtxAWfO3zjwXiap1T4eStt97yGt+9e7eR5PmSkWQGDRrkNaepqckkJCSYCRMmmCNHjng9li5daiSZ9957z1N7fHy82bp1q1/rPxNfe/3ll1+auLg4M3nyZLN3716zevVq07lzZzN79uyg1BuufO1zQUGBiYuLM3/7299MaWmpWbdunenRo4cZOXJkqN5CWKipqTElJSWmpKTESDILFiwwJSUl5sCBA8YYY6ZOnWrGjh3rmX/qUuKHHnrI7N6927hcLi4l9rdFixaZbt26maioKJOZmWk++OADz3M33XSTyc3N9Zr/yiuvmMsuu8xERUWZXr16mTfeeCPIFYcnX/p80UUXGUmnPQoKCoJfeJjx9fP8Q4EMJ6WlpV7jdXV1JiIiwrPXUZK5++67veZUVlY2+zn44WPlypXGGGN27dplunTpYiSZSy65xEyaNMkTXALF116///77Jisry9jtdtO9e3czZ84c/jV/Dnzpc319vZk5c6bp0aOHiY6ONmlpaWbSpEnm2LFjwS88jGzcuLHZv1+nepubm2tuuumm017Tp08fExUVZbp3726WLl0asPpsxhjj/4NFANqqmTNnatasWSotLdXFF1/sGW9oaJDdbtf48eO1ePFi2Ww25eXl6emnn/bMqaioUGpqqv793/9dubm5za7/6quvVufOnSVJbrdbq1ev1tq1a/Xmm2+qsrJSM2bM0KxZswL7JgEEVJs6IRZA8Hz++ede4WTfvn1qampSenr6GV9z4YUXKi4uTo2Njed0GXlMTIxGjRqlUaNGqa6uTr/61a80Z84cTZs2jSu9gDDGacwAAsLlcnktL1q0SJI0ZMiQM74mMjJSt99+u/7+97/rk08+Oe35I0eOeP78z3/+0+u5qKgoZWRkyBij+vr68ykdQIix5wRAQJSVlWnYsGH6xS9+oeLiYv3P//yPRo8erd69e5/1dfPnz9fGjRuVlZWl8ePHKyMjQ99884127Nih9evX65tvvpEk/fznP1dKSoquv/56JScna/fu3Xr66ad16623Ki4uLhhvEUCAEE4ABMTLL7+sGTNmaOrUqWrXrp0mT56s//zP//zJ1yUnJ2vr1q169NFHtXLlSj3zzDPq1KmTevXqpT//+c+eeffee6+Kioq0YMEC1dbWqmvXrvrDH/6ghx9+OJBvC0AQcEIsAL86dULskSNHAnonWgCtF+ecAAAASyGcAAAASyGcAAAAS+GcEwAAYCnsOQEAAJYSdpcSNzU16dChQ4qLi5PNZgt1OQAA4BwYY1RTUyOn06mIiLPvGwm7cHLo0CGlpaWFugwAANAC5eXl6tq161nnhF04OXXnx/LycjkcDr+u2+12y+l0Svo+BMXExPh1/QAAtFXV1dVKS0s7pzs4hyScjBgxQps2bdLgwYO1YsUKn1576lCOw+HweziJjIz0/NnhcBBOAADws3M5JSMkJ8Ted999evHFF0OxaQAAYHEhCScDBw7kh7kAAECzfA4nmzdv1tChQ+V0OmWz2bRq1arT5rhcLqWnpys6OlpZWVnaunWrP2oFAABtgM/nnLjdbvXu3Vt33323fvWrX532/Msvv6z8/HwtXrxYWVlZWrhwoXJycrR371517tzZL0UDABBITU1NqqurC3UZYaV9+/Ze526eD5/DyZAhQzRkyJAzPr9gwQKNHz9e48aNkyQtXrxYb7zxhpYsWaKpU6f6XODJkyd18uRJz3J1dbXP6wAA4FzV1dWprKxMTU1NoS4l7CQkJCglJeW870Pm16t16urqtH37dk2bNs0zFhERoezsbBUXF7donfPmzdOsWbP8VSIAAGdkjNHXX3+tyMhIpaWl/eTNwvA9Y4xOnDihw4cPS5JSU1PPa31+DSdHjx5VY2OjkpOTvcaTk5O1Z88ez3J2drY++ugjud1ude3aVa+++qoGDBjQ7DqnTZum/Px8z/Kp66QBAPC3hoYGnThxQk6nUx07dgx1OWGlQ4cOkqTDhw+rc+fO53WIJyT3OVm/fv05z7Xb7bLb7QGsBgCA7zU2NkqSoqKiQlxJeDoV6Orr688rnPh1f1VSUpIiIyNVWVnpNV5ZWamUlBR/bgoAgIDht9taxl9982s4iYqKUt++fbVhwwbPWFNTkzZs2HDGwzYAAAA/5PNhndraWu3bt8+zXFZWpp07dyoxMVHdunVTfn6+cnNz1a9fP2VmZmrhwoVyu92eq3cAAADOxudwsm3bNg0aNMizfOpk1dzcXBUWFmrUqFE6cuSIZsyYoYqKCvXp00dr16497SRZAADCRfrUN4K6vf3zbw3q9qzG58M6AwcOlDHmtEdhYaFnzuTJk3XgwAGdPHlSH374obKyss67UJfLpYyMDPXv3/+81wUAAH7aN998ozFjxsjhcCghIUH33HOPamtrA77dsLmAOy8vT7t27dI//vGPUJcCAEDYO5c74I4ZM0affvqp3n77ba1evVqbN2/WhAkTAl5b2IQTAABwZjU1NRozZoxiYmKUmpqqv/zlLxo4cKDuv/9+SVJ6eroee+wx3XXXXXI4HD8ZMnbv3q21a9fqhRdeUFZWlm644QYtWrRIy5cv16FDhwL6XggnAAC0Avn5+dqyZYtef/11vf3223r33Xe1Y8cOrzlPPPGEevfurZKSEj3yyCNnXV9xcbESEhLUr18/z1h2drYiIiL04YcfBuQ9nBKSm7ABAAD/qamp0bJly/TSSy9p8ODBkqSlS5fK6XR6zbv55pv14IMPntM6KyoqTvvB3nbt2ikxMVEVFRX+KfwM2HMCAECYKy0tVX19vTIzMz1j8fHx6tmzp9e8H+4FsTLCCQAAbURMTMw5z01JSfH8kN8pDQ0N+uabbwJ+13fCCQAAYa579+5q37691xWtVVVV+uyzz1q8zgEDBuj48ePavn27Z+ydd95RU1OTX24RcjZhc86Jy+WSy+Xy/CgTAAD4XlxcnHJzc/XQQw8pMTFRnTt3VkFBgSIiIlr8ezdXXHGFfvGLX2j8+PFavHix6uvrNXnyZN15552nncvib2ETTvLy8pSXl6fq6mrFx8eHuhwAQBsSDndsXbBggSZOnKjbbrtNDodDU6ZMUXl5uaKjo1u8zqKiIk2ePFmDBw9WRESEbr/9dj311FN+rLp5YRNOAADAmcXFxamoqMiz7Ha7NWvWLM/9TPbv3+/zOhMTE/XSSy/5q8RzRjgBAKAVKCkp0Z49e5SZmamqqio9+uijkqThw4eHuDLfcUIsAACtxKmbrGVnZ8vtduvdd99VUlJSs3Pnzp2r2NjYZh9DhgwJcuXe2HMCAEArcM0113hdWfNTJk6cqJEjRzb7XIcOHfxVVosQTgAAaIMSExOVmJgY6jKaxWEdAABgKYQTAABgKWETTlwulzIyMtS/f/9QlwIAAAIobMJJXl6edu3a5XVrXgAA0PqETTgBAABtA1frAADwU2YG+WdTZlYFd3sWw54TAADQrDlz5ui6665Tx44dlZCQELTtEk4AAGiD6urqzmnOr3/9a/3+978PQkX/QjgBAKAVqKmp0ZgxYxQTE6PU1FT95S9/0cCBA3X//fdLktLT0/XYY4/prrvuksPh8Pwg4NnMmjVLDzzwgK666qoAV++NcAIAQCuQn5+vLVu26PXXX9fbb7+td999Vzt27PCac+q3d0pKSvTII4+EqNKfxgmxAACEuZqaGi1btkwvvfSSBg8eLElaunSpnE6n17ybb75ZDz74YChK9Al7TgAACHOlpaWqr69XZmamZyw+Pl49e/b0mtevX79gl9YiYRNOuEMsAADnJyYmJtQlnJOwCSfcIRYAgOZ1795d7du39/qOrKqq0meffRbCqlqOc04AAAhzcXFxys3N1UMPPaTExER17txZBQUFioiIkM1ma/F6v/zyS33zzTf68ssv1djYqJ07d0qSLrnkEsXGxvqp+tMRTgAA+ClhcMfWBQsWaOLEibrtttvkcDg0ZcoUlZeXKzo6usXrnDFjhpYtW+ZZvuaaayRJGzdu1MCBA8+35DMinAAA0ArExcWpqKjIs+x2uzVr1izP/Uz279/v8zoLCwtVWFjopwrPHeEEAIBWoKSkRHv27FFmZqaqqqr06KOPSpKGDx8e4sp8FzYnxAIAgLM7dZO17Oxsud1uvfvuu0pKSmp27ty5cxUbG9vsY8iQIUGu3Bt7TgAAaAWuueYabd++/ZznT5w4USNHjmz2uQ4dOvirrBYhnAAA0AYlJiYqMTEx1GU0i8M6AAD8iDEm1CWEJX/1jXACAMD/FxkZKUmqq6sLcSXh6cSJE5Kk9u3bn9d6OKwDAMD/165dO3Xs2FFHjhxR+/btFRHBv+HPhTFGJ06c0OHDh5WQkOAJeS0VNuHE5XLJ5XKpsbEx1KUAAFopm82m1NRUlZWV6cCBA6EuJ+wkJCQoJSXlvNdjM2F2YK26ulrx8fGqqqqSw+Hw67rdbrfndry1tbVh8wNJAAD/ampq4tCOj9q3b3/WPSa+fH+HzZ4TAACCJSIi4rxu+47zw8E0AABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKYQTAABgKWETTlwulzIyMtS/f/9QlwIAAALIZowxoS7CF7785LKv3G63YmNjJUm1tbWKiYnx6/oBAGirfPn+Dps9JwAAoG0gnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEshnAAAAEsJm3DicrmUkZGh/v37h7oUAAAQQDZjjAl1Eb6orq5WfHy8qqqq5HA4/Lput9ut2NhYSVJtba1iYmL8un4AANoqX76/w2bPCQAAaBsIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFIIJwAAwFLCJpy4XC5lZGSof//+oS4FAAAEkM0YY0JdhC+qq6sVHx+vqqoqORwOv67b7XYrNjZWklRbW6uYmBi/rh8AgLbKl+/vsNlzAgAA2gbCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsJSQhJPVq1erZ8+euvTSS/XCCy+EogQAAGBR7YK9wYaGBuXn52vjxo2Kj49X3759NWLECHXq1CnYpQAAAAsK+p6TrVu3qlevXurSpYtiY2M1ZMgQrVu3LthlAAAAi/I5nGzevFlDhw6V0+mUzWbTqlWrTpvjcrmUnp6u6OhoZWVlaevWrZ7nDh06pC5duniWu3TpooMHD7asegAA0Or4HE7cbrd69+4tl8vV7PMvv/yy8vPzVVBQoB07dqh3797KycnR4cOHz7tYAADQ+vkcToYMGaLZs2drxIgRzT6/YMECjR8/XuPGjVNGRoYWL16sjh07asmSJZIkp9Pptafk4MGDcjqdZ9zeyZMnVV1d7fUAAACtl1/POamrq9P27duVnZ39rw1ERCg7O1vFxcWSpMzMTH3yySc6ePCgamtr9eabbyonJ+eM65w3b57i4+M9j7S0NH+WDAAALMav4eTo0aNqbGxUcnKy13hycrIqKiokSe3atdOTTz6pQYMGqU+fPnrwwQfPeqXOtGnTVFVV5XmUl5f7s2QAAGAxQb+UWJKGDRumYcOGndNcu90uu90e4IoAAIBV+HXPSVJSkiIjI1VZWek1XllZqZSUFH9uCgAAtFJ+DSdRUVHq27evNmzY4BlramrShg0bNGDAAH9uCgAAtFI+H9apra3Vvn37PMtlZWXauXOnEhMT1a1bN+Xn5ys3N1f9+vVTZmamFi5cKLfbrXHjxvm1cAAA0Dr5HE62bdumQYMGeZbz8/MlSbm5uSosLNSoUaN05MgRzZgxQxUVFerTp4/Wrl172kmyLWWMkaSAXFLsdrs9f66urlZjY6PftwEAQFt06nv71Pf42djMucyyAJfLJZfLpbq6On3xxRehLgcAALRAeXm5unbtetY5YRNOTmlqatKhQ4cUFxcnm83m9/VXV1crLS1N5eXlcjgcfl8/vkefg4deBwd9Dg76HDz+7rUxRjU1NXI6nYqIOPspryG5lPh8RERE/GTi8geHw8EHPwjoc/DQ6+Cgz8FBn4PHn72Oj48/p3lB/1ViAACAsyGcAAAASyGc/IjdbldBQQF3pQ0w+hw89Do46HNw0OfgCWWvw+6EWAAA0Lqx5wQAAFgK4QQAAFgK4QQAAFgK4QQAAFgK4QQAAFhKmwwnLpdL6enpio6OVlZWlrZu3XrW+a+++qouv/xyRUdH66qrrtKaNWuCVGl486XPzz//vG688UZdcMEFuuCCC5Sdnf2T/13wPV8/z6csX75cNptNv/zlLwNbYCvia6+PHz+uvLw8paamym6367LLLuP/H+fA1z4vXLhQPXv2VIcOHZSWlqYHHnhA3333XZCqDU+bN2/W0KFD5XQ6ZbPZtGrVqp98zaZNm3TttdfKbrfrkksuUWFhYeAKNG3M8uXLTVRUlFmyZIn59NNPzfjx401CQoKprKxsdv6WLVtMZGSkefzxx82uXbvMww8/bNq3b28+/vjjIFceXnzt8+jRo43L5TIlJSVm9+7d5re//a2Jj483X331VZArDy++9vmUsrIy06VLF3PjjTea4cOHB6fYMOdrr0+ePGn69etnbrnlFvPee++ZsrIys2nTJrNz584gVx5efO1zUVGRsdvtpqioyJSVlZm33nrLpKammgceeCDIlYeXNWvWmOnTp5uVK1caSea111476/zS0lLTsWNHk5+fb3bt2mUWLVpkIiMjzdq1awNSX5sLJ5mZmSYvL8+z3NjYaJxOp5k3b16z80eOHGluvfVWr7GsrCxz7733BrTOcOdrn3+soaHBxMXFmWXLlgWqxFahJX1uaGgw1113nXnhhRdMbm4u4eQc+drrZ5991nTv3t3U1dUFq8RWwdc+5+XlmZtvvtlrLD8/31x//fUBrbM1OZdwMmXKFNOrVy+vsVGjRpmcnJyA1NSmDuvU1dVp+/btys7O9oxFREQoOztbxcXFzb6muLjYa74k5eTknHE+WtbnHztx4oTq6+uVmJgYqDLDXkv7/Oijj6pz58665557glFmq9CSXr/++usaMGCA8vLylJycrCuvvFJz585VY2NjsMoOOy3p83XXXaft27d7Dv2UlpZqzZo1uuWWW4JSc1sR7O/CsPtV4vNx9OhRNTY2Kjk52Ws8OTlZe/bsafY1FRUVzc6vqKgIWJ3hriV9/rE//vGPcjqdp/1lwL+0pM/vvfee/vrXv2rnzp1BqLD1aEmvS0tL9c4772jMmDFas2aN9u3bp0mTJqm+vl4FBQXBKDvstKTPo0eP1tGjR3XDDTfIGKOGhgZNnDhRf/rTn4JRcptxpu/C6upqffvtt+rQoYNft9em9pwgPMyfP1/Lly/Xa6+9pujo6FCX02rU1NRo7Nixev7555WUlBTqclq9pqYmde7cWc8995z69u2rUaNGafr06Vq8eHGoS2tVNm3apLlz5+qZZ57Rjh07tHLlSr3xxht67LHHQl0azkOb2nOSlJSkyMhIVVZWeo1XVlYqJSWl2dekpKT4NB8t6/MpTzzxhObPn6/169fr6quvDmSZYc/XPn/xxRfav3+/hg4d6hlramqSJLVr10579+5Vjx49Alt0mGrJZzo1NVXt27dXZGSkZ+yKK65QRUWF6urqFBUVFdCaw1FL+vzII49o7Nix+t3vfidJuuqqq+R2uzVhwgRNnz5dERH8G9wfzvRd6HA4/L7XRGpje06ioqLUt29fbdiwwTPW1NSkDRs2aMCAAc2+ZsCAAV7zJentt98+43y0rM+S9Pjjj+uxxx7T2rVr1a9fv2CUGtZ87fPll1+ujz/+WDt37vQ8hg0bpkGDBmnnzp1KS0sLZvlhpSWf6euvv1779u3zBEBJ+uyzz5SamkowOYOW9PnEiROnBZBTgdDwu7Z+E/TvwoCcZmthy5cvN3a73RQWFppdu3aZCRMmmISEBFNRUWGMMWbs2LFm6tSpnvlbtmwx7dq1M0888YTZvXu3KSgo4FLic+Brn+fPn2+ioqLMihUrzNdff+151NTUhOothAVf+/xjXK1z7nzt9Zdffmni4uLM5MmTzd69e83q1atN586dzezZs0P1FsKCr30uKCgwcXFx5m9/+5spLS0169atMz169DAjR44M1VsICzU1NaakpMSUlJQYSWbBggWmpKTEHDhwwBhjzNSpU83YsWM9809dSvzQQw+Z3bt3G5fLxaXE/rZo0SLTrVs3ExUVZTIzM80HH3zgee6mm24yubm5XvNfeeUVc9lll5moqCjTq1cv88YbbwS54vDkS58vuugiI+m0R0FBQfALDzO+fp5/iHDiG197/f7775usrCxjt9tN9+7dzZw5c0xDQ0OQqw4/vvS5vr7ezJw50/To0cNER0ebtLQ0M2nSJHPs2LHgFx5GNm7c2Oz/c0/1Njc319x0002nvaZPnz4mKirKdO/e3SxdujRg9dmMYb8XAACwjjZ1zgkAALA+wgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAALCU/we+u8gvAS4lhQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 0\n", "item counter : 0\n", "ratio : 0.0\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3aa976a7f9034d85aaee23728b8dcb4a", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 847\n", "item counter : 859\n", "ratio : 0.9848837209302326\n", " ratio number predicted/items: 0.030232558139534883\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 846\n", "item counter : 896\n", "ratio : 0.9431438127090301\n", " ratio number predicted/items: 0.08361204013377926\n", "current epoch: 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 847\n", "item counter : 894\n", "ratio : 0.9463687150837988\n", " ratio number predicted/items: 0.06815642458100558\n", "current epoch: 2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 845\n", "item counter : 884\n", "ratio : 0.9548022598870056\n", " ratio number predicted/items: 0.05423728813559322\n", "current epoch: 3\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 846\n", "item counter : 859\n", "ratio : 0.9837209302325581\n", " ratio number predicted/items: 0.01627906976744186\n", "current epoch: 4\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 845\n", "item counter : 848\n", "ratio : 0.9952885747938751\n", " ratio number predicted/items: 0.0035335689045936395\n", "current epoch: 5\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 846\n", "item counter : 846\n", "ratio : 0.9988193624557261\n", " ratio number predicted/items: 0.0\n", "current epoch: 6\n" ] } ], "source": [ "for i in range(3):\n", " model_checkpoint = ModelCheckpoint(monitor='ratio_number_predicted_per_items', mode='max')\n", " trainer = pl.Trainer(\n", " max_epochs=20 if i==2 else 10,\n", "# max_epochs=40,\n", " accelerator='gpu',\n", " devices=1,\n", " log_every_n_steps=1,\n", " # logger=pl.loggers.CSVLogger(save_dir=\"logs/\"),\n", " reload_dataloaders_every_n_epochs=1,\n", " logger=tensorboard,\n", " callbacks=[model_checkpoint]\n", " )\n", " print(i)\n", " model = SudokuLightning(\n", " lr=0.01,\n", " prev_nets=prev_nets,\n", " coef_0 = 10 if i==0 else 20,\n", " )\n", " _ = trainer.fit(model,)\n", "# model.below_threshold_coef=0.9\n", "# model = model.load_from_checkpoint(model_checkpoint.best_model_path)\n", "# print(model_checkpoint.best_model_path)\n", "# trainer.validate(model=model)\n", "# if trainer.logged_metrics['no_improve_counter'].item()==0:\n", " prev_nets.append((model.net, (model.threshold_abs, model.threshold_pres)))" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "import joblib\n", "dump_list = []\n", "for i, (prev_net, (th_abs, th_pres) )in enumerate(prev_nets):\n", " net_name = f\"net_{i}\"\n", " torch.save(prev_net.state_dict(), net_name)\n", " dump_list.append((net_name,(th_abs, th_pres)))\n", "joblib.dump(dump_list, \"thresholds.dump\")" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "-----------------------------------------------------\n", "0 | net | SmallNet | 514 \n", "1 | sym_preprocess | SymPreprocess | 8.5 M \n", "2 | bcewll | BCEWithLogitsLoss | 0 \n", "3 | auroc | BinaryAUROC | 0 \n", "-----------------------------------------------------\n", "514 Trainable params\n", "8.5 M Non-trainable params\n", "8.5 M Total params\n", "34.014 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_3278/2863678930.py:187: UserWarning: Data has no positive values, and therefore cannot be log-scaled.\n", " ax1.set_yscale('log')\n", "/tmp/ipykernel_3278/2863678930.py:193: UserWarning: Data has no positive values, and therefore cannot be log-scaled.\n", " ax2.set_yscale('log')\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 0\n", "item counter : 0\n", "ratio : 0.0\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b33596c465b146adb94cde402279a1a4", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 812\n", "item counter : 830\n", "ratio : 0.9771359807460891\n", " ratio number predicted/items: 0.044524669073405534\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 812\n", "item counter : 827\n", "ratio : 0.9806763285024155\n", " ratio number predicted/items: 0.018115942028985508\n", "current epoch: 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 814\n", "item counter : 818\n", "ratio : 0.9938949938949939\n", " ratio number predicted/items: 0.004884004884004884\n", "current epoch: 2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 813\n", "item counter : 815\n", "ratio : 0.9963235294117647\n", " ratio number predicted/items: 0.0024509803921568627\n", "current epoch: 3\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 812\n", "item counter : 813\n", "ratio : 0.9975429975429976\n", " ratio number predicted/items: 0.0012285012285012285\n", "current epoch: 4\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 811\n", "item counter : 813\n", "ratio : 0.9963144963144963\n", " ratio number predicted/items: 0.002457002457002457\n", "current epoch: 5\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 813\n", "item counter : 813\n", "ratio : 0.9987714987714987\n", " ratio number predicted/items: 0.0\n", "current epoch: 6\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 813\n", "item counter : 813\n", "ratio : 0.9987714987714987\n", " ratio number predicted/items: 0.0\n", "current epoch: 7\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 814\n", "item counter : 814\n", "ratio : 0.9987730061349693\n", " ratio number predicted/items: 0.0\n", "current epoch: 8\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=10` reached.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 812\n", "item counter : 812\n", "ratio : 0.998769987699877\n", " ratio number predicted/items: 0.0\n", "current epoch: 9\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "-----------------------------------------------------\n", "0 | net | SmallNet | 514 \n", "1 | sym_preprocess | SymPreprocess | 8.5 M \n", "2 | bcewll | BCEWithLogitsLoss | 0 \n", "3 | auroc | BinaryAUROC | 0 \n", "-----------------------------------------------------\n", "514 Trainable params\n", "8.5 M Non-trainable params\n", "8.5 M Total params\n", "34.014 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 0\n", "item counter : 0\n", "ratio : 0.0\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "008a268c655a4e7ba7ab0d4224d5b16c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 814\n", "item counter : 829\n", "ratio : 0.980722891566265\n", " ratio number predicted/items: 0.027710843373493974\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 811\n", "item counter : 822\n", "ratio : 0.9854191980558931\n", " ratio number predicted/items: 0.013365735115431349\n", "current epoch: 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 814\n", "item counter : 841\n", "ratio : 0.9667458432304038\n", " ratio number predicted/items: 0.032066508313539195\n", "current epoch: 2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 813\n", "item counter : 817\n", "ratio : 0.9938875305623472\n", " ratio number predicted/items: 0.004889975550122249\n", "current epoch: 3\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 813\n", "item counter : 813\n", "ratio : 0.9987714987714987\n", " ratio number predicted/items: 0.0\n", "current epoch: 4\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 812\n", "item counter : 815\n", "ratio : 0.9950980392156863\n", " ratio number predicted/items: 0.003676470588235294\n", "current epoch: 5\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 813\n", "item counter : 813\n", "ratio : 0.9987714987714987\n", " ratio number predicted/items: 0.0\n", "current epoch: 6\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 814\n", "item counter : 816\n", "ratio : 0.996328029375765\n", " ratio number predicted/items: 0.0024479804161566705\n", "current epoch: 7\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 813\n", "item counter : 815\n", "ratio : 0.9963235294117647\n", " ratio number predicted/items: 0.0024509803921568627\n", "current epoch: 8\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=10` reached.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 814\n", "item counter : 814\n", "ratio : 0.9987730061349693\n", " ratio number predicted/items: 0.0\n", "current epoch: 9\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (cuda), used: True\n", "TPU available: False, using: 0 TPU cores\n", "IPU available: False, using: 0 IPUs\n", "HPU available: False, using: 0 HPUs\n", "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", "\n", " | Name | Type | Params\n", "-----------------------------------------------------\n", "0 | net | SmallNet | 514 \n", "1 | sym_preprocess | SymPreprocess | 8.5 M \n", "2 | bcewll | BCEWithLogitsLoss | 0 \n", "3 | auroc | BinaryAUROC | 0 \n", "-----------------------------------------------------\n", "514 Trainable params\n", "8.5 M Non-trainable params\n", "8.5 M Total params\n", "34.014 Total estimated model params size (MB)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 0\n", "item counter : 0\n", "ratio : 0.0\n", " ratio number predicted/items: 0.0\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "faa9c1612e35440ab49a00dc1602196a", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 812\n", "item counter : 840\n", "ratio : 0.9655172413793104\n", " ratio number predicted/items: 0.052318668252080855\n", "current epoch: 0\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 812\n", "item counter : 837\n", "ratio : 0.9689737470167065\n", " ratio number predicted/items: 0.031026252983293555\n", "current epoch: 1\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGzCAYAAAD0T7cVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA8ZUlEQVR4nO3de3RU5b3/8U8SyIRgLoRILhBM0UoLYtKCifGyDJrTNCparEKrByPa4CVp1bHaUCvBK7SHUk7pKEsshvZAQa1yPEKpGnVFMTaSEH9W0JYSMIoJUCWXQROSPL8/lNGBEDLJXPbMvF9rzVrsZ57Z+zuPkXx49rP3jjDGGAEAAFhEZKALAAAA+CrCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCQAAsBTCCYCAqqysVEREhLZu3RroUgBYBOEEAABYCuEEAABYCuEEAABYCuEEgE/s2bNHt9xyiyZOnKgRI0Zo9OjRuuqqq7R79+4++x86dEg33nijRo8erfj4eF177bX65JNP3Pps3bpVhYWFSk5O1ogRI/S1r31N119/vR++DQB/GhboAgCEpjfffFOvv/66fvCDH2jcuHHavXu3HnnkEeXn52v79u2KjY11619WVqbExEQtXLhQ7733nh555BHt2bNHr7zyiiIiIrRv3z595zvf0cknn6zy8nIlJiZq9+7devrppwP0DQH4CuEEgE9ccskluvLKK93aZsyYoby8PP35z3/WnDlz3N6Ljo5WVVWVhg8fLkk65ZRTdNddd+n//u//dNlll+n111/XJ598oueff17Tpk1zfe6BBx7w/ZcB4Fec1gHgEyNGjHD9+fDhw/r3v/+t0047TYmJiaqvrz+m/7x581zBRJJuvvlmDRs2TJs2bZIkJSYmSpKee+45HT582LfFAwgowgkAn/j000+1YMECZWRkyGazKTk5WSeffLIOHjyo1tbWY/p//etfd9s+6aSTlJaW5lqjcsEFF+j73/++7r33XiUnJ+vyyy/X448/rs7OTn98HQB+RDgB4BM//vGP9eCDD2rWrFl64okn9Pzzz+uFF17Q6NGj1dvb6/H+IiIi9NRTT6mmpkZlZWX68MMPdf3112vq1Knq6OjwwTcAECiEEwA+8dRTT6m4uFi//vWvdeWVV+o//uM/dN555+ngwYN99v/nP//ptt3R0aGPPvpImZmZbu1nn322HnzwQW3dulVr1qzRO++8o3Xr1vnoWwAIBMIJAJ+IioqSMcatbfny5erp6emz/6OPPuq2luSRRx5Rd3e3ioqKJEmffPLJMfvLzs6WJE7tACGGq3UA+MSll16qP/7xj0pISNCkSZNUU1OjF198UaNHj+6zf1dXly666CLNmjVL7733nh5++GGdd955uuyyyyRJq1ev1sMPP6yZM2fq1FNPVXt7u1auXKn4+HhdfPHF/vxqAHyMcALAJ/77v/9bUVFRWrNmjT777DOde+65evHFF1VYWNhn/9/97ndas2aNFixYoMOHD+uHP/yhfvvb3yoiIkLS5wtia2trtW7dOrW0tCghIUE5OTlas2aNvva1r/nzqwHwsQhz9DwpAABAALHmBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWArhBAAAWErQ3eekt7dXe/fuVVxcnOv+BwAAwNqMMWpvb1d6eroiI/ufGwm6cLJ3715lZGQEugwAADAITU1NGjduXL99giacOBwOORwOdXd3S/r8y8XHxwe4KgAIX06nU+np6ZI+/4fjyJEjA1wRrKytrU0ZGRmKi4s7Yd+gu0NsW1ubEhIS1NraSjgBgAByOp066aSTJH3+FGnCCfrjye9vFsQCAABLIZwAAABLIZwAAABLIZwAAABLCZpw4nA4NGnSJJ111lk+P1Zm+UZllm/0+XEAAMCxgiaclJaWavv27XrzzTcDXQoAAPChoAknAAAgPBBOAACApRBOAACApRBOAACApQQsnBw6dEinnHKKfvrTnwaqBAAAYEEBCycPPvigzj777EAdHgAAWFRAwsk///lPvfvuuyoqKgrE4QEAgIV5HE6qq6s1Y8YMpaenKyIiQhs2bDimj8PhUGZmpmJiYpSbm6va2lq393/6059q0aJFgy7a347clI0bswEA4HsehxOn06msrCw5HI4+31+/fr3sdrsqKipUX1+vrKwsFRYWat++fZKk//3f/9Xpp5+u008/fUDH6+zsVFtbm9sLAACErmGefqCoqKjf0zFLly5VSUmJ5s6dK0lasWKFNm7cqFWrVqm8vFxvvPGG1q1bpyeffFIdHR06fPiw4uPjtWDBgj73t2jRIt17772elgkAAIKUV9ecdHV1qa6uTgUFBV8eIDJSBQUFqqmpkfR52GhqatLu3bu1ZMkSlZSUHDeYSNL8+fPV2trqejU1NXmzZAAAYDFeDScHDhxQT0+PUlJS3NpTUlLU3Nw8qH3abDbFx8frj3/8o84++2xddNFF3igVAABYlMendbzpuuuuG3Df0tJSlZaWqq2tTQkJCb4rCgAABJRXZ06Sk5MVFRWllpYWt/aWlhalpqYOad8Oh0OTJk3SWWedNaT9AAAAa/NqOImOjtbUqVNVVVXlauvt7VVVVZXy8vKGtO/S0lJt375db7755lDLBAAAFubxaZ2Ojg7t3LnTtd3Y2KiGhgYlJSVp/PjxstvtKi4u1rRp05STk6Nly5bJ6XS6rt4ZLIfDIYfDoZ6eniHtBwAAWJvH4WTr1q2aPn26a9tut0uSiouLVVlZqdmzZ2v//v1asGCBmpublZ2drc2bNx+zSNZTrDkBACA8eBxO8vPzZYzpt09ZWZnKysoGXVRfmDkBACA8BOzBf55izQkAAOEhaMIJAAAID0ETTriUGACA8BA04YTTOgAAhIegCScAACA8BE044bQOAADhIWjCCad1AAAID0ETTgAAQHggnAAAAEvx+A6xGJrM8o2SpN2LL5EWfn4b/szP1n6+LbnatLC17+3++pzocwAABIGgCSfBePt6tyASaAQYAECQCJrTOkG/IHZhgrQwQbtjrh5Q9yPBxu++qPO428drAwDAS4Jm5iTcWWoW5mh9zcoAADBIQTNzgiDD7AoAYJCYOYF/MLsCABggZk58xYP1JYMVsHUp3sLsCgCgD0ETTrh9fZggsABA2AuacBL0V+v4SdDPphyNsAIAYSdowgkAAAgPhBMvySzf6HpZidXq8QruxQIAIY1wAgAALMXv4eTgwYOaNm2asrOzdcYZZ2jlypX+LiHsheRsyokcmUlhNgUALM/v9zmJi4tTdXW1YmNj5XQ6dcYZZ+iKK67Q6NGj/V0Kwh3PFgIAS/L7zElUVJRiY2MlSZ2dnTLGyBjj7zLwFWE5k9IXZlcAwBI8DifV1dWaMWOG0tPTFRERoQ0bNhzTx+FwKDMzUzExMcrNzVVtba3b+wcPHlRWVpbGjRunO++8U8nJyYP+AvANAssXCCsA4HcehxOn06msrCw5HI4+31+/fr3sdrsqKipUX1+vrKwsFRYWat++fa4+iYmJeuutt9TY2Ki1a9eqpaVl8N8AAACEFI/DSVFRkR544AHNnDmzz/eXLl2qkpISzZ07V5MmTdKKFSsUGxurVatWHdM3JSVFWVlZevXVV497vM7OTrW1tbm94H9WvEw6YAZyKTMAYNC8uuakq6tLdXV1Kigo+PIAkZEqKChQTU2NJKmlpUXt7e2SpNbWVlVXV2vixInH3eeiRYuUkJDgemVkZHizZO/44jk6vn6WDgAA4cCr4eTAgQPq6elRSkqKW3tKSoqam5slSXv27NH555+vrKwsnX/++frxj3+sKVOmHHef8+fPV2trq5YsWaKJEyfqtNNO82bJgG8cb3aFGRYAOCG/X0qck5OjhoaGAfe32Wyy2Wy64447dMcdd6itrU0JCfwFbwWZ5Ru1e/ElgS4DABBivDpzkpycrKioqGMWuLa0tCg1NXVI++apxMGBdSkeYCYFAPrk1XASHR2tqVOnqqqqytXW29urqqoq5eXlDWnfPJUYIY9TPwAgaRCndTo6OrRz507XdmNjoxoaGpSUlKTx48fLbreruLhY06ZNU05OjpYtWyan06m5c+cOqVCHwyGHw6Genp4h7QcAAFibx+Fk69atmj59umvbbrdLkoqLi1VZWanZs2dr//79WrBggZqbm5Wdna3Nmzcfs0jWU6WlpSotLWXNSZBhXcoQcYt9AGHI43CSn59/wtvNl5WVqaysbNBFAejH0YGFAAMgxPj92TqDxYLY0MGiWQBAf4ImnLAgNnQRVnyAhbUAgljQhBNmTgAACA9+vwnbYLEgFhgCt7vVslYFgLUFzcwJwgunegAgfAXNzAnC25GwwmXJPtTX7AoABEDQzJxYbc1JZvlG/nWP0MfCWgABEDThhKt1cDTCIQCEpqAJJwAs4ujZFGZXAHgZ4QQAAFhK0IQTq605gfWwDshCmE0BMARBE05Yc4LBIKxYGAEGwHEETTgBAADhgfucAPA97qECwAPMnCDscKrHoo6c5uFUDxD2CCcArIuwAoSloAknXK0DX2EmBQCsJWjCCVfrwJ8ILBbGbAoQ8oImnACBRFgBAP8hnAAAAEshnAzGwgTtjrk60FUAABCSCCcAghtrUICQ4/dw0tTUpPz8fE2aNElnnnmmnnzySX+XACDcEGCAoOL3cDJs2DAtW7ZM27dv1/PPP6/bbrtNTqfT32UAQ3b0Itm+HjzIQtoAIYwAQc3vt69PS0tTWlqaJCk1NVXJycn6+OOPNXLkSH+XAiCcHQkv3E4fsByPZ06qq6s1Y8YMpaenKyIiQhs2bDimj8PhUGZmpmJiYpSbm6va2to+91VXV6eenh5lZGR4XDgAAAhNHocTp9OprKwsORyOPt9fv3697Ha7KioqVF9fr6ysLBUWFmrfvn1u/T7++GNde+21evTRR/s9Xmdnp9ra2txeQDDjVA8A9M/jcFJUVKQHHnhAM2fO7PP9pUuXqqSkRHPnztWkSZO0YsUKxcbGatWqVa4+nZ2d+t73vqfy8nKdc845/R5v0aJFSkhIcL2YZQEAILR5dUFsV1eX6urqVFBQ8OUBIiNVUFCgmpoaSZIxRtddd50uvPBCzZkz54T7nD9/vlpbW12vpqYmb5YMAJ/r66nILKwFAsKr4eTAgQPq6elRSkqKW3tKSoqam5slSVu2bNH69eu1YcMGZWdnKzs7W2+//fZx92mz2RQfH68//vGPOvvss3XRRRd5s2Qg4DjNAwDu/H61znnnnafe3l6PP1daWqrS0lK1tbUpIYF/ySC0ZZZv1O7FlwS6DAAICK/OnCQnJysqKkotLS1u7S0tLUpNTR3Svh0OhyZNmqSzzjprSPsBAADW5tVwEh0dralTp6qqqsrV1tvbq6qqKuXl5Q1p36Wlpdq+fbvefPPNoZYJAIPT17oUAF7n8Wmdjo4O7dy507Xd2NiohoYGJSUlafz48bLb7SouLta0adOUk5OjZcuWyel0au7cuUMq1OFwyOFwqKenZ0j7AQAA1uZxONm6daumT5/u2rbb7ZKk4uJiVVZWavbs2dq/f78WLFig5uZmZWdna/PmzccskvUUa04AWBJ3mgW8zuNwkp+fL2NMv33KyspUVlY26KL6wswJwtlAFsgeueqHhbQWQGABhsTvD/4bLNacAAAQHoImnABwx/1RAISqoAknXEoMAEB4CJpwwmkdACGFS5KB4wqacALAc32d+hnM6SBOIQHwp6AJJ5zWARC0mCUBPOL3Z+sMFvc5ARDS3J6GzCXICG9BM3MCAADCA+EEwDFYYwIgkAgnQJgjiACwmqAJJyyIBQAgPARNOOE+JwAAhIegCScArC2zfOMxp4g4ZQRgMAgnAGBV3B8FYYpwAgAALIVwAgAALCVo7hDrcDjkcDjU09MT6FIAIDD6uovskTbuKosQEjQzJ1ytAwBAeAiacALAWgZ7JQ5X8AA4EcIJAMvrK9AQcoDQRTgBAACWEpBwMnPmTI0aNUpXXnllIA4PAAAsLCDh5NZbb9Uf/vCHQBwaAABYXEDCSX5+vuLi4gJxaAAAYHEeh5Pq6mrNmDFD6enpioiI0IYNG47p43A4lJmZqZiYGOXm5qq2ttYbtQIIQSxsBXA0j8OJ0+lUVlaWHA5Hn++vX79edrtdFRUVqq+vV1ZWlgoLC7Vv374hFwsgPBBYhohn8iDIeXyH2KKiIhUVFR33/aVLl6qkpERz586VJK1YsUIbN27UqlWrVF5e7nGBnZ2d6uzsdG23tbV5vA8AABA8vLrmpKurS3V1dSooKPjyAJGRKigoUE1NzaD2uWjRIiUkJLheGRkZ3ioXAMIDMykIMl4NJwcOHFBPT49SUlLc2lNSUtTc3OzaLigo0FVXXaVNmzZp3Lhx/QaX+fPnq7W1VUuWLNHEiRN12mmnebNkAABgMQF58N+LL7444L42m002m0133HGH7rjjDrW1tSkhgX8BAAAQqrw6c5KcnKyoqCi1tLS4tbe0tCg1NXVI+3Y4HJo0aZLOOuusIe0HACBO9cDSvBpOoqOjNXXqVFVVVbnaent7VVVVpby8vCHtm6cSAwAQHjwOJx0dHWpoaFBDQ4MkqbGxUQ0NDXr//fclSXa7XStXrtTq1au1Y8cO3XzzzXI6na6rdwaLmRMA/eHyYyB0eLzmZOvWrZo+fbpr2263S5KKi4tVWVmp2bNna//+/VqwYIGam5uVnZ2tzZs3H7NI1lOlpaUqLS1lzQkAACHO43CSn58vY0y/fcrKylRWVjboovricDjkcDjU09Pj1f0CCF2Z5Ru1e/ElbtuS3NoAWE9Anq0zGKw5AQAgPARNOAEAAOEhIPc5GQxO6wCAD331suKFrYPvA3hB0MyccFoHAIDwEDThBAAAhAfCCQAAsJSgCSfchA0A/Ixb3CNAgiacsOYEAIDwEDThBAAAhAfCCQAAsJSgCScBW3OyMEG7Y6727zEBWN7RDxrkwYOA9wRNOGHNCQAA4SFowgkAAAgPhBMAAGAphBMAAGAphBMAAGApQRNOuEMsAF/o6yobb12J09d+vHVVD1cHIZQFTTjhah0AAMJD0IQTAAAQHggnAADAUggnAADAUgISTp577jlNnDhRX//61/XYY48FogQAAGBRw/x9wO7ubtntdr388stKSEjQ1KlTNXPmTI0ePdrfpQAAAAvy+8xJbW2tJk+erLFjx+qkk05SUVGRnn/+eX+XAQAALMrjcFJdXa0ZM2YoPT1dERER2rBhwzF9HA6HMjMzFRMTo9zcXNXW1rre27t3r8aOHevaHjt2rD788MPBVQ8AAEKOx+HE6XQqKytLDoejz/fXr18vu92uiooK1dfXKysrS4WFhdq3b9+QiwUAAKHP43BSVFSkBx54QDNnzuzz/aVLl6qkpERz587VpEmTtGLFCsXGxmrVqlWSpPT0dLeZkg8//FDp6enHPV5nZ6fa2trcXgAAIHR5dc1JV1eX6urqVFBQ8OUBIiNVUFCgmpoaSVJOTo7+/ve/68MPP1RHR4f+8pe/qLCw8Lj7XLRokRISElyvjIwMb5YMAJYzmFvTczt7hBKvhpMDBw6op6dHKSkpbu0pKSlqbm6WJA0bNky//vWvNX36dGVnZ+uOO+7o90qd+fPnq7W11fVqamryZskAAMBi/H4psSRddtlluuyyywbU12azyWazyeFwyOFwqKenx8fVAQCAQPLqzElycrKioqLU0tLi1t7S0qLU1FRvHgoAAIQor4aT6OhoTZ06VVVVVa623t5eVVVVKS8vb0j75qnEAACEB49P63R0dGjnzp2u7cbGRjU0NCgpKUnjx4+X3W5XcXGxpk2bppycHC1btkxOp1Nz5871auEAACA0eRxOtm7dqunTp7u27Xa7JKm4uFiVlZWaPXu29u/frwULFqi5uVnZ2dnavHnzMYtkPcWaEwAAwoPH4SQ/P1/GmH77lJWVqaysbNBF9aW0tFSlpaVqbW1VYmKiT+930tt5SJI+P0an6bftq9t9tXnURzru5zj+iY8fDDVyfN8ePxhqPPr4OuozfR5vAH36Ov4xn/vq35v97Pu4nzuqj9Pp/MpmG/94RL+O/HyeKENIUoQZSC8L+eCDD7jXCQAAQaqpqUnjxo3rt0/QhZPe3l7t3btXcXFxioiI8Pr+29ralJGRoaamJsXHx3t9//gc4+w/jLV/MM7+wTj7j7fH2hij9vZ2paenKzKy/+txAnKfk6GIjIw8YeLyhvj4eH7w/YBx9h/G2j8YZ/9gnP3Hm2OdkJAwoH5evZQYAABgqAgnAADAUggnR7HZbKqoqJDNZgt0KSGNcfYfxto/GGf/YJz9J5BjHXQLYgEAQGhj5gQAAFgK4QQAAFgK4QQAAFgK4QQAAFhKWIYTh8OhzMxMxcTEKDc3V7W1tf32f/LJJ/WNb3xDMTExmjJlijZt2uSnSoObJ+O8cuVKnX/++Ro1apRGjRqlgoKCE/53wZc8/Zk+Yt26dYqIiND3vvc93xYYIjwd54MHD6q0tFRpaWmy2Ww6/fTT+ftjADwd52XLlmnixIkaMWKEMjIydPvtt+uzzz7zU7XBqbq6WjNmzFB6eroiIiK0YcOGE37mlVde0be//W3ZbDaddtppqqys9F2BJsysW7fOREdHm1WrVpl33nnHlJSUmMTERNPS0tJn/y1btpioqCjzq1/9ymzfvt384he/MMOHDzdvv/22nysPLp6O89VXX20cDofZtm2b2bFjh7nuuutMQkKC+eCDD/xcefDxdKyPaGxsNGPHjjXnn3++ufzyy/1TbBDzdJw7OzvNtGnTzMUXX2xee+0109jYaF555RXT0NDg58qDi6fjvGbNGmOz2cyaNWtMY2Oj+etf/2rS0tLM7bff7ufKg8umTZvM3XffbZ5++mkjyTzzzDP99t+1a5eJjY01drvdbN++3SxfvtxERUWZzZs3+6S+sAsnOTk5prS01LXd09Nj0tPTzaJFi/rsP2vWLHPJJZe4teXm5pobb7zRp3UGO0/H+Wjd3d0mLi7OrF692lclhozBjHV3d7c555xzzGOPPWaKi4sJJwPg6Tg/8sgjZsKECaarq8tfJYYET8e5tLTUXHjhhW5tdrvdnHvuuT6tM5QMJJzcddddZvLkyW5ts2fPNoWFhT6pKaxO63R1damurk4FBQWutsjISBUUFKimpqbPz9TU1Lj1l6TCwsLj9sfgxvlohw4d0uHDh5WUlOSrMkPCYMf6vvvu05gxY3TDDTf4o8ygN5hxfvbZZ5WXl6fS0lKlpKTojDPO0EMPPaSenh5/lR10BjPO55xzjurq6lynfnbt2qVNmzbp4osv9kvN4cLfvwuD7sF/Q3HgwAH19PQoJSXFrT0lJUXvvvtun59pbm7us39zc7PP6gx2gxnno/3sZz9Tenr6Mf8zwN1gxvq1117T73//ezU0NPihwoHr7e1VV1eXYmJiAl3KMQYzzrt27dJLL72ka665Rps2bdLOnTt1yy236PDhw6qoqPBH2UFnMON89dVX68CBAzrvvPNkjFF3d7duuukm/fznP/dHyWHjeL8L29ra9Omnn2rEiBFePV5YzZwgOCxevFjr1q3TM888Y8lfVMGsvb1dc+bM0cqVK5WcnOyTYyxcuFARERF69913NWvWLMXHx2v06NG69dZb3RYpRkREqKysTGvWrNHkyZNls9m0efNmSdKHH36o66+/XikpKbLZbJo8ebJWrVp1zLGWL1+uyZMnKzY2VqNGjdK0adO0du1an3wvT/X29mrMmDF69NFHNXXqVM2ePVt33323VqxYEejSQsorr7yihx56SA8//LDq6+v19NNPa+PGjbr//vsDXRqGIKxmTpKTkxUVFaWWlha39paWFqWmpvb5mdTUVI/6Y3DjfMSSJUu0ePFivfjiizrzzDN9WWZI8HSs//Wvf2n37t2aMWOGq623t1eSNGzYML333ns69dRTvVLbrFmzlJmZqUWLFumNN97Qb3/7W33yySf6wx/+4Orz0ksv6YknnlBZWZmSk5OVmZmplpYWnX322a7wcvLJJ+svf/mLbrjhBrW1tem2226T9PkVXj/5yU905ZVXuoLP//t//09/+9vfdPXVV3vlOxwxmJ/ptLQ0DR8+XFFRUa62b37zm2publZXV5eio6O9WmMoGMw433PPPZozZ45+9KMfSZKmTJkip9OpefPm6e6771ZkJP8G94bj/S6Mj4/3+qyJpPC7WicnJ8eUlZW5tnt6eszYsWP7XRB76aWXurXl5eWxIPYEPB1nY4z55S9/aeLj401NTY0/SgwZnoz1p59+at5++2231+WXX24uvPBC8/bbb5vOzs4h11NRUWEkmcsuu8yt/ZZbbjGSzFtvvWWM+XwRXmRkpHnnnXfc+t1www0mLS3NHDhwwK39Bz/4gUlISDCHDh0yxhhz+eWXH7NAz5c8/ZmeP3++OeWUU0xPT4+rbdmyZSYtLc3ntQYzT8f529/+trnrrrvc2tauXWtGjBhhuru7fVprqNAAF8SeccYZbm0//OEPfbYgNuzCybp164zNZjOVlZVm+/btZt68eSYxMdE0NzcbY4yZM2eOKS8vd/XfsmWLGTZsmFmyZInZsWOHqaio4FLiAfB0nBcvXmyio6PNU089ZT766CPXq729PVBfIWh4OtZH8/bVOkfCyV//+le39h07dhhJrl8yksz06dPd+vT29prExEQzb948s3//frfX448/biSZ1157zVV3QkKCqa2t9Vrt/fF0nN9//30TFxdnysrKzHvvvWeee+45M2bMGPPAAw/4pd5g5ek4V1RUmLi4OPOnP/3J7Nq1yzz//PPm1FNPNbNmzQrUVwgK7e3tZtu2bWbbtm1Gklm6dKnZtm2b2bNnjzHGmPLycjNnzhxX/yOXEt95551mx44dxuFwcCmxty1fvtyMHz/eREdHm5ycHPPGG2+43rvgggtMcXGxW/8nnnjCnH766SY6OtpMnjzZbNy40c8VBydPxvmUU04xko55VVRU+L/wIOTpz/RX+Sqc7Nq1y629q6vLREZGumYdJZnrr7/erU9LS0ufPwdffT399NPGGGO2b99uxo4daySZ0047zdxyyy2u4OIrno7z66+/bnJzc43NZjMTJkwwDz74IP+aHwBPxvnw4cNm4cKF5tRTTzUxMTEmIyPD3HLLLeaTTz7xf+FB5OWXX+7z/68jY1tcXGwuuOCCYz6TnZ1toqOjzYQJE8zjjz/us/oijDHG+yeLAISrhQsX6t5779WuXbv0ta99zdXe3d0tm82mkpISrVixQhERESotLdXvfvc7V5/m5malpaXpP//zP1VcXNzn/s8880yNGTNGkuR0OvXcc89p8+bN+stf/qKWlhYtWLBA9957r2+/JACfCqsFsQD855///KdbONm5c6d6e3uVmZl53M+cfPLJiouLU09Pz4AuIx85cqRmz56t2bNnq6urS1dccYUefPBBzZ8/nyu9gCDGMmYAPuFwONy2ly9fLkkqKio67meioqL0/e9/X3/+85/197///Zj39+/f7/rzv//9b7f3oqOjNWnSJBljdPjw4aGUDiDAmDkB4BONjY267LLL9N3vflc1NTX6n//5H1199dXKysrq93OLFy/Wyy+/rNzcXJWUlGjSpEn6+OOPVV9frxdffFEff/yxJOk73/mOUlNTde655yolJUU7duzQ7373O11yySWKi4vzx1cE4COEEwA+sX79ei1YsEDl5eUaNmyYysrK9F//9V8n/FxKSopqa2t133336emnn9bDDz+s0aNHa/LkyfrlL3/p6nfjjTdqzZo1Wrp0qTo6OjRu3Dj95Cc/0S9+8Qtffi0AfsCCWABedWRB7P79+312F1oAoY01JwAAwFIIJwAAwFIIJwAAwFJYcwIAACyFmRMAAGApQXcpcW9vr/bu3au4uDhFREQEuhwAADAAxhi1t7crPT1dkZH9z40EXTjZu3evMjIyAl0GAAAYhKamJo0bN67fPkEXTo7c+bGpqUnx8fEBrgYArMfpdCo9PV3S5/+gGzlyZIArAqS2tjZlZGQM6A7OQRdOjpzKiY+PJ5wAQB+ioqJcf46PjyecwFIGsiSDBbEAAMBSCCcAAMBSCCcAAMBSgm7NCQAAvtbb26uurq5AlxFUhg8f7rbeaSgIJwAAfEVXV5caGxvV29sb6FKCTmJiolJTU4d8HzLCSR8yyzdKknYvviTAlQAA/MkYo48++khRUVHKyMg44c3C8DljjA4dOqR9+/ZJktLS0oa0P8IJAABf6O7u1qFDh5Senq7Y2NhAlxNURowYIUnat2+fxowZM6RTPERCAAC+0NPTI0mKjo4OcCXB6UigO3z48JD2QzgBAOAoPLttcLw1boQTAABgKYQTAABgKSyIBQDgBI5cxekv4X61KDMnAACgTx9//LGuueYaxcfHKzExUTfccIM6Ojp8flzCCQAAYWggd8C95ppr9M477+iFF17Qc889p+rqas2bN8/ntRFOAAAIAe3t7brmmms0cuRIpaWl6Te/+Y3y8/N12223SZIyMzN1//3369prr1V8fPwJQ8aOHTu0efNmPfbYY8rNzdV5552n5cuXa926ddq7d69PvwvhBACAEGC327VlyxY9++yzeuGFF/Tqq6+qvr7erc+SJUuUlZWlbdu26Z577ul3fzU1NUpMTNS0adNcbQUFBYqMjNTf/vY3n3yHI1gQCwBAkGtvb9fq1au1du1aXXTRRZKkxx9/XOnp6W79LrzwQt1xxx0D2mdzc7PGjBnj1jZs2DAlJSWpubnZO4UfR0DCSWZmpuLj4xUZGalRo0bp5ZdfDkQZAACEhF27dunw4cPKyclxtSUkJGjixIlu/b46C2JlAZs5ef3113XSSScF6vAAAISdkSNHDrhvamqq60F+R3R3d+vjjz9Wamqqt0tzw5oTAACC3IQJEzR8+HC9+eabrrbW1lb94x//GPQ+8/LydPDgQdXV1bnaXnrpJfX29io3N3dI9Z6Ix+GkurpaM2bMUHp6uiIiIrRhw4Zj+jgcDmVmZiomJka5ubmqra11ez8iIkIXXHCBzjrrLK1Zs2bQxQMAACkuLk7FxcW688479fLLL+udd97RDTfcoMjIyEE/7+ab3/ymvvvd76qkpES1tbXasmWLysrK9IMf/OCYtSze5vFpHafTqaysLF1//fW64oorjnl//fr1stvtWrFihXJzc7Vs2TIVFhbqvffecy2see211zR27Fh99NFHKigo0JQpU3TmmWcO/dsAAOADwXDH1qVLl+qmm27SpZdeqvj4eN11111qampSTEzMoPe5Zs0alZWV6aKLLlJkZKS+//3v67e//a0Xq+6bx+GkqKhIRUVFx31/6dKlKikp0dy5cyVJK1as0MaNG7Vq1SqVl5dLksaOHStJSktL08UXX6z6+vrjhpPOzk51dna6ttva2jwtGQCAkBcXF+d2NsLpdOree+913c9k9+7dHu8zKSlJa9eu9VaJA+bVNSddXV2qq6tTQUHBlweIjFRBQYFqamokfT5Y7e3tkqSOjg699NJLmjx58nH3uWjRIiUkJLheGRkZ3iwZAICQsG3bNv3pT3/Sv/71L9XX1+uaa66RJF1++eUBrsxzXg0nBw4cUE9Pj1JSUtzaU1JSXNdEt7S06LzzzlNWVpbOPvtsXXvttTrrrLOOu8/58+ertbXV9WpqavJmyQAAhIwjN1krKCiQ0+nUq6++quTk5D77PvTQQzrppJP6fPV3hsQf/H4p8YQJE/TWW28NuL/NZpPNZvNhRQAABL9vfetbblfWnMhNN92kWbNm9fneiBEjvFXWoHg1nCQnJysqKkotLS1u7S0tLT6/JhoAAAxcUlKSkpKSAl1Gn7x6Wic6OlpTp05VVVWVq623t1dVVVXKy8vz5qEAAECI8njmpKOjQzt37nRtNzY2qqGhQUlJSRo/frzsdruKi4s1bdo05eTkaNmyZXI6na6rdwAAAPrjcTjZunWrpk+f7tq22+2SpOLiYlVWVmr27Nnav3+/FixYoObmZmVnZ2vz5s3HLJIFAADoi8fhJD8/X8aYfvuUlZWprKxs0EUBAIDwxbN1AACApQTsqcQAAASNhQl+Pl6rf49nMcycAACAPj344IM655xzFBsbq8TERL8dl3ACAEAY6urqGlCfq666SjfffLMfKvoS4QQAgBDQ3t6ua665RiNHjlRaWpp+85vfKD8/X7fddpskKTMzU/fff7+uvfZaxcfHux4I2J97771Xt99+u6ZMmeLj6t0RTgAACAF2u11btmzRs88+qxdeeEGvvvqq6uvr3focefbOtm3bdM899wSo0hNjQSwAAEGuvb1dq1ev1tq1a3XRRRdJkh5//HGlp6e79bvwwgt1xx13BKJEjzBzAgBAkNu1a5cOHz6snJwcV1tCQoImTpzo1m/atGn+Lm1QCCcAAISJkSNHBrqEASGcAAAQ5CZMmKDhw4frzTffdLW1trbqH//4RwCrGjzWnAAAEOTi4uJUXFysO++8U0lJSRozZowqKioUGRmpiIiIQe/3/fff18cff6z3339fPT09amhokCSddtppOumkk7xU/bEIJwAAnEgQ3LF16dKluummm3TppZcqPj5ed911l5qamhQTEzPofS5YsECrV692bX/rW9+SJL388svKz88fasnHRTgBACAExMXFac2aNa5tp9Ope++913U/k927d3u8z8rKSlVWVnqpwoEjnAAAEAK2bdumd999Vzk5OWptbdV9990nSbr88ssDXJnnWBALAECIOHKTtYKCAjmdTr366qtKTk7us+9DDz2kk046qc9XUVGRnyt3x8wJAAAh4Fvf+pbq6uoG3P+mm27SrFmz+nxvxIgR3iprUAgnAACEoaSkJCUlJQW6jD5xWgcAgKMYYwJdQlDy1rgRTgAA+EJUVJQkqaurK8CVBKdDhw5JkoYPHz6k/XBaBwCALwwbNkyxsbHav3+/hg8frshI/g0/EMYYHTp0SPv27VNiYqIr5A0W4QQAgC9EREQoLS1NjY2N2rNnT6DLCTqJiYlKTU0d8n4IJwAAfEV0dLS+/vWvc2rHQ8OHDx/yjMkRhBMAAI4SGRk5pNu+Y2g4mQYAACyFcAIAACyFcAIAACyFcAIAACyFcAIAACyFcAIAACyFcAIAACyF+5wEWGb5RknS7sWXHLftyHZfbf31AQAgGDFz4meZ5RvdgoS/j+XP4wMAMBiEkzBHWAEAWA3hxIeC9Rd/sNYNAAgNrDnBCbGeBQDgT8ycYFCYXQEA+AozJ14S7rMLA7miCACAgWDmBH7FjAsA4EQIJwgowgoA4GiEE1gOgQUAwpvf15wcPHhQBQUF6u7uVnd3t2699VaVlJT4uwwEkXBfzwMA4cbv4SQuLk7V1dWKjY2V0+nUGWecoSuuuEKjR4/2dykIYty+HwBCl99P60RFRSk2NlaS1NnZKWOMjDH+LgMAAFiUx+GkurpaM2bMUHp6uiIiIrRhw4Zj+jgcDmVmZiomJka5ubmqra11e//gwYPKysrSuHHjdOeddyo5OXnQXwA4HtauAEBw8jicOJ1OZWVlyeFw9Pn++vXrZbfbVVFRofr6emVlZamwsFD79u1z9UlMTNRbb72lxsZGrV27Vi0tLYP/BgESsr/4FiZod8zV3u+zMMF7+x6kI//NvvrfLWT/OwJAEPM4nBQVFemBBx7QzJkz+3x/6dKlKikp0dy5czVp0iStWLFCsbGxWrVq1TF9U1JSlJWVpVdfffW4x+vs7FRbW5vbC17i5SDicagY7PH7CD4D7XPCzwEAAs6ra066urpUV1engoKCLw8QGamCggLV1NRIklpaWtTe3i5Jam1tVXV1tSZOnHjcfS5atEgJCQmuV0ZGhjdLDl2DnbkIZ1+MkRYmfDmbcvQ2AMDnvHq1zoEDB9TT06OUlBS39pSUFL377ruSpD179mjevHmuhbA//vGPNWXKlOPuc/78+bLb7a7ttrY2AsrRFiZod8znf8z8bG1gawkHCxMkfT7WXC0EAN7n90uJc3Jy1NDQMOD+NptNNpvNdwUFoy/CCEHEIgby3+OLQPP5n1t9XxMABDGvhpPk5GRFRUUds8C1paVFqamp3jwUYG19zK4crw9hBQDceXXNSXR0tKZOnaqqqipXW29vr6qqqpSXl+fNQ4UP1omEnOOuX/nKmhcACGceh5OOjg41NDS4Ts00NjaqoaFB77//viTJbrdr5cqVWr16tXbs2KGbb75ZTqdTc+fO9WrhQKjod7FtX2GFAAMgxHl8Wmfr1q2aPn26a/vIYtXi4mJVVlZq9uzZ2r9/vxYsWKDm5mZlZ2dr8+bNxyySxXGwngT6PLAMeGFtX6eHOGUEIIh5PHOSn5/vutLmq6/KykpXn7KyMu3Zs0ednZ3629/+ptzcXG/WHDo4ZYMB6mt2hcubAYQqv1+tAyAAuFoIQBDx+4P/APiGx7fiZ+0KAIsinAAAAEshnAAhbFAzKcymAAgwwom/8GwbWAQLaQFYHeEEAABYCuEEwPFxmgdAABBOAHiGwALAxwgnvsL6EgQJ1qAAsBpuwjYAX/3Le8C3FAfCBbfKB+BlzJwAAABLIZwAOAanegAEEuEEwAl5HFZYNAtgCAgnAAaF2RUAvsKCWG9YmKDdMZ//MfOztYGtBQCAIEc4AeB7Xz3Fc+SqHq7yAXAcnNYB4BWZ5Rs51QPAKwgnAHyGsAJgMAgnAADAUlhzAsAa+lqXAiAsMXMCwK88OtXD/VKAsEQ4AQAAlkI4ARBQLJoFcDTCCQAAsBTCCYDgwjoUIOQRTgZjYYJ2x1wd6CoASIQVIAQRTgAAgKUQTgAAgKUQTgAAgKUQTgBYztGXF3O5MRBeCCcAAMBSCCcAAMBSCCcAAMBSCCcAAMBSCCcAAMBSCCcAAMBSCCcAgpJHlxdzi3sgqBBOAIQewggQ1AgnAEKCxzdqOzrAHNkm1AABRzgBAACWEpBwMnPmTI0aNUpXXnllIA4PAAAsLCDh5NZbb9Uf/vCHQBwaAABYXEDCSX5+vuLi4gJxaAAAYHEeh5Pq6mrNmDFD6enpioiI0IYNG47p43A4lJmZqZiYGOXm5qq2ttYbtQKAR3iaMRCcPA4nTqdTWVlZcjgcfb6/fv162e12VVRUqL6+XllZWSosLNS+ffuGXCwAAAh9wzz9QFFRkYqKio77/tKlS1VSUqK5c+dKklasWKGNGzdq1apVKi8v97jAzs5OdXZ2urbb2to83gcAAAgeXl1z0tXVpbq6OhUUFHx5gMhIFRQUqKamZlD7XLRokRISElyvjIwMb5ULAP3jXihAQHg1nBw4cEA9PT1KSUlxa09JSVFzc7Nru6CgQFdddZU2bdqkcePG9Rtc5s+fr9bWVterqanJmyUDCHOsSwGsx+PTOt7w4osvDrivzWaTzWbzYTUAAMBKvDpzkpycrKioKLW0tLi1t7S0KDU11ZuHAgAAIcqr4SQ6OlpTp05VVVWVq623t1dVVVXKy8vz5qEAAECI8vi0TkdHh3bu3OnabmxsVENDg5KSkjR+/HjZ7XYVFxdr2rRpysnJ0bJly+R0Ol1X7wAAAPTH43CydetWTZ8+3bVtt9slScXFxaqsrNTs2bO1f/9+LViwQM3NzcrOztbmzZuPWSQbNBYmaHeMlPnZ2kBXAmCIjix+3b34Eu/t9MiVOwtbvbdPIMx5HE7y8/NljOm3T1lZmcrKygZdFAAACF8BebYOAIQV7o0CeIRwAgAALIVwAgBH4cZsQGARTgAAgKUQTgAAgKUQTgAAgKUQTgDA27g6BxgSwgkAALAUwgkAALAUwgkAALAUwgkAALAUwgkAnEBfN2XjRm2A7xBOAACApRBOAACApRBOAACApRBOAACApRBOAACApRBOAACApRBOAACApRBOAMAL/Hnfk8zyjdxnBSGNcAIAACyFcAIAACyFcAIAACyFcAIAACyFcAIAACxlWKAL8JQxRpLU1tbms2P0dh768hidpt+2r2731eZRH+m4n+P4Jz5+MNTI8X17fKvVqONtD5Hb9+iD0+l0/bmtrU09PT1eOS4wFEd+Xo/8Hu9PhBlILwv54IMPlJGREegyAADAIDQ1NWncuHH99gm6cNLb26u9e/cqLi5OERERXt9/W1ubMjIy1NTUpPj4eK/vH59jnP2HsfYPxtk/GGf/8fZYG2PU3t6u9PR0RUb2v6ok6E7rREZGnjBxeUN8fDw/+H7AOPsPY+0fjLN/MM7+482xTkhIGFA/FsQCAABLIZwAAABLIZwcxWazqaKiQjabLdClhDTG2X8Ya/9gnP2DcfafQI510C2IBQAAoY2ZEwAAYCmEEwAAYCmEEwAAYCmEEwAAYCmEEwAAYClhGU4cDocyMzMVExOj3Nxc1dbW9tv/ySef1De+8Q3FxMRoypQp2rRpk58qDW6ejPPKlSt1/vnna9SoURo1apQKCgpO+N8FX/L0Z/qIdevWKSIiQt/73vd8W2CI8HScDx48qNLSUqWlpclms+n000/n748B8HScly1bpokTJ2rEiBHKyMjQ7bffrs8++8xP1Qan6upqzZgxQ+np6YqIiNCGDRtO+JlXXnlF3/72t2Wz2XTaaaepsrLSdwWaMLNu3ToTHR1tVq1aZd555x1TUlJiEhMTTUtLS5/9t2zZYqKiosyvfvUrs337dvOLX/zCDB8+3Lz99tt+rjy4eDrOV199tXE4HGbbtm1mx44d5rrrrjMJCQnmgw8+8HPlwcfTsT6isbHRjB071px//vnm8ssv90+xQczTce7s7DTTpk0zF198sXnttddMY2OjeeWVV0xDQ4OfKw8uno7zmjVrjM1mM2vWrDGNjY3mr3/9q0lLSzO33367nysPLps2bTJ33323efrpp40k88wzz/Tbf9euXSY2NtbY7Xazfft2s3z5chMVFWU2b97sk/rCLpzk5OSY0tJS13ZPT49JT083ixYt6rP/rFmzzCWXXOLWlpuba2688Uaf1hnsPB3no3V3d5u4uDizevVqX5UYMgYz1t3d3eacc84xjz32mCkuLiacDICn4/zII4+YCRMmmK6uLn+VGBI8HefS0lJz4YUXurXZ7XZz7rnn+rTOUDKQcHLXXXeZyZMnu7XNnj3bFBYW+qSmsDqt09XVpbq6OhUUFLjaIiMjVVBQoJqamj4/U1NT49ZfkgoLC4/bH4Mb56MdOnRIhw8fVlJSkq/KDAmDHev77rtPY8aM0Q033OCPMoPeYMb52WefVV5enkpLS5WSkqIzzjhDDz30kHp6evxVdtAZzDifc845qqurc5362bVrlzZt2qSLL77YLzWHC3//Lgy6pxIPxYEDB9TT06OUlBS39pSUFL377rt9fqa5ubnP/s3NzT6rM9gNZpyP9rOf/Uzp6enH/M8Ad4MZ69dee02///3v1dDQ4IcKQ8NgxnnXrl166aWXdM0112jTpk3auXOnbrnlFh0+fFgVFRX+KDvoDGacr776ah04cEDnnXeejDHq7u7WTTfdpJ///Of+KDlsHO93YVtbmz799FONGDHCq8cLq5kTBIfFixdr3bp1euaZZxQTExPockJKe3u75syZo5UrVyo5OTnQ5YS03t5ejRkzRo8++qimTp2q2bNn6+6779aKFSsCXVpIeeWVV/TQQw/p4YcfVn19vZ5++mlt3LhR999/f6BLwxCE1cxJcnKyoqKi1NLS4tbe0tKi1NTUPj+TmprqUX8MbpyPWLJkiRYvXqwXX3xRZ555pi/LDAmejvW//vUv7d69WzNmzHC19fb2SpKGDRum9957T6eeeqpviw5Cg/mZTktL0/DhwxUVFeVq++Y3v6nm5mZ1dXUpOjrapzUHo8GM8z333KM5c+boRz/6kSRpypQpcjqdmjdvnu6++25FRvJvcG843u/C+Ph4r8+aSGE2cxIdHa2pU6eqqqrK1dbb26uqqirl5eX1+Zm8vDy3/pL0wgsvHLc/BjfOkvSrX/1K999/vzZv3qxp06b5o9Sg5+lYf+Mb39Dbb7+thoYG1+uyyy7T9OnT1dDQoIyMDH+WHzQG8zN97rnnaufOna7wJ0n/+Mc/lJaWRjA5jsGM86FDh44JIEcCoeG5tl7j99+FPllma2Hr1q0zNpvNVFZWmu3bt5t58+aZxMRE09zcbIwxZs6cOaa8vNzVf8uWLWbYsGFmyZIlZseOHaaiooJLiQfA03FevHixiY6ONk899ZT56KOPXK/29vZAfYWg4elYH42rdQbG03F+//33TVxcnCkrKzPvvfeeee6558yYMWPMAw88EKivEBQ8HeeKigoTFxdn/vSnP5ldu3aZ559/3px66qlm1qxZgfoKQaG9vd1s27bNbNu2zUgyS5cuNdu2bTN79uwxxhhTXl5u5syZ4+p/5FLiO++80+zYscM4HA4uJfa25cuXm/Hjx5vo6GiTk5Nj3njjDdd7F1xwgSkuLnbr/8QTT5jTTz/dREdHm8mTJ5uNGzf6ueLg5Mk4n3LKKUbSMa+Kigr/Fx6EPP2Z/irCycB5Os6vv/66yc3NNTabzUyYMME8+OCDpru7289VBx9Pxvnw4cNm4cKF5tRTTzUxMTEmIyPD3HLLLeaTTz7xf+FB5OWXX+7z79wjY1tcXGwuuOCCYz6TnZ1toqOjzYQJE8zjjz/us/oijGHeCwAAWEdYrTkBAADWRzgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACWQjgBAACW8v8BJ4jROpm8iXQAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 813\n", "item counter : 817\n", "ratio : 0.9938875305623472\n", " ratio number predicted/items: 0.004889975550122249\n", "current epoch: 2\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 812\n", "item counter : 813\n", "ratio : 0.9975429975429976\n", " ratio number predicted/items: 0.0012285012285012285\n", "current epoch: 3\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 811\n", "item counter : 814\n", "ratio : 0.9950920245398773\n", " ratio number predicted/items: 0.0049079754601227\n", "current epoch: 4\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 813\n", "item counter : 814\n", "ratio : 0.9975460122699387\n", " ratio number predicted/items: 0.001226993865030675\n", "current epoch: 5\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 812\n", "item counter : 813\n", "ratio : 0.9975429975429976\n", " ratio number predicted/items: 0.0012285012285012285\n", "current epoch: 6\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 812\n", "item counter : 813\n", "ratio : 0.9975429975429976\n", " ratio number predicted/items: 0.0012285012285012285\n", "current epoch: 7\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 814\n", "item counter : 814\n", "ratio : 0.9987730061349693\n", " ratio number predicted/items: 0.0\n", "current epoch: 8\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Validation: 0it [00:00, ?it/s]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stderr", "output_type": "stream", "text": [ "`Trainer.fit` stopped: `max_epochs=10` reached.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "No improve counter : 810\n", "item counter : 810\n", "ratio : 0.998766954377312\n", " ratio number predicted/items: 0.0\n", "current epoch: 9\n" ] } ], "source": [ "for i in range(3):\n", " model_checkpoint = ModelCheckpoint(monitor='ratio_number_predicted_per_items', mode='max')\n", " trainer = pl.Trainer(\n", " max_epochs=10,\n", "# max_epochs=40,\n", " accelerator='gpu',\n", " devices=1,\n", " log_every_n_steps=1,\n", " # logger=pl.loggers.CSVLogger(save_dir=\"logs/\"),\n", " reload_dataloaders_every_n_epochs=1,\n", " logger=tensorboard,\n", " callbacks=[model_checkpoint]\n", " )\n", " print(i)\n", " model = SudokuLightning(\n", " lr=0.01,\n", " prev_nets=prev_nets,\n", " coef_0 = 2,\n", " )\n", " _ = trainer.fit(model,)\n", "# model.below_threshold_coef=0.9\n", "# model = model.load_from_checkpoint(model_checkpoint.best_model_path)\n", "# print(model_checkpoint.best_model_path)\n", "# trainer.validate(model=model)\n", "# if trainer.logged_metrics['no_improve_counter'].item()==0:\n", " prev_nets.append((model.net, (model.threshold_abs, model.threshold_pres)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from sudoku.loader import get_datasets\n", "from tqdm.notebook import tqdm" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "train, test = get_datasets(train_size=5000, test_size=5000)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for x,y in tqdm(train):\n", " x = x.view(1,2,729)\n", " y = y.view(1,2,729)\n", " \n", " while (x!=y).any():\n", " new_x = forward_from_prev_nets_all(x, y, raise_if_error=False, full_loop=False)\n", " if (new_x == x).all():\n", " print(\"No improvment\")\n", " raise ValueError\n", " break\n", " x = new_x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "new_prev_nets = copy(prev_nets)\n", "for x,y in tqdm(train):\n", " x = x.view(1,2,729)\n", " y = y.view(1,2,729)\n", " \n", " while (x!=y).any():\n", " new_x = forward_from_prev_nets_all(x, y, raise_if_error=False, prev_nets=new_prev_nets, fix=True)\n", " if (new_x == x).all():\n", " print(\"No improvment\")\n", " raise ValueError\n", " break\n", " x = new_x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "new_prev_nets = copy(prev_nets)\n", "for x,y in tqdm(test):\n", " x = x.view(1,2,729)\n", " y = y.view(1,2,729)\n", " \n", " while (x!=y).any():\n", " new_x = forward_from_prev_nets_all(x, y, raise_if_error=False, prev_nets=new_prev_nets, fix=True)\n", " if (new_x == x).all():\n", " print(\"No improvment\")\n", " raise ValueError\n", " break\n", " x = new_x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# new_prev_nets = copy(prev_nets)\n", "for x,y in tqdm(train):\n", " x = x.view(1,2,729)\n", " y = y.view(1,2,729)\n", " \n", " while (x!=y).any():\n", " new_x = forward_from_prev_nets_all(x, y, raise_if_error=False, prev_nets=new_prev_nets, fix=False)\n", " if (new_x == x).all():\n", " print(\"No improvment\")\n", " raise ValueError\n", " break\n", " x = new_x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# new_prev_nets = copy(prev_nets)\n", "for x,y in tqdm(test):\n", " x = x.view(1,2,729)\n", " y = y.view(1,2,729)\n", " \n", " while (x!=y).any():\n", " new_x = forward_from_prev_nets_all(x, y, raise_if_error=False, prev_nets=new_prev_nets, fix=False)\n", " if (new_x == x).all():\n", " print(\"No improvment\")\n", " raise ValueError\n", " break\n", " x = new_x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "prev_nets" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "new_prev_nets" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "final_nets = []\n", "marging = 0.3\n", "for net_ths_1, net_ths_2 in zip(prev_nets, new_prev_nets):\n", " th_abs = net_ths_2[1][0] \n", " if net_ths_1[1][0] != net_ths_2[1][0]:\n", " th_abs = net_ths_2[1][0] + marging\n", " else:\n", " th_abs = net_ths_2[1][0]\n", " \n", " if net_ths_1[1][1] != net_ths_2[1][1]:\n", " th_pres = net_ths_2[1][1] + marging\n", " else:\n", " th_pres = net_ths_2[1][1]\n", " final_nets.append((net_ths_2[0], (th_abs, th_pres)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# new_prev_nets = copy(prev_nets)\n", "for x,y in tqdm(train):\n", " x = x.view(1,2,729)\n", " y = y.view(1,2,729)\n", " \n", " while (x!=y).any():\n", " new_x = forward_from_prev_nets_all(x, y, raise_if_error=False, prev_nets=final_nets, fix=False, full_loop=False)\n", " if (new_x == x).all():\n", " print(\"No improvment\")\n", " raise ValueError\n", " break\n", " x = new_x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "new_prev_nets = copy(final_nets)\n", "for x,y in tqdm(test):\n", " x = x.view(1,2,729)\n", " y = y.view(1,2,729)\n", " \n", " while (x!=y).any():\n", " new_x = forward_from_prev_nets_all(x, y, raise_if_error=False, prev_nets=new_prev_nets, fix=True)\n", " if (new_x == x).all():\n", " print(\"No improvment\")\n", " raise ValueError\n", " break\n", " x = new_x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# new_prev_nets = copy(prev_nets)\n", "for x,y in tqdm(train):\n", " x = x.view(1,2,729)\n", " y = y.view(1,2,729)\n", " \n", " while (x!=y).any():\n", " new_x = forward_from_prev_nets_all(x, y, raise_if_error=False, prev_nets=new_prev_nets, fix=True)\n", " if (new_x == x).all():\n", " print(\"No improvment\")\n", " raise ValueError\n", " break\n", " x = new_x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# new_prev_nets = copy(prev_nets)\n", "for x,y in tqdm(test):\n", " x = x.view(1,2,729)\n", " y = y.view(1,2,729)\n", " \n", " while (x!=y).any():\n", " new_x = forward_from_prev_nets_all(x, y, raise_if_error=False, prev_nets=new_prev_nets, fix=True, full_loop=False)\n", " if (new_x == x).all():\n", " print(\"No improvment\")\n", " raise ValueError\n", " break\n", " x = new_x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# new_prev_nets = copy(prev_nets)\n", "for x,y in tqdm(train):\n", " x = x.view(1,2,729)\n", " y = y.view(1,2,729)\n", " \n", " while (x!=y).any():\n", " new_x = forward_from_prev_nets_all(x, y, raise_if_error=False, prev_nets=final_nets, fix=False, full_loop=False)\n", " if (new_x == x).all():\n", " print(\"No improvment\")\n", " raise ValueError\n", " break\n", " x = new_x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# new_prev_nets = copy(prev_nets)\n", "for x,y in tqdm(test):\n", " x = x.view(1,2,729)\n", " y = y.view(1,2,729)\n", " \n", " while (x!=y).any():\n", " new_x = forward_from_prev_nets_all(x, y, raise_if_error=False, prev_nets=new_prev_nets, fix=False, full_loop=False)\n", " if (new_x == x).all():\n", " print(\"No improvment\")\n", " raise ValueError\n", " break\n", " x = new_x" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import joblib\n", "dump_list = []\n", "for i, (prev_net, (th_abs, th_pres) )in enumerate(final_nets):\n", " net_name = f\"f1_net_{i}\"\n", " torch.save(prev_net.state_dict(), net_name)\n", " dump_list.append((net_name,(th_abs, th_pres)))\n", "joblib.dump(dump_list, \"final_1_nets_thresholds.dump\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.4" }, "vscode": { "interpreter": { "hash": "4a11fbb48287677af515910e344e7fd440458d0e8105f20d811947f898600f5b" } } }, "nbformat": 4, "nbformat_minor": 2 }