diff --git "a/experiments/boost_training_7_m3_base_2.ipynb" "b/experiments/boost_training_7_m3_base_2.ipynb" new file mode 100644--- /dev/null +++ "b/experiments/boost_training_7_m3_base_2.ipynb" @@ -0,0 +1,8480 @@ +{ + "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 SmallNetBis, 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": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tensorboard = pl.loggers.TensorBoardLogger(save_dir=\"\")\n", + "torch.cuda.is_available()\n" + ] + }, + { + "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": 10, + "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=SmallNetBis()\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": 11, + "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": 12, + "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": 16, + "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", + "/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" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params\n", + "-----------------------------------------------------\n", + "0 | net | SmallNetBis | 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" + ] + }, + { + "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" + ] + }, + { + "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": "20639c853e804aed9adf36f18bc9a96b", + "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 : 1280\n", + "ratio : 0.9992193598750976\n", + " ratio number predicted/items: 0.0\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 : 1280\n", + "item counter : 1280\n", + "ratio : 0.9992193598750976\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 : 1280\n", + "item counter : 1280\n", + "ratio : 0.9992193598750976\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": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGzCAYAAAD0T7cVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA/8klEQVR4nO3de3RU1f3//1cSyIRoLoZILhBM0UILatImJsbLMmg+TaOiYi20+sGINmidtNVBbag1QUWhldJ8SkdZYjG2HyioVepHKFWjrijGIoH4tQJWStB4yQBFchk0gcn+/eGP0ZFwmWQyMyfzfKw1a3H27DnnPdtIXuyzzzlRxhgjAACAMBEd6gIAAAC+jHACAADCCuEEAACEFcIJAAAIK4QTAAAQVggnAAAgrBBOAABAWCGcAACAsEI4AQAAYYVwAiCk6urqFBUVpY0bN4a6FABhgnACAADCCuEEAACEFcIJAAAIK4QTAIPivffe080336wJEyZoxIgRGjlypL7//e9r586dffbfv3+/brzxRo0cOVKJiYm69tpr9cknn/j02bhxo0pLS5WamqoRI0boa1/7mq6//vogfBsAwTQs1AUAGJreeOMNvfbaa/rBD36gMWPGaOfOnXrooYdUXFysLVu2KD4+3qd/ZWWlkpOTNXfuXL3zzjt66KGH9N577+nll19WVFSUdu3ape985zs6+eSTVVVVpeTkZO3cuVNPPfVUiL4hgMFCOAEwKC655BJdddVVPm1TpkxRUVGR/vKXv2jGjBk+78XGxqq+vl7Dhw+XJJ1yyim644479H//93+67LLL9Nprr+mTTz7Rc889p/z8fO/n5s2bN/hfBkBQcVoHwKAYMWKE988HDhzQf/7zH5122mlKTk7Wpk2bDus/a9YsbzCRpB//+McaNmyY1q5dK0lKTk6WJD377LM6cODA4BYPIKQIJwAGxaeffqrq6mplZWXJZrMpNTVVJ598svbt26f29vbD+n/961/32T7xxBOVkZHhXaNywQUX6Hvf+57uvvtupaam6vLLL9ejjz6q7u7uYHwdAEFEOAEwKH7yk5/ovvvu07Rp0/T444/rueee0/PPP6+RI0eqt7fX7/1FRUXpySefVGNjoyorK/Xhhx/q+uuvV15enrq6ugbhGwAIFcIJgEHx5JNPqry8XL/5zW901VVX6b/+67903nnnad++fX32f/fdd322u7q69PHHHys7O9un/eyzz9Z9992njRs3avny5Xr77be1cuXKQfoWAEKBcAJgUMTExMgY49O2ePFieTyePvs//PDDPmtJHnroIR08eFBlZWWSpE8++eSw/eXm5koSp3aAIYardQAMiksvvVR/+tOflJSUpIkTJ6qxsVEvvPCCRo4c2Wf/np4eXXTRRZo2bZreeecdPfjggzrvvPN02WWXSZIee+wxPfjgg5o6dapOPfVUdXZ2aunSpUpMTNTFF18czK8GYJARTgAMiv/5n/9RTEyMli9frs8++0znnnuuXnjhBZWWlvbZ//e//72WL1+u6upqHThwQD/84Q/1u9/9TlFRUZI+XxC7YcMGrVy5Ui6XS0lJSSooKNDy5cv1ta99LZhfDcAgizJfnScFAAAIIdacAACAsEI4AQAAYYVwAgAAwgrhBAAAhBXCCQAACCuEEwAAEFYsd5+T3t5effTRR0pISPDe/wAAAIQ3Y4w6OzuVmZmp6Oijz41YLpx89NFHysrKCnUZAACgH1pbWzVmzJij9rFMOHE6nXI6nTp48KCkz79cYmJiiKsCgL653W5lZmZK+vwfVSeccEKIKwJCq6OjQ1lZWUpISDhmX8vdIbajo0NJSUlqb28nnAAIW263WyeeeKKkz5+wTDhBpPPn97dlFsQ6nU5NnDhRZ511VqhLAQAAg4iZEwAYBMycAL6G5MwJAACIDJYJJ5zWAQAgMnBaZyiYm/SlP7eHrg4AXpzWAXxxWmcomZvkGz6O1AYAwBBhmXDCaR0/EWAAABZlmXBit9u1ZcsWvfHGG6EuBQAADCLL3CE2Yhya7Qj02hHWpQAALMIyMycAACAyWCacsOZkELAuBQAQhiwTTobkmhPCAQAAh7FMOAEAAJGBcAIAAMIKV+sEi1Wulhmsq4UAADhOzJwAAICwYplwwtU6AABEBsuEkyF5tQ4AADiMZcIJQoTLnQEAQUY4AQAAYSVk4WT//v065ZRTdNttt4WqBAAAEIZCFk7uu+8+nX322aE6/ODjdAgAAP0SknDy7rvvatu2bSorKwvF4QEAQBjzO5w0NDRoypQpyszMVFRUlFavXn1YH6fTqezsbMXFxamwsFAbNmzwef+2227T/Pnz+130UJNdteaYbdlVa/rsFxLMCgEABpHf4cTtdisnJ0dOp7PP91etWiWHw6Gamhpt2rRJOTk5Ki0t1a5duyRJf/3rXzV+/HiNHz9+YJUDAIAhye/b15eVlR31dMyiRYtUUVGhmTNnSpKWLFmiNWvWaNmyZaqqqtLrr7+ulStX6oknnlBXV5cOHDigxMREVVdX97m/7u5udXd3e7c7Ojr8LTnsZFet0c4Fl4TNfgAACCcBXXPS09OjpqYmlZSUfHGA6GiVlJSosbFRkjR//ny1trZq586dWrhwoSoqKo4YTA71T0pK8r6ysrICWTIAAAgzAQ0ne/bskcfjUVpamk97Wlqa2tra+rXPOXPmqL29XQsXLtSECRN02mmnBaLUISts1qUgeFgDBGCICelTia+77rpj9rHZbLLZbJo9e7Zmz56tjo4OJSVZ5y/iiDj1YpUnLoeb43kCdF99+vs5ALCIgIaT1NRUxcTEyOVy+bS7XC6lp6cPaN9Op1NOp1Mej2dA+wGC4qvhgAAHAMctoKd1YmNjlZeXp/r6em9bb2+v6uvrVVRUNKB98+C//uE0TxAE6rTKof0MximavvbN6SAAYcrvmZOuri5t377du93S0qLm5malpKRo7NixcjgcKi8vV35+vgoKClRbWyu32+29eqe/mDkBACAy+B1ONm7cqMmTJ3u3HQ6HJKm8vFx1dXWaPn26du/ererqarW1tSk3N1fr1q07bJGsv+x2u+x2u+XWnMDi+rvmAwDQb36Hk+LiYhljjtqnsrJSlZWV/S6qL8ycBE5QFula8Rd4pK8L6ev7W/G/IwDLC9mD//zFmhMEHGsuACAshfRS4iEj0v/FbQX8NwocZlMADDLLzJw4nU5NnDhRZ511VqhLOSqujgEAYGAsM3PCgliLG8yZCxathhZjDSDALDNzgsHDbA8AIJxYJpxY5bQOgoCFrAAwpFkmnHC1zhB0PCGDIGJN/HcDMACWCSeIEPxSA4CIRzgBAABhxTLhhDUnAABEBsuEE9acBBdX8AAAQsUy9zkBYGHcoReAHywzcwIAACID4QQAAIQVwgkAAAgrlgknXK0TWtlVa1gki8DinjYAjsAy4YSrdQAAiAyWCScAACAyEE4AAEBYCXo42bdvn/Lz85Wbm6vTTz9dS5cuDXYJAAAgjAX9JmwJCQlqaGhQfHy83G63Tj/9dF155ZUaOXJksEsBAABhKOjhJCYmRvHx8ZKk7u5uGWNkjAl2GQDCDXeRBfD/8/u0TkNDg6ZMmaLMzExFRUVp9erVh/VxOp3Kzs5WXFycCgsLtWHDBp/39+3bp5ycHI0ZM0a33367UlNT+/0FAADA0OJ3OHG73crJyZHT6ezz/VWrVsnhcKimpkabNm1STk6OSktLtWvXLm+f5ORkvfnmm2ppadGKFSvkcrmOeLzu7m51dHT4vAAAwNDldzgpKyvTvHnzNHXq1D7fX7RokSoqKjRz5kxNnDhRS5YsUXx8vJYtW3ZY37S0NOXk5OiVV1454vHmz5+vpKQk7ysrK8vfkjFIuCkbAGAwBPRqnZ6eHjU1NamkpOSLA0RHq6SkRI2NjZIkl8ulzs5OSVJ7e7saGho0YcKEI+5zzpw5am9v975aW1sDWTIAAAgzAV0Qu2fPHnk8HqWlpfm0p6Wladu2bZKk9957T7NmzfIuhP3JT36iM84444j7tNlsstlscjqdcjqd8ng8gSy53w7NGuxccEmIKwEAYGgJ+tU6BQUFam5u9vtzdrtddrtdHR0dSkrieRwAAAxVAT2tk5qaqpiYmMMWuLpcLqWnpw9o3zz4DwCAyBDQcBIbG6u8vDzV19d723p7e1VfX6+ioqIB7ZsH/wEAEBn8Pq3T1dWl7du3e7dbWlrU3NyslJQUjR07Vg6HQ+Xl5crPz1dBQYFqa2vldrs1c+bMARUabmtOAATBoRuzcVM2IKL4HU42btyoyZMne7cdDockqby8XHV1dZo+fbp2796t6upqtbW1KTc3V+vWrTtskay/WHMCAEBk8DucFBcXH/N285WVlaqsrOx3UX0Jq5mTuUnaGSdlf7Yi1JUAADDkBP2pxP3FmhMAACKDZcIJV+tYA3eNBQAMlGXCCTMnAABEBsuEEwCQ9PkVPHNZFA8MZYQTAAAQViwTTlhzAgBAZLBMOGHNCQAAkcEy4QQAAEQGwgkAAAgrlgknrDkBACAyWCacsOYEQJ+4tBgYciwTTgAAQGQgnGBQcTt7AIC/CCcAACCsWCacsCAWAIDIYJlwwoJYAAAig2XCCQAAiAyEEwAAEFYIJwAAIKwEPZy0traquLhYEydO1Jlnnqknnngi2CUAGOq4MRtgacOCfsBhw1RbW6vc3Fy1tbUpLy9PF198sU444YRglwIAAMJQ0MNJRkaGMjIyJEnp6elKTU3V3r17CScAAEBSP07rNDQ0aMqUKcrMzFRUVJRWr159WB+n06ns7GzFxcWpsLBQGzZs6HNfTU1N8ng8ysrK8rtwAAAwNPkdTtxut3JycuR0Ovt8f9WqVXI4HKqpqdGmTZuUk5Oj0tJS7dq1y6ff3r17de211+rhhx8+6vG6u7vV0dHh8wIAAEOX3+GkrKxM8+bN09SpU/t8f9GiRaqoqNDMmTM1ceJELVmyRPHx8Vq2bJm3T3d3t6644gpVVVXpnHPOOerx5s+fr6SkJO+LWRbr43k7AICjCejVOj09PWpqalJJSckXB4iOVklJiRobGyVJxhhdd911uvDCCzVjxoxj7nPOnDlqb2/3vlpbWwNZMgAACDMBDSd79uyRx+NRWlqaT3taWpra2tokSevXr9eqVau0evVq5ebmKjc3V2+99dYR92mz2ZSYmKg//elPOvvss3XRRRcFsmQAABBmgn61znnnnafe3l6/P2e322W329XR0aGkJO5fAADAUBXQmZPU1FTFxMTI5XL5tLtcLqWnpw9o3zyVGACAyBDQcBIbG6u8vDzV19d723p7e1VfX6+ioqJAHgoAAAxRfp/W6erq0vbt273bLS0tam5uVkpKisaOHSuHw6Hy8nLl5+eroKBAtbW1crvdmjlz5oAK5bQOAACRwe9wsnHjRk2ePNm77XA4JEnl5eWqq6vT9OnTtXv3blVXV6utrU25ublat27dYYtkASBoDj1nZ257aOsAcFz8DifFxcUyxhy1T2VlpSorK/tdVF+cTqecTqc8Hk9A9wsAAMJL0J9K3F92u11btmzRG2+8EepSAADAILJMOOFqHQAAIoNlwgkzJwAARAbLhBMAABAZLBNOOK0DAEBksEw44bTO0MVTigEAX2aZcAIAACID4QQAAIQVwgkAAAgrlgknLIgFACAyWCacsCAWAIDIYJlwAgAAIgPhBAAAhBXCCQAACCuWCScsiAUAIDJYJpywIBZAQM1N+vwFIOxYJpwAAIDIMCzUBVjBl5/9snPBJSGsBACAoY+ZEwAAEFZCEk6mTp2qk046SVdddVUoDg8Ahzu0BoV1KEDIhSSc/OxnP9Mf//jHUBwaAACEuZCEk+LiYiUkJITi0AAAIMz5HU4aGho0ZcoUZWZmKioqSqtXrz6sj9PpVHZ2tuLi4lRYWKgNGzYEolYAABAB/A4nbrdbOTk5cjqdfb6/atUqORwO1dTUaNOmTcrJyVFpaal27drVrwK7u7vV0dHh8wIAAEOX3+GkrKxM8+bN09SpU/t8f9GiRaqoqNDMmTM1ceJELVmyRPHx8Vq2bFm/Cpw/f76SkpK8r6ysrH7tBwAAWENA15z09PSoqalJJSUlXxwgOlolJSVqbGzs1z7nzJmj9vZ276u1tTVQ5QIAgDAU0Juw7dmzRx6PR2lpaT7taWlp2rZtm3e7pKREb775ptxut8aMGaMnnnhCRUVFfe7TZrPJZrPJ6XTK6XTK4/EEsmQAABBmQnKH2BdeeCEUh4WFZFet4W68ABChAnpaJzU1VTExMXK5XD7tLpdL6enpA9o3D/4DACAyBDScxMbGKi8vT/X19d623t5e1dfXH/G0zfFyOp2aOHGizjrrrIGWCQAAwpjfp3W6urq0fft273ZLS4uam5uVkpKisWPHyuFwqLy8XPn5+SooKFBtba3cbrdmzpw5oELtdrvsdrs6OjqUlMTtpQEAGKr8DicbN27U5MmTvdsOh0OSVF5errq6Ok2fPl27d+9WdXW12tralJubq3Xr1h22SNZfLIgFACAy+B1OiouLZYw5ap/KykpVVlb2u6i+MHMCAEBkCMmzdQAAAI7EMuGEBbEAAEQGy4QTLiUGACAyWCacAACAyGCZcMJpHQAAIoNlwgmndQAAiAyWCScAACAyEE4AAEBYsUw4Cdmak7lJ2hl3dXCPCSA8zE36/AUgqCwTTlhzAgBAZLBMOAEAAJGBcAIAAMIK4QQAAIQVwgkAAAgrlgkn3CEWQFjiih4g4CwTTrhaBwCAyGCZcAIAACID4QQAAISVkISTZ599VhMmTNDXv/51PfLII6EoAQAAhKlhwT7gwYMH5XA49NJLLykpKUl5eXmaOnWqRo4cGexSAABAGAr6zMmGDRs0adIkjR49WieeeKLKysr03HPPBbsMAAAQpvwOJw0NDZoyZYoyMzMVFRWl1atXH9bH6XQqOztbcXFxKiws1IYNG7zvffTRRxo9erR3e/To0frwww/7Vz0AABhy/A4nbrdbOTk5cjqdfb6/atUqORwO1dTUaNOmTcrJyVFpaal27do14GIBAMDQ53c4KSsr07x58zR16tQ+31+0aJEqKio0c+ZMTZw4UUuWLFF8fLyWLVsmScrMzPSZKfnwww+VmZl5xON1d3ero6PD5wUAAIaugK456enpUVNTk0pKSr44QHS0SkpK1NjYKEkqKCjQP//5T3344Yfq6urS3/72N5WWlh5xn/Pnz1dSUpL3lZWVFciSYRHZVWuUXbUm1GUg0h26Gyx3hAUGVUDDyZ49e+TxeJSWlubTnpaWpra2NknSsGHD9Jvf/EaTJ09Wbm6uZs+efdQrdebMmaP29nbvq7W1NZAlAwCAMBP0S4kl6bLLLtNll112XH1tNptsNpucTqecTqc8Hs8gVwcAAEIpoDMnqampiomJkcvl8ml3uVxKT08P5KEAAMAQFdBwEhsbq7y8PNXX13vbent7VV9fr6KiogHtmwf/AQAQGfw+rdPV1aXt27d7t1taWtTc3KyUlBSNHTtWDodD5eXlys/PV0FBgWpra+V2uzVz5swBFcppHQAAIoPf4WTjxo2aPHmyd9vhcEiSysvLVVdXp+nTp2v37t2qrq5WW1ubcnNztW7dusMWyfrLbrfLbrero6NDSUmslAcAYKjyO5wUFxfLGHPUPpWVlaqsrOx3UX05NHNy8OBBSQre/U66P/+uvd37vzjul9q+vN1Xm199vnK8r/bh+L7H11c+oy//TBypz9E+dzx9jvY5jh/+xw9Wjfr8hpVfdO1g1hcR79Df88fKEJIUZY6nVxj54IMPuNcJAAAW1draqjFjxhy1j+XCSW9vrz766CMlJCQoKioq4Pvv6OhQVlaWWltblZiYGPD943OMc/Aw1sHBOAcH4xw8gR5rY4w6OzuVmZmp6OijX48TkvucDER0dPQxE1cgJCYm8oMfBIxz8DDWwcE4BwfjHDyBHOvjXTMa0EuJAQAABopwAgAAwgrh5CtsNptqampks9lCXcqQxjgHD2MdHIxzcDDOwRPKsbbcglgAADC0MXMCAADCCuEEAACEFcIJAAAIK4QTAAAQViIynDidTmVnZysuLk6FhYXasGHDUfs/8cQT+sY3vqG4uDidccYZWrt2bZAqtTZ/xnnp0qU6//zzddJJJ+mkk05SSUnJMf+74Av+/kwfsnLlSkVFRemKK64Y3AKHCH/Hed++fbLb7crIyJDNZtP48eP5++M4+DvOtbW1mjBhgkaMGKGsrCzdeuut+uyzz4JUrTU1NDRoypQpyszMVFRUlFavXn3Mz7z88sv69re/LZvNptNOO011dXWDV6CJMCtXrjSxsbFm2bJl5u233zYVFRUmOTnZuFyuPvuvX7/exMTEmF//+tdmy5Yt5pe//KUZPny4eeutt4JcubX4O85XX321cTqdZvPmzWbr1q3muuuuM0lJSeaDDz4IcuXW4+9YH9LS0mJGjx5tzj//fHP55ZcHp1gL83ecu7u7TX5+vrn44ovNq6++alpaWszLL79smpubg1y5tfg7zsuXLzc2m80sX77ctLS0mL///e8mIyPD3HrrrUGu3FrWrl1r7rzzTvPUU08ZSebpp58+av8dO3aY+Ph443A4zJYtW8zixYtNTEyMWbdu3aDUF3HhpKCgwNjtdu+2x+MxmZmZZv78+X32nzZtmrnkkkt82goLC82NN944qHVanb/j/FUHDx40CQkJ5rHHHhusEoeM/oz1wYMHzTnnnGMeeeQRU15eTjg5Dv6O80MPPWTGjRtnenp6glXikODvONvtdnPhhRf6tDkcDnPuuecOap1DyfGEkzvuuMNMmjTJp2369OmmtLR0UGqKqNM6PT09ampqUklJibctOjpaJSUlamxs7PMzjY2NPv0lqbS09Ij90b9x/qr9+/frwIEDSklJGawyh4T+jvU999yjUaNG6YYbbghGmZbXn3F+5plnVFRUJLvdrrS0NJ1++um6//775fF4glW25fRnnM855xw1NTV5T/3s2LFDa9eu1cUXXxyUmiNFsH8XWu7BfwOxZ88eeTwepaWl+bSnpaVp27ZtfX6mra2tz/5tbW2DVqfV9Wecv+rnP/+5MjMzD/ufAb76M9avvvqq/vCHP6i5uTkIFR6/3t5e9fT0KC4uLtSlHKY/47xjxw69+OKLuuaaa7R27Vpt375dN998sw4cOKCamppglG05/Rnnq6++Wnv27NF5550nY4wOHjyom266Sb/4xS+CUXLEONLvwo6ODn366acaMWJEQI8XUTMnsIYFCxZo5cqVevrpp8PyF5WVdXZ2asaMGVq6dKlSU1MH5Rhz585VVFSUtm3bpmnTpikxMVEjR47Uz372M59FilFRUaqsrNTy5cs1adIk2Ww2rVu3TpL04Ycf6vrrr1daWppsNpsmTZqkZcuWHXasxYsXa9KkSYqPj9dJJ52k/Px8rVixYlC+l796e3s1atQoPfzww8rLy9P06dN15513asmSJaEubUh5+eWXdf/99+vBBx/Upk2b9NRTT2nNmjW69957Q10aBiCiZk5SU1MVExMjl8vl0+5yuZSent7nZ9LT0/3qj/6N8yELFy7UggUL9MILL+jMM88czDKHBH/H+t///rd27typKVOmeNt6e3slScOGDdM777yjU089NSC1TZs2TdnZ2Zo/f75ef/11/e53v9Mnn3yiP/7xj94+L774oh5//HFVVlYqNTVV2dnZcrlcOvvss73h5eSTT9bf/vY33XDDDero6NAtt9wi6fMrvH7605/qqquu8gaf//f//p/+8Y9/6Oqrrw7IdzikPz/TGRkZGj58uGJiYrxt3/zmN9XW1qaenh7FxsYGtMahoD/jfNddd2nGjBn60Y9+JEk644wz5Ha7NWvWLN15552Kjubf4IFwpN+FiYmJAZ81kRR5V+sUFBSYyspK77bH4zGjR48+6oLYSy+91KetqKiIBbHH4O84G2PMr371K5OYmGgaGxuDUeKQ4c9Yf/rpp+att97yeV1++eXmwgsvNG+99Zbp7u4ecD01NTVGkrnssst82m+++WYjybz55pvGmM8X4UVHR5u3337bp98NN9xgMjIyzJ49e3zaf/CDH5ikpCSzf/9+Y4wxl19++WEL9AaTvz/Tc+bMMaeccorxeDzettraWpORkTHotVqZv+P87W9/29xxxx0+bStWrDAjRowwBw8eHNRahwod54LY008/3afthz/84aAtiI24cLJy5Upjs9lMXV2d2bJli5k1a5ZJTk42bW1txhhjZsyYYaqqqrz9169fb4YNG2YWLlxotm7dampqariU+Dj4O84LFiwwsbGx5sknnzQff/yx99XZ2Rmqr2AZ/o71VwX6ap1D4eTvf/+7T/vWrVuNJO8vGUlm8uTJPn16e3tNcnKymTVrltm9e7fP69FHHzWSzKuvvuqtOykpyWzYsCFgtR+Nv+P8/vvvm4SEBFNZWWneeecd8+yzz5pRo0aZefPmBaVeq/J3nGtqakxCQoL585//bHbs2GGee+45c+qpp5pp06aF6itYQmdnp9m8ebPZvHmzkWQWLVpkNm/ebN577z1jjDFVVVVmxowZ3v6HLiW+/fbbzdatW43T6eRS4kBbvHixGTt2rImNjTUFBQXm9ddf9753wQUXmPLycp/+jz/+uBk/fryJjY01kyZNMmvWrAlyxdbkzzifcsopRtJhr5qamuAXbkH+/kx/2WCFkx07dvi09/T0mOjoaO+soyRz/fXX+/RxuVx9/hx8+fXUU08ZY4zZsmWLGT16tJFkTjvtNHPzzTd7g8tg8XecX3vtNVNYWGhsNpsZN26cue+++/jX/HHwZ5wPHDhg5s6da0499VQTFxdnsrKyzM0332w++eST4BduIS+99FKf/38dGtvy8nJzwQUXHPaZ3NxcExsba8aNG2ceffTRQasvyhhjAn+yCECkmjt3ru6++27t2LFDX/va17ztBw8elM1mU0VFhZYsWaKoqCjZ7Xb9/ve/9/Zpa2tTRkaG/vu//1vl5eV97v/MM8/UqFGjJElut1vPPvus1q1bp7/97W9yuVyqrq7W3XffPbhfEsCgiqgFsQCC59133/UJJ9u3b1dvb6+ys7OP+JmTTz5ZCQkJ8ng8x3UZ+QknnKDp06dr+vTp6unp0ZVXXqn77rtPc+bM4UovwMJYxgxgUDidTp/txYsXS5LKysqO+JmYmBh973vf01/+8hf985//POz93bt3e//8n//8x+e92NhYTZw4UcYYHThwYCClAwgxZk4ADIqWlhZddtll+u53v6vGxkb97//+r66++mrl5OQc9XMLFizQSy+9pMLCQlVUVGjixInau3evNm3apBdeeEF79+6VJH3nO99Renq6zj33XKWlpWnr1q36/e9/r0suuUQJCQnB+IoABgnhBMCgWLVqlaqrq1VVVaVhw4apsrJSDzzwwDE/l5aWpg0bNuiee+7RU089pQcffFAjR47UpEmT9Ktf/crb78Ybb9Ty5cu1aNEidXV1acyYMfrpT3+qX/7yl4P5tQAEAQtiAQTUoQWxu3fvHrS70AIY2lhzAgAAwgrhBAAAhBXCCQAACCusOQEAAGGFmRMAABBWLHcpcW9vrz766CMlJCQoKioq1OUAAIDjYIxRZ2enMjMzFR199LkRy4WTjz76SFlZWaEuAwAA9ENra6vGjBlz1D6WCyeH7vzY2tqqxMTEEFcDINjcbrcyMzMlff6PlRNOOCHEFQE4Hh0dHcrKyjquOzhbJpw4nU45nU55PB5JUmJiIuEEiEAxMTHePycmJhJOAIs5niUZlrtap6OjQ0lJSWpvbyecABHI7XbrxBNPlCR1dXURTgCL8Of3t2Wu1nE6nZo4caLOOuusUJcCAAAGETMnACyFmRPAmvz5/W3ZNScAAAyW3t5e9fT0hLoMSxk+fLjPmrCBYOYEgKUwc4LB1tPTo5aWFvX29oa6FMtJTk5Wenp6n4teh+TMSShlV63x/nnngktCWAkAYDAZY/Txxx8rJiZGWVlZx7xZGD5njNH+/fu1a9cuSVJGRsaA9meZcMJpHQDAYDt48KD279+vzMxMxcfHh7ocSxkxYoQkadeuXRo1atSATvFYJhLa7XZt2bJFb7zxxqAfK7tqjc9sCQAgMhz6B3BsbGyIK7GmQ4HuwIEDA9qPZcIJAADBwrPb+idQ40Y4AQAAYcUy4YSbsAEAEBkssyDWbrfLbrd7L0UCACBYgr0OMdKvDLXMzAkAAAiuvXv36pprrlFiYqKSk5N1ww03qKura9CPSzgBACACHc8dcK+55hq9/fbbev755/Xss8+qoaFBs2bNGvTaCCcAAAwBnZ2duuaaa3TCCScoIyNDv/3tb1VcXKxbbrlFkpSdna17771X1157rRITE48ZMrZu3ap169bpkUceUWFhoc477zwtXrxYK1eu1EcffTSo38Uy4YQFsQAAHJnD4dD69ev1zDPP6Pnnn9crr7yiTZs2+fRZuHChcnJytHnzZt11111H3V9jY6OSk5OVn5/vbSspKVF0dLT+8Y9/DMp3OIQFsQAAWFxnZ6cee+wxrVixQhdddJEk6dFHH1VmZqZPvwsvvFCzZ88+rn22tbVp1KhRPm3Dhg1TSkqK2traAlP4EVhm5gQAAPRtx44dOnDggAoKCrxtSUlJmjBhgk+/L8+ChLOQzJxkZ2crMTFR0dHROumkk/TSSy+FogwAACKKP0/xTk9P9z7I75CDBw9q7969Sk9PD3RpPkI2c/Laa6+pubmZYAIAwACNGzdOw4cP93n+XHt7u/71r3/1e59FRUXat2+fmpqavG0vvviient7VVhYOKB6j8Uya04AAEDfEhISVF5erttvv10pKSkaNWqUampqFB0d3e/n3Xzzm9/Ud7/7XVVUVGjJkiU6cOCAKisr9YMf/OCwtSyB5nc4aWho0AMPPKCmpiZ9/PHHevrpp3XFFVf49HE6nXrggQfU1tamnJwcLV682Oc8WFRUlC644AJFR0frlltu0TXXXDPgLwIAwGCxwh1bFy1apJtuukmXXnqpEhMTdccdd6i1tVVxcXH93ufy5ctVWVmpiy66SNHR0fre976n3/3udwGsum9+hxO3262cnBxdf/31uvLKKw97f9WqVXI4HFqyZIkKCwtVW1ur0tJSvfPOO95Vv6+++qpGjx6tjz/+WCUlJTrjjDN05plnDvzbAAAQoRISErR8+XLvttvt1t133+29n8nOnTv93mdKSopWrFgRqBKPm9/hpKysTGVlZUd8f9GiRaqoqNDMmTMlSUuWLNGaNWu0bNkyVVVVSZJGjx4tScrIyNDFF1+sTZs2HTGcdHd3q7u727vd0dHhb8kAAAx5mzdv1rZt21RQUKD29nbdc889kqTLL788xJX5L6ALYnt6etTU1KSSkpIvDhAdrZKSEjU2Nkr6PMl1dnZKkrq6uvTiiy9q0qRJR9zn/PnzlZSU5H1lZWUFsmQAAIaMQzdZKykpkdvt1iuvvKLU1NQ++95///068cQT+3wdbRIiGAK6IHbPnj3yeDxKS0vzaU9LS9O2bdskSS6XS1OnTpUkeTweVVRUHPWur3PmzJHD4dDSpUu1dOlSeTwebd++PZBlAwBged/61rd8rqw5lptuuknTpk3r870RI0YEqqx+CfrVOuPGjdObb7553P1tNptsNptmz56t2bNnc4dYAAACICUlRSkpKaEuo08BPa2TmpqqmJgYuVwun3aXyzXgG7bwbB0AACJDQMNJbGys8vLyVF9f723r7e1VfX29ioqKAnkoAAAwRPl9Wqerq8tnzUdLS4uam5uVkpKisWPHyuFwqLy8XPn5+SooKFBtba3cbrf36p3+4sF/AABEBr/DycaNGzV58mTvtsPhkCSVl5errq5O06dP1+7du1VdXa22tjbl5uZq3bp1hy2S9ZfT6ZTT6ZTH4xnQfgAAQHjzO5wUFxfLGHPUPpWVlaqsrOx3UX1h5gQAgMjAs3WOZW6SdsZJ2Z8F/w55AIAwMTfI/yie2x7c44WZkD2V2F9crQMAQHDdd999OueccxQfH6/k5OSgHdcy4cRut2vLli0+j4MGAAD909PTc1x9vv/97+vHP/5xECr6gmXCCQAAOLLOzk5dc801OuGEE5SRkaHf/va3Ki4u1i233CJJys7O1r333qtrr71WiYmJ3gcCHs3dd9+tW2+9VWecccYgV+/LMuGE0zoAAByZw+HQ+vXr9cwzz+j555/XK6+8ok2bNvn0OfTsnc2bN+uuu+4KUaXHZpkFsVytAwBA3zo7O/XYY49pxYoVuuiiiyRJjz76qDIzM336XXjhhZo9e3YoSvSLZWZOAABA33bs2KEDBw6ooKDA25aUlKQJEyb49MvPzw92af1imXDCaR0AAAbmhBNOCHUJx8Uy4STcrtbJrlqj7Ko1oS4DAACNGzdOw4cP9/kd2d7ern/9618hrKr/LLPmBAAA9C0hIUHl5eW6/fbblZKSolGjRqmmpkbR0dGKiorq937ff/997d27V++//748Ho+am5slSaeddppOPPHEAFV/OMIJAADHYoE7ti5atEg33XSTLr30UiUmJuqOO+5Qa2ur4uLi+r3P6upqPfbYY97tb33rW5Kkl156ScXFxQMt+YgIJwAADAEJCQlavny5d9vtduvuu+/23s9k586dfu+zrq5OdXV1Aarw+FkmnPBUYgAAjmzz5s3atm2bCgoK1N7ernvuuUeSdPnll4e4Mv+xIBYAgCHi0E3WSkpK5Ha79corryg1NbXPvvfff79OPPHEPl9lZWVBrtyXZWZOAADAkX3rW99SU1PTcfe/6aabNG3atD7fGzFiRKDK6hfCCQAAESglJUUpKSmhLqNPITuts3//fp1yyim67bbbQlUCAAB9MsaEugRLCtS4hSyc3HfffTr77LNDdXgAAA4TExMjSerp6QlxJda0f/9+SdLw4cMHtJ+QnNZ59913tW3bNk2ZMkX//Oc/Q1ECAACHGTZsmOLj47V7924NHz5c0dGWuW4kpIwx2r9/v3bt2qXk5GRvyOsvv8NJQ0ODHnjgATU1Nenjjz/W008/rSuuuMKnj9Pp1AMPPKC2tjbl5ORo8eLFPg8juu222/TAAw/otddeG1Dxg2JuknbGSdmfrQh1JQCAIIuKilJGRoZaWlr03nvvhbocy0lOTlZ6evqA9+N3OHG73crJydH111+vK6+88rD3V61aJYfDoSVLlqiwsFC1tbUqLS3VO++8o1GjRumvf/2rxo8fr/Hjxx9XOOnu7lZ3d7d3u6Ojw9+SAQA4brGxsfr617/OqR0/DR8+fMAzJof4HU7KysqOev3zokWLVFFRoZkzZ0qSlixZojVr1mjZsmWqqqrS66+/rpUrV+qJJ55QV1eXDhw4oMTERFVXV/e5v/nz5+vuu+/2t0wAAPotOjp6QLd9x8AE9GRaT0+PmpqaVFJS8sUBoqNVUlKixsZGSZ+HjdbWVu3cuVMLFy5URUXFEYOJJM2ZM0ft7e3eV2trayBLBgAAYSag4WTPnj3yeDxKS0vzaU9LS1NbW1u/9mmz2ZSYmKg//elPOvvss3XRRRcFolQAABCmQnoTtuuuuy6UhwcAAGEooDMnqampiomJkcvl8ml3uVwDXr3Ls3UAAIgMAQ0nsbGxysvLU319vbett7dX9fX1KioqGtC+nU6nJk6cqLPOOmugZQ7c3CTtjLs61FUAADAk+X1ap6urS9u3b/dut7S0qLm5WSkpKRo7dqwcDofKy8uVn5+vgoIC1dbWyu12e6/e6S+73S673a6Ojg4lJSUNaF8AACB8+R1ONm7cqMmTJ3u3HQ6HJKm8vFx1dXWaPn26du/ererqarW1tSk3N1fr1q07bJGsv5xOp5xOpzwez4D2AwAAwpvf4aS4uPiYD/aprKxUZWVlv4vqCzMnAABEBss8NCCs1pwAAIBBY5lwwtU6AABEBsuEEwAAEBksE044rQMAQGSwTDjhtA4AAJHBMuEEAABEBsIJAAAIK5YJJ6w5AQAgMlgmnLDmBACAyGCZcAIAACID4QQAAIQVwgkAAAgrlgknLIgFACAyWCacsCAWAIDIYJlwAgAAIkPQw8m+ffuUn5+v3NxcnX766Vq6dGmwSwAAAGFsWLAPmJCQoIaGBsXHx8vtduv000/XlVdeqZEjRwa7FAAAEIaCPnMSExOj+Ph4SVJ3d7eMMTLGBLsMAAAQpvwOJw0NDZoyZYoyMzMVFRWl1atXH9bH6XQqOztbcXFxKiws1IYNG3ze37dvn3JycjRmzBjdfvvtSk1N7fcXAAAAQ4vf4cTtdisnJ0dOp7PP91etWiWHw6Gamhpt2rRJOTk5Ki0t1a5du7x9kpOT9eabb6qlpUUrVqyQy+Xq/zcAAABDit/hpKysTPPmzdPUqVP7fH/RokWqqKjQzJkzNXHiRC1ZskTx8fFatmzZYX3T0tKUk5OjV1555YjH6+7uVkdHh88LAAAMXQFdc9LT06OmpiaVlJR8cYDoaJWUlKixsVGS5HK51NnZKUlqb29XQ0ODJkyYcMR9zp8/X0lJSd5XVlZWIEsGAABhJqDhZM+ePfJ4PEpLS/NpT0tLU1tbmyTpvffe0/nnn6+cnBydf/75+slPfqIzzjjjiPucM2eO2tvbtXDhQk2YMEGnnXZaIEsGAABhJuiXEhcUFKi5ufm4+9tsNtlsNs2ePVuzZ89WR0eHkpKSBq9AAAAQUgGdOUlNTVVMTMxhC1xdLpfS09MHtG+erQMAQGQIaDiJjY1VXl6e6uvrvW29vb2qr69XUVHRgPYd7s/Wya5a430BAID+8/u0TldXl7Zv3+7dbmlpUXNzs1JSUjR27Fg5HA6Vl5crPz9fBQUFqq2tldvt1syZMwdUqNPplNPplMfjGdB+AABAePM7nGzcuFGTJ0/2bjscDklSeXm56urqNH36dO3evVvV1dVqa2tTbm6u1q1bd9giWX/Z7XbZ7XbWnAAAMMT5HU6Ki4uPebv5yspKVVZW9ruovjBzAgBAZAj6s3X6K9zXnAAAgMCwTDjhah0AACKDZcIJMycAAEQGy4QTAAAQGSwTTjitAwBAZLBMOOG0DgAAkcEy4QQAAESGoD/4r7/C+j4nc5O0M+7zP2Z/tiK0tQAAYHGWmTnhtA4AAJHBMuEEAABEBsIJAAAIK4QTAAAQVggnAAAgrFgmnHATNgAAIoNlwglX6wAAEBksE04AAEBkCHo4aW1tVXFxsSZOnKgzzzxTTzzxRLBLAAAAYSzod4gdNmyYamtrlZubq7a2NuXl5eniiy/WCSecEOxSAABAGAp6OMnIyFBGRoYkKT09Xampqdq7dy/hBAAASOrHaZ2GhgZNmTJFmZmZioqK0urVqw/r43Q6lZ2drbi4OBUWFmrDhg197qupqUkej0dZWVl+Fw4AAIYmv8OJ2+1WTk6OnE5nn++vWrVKDodDNTU12rRpk3JyclRaWqpdu3b59Nu7d6+uvfZaPfzww/2rHAAADEl+n9YpKytTWVnZEd9ftGiRKioqNHPmTEnSkiVLtGbNGi1btkxVVVWSpO7ubl1xxRWqqqrSOeecc9TjdXd3q7u727vd0dHhb8kAAMBCAnq1Tk9Pj5qamlRSUvLFAaKjVVJSosbGRkmSMUbXXXedLrzwQs2YMeOY+5w/f76SkpK8L04BAQAwtAU0nOzZs0cej0dpaWk+7WlpaWpra5MkrV+/XqtWrdLq1auVm5ur3NxcvfXWW0fc55w5c9Te3q6FCxdqwoQJOu200wJZMgAACDNBv1rnvPPOU29v73H3t9lsstlsiouLU3R0tIwxg1gdAAAItYDOnKSmpiomJkYul8un3eVyKT09fUD75vb1AABEhoCGk9jYWOXl5am+vt7b1tvbq/r6ehUVFQ1o3zz4DwCAyOD3aZ2uri5t377du93S0qLm5malpKRo7NixcjgcKi8vV35+vgoKClRbWyu32+29eqe/7Ha77Ha7Ojo6lJSUNKB9AQCA8OV3ONm4caMmT57s3XY4HJKk8vJy1dXVafr06dq9e7eqq6vV1tam3NxcrVu37rBFsv5yOp1yOp3yeDwD2g8AAAhvfoeT4uLiYy5KraysVGVlZb+L6gszJwAARIagP5W4v1hzAgBAZLBMOOFqHQAAIoNlwgkAAIgMlgknnNYBACAyWCaccFoHAIDIYJlwAgAAIgPhBAAAhBXLhBPWnAAAEBksE05YcwIAQGSwTDgBAACRgXACAADCCuEEAACEFcuEExbEAgAQGSwTTlgQCwBAZLBMOAEAAJGBcAIAAMJKSMLJ1KlTddJJJ+mqq64KxeEBAEAYC0k4+dnPfqY//vGPoTg0AAAIcyEJJ8XFxUpISAjFoQEAQJjzO5w0NDRoypQpyszMVFRUlFavXn1YH6fTqezsbMXFxamwsFAbNmwIRK0AACAC+B1O3G63cnJy5HQ6+3x/1apVcjgcqqmp0aZNm5STk6PS0lLt2rWrXwV2d3ero6PD5wUAAIYuv8NJWVmZ5s2bp6lTp/b5/qJFi1RRUaGZM2dq4sSJWrJkieLj47Vs2bJ+FTh//nwlJSV5X1lZWf3aDwAAsIaArjnp6elRU1OTSkpKvjhAdLRKSkrU2NjYr33OmTNH7e3t3ldra2ugygUAAGFoWCB3tmfPHnk8HqWlpfm0p6Wladu2bd7tkpISvfnmm3K73RozZoyeeOIJFRUV9blPm80mm80mp9Mpp9Mpj8cTyJIBAECYCWg4OV4vvPBCKA4LAAAsIKCndVJTUxUTEyOXy+XT7nK5lJ6ePqB982wdAAAiQ0DDSWxsrPLy8lRfX+9t6+3tVX19/RFP2xwvnkoMAEBk8Pu0TldXl7Zv3+7dbmlpUXNzs1JSUjR27Fg5HA6Vl5crPz9fBQUFqq2tldvt1syZMwdUqN1ul91uV0dHh5KSkga0LwAAEL78DicbN27U5MmTvdsOh0OSVF5errq6Ok2fPl27d+9WdXW12tralJubq3Xr1h22SNZfLIgFACAy+B1OiouLZYw5ap/KykpVVlb2u6i+MHMCAEBkCMmzdfqDNScAAEQGy4QTrtYBACAyWCacAACAyGCZcMJpHQAAIoNlwgmndQAAiAyWCScAACAyEE4AAEBYsUw4seKak+yqNcquWhPqMgAAsBTLhBPWnAAAEBksE04AAEBkIJwAAICwQjgBAABhxTLhxIoLYgEAgP/8fipxqBx6KnF7e7uSk5PV0dExOAfq/vyJy73d+z8/xpe2JR3W9uVtn7avfgZAQLjdbu+fOzo65PF4QlgNgON16HehMeYYPaUoczy9wsgHH3ygrKysUJcBAAD6obW1VWPGjDlqH8uFk97eXn300UdKSEhQVFRUwPff0dGhrKwstba2KjExMeD7x+cY5+BhrIODcQ4Oxjl4Aj3Wxhh1dnYqMzNT0dFHX1VimdM6h0RHRx8zcQVCYmIiP/hBwDgHD2MdHIxzcDDOwRPIsU5KSjqufpZZEAsAACID4QQAAIQVwslX2Gw21dTUyGazhbqUIY1xDh7GOjgY5+BgnIMnlGNtuQWxAABgaGPmBAAAhBXCCQAACCuEEwAAEFYIJwAAIKwQTgAAQFiJyHDidDqVnZ2tuLg4FRYWasOGDUft/8QTT+gb3/iG4uLidMYZZ2jt2rVBqtTa/BnnpUuX6vzzz9dJJ52kk046SSUlJcf874Iv+PszfcjKlSsVFRWlK664YnALHCL8Hed9+/bJbrcrIyNDNptN48eP5++P4+DvONfW1mrChAkaMWKEsrKydOutt+qzzz4LUrXW1NDQoClTpigzM1NRUVFavXr1MT/z8ssv69vf/rZsNptOO+001dXVDV6BJsKsXLnSxMbGmmXLlpm3337bVFRUmOTkZONyufrsv379ehMTE2N+/etfmy1btphf/vKXZvjw4eatt94KcuXW4u84X3311cbpdJrNmzebrVu3muuuu84kJSWZDz74IMiVW4+/Y31IS0uLGT16tDn//PPN5ZdfHpxiLczfce7u7jb5+fnm4osvNq+++qppaWkxL7/8smlubg5y5dbi7zgvX77c2Gw2s3z5ctPS0mL+/ve/m4yMDHPrrbcGuXJrWbt2rbnzzjvNU089ZSSZp59++qj9d+zYYeLj443D4TBbtmwxixcvNjExMWbdunWDUl/EhZOCggJjt9u92x6Px2RmZpr58+f32X/atGnmkksu8WkrLCw0N95446DWaXX+jvNXHTx40CQkJJjHHntssEocMvoz1gcPHjTnnHOOeeSRR0x5eTnh5Dj4O84PPfSQGTdunOnp6QlWiUOCv+Nst9vNhRde6NPmcDjMueeeO6h1DiXHE07uuOMOM2nSJJ+26dOnm9LS0kGpKaJO6/T09KipqUklJSXetujoaJWUlKixsbHPzzQ2Nvr0l6TS0tIj9kf/xvmr9u/frwMHDiglJWWwyhwS+jvW99xzj0aNGqUbbrghGGVaXn/G+ZlnnlFRUZHsdrvS0tJ0+umn6/7775fH4wlW2ZbTn3E+55xz1NTU5D31s2PHDq1du1YXX3xxUGqOFMH+XWi5pxIPxJ49e+TxeJSWlubTnpaWpm3btvX5mba2tj77t7W1DVqdVtefcf6qn//858rMzDzsfwb46s9Yv/rqq/rDH/6g5ubmIFQ4NPRnnHfs2KEXX3xR11xzjdauXavt27fr5ptv1oEDB1RTUxOMsi2nP+N89dVXa8+ePTrvvPNkjNHBgwd100036Re/+EUwSo4YR/pd2NHRoU8//VQjRowI6PEiauYE1rBgwQKtXLlSTz/9tOLi4kJdzpDS2dmpGTNmaOnSpUpNTQ11OUNab2+vRo0apYcfflh5eXmaPn267rzzTi1ZsiTUpQ0pL7/8su6//349+OCD2rRpk5566imtWbNG9957b6hLwwBE1MxJamqqYmJi5HK5fNpdLpfS09P7/Ex6erpf/dG/cT5k4cKFWrBggV544QWdeeaZg1nmkODvWP/73//Wzp07NWXKFG9bb2+vJGnYsGF65513dOqppw5u0RbUn5/pjIwMDR8+XDExMd62b37zm2pra1NPT49iY2MHtWYr6s8433XXXZoxY4Z+9KMfSZLOOOMMud1uzZo1S3feeaeio/k3eCAc6XdhYmJiwGdNpAibOYmNjVVeXp7q6+u9bb29vaqvr1dRUVGfnykqKvLpL0nPP//8Efujf+MsSb/+9a917733at26dcrPzw9GqZbn71h/4xvf0FtvvaXm5mbv67LLLtPkyZPV3NysrKysYJZvGf35mT733HO1fft2b/iTpH/961/KyMggmBxBf8Z5//79hwWQQ4HQ8FzbgAn678JBWWYbxlauXGlsNpupq6szW7ZsMbNmzTLJycmmra3NGGPMjBkzTFVVlbf/+vXrzbBhw8zChQvN1q1bTU1NDZcSHwd/x3nBggUmNjbWPPnkk+bjjz/2vjo7O0P1FSzD37H+Kq7WOT7+jvP7779vEhISTGVlpXnnnXfMs88+a0aNGmXmzZsXqq9gCf6Oc01NjUlISDB//vOfzY4dO8xzzz1nTj31VDNt2rRQfQVL6OzsNJs3bzabN282ksyiRYvM5s2bzXvvvWeMMaaqqsrMmDHD2//QpcS333672bp1q3E6nVxKHGiLFy82Y8eONbGxsaagoMC8/vrr3vcuuOACU15e7tP/8ccfN+PHjzexsbFm0qRJZs2aNUGu2Jr8GedTTjnFSDrsVVNTE/zCLcjfn+kvI5wcP3/H+bXXXjOFhYXGZrOZcePGmfvuu88cPHgwyFVbjz/jfODAATN37lxz6qmnmri4OJOVlWVuvvlm88knnwS/cAt56aWX+vw799DYlpeXmwsuuOCwz+Tm5prY2Fgzbtw48+ijjw5afVHGMO8FAADCR0StOQEAAOGPcAIAAMIK4QQAAIQVwgkAAAgrhBMAABBWCCcAACCsEE4AAEBYIZwAAICwQjgBAABhhXACAADCCuEEAACElf8PyMF+iKyaT+8AAAAASUVORK5CYII=", + "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: 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 : 1247\n", + "item counter : 3292\n", + "ratio : 0.3786820528393562\n", + " ratio number predicted/items: 18.160340115396295\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_83/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 | SmallNetBis | 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_7205/2830455942.py:187: UserWarning: Data has no positive values, and therefore cannot be log-scaled.\n", + " ax1.set_yscale('log')\n", + "/tmp/ipykernel_7205/2830455942.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": "fd7db4a142a244bcbd464594f29acd8a", + "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 : 1252\n", + "ratio : 0.994413407821229\n", + " ratio number predicted/items: 0.00558659217877095\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 : 1230\n", + "item counter : 3728\n", + "ratio : 0.32984714400643605\n", + " ratio number predicted/items: 33.18181818181818\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 : 1239\n", + "item counter : 4787\n", + "ratio : 0.25877192982456143\n", + " ratio number predicted/items: 30.972013366750208\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 : 1231\n", + "item counter : 5656\n", + "ratio : 0.21760650521477815\n", + " ratio number predicted/items: 34.284426374403395\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 : 1229\n", + "item counter : 5980\n", + "ratio : 0.20548403277043972\n", + " ratio number predicted/items: 37.10081926099315\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 : 1232\n", + "item counter : 5972\n", + "ratio : 0.20626151012891344\n", + " ratio number predicted/items: 40.74183827222501\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 : 1227\n", + "item counter : 5847\n", + "ratio : 0.20981532147742818\n", + " ratio number predicted/items: 44.54976060191518\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 : 1225\n", + "item counter : 5627\n", + "ratio : 0.21766169154228857\n", + " ratio number predicted/items: 51.17857142857143\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 : 5721\n", + "ratio : 0.21548409646976582\n", + " ratio number predicted/items: 52.79360363509262\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 : 1227\n", + "item counter : 5530\n", + "ratio : 0.2218405351654312\n", + " ratio number predicted/items: 55.611824263243534\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 | SmallNetBis | 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": "e00551b7e5be441d90c3a04e8c3289de", + "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 : 1233\n", + "item counter : 1236\n", + "ratio : 0.9967663702506063\n", + " ratio number predicted/items: 0.004850444624090542\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 : 1500\n", + "ratio : 0.8241172551632245\n", + " ratio number predicted/items: 0.22318454363757495\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 : 2578\n", + "ratio : 0.4784800310197751\n", + " ratio number predicted/items: 2.7309034509499805\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 : 1224\n", + "item counter : 2672\n", + "ratio : 0.45791245791245794\n", + " ratio number predicted/items: 3.9135802469135803\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 : 1228\n", + "item counter : 2685\n", + "ratio : 0.4571854058078928\n", + " ratio number predicted/items: 4.1407297096053615\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 : 1227\n", + "item counter : 2701\n", + "ratio : 0.45410806809770543\n", + " ratio number predicted/items: 4.208734270910437\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 : 1228\n", + "item counter : 2795\n", + "ratio : 0.43919885550786836\n", + " ratio number predicted/items: 4.253576537911302\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": "iVBORw0KGgoAAAANSUhEUgAAAiYAAAGzCAYAAAAbjdwrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA1+ElEQVR4nO3dfXRU1b3/8c8kkAnBPBBiniQYwSsVpMGSJo3KD9DcUlCkVAULF1O0QQtp1XRpQ20TVJ7acim3NMpSi9h7Q8FaZHmFohJlRTQtJSHWK2hLCRqLGaBKEgbN4/79oRkdSCAzzMOZyfu11iyZM3vO+c42D5/svc85NmOMEQAAgAVEBLsAAACAbgQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTAABgGQQTAEG1YcMG2Ww27d27N9ilALAAggkAALAMggkAALAMggkAALAMggkAv3j33Xe1cOFCjRo1SoMGDdLQoUN1yy236PDhwz22P3XqlO68804NHTpUcXFxuu222/TRRx+5tdm7d6+mTJmipKQkDRo0SJdccoluv/32AHwaAIEyINgFAAhPf/nLX/T666/r1ltv1bBhw3T48GE9+uijmjRpkvbv36+YmBi39kVFRUpISNCSJUv0zjvv6NFHH9W7776rXbt2yWaz6ejRo/r617+uCy+8UCUlJUpISNDhw4e1ZcuWIH1CAP5AMAHgF9dff71uvvlmt23Tp09XXl6e/vCHP2jevHlur0VFRamyslIDBw6UJF188cW6//779b//+7+68cYb9frrr+ujjz7Siy++qOzsbNf7li5d6v8PAyBgmMoB4BeDBg1y/bu9vV3/+te/dOmllyohIUG1tbVntF+wYIErlEjS9773PQ0YMEDbt2+XJCUkJEiSnn/+ebW3t/u3eABBQzAB4Bcff/yxSktLlZGRIbvdrqSkJF144YU6ceKEmpqazmj/b//2b27PL7jgAqWlpbnWpEycOFE33XSTHnzwQSUlJWnGjBl68skn1draGoiPAyBACCYA/OL73/++li1bplmzZunpp5/Wiy++qJdeeklDhw5VV1eXx/uz2Wx65plnVF1draKiIv3zn//U7bffrvHjx+vkyZN++AQAgoFgAsAvnnnmGRUUFOg///M/dfPNN+vf//3fdc011+jEiRM9tv/73//u9vzkyZP64IMPlJmZ6bb9a1/7mpYtW6a9e/eqoqJCb731ljZt2uSnTwEg0AgmAPwiMjJSxhi3bWvXrlVnZ2eP7R977DG3tSOPPvqoOjo6NHXqVEnSRx99dMb+xo0bJ0lM5wBhhLNyAPjFDTfcoP/+7/9WfHy8Ro8ererqau3cuVNDhw7tsX1bW5uuu+46zZo1S++8844eeeQRXXPNNbrxxhslSU899ZQeeeQRzZw5UyNHjlRLS4sef/xxxcXFadq0aYH8aAD8iGACwC/+67/+S5GRkaqoqNAnn3yiq6++Wjt37tSUKVN6bP/rX/9aFRUVKi0tVXt7u7797W/rV7/6lWw2m6RPF7/u2bNHmzZtksPhUHx8vHJyclRRUaFLLrkkkB8NgB/ZzOljowAAAEHCGhMAAGAZBBMAAGAZBBMAAGAZBBMAAGAZBBMAAGAZBBMAAGAZIXcdk66uLh05ckSxsbGu6xsAAABrM8aopaVF6enpiojofVwk5ILJkSNHlJGREewyAACAFxoaGjRs2LBeXw+5YBIbGyvp0w8WFxcX5GqA8OV0OpWeni7p0z8IBg8eHOSKAISy5uZmZWRkuH6P9yYowSQzM1NxcXGKiIjQkCFD9Morr/T5vd3TN3FxcQQTwI8iIyNd/46LiyOYAPCJcy3DCNqIyeuvv64LLrggWIcHAAAWxFk5AADAMjwOJlVVVZo+fbrS09Nls9m0devWM9qUl5crMzNT0dHRys3N1Z49e9xet9lsmjhxor761a+qoqLC6+IBAEB48TiYOJ1OZWVlqby8vMfXN2/erOLiYpWVlam2tlZZWVmaMmWKjh496mqze/du1dTU6LnnntPy5cv117/+1ftPAAAAwobHwWTq1KlaunSpZs6c2ePrq1evVmFhoebPn6/Ro0dr3bp1iomJ0fr1611tLrroIklSWlqapk2bptra2l6P19raqubmZreHv2WWbFNmyTa/HwcAALjz6RqTtrY21dTUKD8///MDREQoPz9f1dXVkj4dcWlpaZEknTx5Ui+//LLGjBnT6z5XrFih+Ph414NrmAAAEL58GkyOHz+uzs5OpaSkuG1PSUlRY2OjJMnhcOiaa65RVlaWvva1r+m2227TV7/61V73uXjxYjU1NbkeDQ0NviwZAABYSMBPFx4xYoTeeOONPre32+2y2+1+rAgAAFiFT0dMkpKSFBkZKYfD4bbd4XAoNTXVl4cCAABhyKfBJCoqSuPHj1dlZaVrW1dXlyorK5WXl+fLQwEAgDDk8VTOyZMndfDgQdfz+vp61dXVKTExUcOHD1dxcbEKCgqUnZ2tnJwcrVmzRk6nU/Pnz/dp4QAAIPx4HEz27t2ryZMnu54XFxdLkgoKCrRhwwbNnj1bx44dU2lpqRobGzVu3Djt2LHjjAWxIW1J/Gf/bQpuHQAAhBmPg8mkSZNkjDlrm6KiIhUVFXldVMghqAAA4BPcK8dflsR/HlgAAECfEEwAAIBlEEzOhZEPAAACJuAXWOu3vhhuWIsCAECPGDHpI27qBwCA/xFMgolpIgAA3BBMAACAZRBMzgPTOwAA+BaLX62EBbIAgH6OERMAAGAZBBMAAGAZBBOr48wdAEA/QjDxocySbSyIBQDgPBBMAACAZRBMQhHTOwCAMEUwAQAAlkEwAQAAlkEwAQAAlkEw8bOAnKXDmhMAQJjgkvRf9Nkv98PRUuYnG4NcDAAA/Q8jJuGKURQAQAgimAAAAMsgmAAAAMsgmARBUC5b3z21w/QOAMDCCCYAAMAyCCYAAMAyCCb9GVM7AACLIZgAAADLIJhYQFAWwwIAYEFc+RWf++K0zpKm4NUBAOi3GDEBAACWQTDB2bFAFgAQQAQTAABgGQQTAABgGQQTi7L0mTpM7wAA/IRgAgAALINgAgAALINggvPH1A4AwEcIJiHC0mtOAADwEYIJ/INRFACAFwgmAADAMggmAADAMriJHwKDGwQCAPqAEZMQxoJYAEC4IZggeFggCwA4DcEEAABYBsEEAABYRsAXv544cUL5+fnq6OhQR0eH7r77bhUWFga6DFgRC2QBoN8LeDCJjY1VVVWVYmJi5HQ6dcUVV+hb3/qWhg4dGuhSwk73YtjDK68PciUAAHgn4FM5kZGRiomJkSS1trbKGCNjTKDLQKhggSwA9CseB5OqqipNnz5d6enpstls2rp16xltysvLlZmZqejoaOXm5mrPnj1ur584cUJZWVkaNmyY7rvvPiUlJXn9AQAAQPjwOJg4nU5lZWWpvLy8x9c3b96s4uJilZWVqba2VllZWZoyZYqOHj3qapOQkKA33nhD9fX12rhxoxwOh/efAP0PoygA0LPun48h/DPS42AydepULV26VDNnzuzx9dWrV6uwsFDz58/X6NGjtW7dOsXExGj9+vVntE1JSVFWVpZeffXVXo/X2tqq5uZmtwcAAFDfQkiIBRWfrjFpa2tTTU2N8vPzPz9ARITy8/NVXV0tSXI4HGppaZEkNTU1qaqqSqNGjep1nytWrFB8fLzrkZGR4cuSwx5XhwUAhBKfBpPjx4+rs7NTKSkpbttTUlLU2NgoSXr33Xc1YcIEZWVlacKECfr+97+vsWPH9rrPxYsXq6mpyfVoaGjwZckIByH21wAAeKWf/KwL+OnCOTk5qqur63N7u90uu93uv4L6ocySbZxSDABW1x1C+tl1nXwaTJKSkhQZGXnGYlaHw6HU1FRfHgo4u376DQ0A52Txi1n6dConKipK48ePV2VlpWtbV1eXKisrlZeX58tDAQCAMOTxiMnJkyd18OBB1/P6+nrV1dUpMTFRw4cPV3FxsQoKCpSdna2cnBytWbNGTqdT8+fP92nhAAAg/HgcTPbu3avJkye7nhcXF0uSCgoKtGHDBs2ePVvHjh1TaWmpGhsbNW7cOO3YseOMBbFA0DHdAyAYeppK4eeRi8fBZNKkSee8hHxRUZGKioq8LgrwOb7pASAkBPxeObAernUCALAKggkAAP7UT64/4isBv44JYFnM+wJA0DFigh4xvQMAXgiDm+gFG8EEAABYBlM5gCcsfsVEAAHGdK/PMWKCPmFq5ywYtgX6B77XA4JgAgAALINgAvgDf1kBgFcIJgAAwDIIJkAgMIICwMos9DOKYAKvsSD2PFnoBwGAHvA9GhScLgxYBVeeBQKD7zVLY8QEAABYBiMmQCjhLz0AYY4REyAcMTcOfI7vh5BCMIHPZJZsY0FsKOGHNQALYioHABC6Tp/K5H5WIY8RE/gVIygW0ZfREW7XDqvh67FfIpgAAIKPEILPMJUDoO8YJkcwcQZav8CICYDz09Nfur7665e/oq3Pk2lCoA8IJgCAwCOsoBdM5SDgMku26fDK64NdBqzGV9NETDf5jjdTJ/Q/zhPBBEFHUOkHevoFx3oBz/nzl35f/n8QOhAABBMAoc2TX6hnC0a++sXs7S9vXwU1wgNCHMEEQOjob790vQ1dfWnDiBUsisWvAOBv/jxzCQgzBBMAAGAZBBNYEpeyhyVwjQ4g4AgmAADAMggmAADAMggmAADAMggmAADAMggmAADAMggmCAmcpQMA/QPBBAAAWAbBBAAAWAbBBCGL6R0ACD8EEwAAYBkEEwAAYBkEEwAAYBkEE4QN1pwAQOgjmAAAAMsgmCCsMYoCAKGFYAIAACyDYAIAACwjKMFk5syZGjJkiG6++eZgHB4AAFhUUILJ3Xffrd/+9rfBODQAALCwoASTSZMmKTY2NhiHBgAAFuZxMKmqqtL06dOVnp4um82mrVu3ntGmvLxcmZmZio6OVm5urvbs2eOLWgEAQJjzOJg4nU5lZWWpvLy8x9c3b96s4uJilZWVqba2VllZWZoyZYqOHj163sUCAIDwNsDTN0ydOlVTp07t9fXVq1ersLBQ8+fPlyStW7dO27Zt0/r161VSUuJxga2trWptbXU9b25u9ngfAAAgNPh0jUlbW5tqamqUn5//+QEiIpSfn6/q6mqv9rlixQrFx8e7HhkZGb4qFwAAWIxPg8nx48fV2dmplJQUt+0pKSlqbGx0Pc/Pz9ctt9yi7du3a9iwYWcNLYsXL1ZTU5Pr0dDQ4MuSAQCAhXg8leMLO3fu7HNbu90uu93ux2oAAIBV+HTEJCkpSZGRkXI4HG7bHQ6HUlNTfXkoAAAQhnwaTKKiojR+/HhVVla6tnV1damyslJ5eXm+PBQAAAhDHk/lnDx5UgcPHnQ9r6+vV11dnRITEzV8+HAVFxeroKBA2dnZysnJ0Zo1a+R0Ol1n6QAAAPTG4xGTvXv36sorr9SVV14pSSouLtaVV16p0tJSSdLs2bO1atUqlZaWaty4caqrq9OOHTvOWBALBENmyTZllmw7Y1tf3gcA8D+PR0wmTZokY8xZ2xQVFamoqMjrogAAQP8UlHvlAAAA9IRgAgAALINgAgAALINgAgAALINgAvSAs3AAIDgIJgAAwDIIJgAAwDIIJgAAwDIIJoCXWIcCAL5HMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAEAAJZBMAF8xJd3G+bOxQD6K4IJAACwDIIJAACwDIIJAACwDIIJAACwDIIJAACwDIIJAACwjAHBLsBTxhhJUnNzs+933mpc/+xqPfXpMT7b5nr+hXY9tXHV1kubs+6b45/38a1Wo3p7frY2PR2vhzZe7buPx1dzs5xO5xeeNquzszOgx/drm2DXyPHP7/ihUGM4HN/Hun8+dv8e743NnKuFxbz//vvKyMgIdhkAAMALDQ0NGjZsWK+vh1ww6erq0pEjRxQbGyubzebz/Tc3NysjI0MNDQ2Ki4vz+f7xKfo5MOjnwKGvA4N+Dhxf97UxRi0tLUpPT1dERO8rSUJuKiciIuKsSctX4uLi+KIPAPo5MOjnwKGvA4N+Dhxf9nV8fPw527D4FQAAWAbBBAAAWAbB5DR2u11lZWWy2+3BLiWs0c+BQT8HDn0dGPRz4ASrr0Nu8SsAAAhfjJgAAADLIJgAAADLIJgAAADLIJgAAADL6JfBpLy8XJmZmYqOjlZubq727Nlz1va///3v9aUvfUnR0dEaO3astm/fHqBKQ5sn/fz4449rwoQJGjJkiIYMGaL8/Pxz/n/Bpzz9eu62adMm2Ww2ffOb3/RvgWHE074+ceKEFi1apLS0NNntdl122WX8/OgDT/t5zZo1GjVqlAYNGqSMjAzde++9+uSTTwJUbWiqqqrS9OnTlZ6eLpvNpq1bt57zPbt27dJXvvIV2e12XXrppdqwYYN/ijP9zKZNm0xUVJRZv369eeutt0xhYaFJSEgwDoejx/avvfaaiYyMND//+c/N/v37zU9+8hMzcOBA8+abbwa48tDiaT/PmTPHlJeXm3379pkDBw6Y73znOyY+Pt68//77Aa48tHjaz93q6+vNRRddZCZMmGBmzJgRmGJDnKd93draarKzs820adPM7t27TX19vdm1a5epq6sLcOWhxdN+rqioMHa73VRUVJj6+nrzwgsvmLS0NHPvvfcGuPLQsn37dvPAAw+YLVu2GEnm2WefPWv7Q4cOmZiYGFNcXGz2799v1q5dayIjI82OHTt8Xlu/CyY5OTlm0aJFruednZ0mPT3drFixosf2s2bNMtdff73bttzcXHPnnXf6tc5Q52k/n66jo8PExsaap556yl8lhgVv+rmjo8NcddVV5oknnjAFBQUEkz7ytK8fffRRM2LECNPW1haoEsOCp/28aNEic+2117ptKy4uNldffbVf6wwnfQkm999/vxkzZozbttmzZ5spU6b4vJ5+NZXT1tammpoa5efnu7ZFREQoPz9f1dXVPb6nurrarb0kTZkypdf28K6fT3fq1Cm1t7crMTHRX2WGPG/7+aGHHlJycrLuuOOOQJQZFrzp6+eee055eXlatGiRUlJSdMUVV2j58uXq7OwMVNkhx5t+vuqqq1RTU+Oa7jl06JC2b9+uadOmBaTm/iKQvwtD7iZ+5+P48ePq7OxUSkqK2/aUlBS9/fbbPb6nsbGxx/aNjY1+qzPUedPPp/vRj36k9PT0M74R8Dlv+nn37t36zW9+o7q6ugBU2HddXV1qa2tTdHR0sEvpkTd9fejQIb388suaO3eutm/froMHD2rhwoVqb29XWVlZIMoOOd7085w5c3T8+HFdc801Msaoo6NDd911l3784x8HouR+o7ffhc3Nzfr44481aNAgnx2rX42YIDSsXLlSmzZt0rPPPmvZX1ShqKWlRfPmzdPjjz+upKQkvxxjyZIlstlsevvttzVr1izFxcVp6NChuvvuu90WI9psNhUVFamiokJjxoyR3W7Xjh07JEn//Oc/dfvttyslJUV2u11jxozR+vXrzzjW2rVrNWbMGMXExGjIkCHKzs7Wxo0b/fK5vNHV1aXk5GQ99thjGj9+vGbPnq0HHnhA69atC3ZpYWXXrl1avny5HnnkEdXW1mrLli3atm2bHn744WCXBi/1qxGTpKQkRUZGyuFwuG13OBxKTU3t8T2pqaketYd3/dxt1apVWrlypXbu3Kkvf/nL/iwz5Hnaz//4xz90+PBhTZ8+3bWtq6tLkjRgwAC98847GjlypE9qmzVrljIzM7VixQr96U9/0q9+9St99NFH+u1vf+tq8/LLL+vpp59WUVGRkpKSlJmZKYfDoa997Wuu4HLhhRfqj3/8o+644w41NzfrnnvukfTpWVw/+MEPdPPNN7tCz1//+lf9+c9/1pw5c3zyGb7Im6/ptLQ0DRw4UJGRka5tl19+uRobG9XW1qaoqCif1xnqvOnnn/70p5o3b56++93vSpLGjh0rp9OpBQsW6IEHHlBEBH9/+0Jvvwvj4uJ8Oloiqf+dlZOTk2OKiopczzs7O81FF1101sWvN9xwg9u2vLw8Fr+eg6f9bIwxP/vZz0xcXJyprq4ORIlhwZN+/vjjj82bb77p9pgxY4a59tprzZtvvmlaW1vPu56ysjIjydx4441u2xcuXGgkmTfeeMMY8+liu4iICPPWW2+5tbvjjjtMWlqaOX78uNv2W2+91cTHx5tTp04ZY4yZMWPGGQvx/M3Tr+nFixebiy++2HR2drq2rVmzxqSlpfm91lDmaT9/5StfMffff7/bto0bN5pBgwaZjo4Ov9YaLtTHxa9XXHGF27Zvf/vbfln82u+CyaZNm4zdbjcbNmww+/fvNwsWLDAJCQmmsbHRGGPMvHnzTElJiav9a6+9ZgYMGGBWrVplDhw4YMrKyjhduA887eeVK1eaqKgo88wzz5gPPvjA9WhpaQnWRwgJnvbz6Xx9Vk53MHnhhRfcth84cMBIcv1ykWQmT57s1qarq8skJCSYBQsWmGPHjrk9nnzySSPJ7N6921V3fHy82bNnj89qPxdP+/q9994zsbGxpqioyLzzzjvm+eefN8nJyWbp0qUBqzkUedrPZWVlJjY21vzud78zhw4dMi+++KIZOXKkmTVrVrA+QkhoaWkx+/btM/v27TOSzOrVq82+ffvMu+++a4wxpqSkxMybN8/Vvvt04fvuu88cOHDAlJeXc7qwL61du9YMHz7cREVFmZycHPOnP/3J9drEiRNNQUGBW/unn37aXHbZZSYqKsqMGTPGbNu2LcAVhyZP+vniiy82ks54lJWVBb7wEOPp1/MX+SuYHDp0yG17W1ubiYiIcI00SjK33367WxuHw9Hj18AXH1u2bDHGGLN//35z0UUXGUnm0ksvNQsXLnSFFn/ytK9ff/11k5uba+x2uxkxYoRZtmwZf8X3gSf93N7ebpYsWWJGjhxpoqOjTUZGhlm4cKH56KOPAl94CHnllVd6/B7r7tuCggIzceLEM94zbtw4ExUVZUaMGGGefPJJv9RmM8YY304OAeivlixZogcffFCHDh3SJZdc4tre0dEhu92uwsJCrVu3TjabTYsWLdKvf/1rV5vGxkalpaXpP/7jP1RQUNDj/r/85S8rOTlZkuR0OvX8889rx44d+uMf/yiHw6HS0lI9+OCD/v2QAPyqXy1+BRAYf//7392CycGDB9XV1aXMzMxe33PhhRcqNjZWnZ2dfTpNfPDgwZo9e7Zmz56ttrY2fetb39KyZcu0ePFizuYCQhjLlQH4XHl5udvztWvXSpKmTp3a63siIyN100036Q9/+IP+7//+74zXjx075vr3v/71L7fXoqKiNHr0aBlj1N7efj6lAwgyRkwA+Fx9fb1uvPFGfeMb31B1dbX+53/+R3PmzFFWVtZZ37dy5Uq98sorys3NVWFhoUaPHq0PP/xQtbW12rlzpz788ENJ0te//nWlpqbq6quvVkpKig4cOKBf//rXuv766xUbGxuIjwjATwgmAHxu8+bNKi0tVUlJiQYMGKCioiL94he/OOf7UlJStGfPHj300EPasmWLHnnkEQ0dOlRjxozRz372M1e7O++8UxUVFVq9erVOnjypYcOG6Qc/+IF+8pOf+PNjAQgAFr8C8Jnuxa/Hjh3z29VlAYQ31pgAAADLIJgAAADLIJgAAADLYI0JAACwDEZMAACAZYTc6cJdXV06cuSIYmNjZbPZgl0OAADoA2OMWlpalJ6eroiI3sdFQi6YHDlyRBkZGcEuAwAAeKGhoUHDhg3r9fWQCybdV3VsaGhQXFxckKsBEAxOp1Pp6emSPv1jZfDgwUGuCMC5NDc3KyMj45xXZw65YNI9fRMXF0cwAfqpyMhI17/j4uIIJkAIOdcyDBa/AgAAyyCYAAAAyyCYAAAAywi5NSYAAPhbZ2en2tvbg11GSBk4cKDb+i9vEUwAAPiMMUaNjY06ceJEsEsJSQkJCUpNTT2v64wRTHqQWbJNknR45fVBrgQAEEjdoSQ5OVkxMTFcyLOPjDE6deqUjh49KklKS0vzel8EEwAA9On0TXcoGTp0aLDLCTmDBg2SJB09elTJycleT+uw+BUAAMm1piQmJibIlYSu7r47n/U5BBMAAL6A6Rvv+aLvCCYAAMAyCCYAAMAyWPwKAMA5dJ+tGSj9+axQRkwAAECPPvzwQ82dO1dxcXFKSEjQHXfcoZMnT/r1mAQTAAD6oba2tnO2mTt3rt566y299NJLev7551VVVaUFCxb4tS6CCQAAYaClpUVz587V4MGDlZaWpl/+8peaNGmS7rnnHklSZmamHn74Yd12222Ki4s7Z8A4cOCAduzYoSeeeEK5ubm65pprtHbtWm3atElHjhzx2+cgmAAAEAaKi4v12muv6bnnntNLL72kV199VbW1tW5tVq1apaysLO3bt08//elPz7q/6upqJSQkKDs727UtPz9fERER+vOf/+yXzyCx+BUAgJDX0tKip556Shs3btR1110nSXryySeVnp7u1u7aa6/VD3/4wz7ts7GxUcnJyW7bBgwYoMTERDU2Nvqm8B4wYgIAQIg7dOiQ2tvblZOT49oWHx+vUaNGubX74uiHVRFMAADoJwYPHtzntqmpqa6b8nXr6OjQhx9+qNTUVF+X5kIwAQAgxI0YMUIDBw7UX/7yF9e2pqYm/e1vf/N6n3l5eTpx4oRqampc215++WV1dXUpNzf3vOo9G9aYAAAQ4mJjY1VQUKD77rtPiYmJSk5OVllZmSIiIry+f83ll1+ub3zjGyosLNS6devU3t6uoqIi3XrrrWesXfElggkAAOcQCldiXb16te666y7dcMMNiouL0/3336+GhgZFR0d7vc+KigoVFRXpuuuuU0REhG666Sb96le/8mHVZyKYAAAQBmJjY1VRUeF67nQ69eCDD7quV3L48GGP95mYmKiNGzf6qsQ+IZgAABAG9u3bp7fffls5OTlqamrSQw89JEmaMWNGkCvzDItfAQAIE90XUMvPz5fT6dSrr76qpKSkHtsuX75cF1xwQY+PqVOnBrjyzzFiAgBAGLjyyivdzqA5l7vuukuzZs3q8bVBgwb5qiyPEUwAAOiHEhMTlZiYGOwyzsBUDgAAsAyCCQAAsIygTOVkZmYqLi5OERERGjJkiF555ZVglAEAACwmaGtMXn/9dV1wwQXBOjwAALAgpnIAAIBleDxiUlVVpV/84heqqanRBx98oGeffVbf/OY33dqUl5frF7/4hRobG5WVlaW1a9e63YrZZrNp4sSJioiI0D333KO5c+ee9wfxp8ySbZJC45LEAAA/WBIf4OM1BfZ4FuLxiInT6VRWVpbKy8t7fH3z5s0qLi5WWVmZamtrlZWVpSlTprjdOnn37t2qqanRc889p+XLl+uvf/1rr8drbW1Vc3Oz2wMAAPjfsmXLdNVVVykmJkYJCQkBOabHwWTq1KlaunSpZs6c2ePrq1evVmFhoebPn6/Ro0dr3bp1iomJ0fr1611tLrroIklSWlqapk2bptra2l6Pt2LFCsXHx7seGRkZnpYMAABO09bW1qc2t9xyi773ve8FoKJP+XSNSVtbm2pqapSfn//5ASIilJ+fr+rqakmfjri0tLRIkk6ePKmXX35ZY8aM6XWfixcvVlNTk+vR0NDgy5IBAAgLLS0tmjt3rgYPHqy0tDT98pe/1KRJk3TPPfdI+vSM2Icffli33Xab4uLiXDf3O5sHH3xQ9957r8aOHevn6j/n07Nyjh8/rs7OTqWkpLhtT0lJ0dtvvy1JcjgcrtGWzs5OFRYW6qtf/Wqv+7Tb7bLb7b4s0ydYdwIAsJLi4mK99tpreu6555SSkqLS0lLV1tZq3LhxrjarVq1SaWmpysrKglfoOQT8dOERI0bojTfeCPRhAQAIWy0tLXrqqae0ceNGXXfddZKkJ598Uunp6W7trr32Wv3whz8MRol95tOpnKSkJEVGRsrhcLhtdzgcSk1N9eWhAADAZw4dOqT29na3M2Dj4+M1atQot3bZ2dmBLs1jPg0mUVFRGj9+vCorK13burq6VFlZqby8PF8eCgAAeGjw4MHBLuGcPJ7KOXnypA4ePOh6Xl9fr7q6OiUmJmr48OEqLi5WQUGBsrOzlZOTozVr1sjpdGr+/Pk+LdxqutecSKw7AQAE1ogRIzRw4ED95S9/0fDhwyVJTU1N+tvf/qb/9//+X5Cr84zHwWTv3r2aPHmy63lxcbEkqaCgQBs2bNDs2bN17NgxlZaWqrGxUePGjdOOHTvOWBALAAB8IzY2VgUFBbrvvvuUmJio5ORklZWVKSIiQjabzev9vvfee/rwww/13nvvqbOzU3V1dZKkSy+91G+3lfE4mEyaNEnGmLO2KSoqUlFRkddFAQBgKSFwJdbVq1frrrvu0g033KC4uDjdf//9amhoUHR0tNf7LC0t1VNPPeV6fuWVV0qSXnnlFU2aNOl8S+5R0G7iBwAAfCc2NlYVFRWu506nUw8++KDreiWHDx/2eJ8bNmzQhg0bfFRh3xBMAAAIA/v27dPbb7+tnJwcNTU16aGHHpIkzZgxI8iVeYa7C/tRZsk2t0WxAAD406pVq5SVlaX8/Hw5nU69+uqrSkpK6rHt8uXLdcEFF/T4mDp1aoAr/xwjJgAAhIErr7xSNTU1fW5/1113adasWT2+NmjQIF+V5TGCCQAA/VBiYqISExODXcYZmMoBAOALznXmKXrni74jmAAAIGngwIGSpFOnTgW5ktDV3XfdfekNpnK8sSReh6OlzE82evQ2rg4LANYVGRmphIQEHT16VJIUExNzXhcn60+MMTp16pSOHj2qhIQERUZGer0vggkAAJ/pvuFsdziBZxISEs77pr0Ek3Ppy+iIlyMoAABrsdlsSktLU3Jystrb24NdTkgZOHDgeY2UdCOYBFn39A5TOwBgHZGRkT75JQvPsfjVX5bE63D0nGBXAQBASCGYAAAAy2AqJ1A+W4cisRYFAIDeMGJiQdxjBwDQXxFMgol1KAAAuCGYAAAAy2CNiZUsiZckrokCAOi3GDEJAaw5AQD0FwQTq2MdCgCgHyGYAAAAy2CNSSj6bC1K5icbuZQ9ACCsEEy+iMWnAAAEFVM5AADAMhgxCQdfmNqRuFMxACB0MWISrpbEuwILAAChgmACAAAsg2AS5lwXZuseQWEUBQBgYQST/oygAgCwGIIJAACwDIIJAACwDIJJP9TrDQFZhwIACDKCCc6OoAIACCCCCXofQQEAIMAIJvAcoygAAD8JeDA5ceKEsrOzNW7cOF1xxRV6/PHHA10CfI2gAgDwkYDfKyc2NlZVVVWKiYmR0+nUFVdcoW9961saOnRooEvBWWSWbOOeOwCAgAv4iElkZKRiYmIkSa2trTLGyBgT6DLgb4yiAAC84HEwqaqq0vTp05Weni6bzaatW7ee0aa8vFyZmZmKjo5Wbm6u9uzZ4/b6iRMnlJWVpWHDhum+++5TUlKS1x8AIYJTkQEAfeBxMHE6ncrKylJ5eXmPr2/evFnFxcUqKytTbW2tsrKyNGXKFB09etTVJiEhQW+88Ybq6+u1ceNGORwO7z8BAsIvZ+6cHlQILwDQ73kcTKZOnaqlS5dq5syZPb6+evVqFRYWav78+Ro9erTWrVunmJgYrV+//oy2KSkpysrK0quvvtrr8VpbW9Xc3Oz2AAAA4cmna0za2tpUU1Oj/Pz8zw8QEaH8/HxVV1dLkhwOh1paWiRJTU1Nqqqq0qhRo3rd54oVKxQfH+96ZGRk+LJkWB0jKADQr/g0mBw/flydnZ1KSUlx256SkqLGxkZJ0rvvvqsJEyYoKytLEyZM0Pe//32NHTu2130uXrxYTU1NrkdDQ4MvS8Z54MJsAABfC/jpwjk5Oaqrq+tze7vdLrvd7r+CEHq6R1CWNPX8HAAQsnw6YpKUlKTIyMgzFrM6HA6lpqb68lAAACAM+TSYREVFafz48aqsrHRt6+rqUmVlpfLy8nx5KFhQZsk2pncAAOfF46mckydP6uDBg67n9fX1qqurU2JiooYPH67i4mIVFBQoOztbOTk5WrNmjZxOp+bPn+/TwoGz6st0D1NAAGA5HgeTvXv3avLkya7nxcXFkqSCggJt2LBBs2fP1rFjx1RaWqrGxkaNGzdOO3bsOGNBLGA5btdUIawAQDB4HEwmTZp0zkvIFxUVqaioyOuiED5C/p47jKoAQEAF/F45AAAAvSGYIOBCeoEsl80HAL8imAAAAMsgmADnixEUAPAZggmCLqSndnrT252T+/IeQg6AfoxgAgAALINgAksKy1GU03kyigIA/QTBBAAAWAbBBAAAWAbBBCGhX0zt9EVPC2SZ7gEQRggmAADAMggmAADAMggmCFlM7wBA+CGYAOGIdScAQhTBBOgPCCoAQgTBBAAAWAbBBGGDNSceYhQFgAUNCHYBACzC7dooTcGrA0C/xogJwhqjKD7GHZAB+BnBBEDvCCEAAoxgAgAALINgAgAALINggn4ls2Qb604AwMIIJgDOD+tQAPgQwQToAaMqABAcBBP0e4QQPzh9FIVRFQB9RDAB+oDw4geEFQA94MqvAKyBK88CECMmAADAQggmAADAMggmgJdYdwIAvkcwAQAAlkEwAQAAlkEwAQAAlkEwAWBdXOsE6HeCEkxmzpypIUOG6Oabbw7G4QG/YDEsAJy/oASTu+++W7/97W+DcWgAAGBhQQkmkyZNUmxsbDAODQRVZsk2RlYA4Cw8DiZVVVWaPn260tPTZbPZtHXr1jPalJeXKzMzU9HR0crNzdWePXt8USuA/q57zcmytM+3LUtjHQoQRjwOJk6nU1lZWSovL+/x9c2bN6u4uFhlZWWqra1VVlaWpkyZoqNHj553sUCoYXQEADzj8U38pk6dqqlTp/b6+urVq1VYWKj58+dLktatW6dt27Zp/fr1Kikp8bjA1tZWtba2up43Nzd7vA8AABAafLrGpK2tTTU1NcrPz//8ABERys/PV3V1tVf7XLFiheLj412PjIwMX5ULAAAsxqfB5Pjx4+rs7FRKSorb9pSUFDU2Nrqe5+fn65ZbbtH27ds1bNiws4aWxYsXq6mpyfVoaGjwZckAAMBCPJ7K8YWdO3f2ua3dbpfdbvdjNQAAwCp8OmKSlJSkyMhIORwOt+0Oh0Opqam+PBQAAAhDPg0mUVFRGj9+vCorK13burq6VFlZqby8PF8eCgAAhCGPp3JOnjypgwcPup7X19errq5OiYmJGj58uIqLi1VQUKDs7Gzl5ORozZo1cjqdrrN0AAAAeuNxMNm7d68mT57sel5cXCxJKigo0IYNGzR79mwdO3ZMpaWlamxs1Lhx47Rjx44zFsQCAACczuNgMmnSJBljztqmqKhIRUVFXhcF9HeZJdt0eOX1wS4jNH3xKrBLmoJXBwCvBOVeOQAAAD0hmAAAAMsgmAAhgHvu+EH3DQF7ew4gKAgmAADAMggmAADAMggmQBhjCugzvpqm6d4PUz6A3xBMAACAZRBMAACAZRBMAACAZRBMgBDF+hEA4YhgAgAALINgAgAALINgAgAALINgAgAALINgAgAALINgAgAALINgAgAALINgAgRZuFyPpKfP4e1ns0yf+PoeO8E6PhBCCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyCCYAAMAyBgS7AE8ZYyRJzc3Nvt95q3H9s6v11KfH+Gyb6/kX2vXUxlVbL23Oum+Of97HD4Ua/XV8ffF7orf39dBGp9Xc47Y+tOnL5+/r8Xt932fPnW2ft21uNeo0Hn6Osx3f0z7qi5727c/3ARbU/fOh+/d4b2zmXC0s5v3331dGRkawywAAAF5oaGjQsGHDen095IJJV1eXjhw5otjYWNlsNp/vv7m5WRkZGWpoaFBcXJzP949P0c+BQT8HDn0dGPRz4Pi6r40xamlpUXp6uiIiel9JEnJTOREREWdNWr4SFxfHF30A0M+BQT8HDn0dGPRz4Piyr+Pjz33BQBa/AgAAyyCYAAAAyyCYnMZut6usrEx2uz3YpYQ1+jkw6OfAoa8Dg34OnGD1dcgtfgUAAOGLERMAAGAZBBMAAGAZBBMAAGAZBBMAAGAZBBMAAGAZ/TKYlJeXKzMzU9HR0crNzdWePXvO2v73v/+9vvSlLyk6Olpjx47V9u3bA1RpaPOknx9//HFNmDBBQ4YM0ZAhQ5Sfn3/O/y/4lKdfz902bdokm82mb37zm/4tMIx42tcnTpzQokWLlJaWJrvdrssuu4yfH33gaT+vWbNGo0aN0qBBg5SRkaF7771Xn3zySYCqDU1VVVWaPn260tPTZbPZtHXr1nO+Z9euXfrKV74iu92uSy+9VBs2bPBPcaaf2bRpk4mKijLr1683b731liksLDQJCQnG4XD02P61114zkZGR5uc//7nZv3+/+clPfmIGDhxo3nzzzQBXHlo87ec5c+aY8vJys2/fPnPgwAHzne98x8THx5v3338/wJWHFk/7uVt9fb256KKLzIQJE8yMGTMCU2yI87SvW1tbTXZ2tpk2bZrZvXu3qa+vN7t27TJ1dXUBrjy0eNrPFRUVxm63m4qKClNfX29eeOEFk5aWZu69994AVx5atm/fbh544AGzZcsWI8k8++yzZ21/6NAhExMTY4qLi83+/fvN2rVrTWRkpNmxY4fPa+t3wSQnJ8csWrTI9byzs9Okp6ebFStW9Nh+1qxZ5vrrr3fblpuba+68806/1hnqPO3n03V0dJjY2Fjz1FNP+avEsOBNP3d0dJirrrrKPPHEE6agoIBg0kee9vWjjz5qRowYYdra2gJVYljwtJ8XLVpkrr32WrdtxcXF5uqrr/ZrneGkL8Hk/vvvN2PGjHHbNnv2bDNlyhSf19OvpnLa2tpUU1Oj/Px817aIiAjl5+erurq6x/dUV1e7tZekKVOm9Noe3vXz6U6dOqX29nYlJib6q8yQ520/P/TQQ0pOTtYdd9wRiDLDgjd9/dxzzykvL0+LFi1SSkqKrrjiCi1fvlydnZ2BKjvkeNPPV111lWpqalzTPYcOHdL27ds1bdq0gNTcXwTyd2HI3V34fBw/flydnZ1KSUlx256SkqK33367x/c0Njb22L6xsdFvdYY6b/r5dD/60Y+Unp5+xjcCPudNP+/evVu/+c1vVFdXF4AKw4c3fX3o0CG9/PLLmjt3rrZv366DBw9q4cKFam9vV1lZWSDKDjne9POcOXN0/PhxXXPNNTLGqKOjQ3fddZd+/OMfB6LkfqO334XNzc36+OOPNWjQIJ8dq1+NmCA0rFy5Ups2bdKzzz6r6OjoYJcTNlpaWjRv3jw9/vjjSkpKCnY5Ya+rq0vJycl67LHHNH78eM2ePVsPPPCA1q1bF+zSwsquXbu0fPlyPfLII6qtrdWWLVu0bds2Pfzww8EuDV7qVyMmSUlJioyMlMPhcNvucDiUmpra43tSU1M9ag/v+rnbqlWrtHLlSu3cuVNf/vKX/VlmyPO0n//xj3/o8OHDmj59umtbV1eXJGnAgAF65513NHLkSP8WHaK8+ZpOS0vTwIEDFRkZ6dp2+eWXq7GxUW1tbYqKivJrzaHIm37+6U9/qnnz5um73/2uJGns2LFyOp1asGCBHnjgAUVE8Pe3L/T2uzAuLs6noyVSPxsxiYqK0vjx41VZWena1tXVpcrKSuXl5fX4nry8PLf2kvTSSy/12h7e9bMk/fznP9fDDz+sHTt2KDs7OxClhjRP+/lLX/qS3nzzTdXV1bkeN954oyZPnqy6ujplZGQEsvyQ4s3X9NVXX62DBw+6wp8k/e1vf1NaWhqhpBfe9POpU6fOCB/dYdBwj1qfCejvQp8vp7W4TZs2GbvdbjZs2GD2799vFixYYBISEkxjY6Mxxph58+aZkpISV/vXXnvNDBgwwKxatcocOHDAlJWVcbpwH3jazytXrjRRUVHmmWeeMR988IHr0dLSEqyPEBI87efTcVZO33na1++9956JjY01RUVF5p133jHPP/+8SU5ONkuXLg3WRwgJnvZzWVmZiY2NNb/73e/MoUOHzIsvvmhGjhxpZs2aFayPEBJaWlrMvn37zL59+4wks3r1arNv3z7z7rvvGmOMKSkpMfPmzXO17z5d+L777jMHDhww5eXlnC7sS2vXrjXDhw83UVFRJicnx/zpT39yvTZx4kRTUFDg1v7pp582l112mYmKijJjxowx27ZtC3DFocmTfr744ouNpDMeZWVlgS88xHj69fxFBBPPeNrXr7/+usnNzTV2u92MGDHCLFu2zHR0dAS46tDjST+3t7ebJUuWmJEjR5ro6GiTkZFhFi5caD766KPAFx5CXnnllR5/5nb3bUFBgZk4ceIZ7xk3bpyJiooyI0aMME8++aRfarMZw1gXAACwhn61xgQAAFgbwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFgGwQQAAFjG/wdXWdf/9L1xqgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No improve counter : 1230\n", + "item counter : 2959\n", + "ratio : 0.4155405405405405\n", + " ratio number predicted/items: 4.475675675675675\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 : 1230\n", + "item counter : 3155\n", + "ratio : 0.3897338403041825\n", + " ratio number predicted/items: 4.769961977186312\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 : 1227\n", + "item counter : 3261\n", + "ratio : 0.3761496014714899\n", + " ratio number predicted/items: 4.848252605763335\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 | SmallNetBis | 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": [ + "3\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": "de21ed4cc2d84a549195074ba8e65543", + "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 : 1247\n", + "item counter : 1247\n", + "ratio : 0.999198717948718\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 : 1247\n", + "item counter : 1247\n", + "ratio : 0.999198717948718\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 : 1230\n", + "item counter : 2454\n", + "ratio : 0.5010183299389002\n", + " ratio number predicted/items: 0.8773930753564155\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 : 1234\n", + "item counter : 2235\n", + "ratio : 0.5518783542039356\n", + " ratio number predicted/items: 0.881484794275492\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 : 1225\n", + "item counter : 3093\n", + "ratio : 0.39592760180995473\n", + " ratio number predicted/items: 2.13639301874596\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 : 1225\n", + "item counter : 3322\n", + "ratio : 0.36864279265723743\n", + " ratio number predicted/items: 2.269334938308757\n", + "current epoch: 5\n" + ] + } + ], + "source": [ + "prev_nets= []\n", + "for i in range(12):\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='cuda',\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,\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": null, + "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": null, + "metadata": {}, + "outputs": [], + "source": [ + "model.no_improve_counter" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(prev_nets)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "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": 35, + "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": 35, + "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": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(568.)\n", + "tensor(31.)\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": 36, + "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": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(581.)\n", + "tensor(32.)\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": 37, + "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": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(587.)\n", + "tensor(33.)\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": 38, + "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": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(594.)\n", + "tensor(34.)\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": 39, + "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": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(594.)\n", + "tensor(34.)\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": 40, + "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": 32, + "metadata": {}, + "outputs": [], + "source": [ + "from sudoku.loader import get_datasets\n", + "from tqdm.notebook import tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "train, test = get_datasets(train_size=5000, test_size=5000)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bf2bb1b730f04d97bf623ec7224ee0b7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/5000 [00:00 9\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[1;32m 11\u001b[0m x \u001b[38;5;241m=\u001b[39m new_x\n", + "\u001b[0;31mValueError\u001b[0m: " + ] + } + ], + "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": 31, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[31], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# stop \u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m\n", + "\u001b[0;31mValueError\u001b[0m: " + ] + } + ], + "source": [ + "# stop \n", + "raise ValueError" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "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": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "print(test_x.sum())\n", + "print(test_x[:,1].sum())\n", + "display_as_dataframe(test_x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "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": null, + "metadata": {}, + "outputs": [], + "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": null, + "metadata": {}, + "outputs": [], + "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": null, + "metadata": {}, + "outputs": [], + "source": [ + "new_x.reshape((2,9,9,9))[0,6:,6:,7]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model.sym_preprocess(new_x).reshape(32,9,9,9)[:,:3,6:,7]" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "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_83/checkpoints exists and is not empty.\n", + " rank_zero_warn(f\"Checkpoint directory {dirpath} exists and is not empty.\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + }, + { + "ename": "RuntimeError", + "evalue": "CUDA error: unspecified launch failure\nCUDA kernel errors might be asynchronously reported at some other API call,so the stacktrace below might be incorrect.\nFor debugging consider passing CUDA_LAUNCH_BLOCKING=1.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[41], line 20\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[38;5;28mprint\u001b[39m(i)\n\u001b[1;32m 15\u001b[0m model \u001b[38;5;241m=\u001b[39m SudokuLightning(\n\u001b[1;32m 16\u001b[0m lr\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.01\u001b[39m,\n\u001b[1;32m 17\u001b[0m prev_nets\u001b[38;5;241m=\u001b[39mprev_nets,\n\u001b[1;32m 18\u001b[0m coef_0 \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m10\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m i\u001b[38;5;241m==\u001b[39m\u001b[38;5;241m0\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;241m20\u001b[39m,\n\u001b[1;32m 19\u001b[0m )\n\u001b[0;32m---> 20\u001b[0m _ \u001b[38;5;241m=\u001b[39m \u001b[43mtrainer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 21\u001b[0m \u001b[38;5;66;03m# model.below_threshold_coef=0.9\u001b[39;00m\n\u001b[1;32m 22\u001b[0m \u001b[38;5;66;03m# model = model.load_from_checkpoint(model_checkpoint.best_model_path)\u001b[39;00m\n\u001b[1;32m 23\u001b[0m \u001b[38;5;66;03m# print(model_checkpoint.best_model_path)\u001b[39;00m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;66;03m# trainer.validate(model=model)\u001b[39;00m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;66;03m# if trainer.logged_metrics['no_improve_counter'].item()==0:\u001b[39;00m\n\u001b[1;32m 26\u001b[0m prev_nets\u001b[38;5;241m.\u001b[39mappend((model\u001b[38;5;241m.\u001b[39mnet, (model\u001b[38;5;241m.\u001b[39mthreshold_abs, model\u001b[38;5;241m.\u001b[39mthreshold_pres)))\n", + "File \u001b[0;32m~/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:520\u001b[0m, in \u001b[0;36mTrainer.fit\u001b[0;34m(self, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path)\u001b[0m\n\u001b[1;32m 518\u001b[0m model \u001b[38;5;241m=\u001b[39m _maybe_unwrap_optimized(model)\n\u001b[1;32m 519\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstrategy\u001b[38;5;241m.\u001b[39m_lightning_module \u001b[38;5;241m=\u001b[39m model\n\u001b[0;32m--> 520\u001b[0m \u001b[43mcall\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_and_handle_interrupt\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 521\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_fit_impl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_dataloaders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mval_dataloaders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdatamodule\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mckpt_path\u001b[49m\n\u001b[1;32m 522\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/trainer/call.py:44\u001b[0m, in \u001b[0;36m_call_and_handle_interrupt\u001b[0;34m(trainer, trainer_fn, *args, **kwargs)\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m trainer\u001b[38;5;241m.\u001b[39mstrategy\u001b[38;5;241m.\u001b[39mlauncher\u001b[38;5;241m.\u001b[39mlaunch(trainer_fn, \u001b[38;5;241m*\u001b[39margs, trainer\u001b[38;5;241m=\u001b[39mtrainer, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 43\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 44\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtrainer_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 46\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m _TunerExitException:\n\u001b[1;32m 47\u001b[0m _call_teardown_hook(trainer)\n", + "File \u001b[0;32m~/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:559\u001b[0m, in \u001b[0;36mTrainer._fit_impl\u001b[0;34m(self, model, train_dataloaders, val_dataloaders, datamodule, ckpt_path)\u001b[0m\n\u001b[1;32m 549\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_data_connector\u001b[38;5;241m.\u001b[39mattach_data(\n\u001b[1;32m 550\u001b[0m model, train_dataloaders\u001b[38;5;241m=\u001b[39mtrain_dataloaders, val_dataloaders\u001b[38;5;241m=\u001b[39mval_dataloaders, datamodule\u001b[38;5;241m=\u001b[39mdatamodule\n\u001b[1;32m 551\u001b[0m )\n\u001b[1;32m 553\u001b[0m ckpt_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_checkpoint_connector\u001b[38;5;241m.\u001b[39m_select_ckpt_path(\n\u001b[1;32m 554\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate\u001b[38;5;241m.\u001b[39mfn,\n\u001b[1;32m 555\u001b[0m ckpt_path,\n\u001b[1;32m 556\u001b[0m model_provided\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m 557\u001b[0m model_connected\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlightning_module \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 558\u001b[0m )\n\u001b[0;32m--> 559\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_run\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mckpt_path\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mckpt_path\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 561\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate\u001b[38;5;241m.\u001b[39mstopped\n\u001b[1;32m 562\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtraining \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n", + "File \u001b[0;32m~/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/trainer/trainer.py:911\u001b[0m, in \u001b[0;36mTrainer._run\u001b[0;34m(self, model, ckpt_path)\u001b[0m\n\u001b[1;32m 908\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_logger_connector\u001b[38;5;241m.\u001b[39mreset_metrics()\n\u001b[1;32m 910\u001b[0m \u001b[38;5;66;03m# strategy will configure model and move it to the device\u001b[39;00m\n\u001b[0;32m--> 911\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstrategy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msetup\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 913\u001b[0m \u001b[38;5;66;03m# hook\u001b[39;00m\n\u001b[1;32m 914\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate\u001b[38;5;241m.\u001b[39mfn \u001b[38;5;241m==\u001b[39m TrainerFn\u001b[38;5;241m.\u001b[39mFITTING:\n", + "File \u001b[0;32m~/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/strategies/single_device.py:73\u001b[0m, in \u001b[0;36mSingleDeviceStrategy.setup\u001b[0;34m(self, trainer)\u001b[0m\n\u001b[1;32m 72\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msetup\u001b[39m(\u001b[38;5;28mself\u001b[39m, trainer: pl\u001b[38;5;241m.\u001b[39mTrainer) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m---> 73\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel_to_device\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 74\u001b[0m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39msetup(trainer)\n", + "File \u001b[0;32m~/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/pytorch_lightning/strategies/single_device.py:70\u001b[0m, in \u001b[0;36mSingleDeviceStrategy.model_to_device\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmodel_to_device\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 69\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmodel \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mself.model must be set before self.model.to()\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m---> 70\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mroot_device\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/lightning_fabric/utilities/device_dtype_mixin.py:54\u001b[0m, in \u001b[0;36m_DeviceDtypeModuleMixin.to\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 52\u001b[0m device, dtype \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39m_C\u001b[38;5;241m.\u001b[39m_nn\u001b[38;5;241m.\u001b[39m_parse_to(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)[:\u001b[38;5;241m2\u001b[39m]\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__update_properties(device\u001b[38;5;241m=\u001b[39mdevice, dtype\u001b[38;5;241m=\u001b[39mdtype)\n\u001b[0;32m---> 54\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/torch/nn/modules/module.py:927\u001b[0m, in \u001b[0;36mModule.to\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 923\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m t\u001b[38;5;241m.\u001b[39mto(device, dtype \u001b[38;5;28;01mif\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_floating_point() \u001b[38;5;129;01mor\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_complex() \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 924\u001b[0m non_blocking, memory_format\u001b[38;5;241m=\u001b[39mconvert_to_format)\n\u001b[1;32m 925\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m t\u001b[38;5;241m.\u001b[39mto(device, dtype \u001b[38;5;28;01mif\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_floating_point() \u001b[38;5;129;01mor\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_complex() \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m, non_blocking)\n\u001b[0;32m--> 927\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_apply\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconvert\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/torch/nn/modules/module.py:579\u001b[0m, in \u001b[0;36mModule._apply\u001b[0;34m(self, fn)\u001b[0m\n\u001b[1;32m 577\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_apply\u001b[39m(\u001b[38;5;28mself\u001b[39m, fn):\n\u001b[1;32m 578\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchildren():\n\u001b[0;32m--> 579\u001b[0m \u001b[43mmodule\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_apply\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 581\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcompute_should_use_set_data\u001b[39m(tensor, tensor_applied):\n\u001b[1;32m 582\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m torch\u001b[38;5;241m.\u001b[39m_has_compatible_shallow_copy_type(tensor, tensor_applied):\n\u001b[1;32m 583\u001b[0m \u001b[38;5;66;03m# If the new tensor has compatible tensor type as the existing tensor,\u001b[39;00m\n\u001b[1;32m 584\u001b[0m \u001b[38;5;66;03m# the current behavior is to change the tensor in-place using `.data =`,\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 589\u001b[0m \u001b[38;5;66;03m# global flag to let the user control whether they want the future\u001b[39;00m\n\u001b[1;32m 590\u001b[0m \u001b[38;5;66;03m# behavior of overwriting the existing tensor or not.\u001b[39;00m\n", + "File \u001b[0;32m~/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/torch/nn/modules/module.py:579\u001b[0m, in \u001b[0;36mModule._apply\u001b[0;34m(self, fn)\u001b[0m\n\u001b[1;32m 577\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_apply\u001b[39m(\u001b[38;5;28mself\u001b[39m, fn):\n\u001b[1;32m 578\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchildren():\n\u001b[0;32m--> 579\u001b[0m \u001b[43mmodule\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_apply\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfn\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 581\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcompute_should_use_set_data\u001b[39m(tensor, tensor_applied):\n\u001b[1;32m 582\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m torch\u001b[38;5;241m.\u001b[39m_has_compatible_shallow_copy_type(tensor, tensor_applied):\n\u001b[1;32m 583\u001b[0m \u001b[38;5;66;03m# If the new tensor has compatible tensor type as the existing tensor,\u001b[39;00m\n\u001b[1;32m 584\u001b[0m \u001b[38;5;66;03m# the current behavior is to change the tensor in-place using `.data =`,\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 589\u001b[0m \u001b[38;5;66;03m# global flag to let the user control whether they want the future\u001b[39;00m\n\u001b[1;32m 590\u001b[0m \u001b[38;5;66;03m# behavior of overwriting the existing tensor or not.\u001b[39;00m\n", + "File \u001b[0;32m~/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/torch/nn/modules/module.py:602\u001b[0m, in \u001b[0;36mModule._apply\u001b[0;34m(self, fn)\u001b[0m\n\u001b[1;32m 598\u001b[0m \u001b[38;5;66;03m# Tensors stored in modules are graph leaves, and we don't want to\u001b[39;00m\n\u001b[1;32m 599\u001b[0m \u001b[38;5;66;03m# track autograd history of `param_applied`, so we have to use\u001b[39;00m\n\u001b[1;32m 600\u001b[0m \u001b[38;5;66;03m# `with torch.no_grad():`\u001b[39;00m\n\u001b[1;32m 601\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mno_grad():\n\u001b[0;32m--> 602\u001b[0m param_applied \u001b[38;5;241m=\u001b[39m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparam\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 603\u001b[0m should_use_set_data \u001b[38;5;241m=\u001b[39m compute_should_use_set_data(param, param_applied)\n\u001b[1;32m 604\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m should_use_set_data:\n", + "File \u001b[0;32m~/Perso/git/sudoku/sudoku_clean_v2/venv/lib/python3.10/site-packages/torch/nn/modules/module.py:925\u001b[0m, in \u001b[0;36mModule.to..convert\u001b[0;34m(t)\u001b[0m\n\u001b[1;32m 922\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m convert_to_format \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m t\u001b[38;5;241m.\u001b[39mdim() \u001b[38;5;129;01min\u001b[39;00m (\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m5\u001b[39m):\n\u001b[1;32m 923\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m t\u001b[38;5;241m.\u001b[39mto(device, dtype \u001b[38;5;28;01mif\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_floating_point() \u001b[38;5;129;01mor\u001b[39;00m t\u001b[38;5;241m.\u001b[39mis_complex() \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 924\u001b[0m non_blocking, memory_format\u001b[38;5;241m=\u001b[39mconvert_to_format)\n\u001b[0;32m--> 925\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdtype\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mis_floating_point\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mis_complex\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnon_blocking\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mRuntimeError\u001b[0m: CUDA error: unspecified launch failure\nCUDA kernel errors might be asynchronously reported at some other API call,so the stacktrace below might be incorrect.\nFor debugging consider passing CUDA_LAUNCH_BLOCKING=1." + ] + } + ], + "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": null, + "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": null, + "metadata": {}, + "outputs": [], + "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": 32, + "metadata": {}, + "outputs": [], + "source": [ + "from sudoku.loader import get_datasets\n", + "from tqdm.notebook import tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "train, test = get_datasets(train_size=5000, test_size=5000)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bf2bb1b730f04d97bf623ec7224ee0b7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/5000 [00:00 9\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[1;32m 11\u001b[0m x \u001b[38;5;241m=\u001b[39m new_x\n", + "\u001b[0;31mValueError\u001b[0m: " + ] + } + ], + "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 +}