diff --git "a/experiments/boost_training_7_base_2_loading.ipynb" "b/experiments/boost_training_7_base_2_loading.ipynb" new file mode 100644--- /dev/null +++ "b/experiments/boost_training_7_base_2_loading.ipynb" @@ -0,0 +1,12387 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/seb/Perso/git/sudoku/sudoku_clean_v2\n" + ] + } + ], + "source": [ + "%cd .." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "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", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "torch.cuda.is_available()\n", + "tensorboard = pl.loggers.TensorBoardLogger(save_dir=\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Global seed set to 1\n" + ] + }, + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "seed_everything(seed=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "train_dataset, test_dataset = get_datasets(train_size=1280, test_size=1280)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "test_x, test_y = tuple(next(iter(data_loader(batch_size=1)[1])))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "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": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(0.9820)" + ] + }, + "execution_count": 9, + "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": 10, + "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": 11, + "metadata": {}, + "outputs": [], + "source": [ + "sym_preprocess = SymPreprocess().cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "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", + " plot = True,\n", + " ):\n", + " \n", + " super().__init__()\n", + " self.net=SmallNet()\n", + " pos_weight = torch.ones((2,9*9*9))\n", + " pos_weight[0,:] = 1./8.\n", + " pos_weight[1,:]= 8.\n", + " weight = torch.ones((2,9*9*9))\n", + " weight[0,:] = 8.\n", + " weight[1,:]= 1.\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.no_improve_counter = 0\n", + " self.item_counter = 0\n", + " self.number_predicted = 0\n", + " self.prev_nets = prev_nets\n", + " self.below_threshold_coef = 1\n", + " self.plot = plot \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 = sym_preprocess.forward(x)\n", + " return self.net(x)\n", + " \n", + " def predict_from_net(self, x, net, th_abs, th_pres):\n", + " x = 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_y = y.clone()\n", + " # \n", + "# mask_y_0 = (x[:,0].reshape(-1,9,9,9).sum(dim=1, keepdim=True)<7).expand((x.shape[0],9,9,9)).reshape_as(x[:,0])\n", + "# new_y[:,1][mask_y_0] = 0\n", + " # \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(), new_y[~mask_no_improve].clone().cpu())\n", + "\n", + " if mask_no_improve.sum()>0: \n", + " return x[mask_no_improve], new_y[mask_no_improve], y[mask_no_improve]\n", + " else:\n", + " return None, None, None\n", + " return x,new_y,y\n", + " \n", + " def computing_loss(self, x, y, output, true_y):\n", + " loss = self.bcewll(output, y)\n", + " # mask = (x==0).float()\n", + " mask = ((x==0)&(output.detach()<4)).float()\n", + " th_enforce = 1.5\n", + " mask_add = ((output.detach()>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", + " self.train_append_data(x, y, output)\n", + " return loss\n", + " \n", + " def train_append_data(self, x, y, output):\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", + "\n", + " self.train_data_iter.append(new_X[~mask_no_improve].cpu(), y[~mask_no_improve].clone().cpu())\n", + "\n", + " \n", + " \n", + " def on_validation_epoch_end(self):\n", + " tensorboard = self.logger.experiment\n", + " if self.plot :\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", + " \n", + " def validation_step(self, batch, batch_idx):\n", + " print(self.threshold_pres_train, self.threshold_abs_train)\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", + " print(self.threshold_pres_train, self.threshold_abs_train)\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", + " \n", + " \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": 13, + "metadata": {}, + "outputs": [], + "source": [ + "class StrengtheningMarge(SudokuLightning):\n", + " def __init__(self, prev_model, th_abs, th_pres, marge = 0.2, **kwargs):\n", + " super().__init__(**kwargs)\n", + " self.prev_model = prev_model\n", + " self.th_abs = th_abs\n", + " self.th_pres = th_pres\n", + " self.marge = marge\n", + " \n", + " def computing_loss(self, x, y, output, true_y):\n", + " loss = self.bcewll(output, y)\n", + " with torch.no_grad():\n", + " x = sym_preprocess.forward(x)\n", + " prev_output = self.prev_model(x)\n", + " mask = torch.empty(y.shape, device=x.device)\n", + " mask[:,0] = (\n", + " ((y[:,0]==0)&(output[:,0] >th_abs-self.marge))\n", + "# | ((y[:,0]==1)&(output[:,0]th_abs))\n", + " ).float()\n", + " mask[:,1] = (\n", + " ((y[:,1]==0)&(output[:,1] >th_pres-self.marge))\n", + "# | ((y[:,1]==1)&(output[:,1]th_pres))\n", + " ).float()\n", + " loss = (loss*mask).sum() \n", + " return loss\n", + " \n", + " def process_batch(self, batch, dataset):\n", + " x, y = batch\n", + " new_y = y.clone()\n", + " # \n", + "# mask_y_0 = (x[:,0].reshape(-1,9,9,9).sum(dim=1, keepdim=True)<7).expand((x.shape[0],9,9,9)).reshape_as(x[:,0])\n", + "# new_y[:,1][mask_y_0] = 0\n", + " # \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(), new_y[~mask_no_improve].clone().cpu())\n", + "\n", + "# return x, new_y, y\n", + " return x,new_y,y\n", + " \n", + " def train_append_data(self, x, y, output):\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", + "\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.detach()==1]=1\n", + " new_X[x.detach()==1]=1\n", + " new_X[(new_X==1)&(y==0)]=0\n", + " \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", + "\n", + " self.train_data_iter.append(new_X[~mask_no_improve].cpu(), y[~mask_no_improve].clone().cpu())\n", + "\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "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": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import joblib\n", + "thresholds = joblib.load(\"thresholds.dump\")\n", + "prev_nets = []\n", + "for model_name, (th_abs, th_pres) in thresholds:\n", + " net = SmallNetBis()\n", + " net.load_state_dict(torch.load(model_name))\n", + " prev_nets.append((net, (th_abs, th_pres)))\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(prev_nets)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "preve_nets = prev_nets[:7]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/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", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params\n", + "-------------------------------------------------\n", + "0 | net | SmallNet | 514 \n", + "1 | bcewll | BCEWithLogitsLoss | 0 \n", + "2 | auroc | BinaryAUROC | 0 \n", + "3 | prev_model | SmallNet | 514 \n", + "-------------------------------------------------\n", + "1.0 K Trainable params\n", + "0 Non-trainable params\n", + "1.0 K Total params\n", + "0.004 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" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-10 -10\n", + "3.0320261478424073 0.9992486000061035\n", + "3.0320261478424073 0.9992486000061035\n", + "3.058953380584717 1.4525580167770387\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 : 64\n", + "ratio : 0.0\n", + " ratio number predicted/items: 311.3076923076923\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": "77e3b4a121e74bfc8b84768d09cbef60", + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 1.4525580167770387\n", + "3.058953380584717 1.4525580167770387\n", + "3.058953380584717 1.4525580167770387\n", + "3.058953380584717 1.4525580167770387\n", + "3.058953380584717 1.4525580167770387\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.2698455810546876\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.3650651931762696\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.477797603607178\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No improve counter : 1240\n", + "item counter : 3929\n", + "ratio : 0.3155216284987277\n", + " ratio number predicted/items: 91.48625954198474\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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No improve counter : 1241\n", + "item counter : 4186\n", + "ratio : 0.29639359923572967\n", + " ratio number predicted/items: 88.69954621447337\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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No improve counter : 1241\n", + "item counter : 4186\n", + "ratio : 0.29639359923572967\n", + " ratio number predicted/items: 88.69954621447337\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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No improve counter : 1241\n", + "item counter : 4186\n", + "ratio : 0.29639359923572967\n", + " ratio number predicted/items: 88.69954621447337\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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No improve counter : 1241\n", + "item counter : 4186\n", + "ratio : 0.29639359923572967\n", + " ratio number predicted/items: 88.69954621447337\n", + "current epoch: 4\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No improve counter : 1241\n", + "item counter : 4186\n", + "ratio : 0.29639359923572967\n", + " ratio number predicted/items: 88.69954621447337\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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No improve counter : 1241\n", + "item counter : 4187\n", + "ratio : 0.29632282712511937\n", + " ratio number predicted/items: 88.68051575931231\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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No improve counter : 1241\n", + "item counter : 4186\n", + "ratio : 0.29639359923572967\n", + " ratio number predicted/items: 88.69954621447337\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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No improve counter : 1241\n", + "item counter : 4186\n", + "ratio : 0.29639359923572967\n", + " ratio number predicted/items: 88.69954621447337\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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n", + "3.058953380584717 2.6957117080688477\n" + ] + }, + { + "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 : 1241\n", + "item counter : 4186\n", + "ratio : 0.29639359923572967\n", + " ratio number predicted/items: 88.69954621447337\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_135/checkpoints exists and is not empty.\n", + " rank_zero_warn(f\"Checkpoint directory {dirpath} exists and is not empty.\")\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params\n", + "-------------------------------------------------\n", + "0 | net | SmallNet | 514 \n", + "1 | bcewll | BCEWithLogitsLoss | 0 \n", + "2 | auroc | BinaryAUROC | 0 \n", + "3 | prev_model | SmallNet | 514 \n", + "-------------------------------------------------\n", + "1.0 K Trainable params\n", + "0 Non-trainable params\n", + "1.0 K Total params\n", + "0.004 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": "stdout", + "output_type": "stream", + "text": [ + "-10 -10\n", + "3.6478014945983888 -1.2331152200698852\n", + "3.6478014945983888 -1.2331152200698852\n", + "3.6478014945983888 -0.8967133402824402\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 : 64\n", + "ratio : 0.0\n", + " ratio number predicted/items: 309.6461538461538\n", + "current epoch: 0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cdb68c1ddbd14b6a9419319b994aef7c", + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n" + ] + }, + { + "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: 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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n" + ] + }, + { + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n" + ] + }, + { + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n" + ] + }, + { + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n" + ] + }, + { + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n" + ] + }, + { + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAGzCAYAAAAv9B03AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA6NUlEQVR4nO3df1yV9f3/8ecBBPwBKKL8UJDop1jiEiFKPyqyOSzSPtt0s6+SNawF25KV07WJlr+29XEuI/3UMv30oUE1cy6dZaiZSjP5US1/LBPLzTjKLH4cS5Dz/v7hPJ+RaIJwDofrcb/dzi2u9/W+rut1vUXPs+t6X+fYjDFGAAAAFuDj6QIAAADcheADAAAsg+ADAAAsg+ADAAAsg+ADAAAsg+ADAAAsg+ADAAAsg+ADAAAsg+ADAAAsg+ADoEtbs2aNbDab9u7d6+lSAHQCBB8AAGAZBB8AAGAZBB8AAGAZBB8AXumjjz7S/fffr2uvvVbdu3dX37599Z3vfEdHjhxpsf+pU6d07733qm/fvgoODtb06dP16aefNuuzd+9ejR8/XmFhYerevbuuuOIK3X333W44GwDu4ufpAgCgLd5++23t3r1b3/3udzVw4EAdOXJEK1eu1JgxY7Rv3z716NGjWf+cnBz17t1b8+fP18GDB7Vy5Up99NFH2r59u2w2m44fP65vfOMb6tevn+bMmaPevXvryJEjWrdunYfOEEBHIPgA8Eq33nqrvv3tbzdry8jIUEpKiv7whz9o2rRpzdb5+/uruLhY3bp1kyQNGjRIs2fP1p/+9Cfdfvvt2r17tz799FO99tprSkxMdG23cOHCjj8ZAG7DrS4AXql79+6unxsbG/XPf/5TV111lXr37q2ysrLz+s+cOdMVeiTpBz/4gfz8/LRp0yZJUu/evSVJr7zyihobGzu2eAAeQ/AB4JU+//xzzZs3T9HR0QoICFBYWJj69eunzz77TDU1Nef1v/rqq5st9+rVS5GRka45QaNHj9a3vvUtLViwQGFhYZo4caKeffZZnT592h2nA8BNCD4AvNIPf/hDLVq0SJMnT9YLL7yg1157TVu2bFHfvn3ldDpbvT+bzaaXXnpJJSUlysnJ0T/+8Q/dfffdGj58uOrr6zvgDAB4AsEHgFd66aWXlJmZqf/6r//St7/9bX3961/XyJEj9dlnn7XY/4MPPmi2XF9fr08++USxsbHN2m+66SYtWrRIe/fuVUFBgd5//30VFhZ20FkAcDeCDwCv5OvrK2NMs7YVK1aoqampxf5PPfVUs7k7K1eu1JkzZ5Seni5J+vTTT8/b37BhwySJ211AF8JTXQC80m233abnnntOISEhio+PV0lJiV5//XX17du3xf4NDQ0aN26cJk+erIMHD+rJJ5/UyJEjdfvtt0uS1q5dqyeffFJ33HGHrrzyStXV1enpp59WcHCwJkyY4M5TA9CBCD4AvNJvf/tb+fr6qqCgQF988YVuueUWvf766xo/fnyL/Z944gkVFBRo3rx5amxs1Pe+9z09/vjjstlsks5Obt6zZ48KCwtlt9sVEhKipKQkFRQU6IorrnDnqQHoQDbz5Wu7AAAAXRRzfAAAgGUQfAAAgGUQfAAAgGUQfAAAgGUQfAAAgGUQfAAAgGXwOT5f4nQ6dezYMQUFBbk+3wMAAHRuxhjV1dUpKipKPj4Xvq5D8PmSY8eOKTo62tNlAACANjh69KgGDhx4wfUEny8JCgqSdHbggoODPVwNuiKHw6GoqChJZ4N2z549PVwRAHi/2tpaRUdHu97HL4Tg8yXnbm8FBwcTfNAhfH19XT8HBwcTfACgHX3VNBUmNwMAAMsg+PxLfn6+4uPjNWLECE+XAgAAOghfUvoltbW1CgkJUU1NDbe60CEcDod69eolSaqvr+dWFwC0g0t9/+aKDwAAsAyCjzvNDzn7AgAAHkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAluHn6QI6UmxsrIKDg+Xj46M+ffpo27Ztni4JAAB4UJcOPpK0e/du9erVy9NlAACAToBbXQAAwDIuK/gsXbpUNptNDzzwQDuVc9aOHTuUkZGhqKgo2Ww2rV+/vsV++fn5io2NVWBgoJKTk7Vnz55m6202m0aPHq0RI0aooKCgXWsEAADep83B5+2339Z///d/a+jQoRftt2vXLjU2Np7Xvm/fPtnt9ha3cTgcSkhIUH5+/gX3W1RUpNzcXOXl5amsrEwJCQkaP368jh8/7uqzc+dOlZaWasOGDVq8eLHefffdSzw7AADQFbUp+NTX1+vOO+/U008/rT59+lywn9PpVHZ2tqZOnaqmpiZX+8GDB5Wamqq1a9e2uF16eroWLlyoO+6444L7XrZsmbKysjRjxgzFx8dr1apV6tGjh1avXu3qM2DAAElSZGSkJkyYoLKysgvuLz8/X/Hx8RoxYsQF+wAAAO/WpuCTnZ2tW2+9VWlpaRffuY+PNm3apPLyck2fPl1Op1MffvihUlNTNWnSJM2ePbtNRTc0NKi0tLTZ8X18fJSWlqaSkhJJZ68a1dXVSTob1LZu3aohQ4Zc9Jz27dunt99+u001AQCAzq/VT3UVFhaqrKzskgNCVFSUtm7dqlGjRmnq1KkqKSlRWlqaVq5c2epiz6murlZTU5PCw8ObtYeHh+vAgQOSJLvd7rpi1NTUpKysLK7mAABgca0KPkePHtWPf/xjbdmyRYGBgZe8XUxMjJ577jmNHj1acXFxeuaZZ2Sz2VpdbGvExcXpnXfe6dBjAAAA79KqW12lpaU6fvy4brzxRvn5+cnPz09vvPGGHn/8cfn5+TWbx/Pv7Ha7Zs6cqYyMDJ06dUqzZs26rKLDwsLk6+t73uRou92uiIiIy9o3AADouloVfMaNG6f33ntPFRUVrldiYqLuvPNOVVRUyNfX97xtqqurNW7cOA0ePFjr1q1TcXGxioqK9OCDD7a5aH9/fw0fPlzFxcWuNqfTqeLiYqWkpLR5vwAAoGtr1a2uoKAgXX/99c3aevbsqb59+57XLp0NI+np6Ro0aJCKiork5+en+Ph4bdmyRampqRowYECLV3/q6+t16NAh13JlZaUqKioUGhqqmJgYSVJubq4yMzOVmJiopKQkLV++XA6HQzNmzGjNKQEAAAvp0K+s8PHx0eLFizVq1Cj5+/u72hMSEvT666+rX79+LW63d+9ejR071rWcm5srScrMzNSaNWskSVOmTNGJEyc0b948VVVVadiwYdq8efN5E54BAADOsRljjKeL6Exqa2sVEhKimpoaBQcHt+/O54f867817btfeBWHw+H6/rj6+nr17NnTwxUBgPe71PdvvqsLAABYBsEHAABYBsEHAABYBsEHAABYBsEHAABYBsEHAABYBsEHAABYBsEHAABYBsEHAABYBsEHAABYBsEHAABYBsEHAABYBsEHAABYBsEHAABYhp+nC+hIsbGxCg4Olo+Pj/r06aNt27Z5uiQAAOBBXTr4SNLu3bvVq1cvT5cBAAA6AW51AQAAy2h18Fm5cqWGDh2q4OBgBQcHKyUlRX/+85/btagdO3YoIyNDUVFRstlsWr9+fYv98vPzFRsbq8DAQCUnJ2vPnj3N1ttsNo0ePVojRoxQQUFBu9YIAAC8T6uDz8CBA7V06VKVlpZq7969Sk1N1cSJE/X++++32H/Xrl1qbGw8r33fvn2y2+0tbuNwOJSQkKD8/PwL1lFUVKTc3Fzl5eWprKxMCQkJGj9+vI4fP+7qs3PnTpWWlmrDhg1avHix3n333VaeLQAA6EpaHXwyMjI0YcIEXX311brmmmu0aNEi9erVS2+99dZ5fZ1Op7KzszV16lQ1NTW52g8ePKjU1FStXbu2xWOkp6dr4cKFuuOOOy5Yx7Jly5SVlaUZM2YoPj5eq1atUo8ePbR69WpXnwEDBkiSIiMjNWHCBJWVlbX2dAEAQBdyWXN8mpqaVFhYKIfDoZSUlPN37uOjTZs2qby8XNOnT5fT6dSHH36o1NRUTZo0SbNnz27TcRsaGlRaWqq0tLRmx0pLS1NJSYmks1eN6urqJEn19fXaunWrhgwZcsF95ufnKz4+XiNGjGhTTQAAoPNr01Nd7733nlJSUvTFF1+oV69eevnllxUfH99i36ioKG3dulWjRo3S1KlTVVJSorS0NK1cubLNRVdXV6upqUnh4eHN2sPDw3XgwAFJkt1ud10xampqUlZW1kVDTXZ2trKzs1VbW6uQkJA21wYAADqvNgWfa6+9VhUVFaqpqdFLL72kzMxMvfHGGxcMPzExMXruuec0evRoxcXF6ZlnnpHNZruswr9KXFyc3nnnnQ49BgAA8C5tutXl7++vq666SsOHD9eSJUuUkJCg3/72txfsb7fbNXPmTGVkZOjUqVOaNWtWmwuWpLCwMPn6+p43OdputysiIuKy9g0AALqudvkcH6fTqdOnT7e4rrq6WuPGjdPgwYO1bt06FRcXq6ioSA8++GCbj+fv76/hw4eruLi4WQ3FxcUtzjUCAACQ2nCra+7cuUpPT1dMTIzq6ur0/PPPa/v27Xr11VfP6+t0OpWenq5BgwapqKhIfn5+io+P15YtW5SamqoBAwa0ePWnvr5ehw4dci1XVlaqoqJCoaGhiomJkSTl5uYqMzNTiYmJSkpK0vLly+VwODRjxozWnhIAALCIVgef48ePa/r06frkk08UEhKioUOH6tVXX9XXv/718/r6+Pho8eLFGjVqlPz9/V3tCQkJev3119WvX78Wj7F3716NHTvWtZybmytJyszM1Jo1ayRJU6ZM0YkTJzRv3jxVVVVp2LBh2rx583kTngEAAM6xGWOMp4voTM491VVTU6Pg4OD23fn8fz0tNr+mffcLr+JwOFzfH1dfX6+ePXt6uCIA8H6X+v7Nd3UBAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADL8PN0AR0pNjZWwcHB8vHxUZ8+fbRt2zZPlwQAADyoSwcfSdq9e7d69erl6TIAAEAnwK0uAABgGa0OPkuWLNGIESMUFBSk/v37a9KkSTp48GC7FrVjxw5lZGQoKipKNptN69evb7Fffn6+YmNjFRgYqOTkZO3Zs6fZepvNptGjR2vEiBEqKCho1xoBAID3aXXweeONN5Sdna233npLW7ZsUWNjo77xjW/I4XC02H/Xrl1qbGw8r33fvn2y2+0tbuNwOJSQkKD8/PwL1lFUVKTc3Fzl5eWprKxMCQkJGj9+vI4fP+7qs3PnTpWWlmrDhg1avHix3n333VaeLQAA6EpsxhhzOTs4ceKE+vfvrzfeeEP/8R//0Wyd0+nUjTfeqKuvvlqFhYXy9fWVJB08eFCjR49Wbm6uZs+effECbTa9/PLLmjRpUrP25ORkjRgxQk888YTrWNHR0frhD3+oOXPmnLefhx56SEOGDNFdd9110ePV1tYqJCRENTU1Cg4O/oqzb6X5If/6b0377hdexeFwuOad1dfXq2fPnh6uCAC836W+f1/2HJ+amrNv4qGhoefv3MdHmzZtUnl5uaZPny6n06kPP/xQqampmjRp0leGngtpaGhQaWmp0tLSmh0rLS1NJSUlks6+udTV1Uk6++aydetWDRky5IL7zM/PV3x8vEaMGNGmmgAAQOd3WU91OZ1OPfDAA7rlllt0/fXXt9gnKipKW7du1ahRozR16lSVlJQoLS1NK1eubPNxq6ur1dTUpPDw8Gbt4eHhOnDggCTJbrfrjjvukCQ1NTUpKyvroqEmOztb2dnZrsQIAAC6nssKPtnZ2frrX/+qnTt3XrRfTEyMnnvuOY0ePVpxcXF65plnZLPZLufQXykuLk7vvPNOhx4DAAB4lzbf6srJydErr7yibdu2aeDAgRfta7fbNXPmTGVkZOjUqVOaNWtWWw8rSQoLC5Ovr+95k6PtdrsiIiIua98AAKDranXwMcYoJydHL7/8srZu3aorrrjiov2rq6s1btw4DR48WOvWrVNxcbGKior04IMPtrlof39/DR8+XMXFxa42p9Op4uJipaSktHm/AACga2v1ra7s7Gw9//zz+uMf/6igoCBVVVVJkkJCQtS9e/dmfZ1Op9LT0zVo0CAVFRXJz89P8fHx2rJli1JTUzVgwIAWr/7U19fr0KFDruXKykpVVFQoNDRUMTExkqTc3FxlZmYqMTFRSUlJWr58uRwOh2bMmNHaUwIAABbR6sfZLzQ359lnn23xUfEtW7Zo1KhRCgwMbNZeXl6ufv36tXibbPv27Ro7dux57ZmZmVqzZo1r+YknntCvf/1rVVVVadiwYXr88ceVnJzcmtM5D4+zo6PxODsAtL9Lff++7M/x6WoIPuhoBB8AaH9u+xwfAAAAb0HwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAluHn6QI6QmxsrIKDg+Xj46M+ffpo27Ztni4JAAB0Al0y+EjS7t271atXL0+XAQAAOhFudXlA7JyNip2z0dNlAABgOZ0u+OzYsUMZGRmKioqSzWbT+vXrz+uTn5+v2NhYBQYGKjk5WXv27Gm23mazafTo0RoxYoQKCgrcVDkAAOjsOl3wcTgcSkhIUH5+fovri4qKlJubq7y8PJWVlSkhIUHjx4/X8ePHXX127typ0tJSbdiwQYsXL9a7777rrvIBAEAn1umCT3p6uhYuXKg77rijxfXLli1TVlaWZsyYofj4eK1atUo9evTQ6tWrXX0GDBggSYqMjNSECRNUVlZ2weOdPn1atbW1zV4AAKBr6nTB52IaGhpUWlqqtLQ0V5uPj4/S0tJUUlIi6ewVo7q6OklSfX29tm7dqiFDhlxwn0uWLFFISIjrFR0d3bEnAQAAPMargk91dbWampoUHh7erD08PFxVVVWSJLvdrpEjRyohIUE33XSTpk+frhEjRlxwn3PnzlVNTY3rdfTo0Q49BwAA4Dld7nH2uLg4vfPOO5fcPyAgQAEBAR1YEQAA6Cy8KviEhYXJ19dXdru9WbvdbldERES7HMMYI0kdM9fn9Nl9O0+f6rhjoNNzOByun2tra9XU1OTBagCgazj3nnruffxCvCr4+Pv7a/jw4SouLtakSZMkSU6nU8XFxcrJyWmXY5ybH9Sxc30mS5JClnfgIeAVoqKiPF0CAHQpdXV1CgkJueD6Thd86uvrdejQIddyZWWlKioqFBoaqpiYGOXm5iozM1OJiYlKSkrS8uXL5XA4NGPGjHY5flRUlI4ePaqgoCDZbLZ22ec5tbW1io6O1tGjRxUcHNyu+0ZzjLV7MM7uwTi7D2PtHh0xzsYY1dXVfeX/UHa64LN3716NHTvWtZybmytJyszM1Jo1azRlyhSdOHFC8+bNU1VVlYYNG6bNmzefN+G5rXx8fDRw4MB22deFBAcH8xfKTRhr92Cc3YNxdh/G2j3ae5wvdqXnnE4XfMaMGfOV9+dycnLa7dYWAACwDq96nB0AAOByEHzcKCAgQHl5eTw+7waMtXswzu7BOLsPY+0enhxnm/mq+0oAAABdBFd8AACAZRB8AACAZRB8AACAZRB8AACAZRB82ll+fr5iY2MVGBio5ORk7dmz56L9X3zxRV133XUKDAzUDTfcoE2bNrmpUu/XmrF++umnNWrUKPXp00d9+vRRWlraV/7Z4KzW/k6fU1hYKJvN5vp6GVxca8f5s88+U3Z2tiIjIxUQEKBrrrmGfz8uUWvHevny5br22mvVvXt3RUdHa9asWfriiy/cVK132rFjhzIyMhQVFSWbzab169d/5Tbbt2/XjTfeqICAAF111VVas2ZNxxRn0G4KCwuNv7+/Wb16tXn//fdNVlaW6d27t7Hb7S3237Vrl/H19TW/+tWvzL59+8zPf/5z061bN/Pee++5uXLv09qxnjp1qsnPzzfl5eVm//795q677jIhISHm73//u5sr9y6tHedzKisrzYABA8yoUaPMxIkT3VOsF2vtOJ8+fdokJiaaCRMmmJ07d5rKykqzfft2U1FR4ebKvU9rx7qgoMAEBASYgoICU1lZaV599VUTGRlpZs2a5ebKvcumTZvMww8/bNatW2ckmZdffvmi/Q8fPmx69OhhcnNzzb59+8yKFSuMr6+v2bx5c7vXRvBpR0lJSSY7O9u13NTUZKKiosySJUta7D958mRz6623NmtLTk429957b4fW2RW0dqy/7MyZMyYoKMisXbu2o0rsEtoyzmfOnDE333yz+d3vfmcyMzMJPpegteO8cuVKExcXZxoaGtxVYpfR2rHOzs42qampzdpyc3PNLbfc0qF1diWXEnxmz55thgwZ0qxtypQpZvz48e1eD7e62klDQ4NKS0uVlpbmavPx8VFaWppKSkpa3KakpKRZf0kaP378BfvjrLaM9ZedOnVKjY2NCg0N7agyvV5bx/mRRx5R//79dc8997ijTK/XlnHesGGDUlJSlJ2drfDwcF1//fVavHixmpqa3FW2V2rLWN98880qLS113Q47fPiwNm3apAkTJrilZqtw5/thp/uuLm9VXV2tpqam874sNTw8XAcOHGhxm6qqqhb7V1VVdVidXUFbxvrLfvrTnyoqKuq8v2j4P20Z5507d+qZZ55RRUWFGyq8dE6nUw0NDQoMDPR0KedpyzgfPnxYW7du1Z133qlNmzbp0KFDuv/++9XY2Ki8vDx3lO2V2jLWU6dOVXV1tUaOHCljjM6cOaP77rtPP/vZz9xRsmVc6P2wtrZWn3/+ubp3795ux+KKDyxn6dKlKiws1Msvv9wp3wi9VV1dnaZNm6ann35aYWFhHXKM+fPny2az6cCBA5o8ebKCg4PVt29f/fjHP2422dRmsyknJ0cFBQUaMmSIAgICtHnzZknSP/7xD919990KDw9XQECAhgwZotWrV593rBUrVmjIkCHq0aOH+vTpo8TERD3//PMdcl6t5XQ61b9/fz311FMaPny4pkyZoocfflirVq3ydGldzvbt27V48WI9+eSTKisr07p167Rx40Y9+uijni4NbcQVn3YSFhYmX19f2e32Zu12u10REREtbhMREdGq/jirLWN9zmOPPaalS5fq9ddf19ChQzuyTK/X2nH+8MMPdeTIEWVkZLjanE6nJMnPz08HDx7UlVde2S61TZ48WbGxsVqyZIneeustPf744/r000/1P//zP64+W7du1QsvvKCcnByFhYUpNjZWdrtdN910kysY9evXT3/+8591zz33qLa2Vg888ICks08B/uhHP9K3v/1tV6h699139Ze//EVTp05tl3M4py2/z5GRkerWrZt8fX1dbYMHD1ZVVZUaGhrk7+/frjV2FW0Z61/84heaNm2avv/970uSbrjhBjkcDs2cOVMPP/ywfHy4ftAeLvR+GBwc3K5XeyTxVFd7SkpKMjk5Oa7lpqYmM2DAgItObr7tttuataWkpDC5+RK0dqyNMeaXv/ylCQ4ONiUlJe4osUtozTh//vnn5r333mv2mjhxoklNTTXvvfeeOX369GXXk5eXZySZ22+/vVn7/fffbySZd955xxhzdjKlj4+Pef/995v1u+eee0xkZKSprq5u1v7d737XhISEmFOnThljjJk4ceJ5Ey07Umt/n+fOnWsGDRpkmpqaXG3Lly83kZGRHV6rt2vtWN94441m9uzZzdqef/550717d3PmzJkOrbWr0CVObr7++uubtX3ve9/rkMnNBJ92VFhYaAICAsyaNWvMvn37zMyZM03v3r1NVVWVMcaYadOmmTlz5rj679q1y/j5+ZnHHnvM7N+/3+Tl5fE4+yVq7VgvXbrU+Pv7m5deesl88sknrlddXZ2nTsErtHacv6y9n+o6F3xeffXVZu379+83klxvXpLM2LFjm/VxOp2md+/eZubMmebEiRPNXs8++6yRZHbu3OmqOyQkxOzZs6fdar+Y1o7zxx9/bIKCgkxOTo45ePCgeeWVV0z//v3NwoUL3VKvN2vtWOfl5ZmgoCDz+9//3hw+fNi89tpr5sorrzSTJ0/21Cl4hbq6OlNeXm7Ky8uNJLNs2TJTXl5uPvroI2OMMXPmzDHTpk1z9T/3OPtDDz1k9u/fb/Lz83mc3VusWLHCxMTEGH9/f5OUlGTeeust17rRo0ebzMzMZv1feOEFc8011xh/f38zZMgQs3HjRjdX7L1aM9aDBg0yks575eXlub9wL9Pa3+l/11HB5/Dhw83aGxoajI+Pj+tqqSRz9913N+tjt9tb/B3499e6deuMMcbs27fPDBgwwEgyV111lbn//vtdoaijtHacd+/ebZKTk01AQICJi4szixYt4grEJWrNWDc2Npr58+ebK6+80gQGBpro6Ghz//33m08//dT9hXuRbdu2tfh37NzYZmZmmtGjR5+3zbBhw4y/v7+Ji4szzz77bIfUZjPGmPa9eQYAHWP+/PlasGCBDh8+rCuuuMLVfubMGQUEBCgrK0urVq2SzWZTdna2nnjiCVefqqoqRUZG6v/9v/+nzMzMFvc/dOhQ9e/fX5LkcDj0yiuvaPPmzfrzn/8su92uefPmacGCBR17kgA6FJObAXidDz74oFnwOXTokJxOp2JjYy+4Tb9+/RQUFKSmpqZL+hiDnj17asqUKZoyZYoaGhr0n//5n1q0aJHmzp3L04CAF2M6OgCvk5+f32x5xYoVkqT09PQLbuPr66tvfetb+sMf/qC//vWv560/ceKE6+d//vOfzdb5+/srPj5exhg1NjZeTukAPIwrPgC8TmVlpW6//XZ985vfVElJif73f/9XU6dOVUJCwkW3W7p0qbZt26bk5GRlZWUpPj5eJ0+eVFlZmV5//XWdPHlSkvSNb3xDERERuuWWWxQeHq79+/friSee0K233qqgoCB3nCKADkLwAeB1ioqKNG/ePM2ZM0d+fn7KycnRr3/966/cLjw8XHv27NEjjzyidevW6cknn1Tfvn01ZMgQ/fKXv3T1u/fee1VQUKBly5apvr5eAwcO1I9+9CP9/Oc/78jTAuAGTG4G4DXOTW4+ceJEh306NICujTk+AADAMgg+AADAMgg+AADAMpjjAwAALIMrPgAAwDJ4nP1LnE6njh07pqCgINlsNk+XAwAALoExRnV1dYqKipKPz4Wv63TJ4FNZWam7775bdrtdvr6+euutt9SzZ89L2vbYsWOKjo7u4AoBAEBHOHr0qAYOHHjB9V0y+Nx1111auHChRo0apZMnTyogIOCStz33qaxHjx5VcHBwR5UIAECX4XA4FBUVJensBYRLvdjQnmpraxUdHf2Vn67e5YLP+++/r27dumnUqFGSpNDQ0FZtf+72VnBwMMEHAIBL4Ovr6/o5ODjYI8HnnK+aptLpJjfv2LFDGRkZioqKks1m0/r168/rk5+fr9jYWAUGBio5OVl79uxxrfvggw/Uq1cvZWRk6MYbb9TixYvdWD0AAOjMOl3wcTgcSkhIOO/bl88pKipSbm6u8vLyVFZWpoSEBI0fP17Hjx+XJJ05c0ZvvvmmnnzySZWUlGjLli3asmWLO08BAAB0Up0u+KSnp2vhwoW64447Wly/bNkyZWVlacaMGYqPj9eqVavUo0cPrV69WpI0YMAAJSYmKjo6WgEBAZowYYIqKioueLzTp0+rtra22QsAAHRNnS74XExDQ4NKS0uVlpbmavPx8VFaWppKSkokSSNGjNDx48f16aefyul0aseOHRo8ePAF97lkyRKFhIS4XjzRBQBA1+VVwae6ulpNTU0KDw9v1h4eHq6qqipJkp+fnxYvXqz/+I//0NChQ3X11Vfrtttuu+A+586dq5qaGtfr6NGjHXoOAADAc7rcU13S2dtl6enpl9Q3ICCgVY+7X67YORtdPx9ZeqvbjgsAALzsik9YWJh8fX1lt9ubtdvtdkVERHioKgAA4C28Kvj4+/tr+PDhKi4udrU5nU4VFxcrJSXFg5UBAABv0OluddXX1+vQoUOu5crKSlVUVCg0NFQxMTHKzc1VZmamEhMTlZSUpOXLl8vhcGjGjBkerBoAAHiDThd89u7dq7Fjx7qWc3NzJUmZmZlas2aNpkyZohMnTmjevHmqqqrSsGHDtHnz5vMmPAMAAHxZpws+Y8aMkTHmon1ycnKUk5PjpooAAEBX4VVzfAAAAC4HwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwced5ofoSOBUT1cBAIBlEXwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBldMngc+rUKQ0aNEgPPvigp0sBAACdSJcMPosWLdJNN93k6TIAAEAn0+WCzwcffKADBw4oPT3d06UAAIBOplMFnx07digjI0NRUVGy2Wxav379eX3y8/MVGxurwMBAJScna8+ePc3WP/jgg1qyZImbKgYAAN6kUwUfh8OhhIQE5efnt7i+qKhIubm5ysvLU1lZmRISEjR+/HgdP35ckvTHP/5R11xzja655ppLPubp06dVW1vb7AUAALomP08X8O/S09Mveotq2bJlysrK0owZMyRJq1at0saNG7V69WrNmTNHb731lgoLC/Xiiy+qvr5ejY2NCg4O1rx58y64zyVLlmjBggXtfi4AAKDz6VRXfC6moaFBpaWlSktLc7X5+PgoLS1NJSUlks6GmKNHj+rIkSN67LHHlJWVddHQI0lz585VTU2N63X06NEOPQ8AAOA5neqKz8VUV1erqalJ4eHhzdrDw8N14MCBNu83ICBAAQEBl1seAADwAl4TfFrrrrvu8nQJAACgk/GaW11hYWHy9fWV3W5v1m632xUREeGhqgAAgDfxmuDj7++v4cOHq7i42NXmdDpVXFyslJQUD1YGAAC8Rae61VVfX69Dhw65lisrK1VRUaHQ0FDFxMQoNzdXmZmZSkxMVFJSkpYvXy6Hw+F6ygsAAOBiOlXw2bt3r8aOHetazs3NlSRlZmZqzZo1mjJlik6cOKF58+apqqpKw4YN0+bNm8+b8AwAANCSThV8xowZI2PMRfvk5OQoJyfHTRUBAICuxGvm+AAAAFwugg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgo+nzQ85+wIAAB2O4AMAACyD4AMAACyD4AMAACyD4AMAACyD4AMAACyD4AMAACyD4AMAACyD4AMAACyD4AMAACyD4AMAACyD4AMAACyjywWfo0ePasyYMYqPj9fQoUP14osverokAADQSfh5uoD25ufnp+XLl2vYsGGqqqrS8OHDNWHCBPXs2dPTpQEAAA/rcsEnMjJSkZGRkqSIiAiFhYXp5MmTBB8AAND5bnXt2LFDGRkZioqKks1m0/r168/rk5+fr9jYWAUGBio5OVl79uxpcV+lpaVqampSdHR0B1cNAAC8QacLPg6HQwkJCcrPz29xfVFRkXJzc5WXl6eysjIlJCRo/PjxOn78eLN+J0+e1PTp0/XUU09d9HinT59WbW1tsxcAAOiaOt2trvT0dKWnp19w/bJly5SVlaUZM2ZIklatWqWNGzdq9erVmjNnjqSzYWbSpEmaM2eObr755oseb8mSJVqwYEH7nQAANTU1qbGx0dNleJVu3brJ19fX02UAXV6nCz4X09DQoNLSUs2dO9fV5uPjo7S0NJWUlEiSjDG66667lJqaqmnTpn3lPufOnavc3FzXcm1tLbfGgDYyxqiqqkqfffaZp0vxSr1791ZERIRsNpunSwG6LK8KPtXV1WpqalJ4eHiz9vDwcB04cECStGvXLhUVFWno0KGu+UHPPfecbrjhhhb3GRAQoICAgA6tG7CKc6Gnf//+6tGjB2/gl8gYo1OnTrlu2Z97QANA+/Oq4HMpRo4cKafT6ekyWi12zkYdWXqrp8sA2qypqckVevr27evpcrxO9+7dJUnHjx9X//79ue0FdJBON7n5YsLCwuTr6yu73d6s3W63KyIiwkNVAZDkmtPTo0cPD1fivc6NHfOjgI7jVcHH399fw4cPV3FxsavN6XSquLhYKSkpHqwMwDnc3mo7xg7oeJ3uVld9fb0OHTrkWq6srFRFRYVCQ0MVExOj3NxcZWZmKjExUUlJSVq+fLkcDofrKS8AAIAL6XTBZ+/evRo7dqxr+dwTV5mZmVqzZo2mTJmiEydOaN68eaqqqtKwYcO0efPm8yY8AwAAfFmnCz5jxoyRMeaifXJycpSTk+OmigBcrtg5G916vM7yoMDJkyf1wx/+UH/605/k4+Ojb33rW/rtb3+rXr16ebo0wLK8ao4PAHQWDQ0NX9nnzjvv1Pvvv68tW7bolVde0Y4dOzRz5kw3VAfgQgg+ACCprq5Od955p3r27KnIyEj95je/0ZgxY/TAAw9IkmJjY/Xoo49q+vTpCg4O/soAs3//fm3evFm/+93vlJycrJEjR2rFihUqLCzUsWPH3HBGAFpC8AEAnZ1PuGvXLm3YsEFbtmzRm2++qbKysmZ9HnvsMSUkJKi8vFy/+MUvLrq/kpIS9e7dW4mJia62tLQ0+fj46C9/+UuHnAOAr9bp5vgAgLvV1dVp7dq1ev755zVu3DhJ0rPPPquoqKhm/VJTU/WTn/zkkvZZVVWl/v37N2vz8/NTaGioqqqq2qdwAK3GFR8Alnf48GE1NjYqKSnJ1RYSEqJrr722Wb9/v3oDwDsRfADgEvXs2fOS+0ZERLi+e+ucM2fO6OTJk3zSPOBBBB8AlhcXF6du3brp7bffdrXV1NTob3/7W5v3mZKSos8++0ylpaWutq1bt8rpdCo5Ofmy6gXQdszxAWB5QUFByszM1EMPPaTQ0FD1799feXl58vHxafPXSAwePFjf/OY3lZWVpVWrVqmxsVE5OTn67ne/e97cIQDuwxUfAJC0bNkypaSk6LbbblNaWppuueUWDR48WIGBgW3eZ0FBga677jqNGzdOEyZM0MiRI/XUU0+1Y9UAWosrPp3N/JB/+7nGc3UA7aizfJLyxQQFBamgoMC17HA4tGDBAtfn9Rw5cqTV+wwNDdXzzz/fXiUCaAcEHwCQVF5ergMHDigpKUk1NTV65JFHJEkTJ070cGUA2hO3ugDgX859QGFaWpocDofefPNNhYWFtdh38eLF6tWrV4uv9PR0N1cO4FJxxQcAJH3ta19r9gTWV7nvvvs0efLkFtd17969vcoC0M4IPgDQBqGhoQoNDfV0GQBaiVtdAADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMnicHUDH+/evYnHL8TrH170sWrRIGzduVEVFhfz9/fXZZ595uiTA8rjiAwBt0NDQcEl9vvOd7+gHP/iBGyoCcCkIPgAgqa6uTnfeead69uypyMhI/eY3v9GYMWP0wAMPSJJiY2P16KOPavr06QoODnZ9eenFLFiwQLNmzdINN9zQwdUDuFQEHwCQlJubq127dmnDhg3asmWL3nzzTZWVlTXrc+67vMrLy/WLX/zCQ5UCuBzM8QFgeXV1dVq7dq2ef/55jRs3TpL07LPPKioqqlm/1NRU/eQnP/FEiQDaCVd8AFje4cOH1djYqKSkJFdbSEiIrr322mb9EhMT3V0agHZG8AGAS9SzZ09PlwDgMhF8AFheXFycunXrprffftvVVlNTo7/97W8erApAR2CODwDLCwoKUmZmph566CGFhoaqf//+ysvLk4+Pj2w2W5v3+/HHH+vkyZP6+OOP1dTUpIqKCknSVVddpV69erVT9QBag+ADAJKWLVum++67T7fddpuCg4M1e/ZsHT16VIGBgW3e57x587R27VrX8te+9jVJ0rZt2zRmzJjLLRlAGxB8AHS8TvJJyhcTFBSkgoIC17LD4dCCBQtcn9dz5MiRVu9zzZo1WrNmTTtVCKA9EHwAQFJ5ebkOHDigpKQk1dTU6JFHHpEkTZw40cOVAWhPTG4GgH859wGFaWlpcjgcevPNNxUWFtZi38WLF6tXr14tvtLT091cOYBLxRUfANDZ+TelpaWX3P++++7T5MmTW1zXvXv39ioLQDsj+ABAG4SGhio0NNTTZQBoJW51AQAAyyD4AGhXTqfT0yV4LcYO6Hjc6gLQLvz9/eXj46Njx46pX79+8vf3v6wP/7MSY4waGhp04sQJ+fj4yN/f39MlAV0WwacTi52zUUeW3urpMoBL4uPjoyuuuEKffPKJjh075ulyvFKPHj0UExMjHx8uxgMdheADoN34+/srJiZGZ86cUVNTk6fL8Sq+vr7y8/PjKhnQwQg+ANqVzWZTt27d1K1bN0+XAgDn4XoqAACwDIIPAACwDIIPAACwDOb4fIkxRpJUW1vb/js/fXbfztOn/u8Y/9b278vN2gAA6MQcDofr59raWo883HDu/fLc+/iF2MxX9bCYv//974qOjvZ0GQAAoA2OHj2qgQMHXnA9wedLnE6njh07pqCgoHZ/rLS2tlbR0dE6evSogoOD23XfaI6xdg/G2T0YZ/dhrN2jI8bZGKO6ujpFRUVd9LOwuNX1JT4+PhdNiu0hODiYv1Buwli7B+PsHoyz+zDW7tHe4xwSEvKVfZjcDAAALIPgAwAALIPg40YBAQHKy8tTQECAp0vp8hhr92Cc3YNxdh/G2j08Oc5MbgYAAJbBFR8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBJ92lp+fr9jYWAUGBio5OVl79uy5aP8XX3xR1113nQIDA3XDDTdo06ZNbqrU+7VmrJ9++mmNGjVKffr0UZ8+fZSWlvaVfzY4q7W/0+cUFhbKZrNp0qRJHVtgF9Hacf7ss8+UnZ2tyMhIBQQE6JprruHfj0vU2rFevny5rr32WnXv3l3R0dGaNWuWvvjiCzdV65127NihjIwMRUVFyWazaf369V+5zfbt23XjjTcqICBAV111ldasWdMxxRm0m8LCQuPv729Wr15t3n//fZOVlWV69+5t7HZ7i/137dplfH19za9+9Suzb98+8/Of/9x069bNvPfee26u3Pu0dqynTp1q8vPzTXl5udm/f7+56667TEhIiPn73//u5sq9S2vH+ZzKykozYMAAM2rUKDNx4kT3FOvFWjvOp0+fNomJiWbChAlm586dprKy0mzfvt1UVFS4uXLv09qxLigoMAEBAaagoMBUVlaaV1991URGRppZs2a5uXLvsmnTJvPwww+bdevWGUnm5Zdfvmj/w4cPmx49epjc3Fyzb98+s2LFCuPr62s2b97c7rURfNpRUlKSyc7Odi03NTWZqKgos2TJkhb7T5482dx6663N2pKTk829997boXV2Ba0d6y87c+aMCQoKMmvXru2oEruEtozzmTNnzM0332x+97vfmczMTILPJWjtOK9cudLExcWZhoYGd5XYZbR2rLOzs01qamqzttzcXHPLLbd0aJ1dyaUEn9mzZ5shQ4Y0a5syZYoZP358u9fDra520tDQoNLSUqWlpbnafHx8lJaWppKSkha3KSkpadZfksaPH3/B/jirLWP9ZadOnVJjY6NCQ0M7qkyv19ZxfuSRR9S/f3/dc8897ijT67VlnDds2KCUlBRlZ2crPDxc119/vRYvXqympiZ3le2V2jLWN998s0pLS123ww4fPqxNmzZpwoQJbqnZKtz5fsi3s7eT6upqNTU1KTw8vFl7eHi4Dhw40OI2VVVVLfavqqrqsDq7graM9Zf99Kc/VVRU1Hl/0fB/2jLOO3fu1DPPPKOKigo3VNg1tGWcDx8+rK1bt+rOO+/Upk2bdOjQId1///1qbGxUXl6eO8r2Sm0Z66lTp6q6ulojR46UMUZnzpzRfffdp5/97GfuKNkyLvR+WFtbq88//1zdu3dvt2NxxQeWs3TpUhUWFurll19WYGCgp8vpMurq6jRt2jQ9/fTTCgsL83Q5XZrT6VT//v311FNPafjw4ZoyZYoefvhhrVq1ytOldTnbt2/X4sWL9eSTT6qsrEzr1q3Txo0b9eijj3q6NLQRV3zaSVhYmHx9fWW325u12+12RUREtLhNREREq/rjrLaM9TmPPfaYli5dqtdff11Dhw7tyDK9XmvH+cMPP9SRI0eUkZHhanM6nZIkPz8/HTx4UFdeeWXHFu2F2vL7HBkZqW7dusnX19fVNnjwYFVVVamhoUH+/v4dWrO3astY/+IXv9C0adP0/e9/X5J0ww03yOFwaObMmXr44Yfl48P1g/ZwoffD4ODgdr3aI3HFp934+/tr+PDhKi4udrU5nU4VFxcrJSWlxW1SUlKa9ZekLVu2XLA/zmrLWEvSr371Kz366KPavHmzEhMT3VGqV2vtOF933XV67733VFFR4XrdfvvtGjt2rCoqKhQdHe3O8r1GW36fb7nlFh06dMgVLCXpb3/7myIjIwk9F9GWsT516tR54eZc4DR8x3e7cev7YbtPl7awwsJCExAQYNasWWP27dtnZs6caXr37m2qqqqMMcZMmzbNzJkzx9V/165dxs/Pzzz22GNm//79Ji8vj8fZL1Frx3rp0qXG39/fvPTSS+aTTz5xverq6jx1Cl6hteP8ZTzVdWlaO84ff/yxCQoKMjk5OebgwYPmlVdeMf379zcLFy701Cl4jdaOdV5engkKCjK///3vzeHDh81rr71mrrzySjN58mRPnYJXqKurM+Xl5aa8vNxIMsuWLTPl5eXmo48+MsYYM2fOHDNt2jRX/3OPsz/00ENm//79Jj8/n8fZvcWKFStMTEyM8ff3N0lJSeatt95yrRs9erTJzMxs1v+FF14w11xzjfH39zdDhgwxGzdudHPF3qs1Yz1o0CAj6bxXXl6e+wv3Mq39nf53BJ9L19px3r17t0lOTjYBAQEmLi7OLFq0yJw5c8bNVXun1ox1Y2OjmT9/vrnyyitNYGCgiY6ONvfff7/59NNP3V+4F9m2bVuL/+aeG9vMzEwzevTo87YZNmyY8ff3N3FxcebZZ5/tkNpsxnCtDgAAWANzfAAAgGUQfAAAgGUQfAAAgGUQfAAAgGUQfAAAgGUQfAAAgGUQfAAAgGUQfAAAgGUQfAAAgGUQfAAAgGUQfAAAgGX8f2MBYiHQCLPLAAAAAElFTkSuQmCC", + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n" + ] + }, + { + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n" + ] + }, + { + "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: 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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n", + "3.6478014945983888 -0.8967133402824402\n" + ] + }, + { + "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 : 1280\n", + "item counter : 1280\n", + "ratio : 0.9992193598750976\n", + " ratio number predicted/items: 0.0\n", + "current epoch: 9\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params\n", + "-------------------------------------------------\n", + "0 | net | SmallNet | 514 \n", + "1 | bcewll | BCEWithLogitsLoss | 0 \n", + "2 | auroc | BinaryAUROC | 0 \n", + "3 | prev_model | SmallNet | 514 \n", + "-------------------------------------------------\n", + "1.0 K Trainable params\n", + "0 Non-trainable params\n", + "1.0 K Total params\n", + "0.004 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": "stdout", + "output_type": "stream", + "text": [ + "-10 -10\n", + "5.131713008880615 -2.337795639038086\n", + "5.131713008880615 -2.337795639038086\n", + "5.131713008880615 -1.5593011617660522\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 : 64\n", + "ratio : 0.0\n", + " ratio number predicted/items: 284.4153846153846\n", + "current epoch: 0\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7183ccac22704f4ca6bb612318d0f2fb", + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n" + ] + }, + { + "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: 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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n" + ] + }, + { + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n" + ] + }, + { + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n" + ] + }, + { + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n" + ] + }, + { + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n" + ] + }, + { + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAGzCAYAAAAv9B03AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA29ElEQVR4nO3dfXwU1b3H8e9uwiY8ZAMhJCQQiMGqBCVUSFJELgJpKWgE+wAtXEjRgpakraSVYq0Elae2lFIxwtXKw/WGgrXApYooBBCBWCAkSg3QIqC0mABV8oSSkD33D2BvAwmQsNnNZj7v12tfZs+emfnNMTBfZs7M2owxRgAAABZg93UBAAAA3kLwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAQAAlkHwAdCiLV++XDabTXv37vV1KQCaAYIPAACwDIIPAACwDIIPAACwDIIPAL/00UcfacqUKbr11lvVunVrdezYUd/+9rd17NixOvufPXtWDz/8sDp27Cin06kJEybos88+q9Vn7969GjZsmMLDw9W6dWvddNNNevDBB72wNwC8JdDXBQBAY+zZs0e7du3Sd77zHXXt2lXHjh3T4sWLdc8996ioqEht2rSp1T8jI0Pt27fXzJkzdejQIS1evFgfffSRtm3bJpvNppMnT+prX/uaOnXqpOnTp6t9+/Y6duyY1qxZ46M9BNAUCD4A/NK9996rb33rW7XaUlNT1b9/f/3pT3/S+PHja33mcDiUm5urVq1aSZK6d++uadOm6c9//rPuv/9+7dq1S5999pneeust9evXz73crFmzmn5nAHgNl7oA+KXWrVu7f66urta//vUv3XzzzWrfvr327dt3Rf/Jkye7Q48k/eAHP1BgYKA2bNggSWrfvr0k6bXXXlN1dXXTFg/AZwg+APzS559/rhkzZigmJkZBQUEKDw9Xp06ddObMGZWWll7R/0tf+lKt9+3atVNUVJR7TtCgQYP0zW9+U0899ZTCw8M1cuRILVu2TOfOnfPG7gDwEoIPAL/0wx/+ULNnz9bo0aP1yiuv6K233tKmTZvUsWNHuVyuBq/PZrPp1VdfVV5enjIyMvTPf/5TDz74oPr27auKioom2AMAvkDwAeCXXn31VaWlpek3v/mNvvWtb+mrX/2q7r77bp05c6bO/n//+99rva+oqNAnn3yi2NjYWu1f+cpXNHv2bO3du1c5OTn64IMPtGrVqibaCwDeRvAB4JcCAgJkjKnVtmjRItXU1NTZ/4UXXqg1d2fx4sU6f/68hg8fLkn67LPPrlhfnz59JInLXUALwl1dAPzSfffdp5dfflmhoaGKj49XXl6eNm/erI4dO9bZv6qqSkOHDtXo0aN16NAhPf/887r77rt1//33S5JWrFih559/Xg888IB69Oih8vJyvfjii3I6nRoxYoQ3dw1AEyL4APBLv/vd7xQQEKCcnBx98cUXGjBggDZv3qxhw4bV2f+5555TTk6OZsyYoerqan33u9/Vs88+K5vNJunC5Obdu3dr1apVKikpUWhoqJKSkpSTk6ObbrrJm7sGoAnZzOXndgEAAFoo5vgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADLIPgAAADL4Dk+l3G5XDpx4oRCQkLcz/cAAADNmzFG5eXlio6Olt1e/3kdgs9lTpw4oZiYGF+XAQAAGuH48ePq2rVrvZ8TfC4TEhIi6cLAOZ1OH1cDSaqsrFR0dLSkC8G0bdu2Pq4IANDclJWVKSYmxn0crw/B5zKXLm85nU6CTzMREBDg/tnpdBJ8AAD1utY0FSY3AwAAyyD4XJSdna34+HglJib6uhQAANBE+JLSy5SVlSk0NFSlpaVc6momKisr1a5dO0lSRUUFl7oAAFe43uM3Z3wAAIBlEHy8aWbohRcAAPAJgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALCMQF8X0JRiY2PldDplt9vVoUMHbd261dclAQAAH2rRwUeSdu3apXbt2vm6DAAA0AxwqQsAAFjGDQWfefPmyWaz6dFHH/VQORds375dqampio6Ols1m07p16+rsl52drdjYWAUHBys5OVm7d++u9bnNZtOgQYOUmJionJwcj9YIAAD8T6ODz549e/Rf//Vf6t2791X77dy5U9XV1Ve0FxUVqaSkpM5lKisrlZCQoOzs7HrXu3r1amVmZiorK0v79u1TQkKChg0bppMnT7r77NixQ/n5+Vq/fr3mzJmj999//zr3DgAAtESNCj4VFRUaN26cXnzxRXXo0KHefi6XS+np6Ro7dqxqamrc7YcOHdKQIUO0YsWKOpcbPny4Zs2apQceeKDedS9YsECTJk3SxIkTFR8fryVLlqhNmzZaunSpu0+XLl0kSVFRURoxYoT27dtX7/qys7MVHx+vxMTEevsAAAD/1qjgk56ernvvvVcpKSlXX7ndrg0bNqigoEATJkyQy+XShx9+qCFDhmjUqFGaNm1ao4quqqpSfn5+re3b7XalpKQoLy9P0oWzRuXl5ZIuBLUtW7aoV69eV92noqIi7dmzp1E1AQCA5q/Bd3WtWrVK+/btu+6AEB0drS1btmjgwIEaO3as8vLylJKSosWLFze42EtOnz6tmpoaRUZG1mqPjIzUwYMHJUklJSXuM0Y1NTWaNGkSZ3MAALC4BgWf48eP68c//rE2bdqk4ODg616uW7duevnllzVo0CDFxcXppZdeks1ma3CxDREXF6f33nuvSbcBAAD8S4MudeXn5+vkyZO68847FRgYqMDAQL399tt69tlnFRgYWGsez78rKSnR5MmTlZqaqrNnz2rq1Kk3VHR4eLgCAgKumBxdUlKizp0739C6AQBAy9Wg4DN06FDt379fhYWF7le/fv00btw4FRYWKiAg4IplTp8+raFDh6pnz55as2aNcnNztXr1av30pz9tdNEOh0N9+/ZVbm6uu83lcik3N1f9+/dv9HoBAEDL1qBLXSEhIbr99ttrtbVt21YdO3a8ol26EEaGDx+u7t27a/Xq1QoMDFR8fLw2bdqkIUOGqEuXLnWe/amoqNDhw4fd748eParCwkKFhYWpW7dukqTMzEylpaWpX79+SkpK0sKFC1VZWamJEyc2ZJcAAICFNOlXVtjtds2ZM0cDBw6Uw+FwtyckJGjz5s3q1KlTncvt3btXgwcPdr/PzMyUJKWlpWn58uWSpDFjxujUqVOaMWOGiouL1adPH23cuPGKCc8AAACX2IwxxtdFNCdlZWUKDQ1VaWmpnE6nZ1c+M/Tif0s9u94WrrKy0v19axUVFWrbtq2PKwIANDfXe/zmu7oAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlEHwAAIBlBPq6gKYUGxsrp9Mpu92uDh06aOvWrb4uCQAA+FCLDj6StGvXLrVr187XZQAAgGaAS10AAMAyGhx8Fi9erN69e8vpdMrpdKp///564403PFrU9u3blZqaqujoaNlsNq1bt67OftnZ2YqNjVVwcLCSk5O1e/fuWp/bbDYNGjRIiYmJysnJ8WiNAADA/zQ4+HTt2lXz5s1Tfn6+9u7dqyFDhmjkyJH64IMP6uy/c+dOVVdXX9FeVFSkkpKSOpeprKxUQkKCsrOz661j9erVyszMVFZWlvbt26eEhAQNGzZMJ0+edPfZsWOH8vPztX79es2ZM0fvv/9+A/cWAAC0JA0OPqmpqRoxYoS+9KUv6ZZbbtHs2bPVrl07vfvuu1f0dblcSk9P19ixY1VTU+NuP3TokIYMGaIVK1bUuY3hw4dr1qxZeuCBB+qtY8GCBZo0aZImTpyo+Ph4LVmyRG3atNHSpUvdfbp06SJJioqK0ogRI7Rv376G7i4AAGhBbmiOT01NjVatWqXKykr179//ypXb7dqwYYMKCgo0YcIEuVwuffjhhxoyZIhGjRqladOmNWq7VVVVys/PV0pKSq1tpaSkKC8vT9KFs0bl5eWSpIqKCm3ZskW9evWqd53Z2dmKj49XYmJio2oCAADNX6Pu6tq/f7/69++vL774Qu3atdPatWsVHx9fZ9/o6Ght2bJFAwcO1NixY5WXl6eUlBQtXry40UWfPn1aNTU1ioyMrNUeGRmpgwcPSpJKSkrcZ4xqamo0adKkq4aa9PR0paenq6ysTKGhoY2uDQAANF+NCj633nqrCgsLVVpaqldffVVpaWl6++236w0/3bp108svv6xBgwYpLi5OL730kmw22w0Vfi1xcXF67733mnQbAADAvzTqUpfD4dDNN9+svn37au7cuUpISNDvfve7evuXlJRo8uTJSk1N1dmzZzV16tRGFyxJ4eHhCggIuGJydElJiTp37nxD6wYAAC2XR57j43K5dO7cuTo/O336tIYOHaqePXtqzZo1ys3N1erVq/XTn/600dtzOBzq27evcnNza9WQm5tb51wjAAAAqRGXuh5//HENHz5c3bp1U3l5uVauXKlt27bpzTffvKKvy+XS8OHD1b17d61evVqBgYGKj4/Xpk2bNGTIEHXp0qXOsz8VFRU6fPiw+/3Ro0dVWFiosLAwdevWTZKUmZmptLQ09evXT0lJSVq4cKEqKys1ceLEhu4SAACwiAYHn5MnT2rChAn65JNPFBoaqt69e+vNN9/UV7/61Sv62u12zZkzRwMHDpTD4XC3JyQkaPPmzerUqVOd29i7d68GDx7sfp+ZmSlJSktL0/LlyyVJY8aM0alTpzRjxgwVFxerT58+2rhx4xUTngEAAC6xGWOMr4toTi7d1VVaWiqn0+nZlc+8eLfYzFLPrreFq6ysdH/fWkVFhdq2bevjigAAzc31Hr/5ri4AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZBB8AAGAZgb4uoCnFxsbK6XTKbrerQ4cO2rp1q69LAgAAPtSig48k7dq1S+3atfN1GQAAoBngUhcAALCMBgefuXPnKjExUSEhIYqIiNCoUaN06NAhjxa1fft2paamKjo6WjabTevWrauzX3Z2tmJjYxUcHKzk5GTt3r271uc2m02DBg1SYmKicnJyPFojAADwPw0OPm+//bbS09P17rvvatOmTaqurtbXvvY1VVZW1tl/586dqq6uvqK9qKhIJSUldS5TWVmphIQEZWdn11vH6tWrlZmZqaysLO3bt08JCQkaNmyYTp486e6zY8cO5efna/369ZozZ47ef//9Bu4tAABoSWzGGHMjKzh16pQiIiL09ttv6z/+4z9qfeZyuXTnnXfqS1/6klatWqWAgABJ0qFDhzRo0CBlZmZq2rRpVy/QZtPatWs1atSoWu3JyclKTEzUc889595WTEyMfvjDH2r69OlXrOexxx5Tr1699L3vfe+q2ysrK1NoaKhKS0vldDqvsfcNNDP04n9LPbveFq6ystI9T6uiokJt27b1cUUAgObmeo/fNzzHp7T0wkE8LCzsypXb7dqwYYMKCgo0YcIEuVwuffjhhxoyZIhGjRp1zdBTn6qqKuXn5yslJaXWtlJSUpSXlyfpwsGyvLxc0oWD5ZYtW9SrV69615mdna34+HglJiY2qiYAAND83dBdXS6XS48++qgGDBig22+/vc4+0dHR2rJliwYOHKixY8cqLy9PKSkpWrx4caO3e/r0adXU1CgyMrJWe2RkpA4ePChJKikp0QMPPCBJqqmp0aRJk64aatLT05Wenu5OjAAAoOW5oeCTnp6uv/71r9qxY8dV+3Xr1k0vv/yyBg0apLi4OL300kuy2Ww3sulriouL03vvvdek2wAAAP6l0Ze6MjIy9Nprr2nr1q3q2rXrVfuWlJRo8uTJSk1N1dmzZzV16tTGblaSFB4eroCAgCsmR5eUlKhz5843tG4AANByNTj4GGOUkZGhtWvXasuWLbrpppuu2v/06dMaOnSoevbsqTVr1ig3N1erV6/WT3/600YX7XA41LdvX+Xm5rrbXC6XcnNz1b9//0avFwAAtGwNvtSVnp6ulStX6n//938VEhKi4uJiSVJoaKhat25dq6/L5dLw4cPVvXt3rV69WoGBgYqPj9emTZs0ZMgQdenSpc6zPxUVFTp8+LD7/dGjR1VYWKiwsDB169ZNkpSZmam0tDT169dPSUlJWrhwoSorKzVx4sSG7hIAALCIBt/OXt/cnGXLltV5q/imTZs0cOBABQcH12ovKChQp06d6rxMtm3bNg0ePPiK9rS0NC1fvtz9/rnnntOvf/1rFRcXq0+fPnr22WeVnJzckN25ArezNz/czg4AuJbrPX7f8HN8WhqCT/ND8AEAXIvXnuMDAADgLwg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgJ9XUBTiI2NldPplN1uV4cOHbR161ZflwQAAJqBFhl8JGnXrl1q166dr8sAAADNCJe6fCB2+uuKnf66r8sAAMByml3w2b59u1JTUxUdHS2bzaZ169Zd0Sc7O1uxsbEKDg5WcnKydu/eXetzm82mQYMGKTExUTk5OV6qHAAANHfNLvhUVlYqISFB2dnZdX6+evVqZWZmKisrS/v27VNCQoKGDRumkydPuvvs2LFD+fn5Wr9+vebMmaP333/fW+UDAIBmrNkFn+HDh2vWrFl64IEH6vx8wYIFmjRpkiZOnKj4+HgtWbJEbdq00dKlS919unTpIkmKiorSiBEjtG/fvnq3d+7cOZWVldV6AQCAlqnZBZ+rqaqqUn5+vlJSUtxtdrtdKSkpysvLk3ThjFF5ebkkqaKiQlu2bFGvXr3qXefcuXMVGhrqfsXExDTtTgAAAJ/xq+Bz+vRp1dTUKDIyslZ7ZGSkiouLJUklJSW6++67lZCQoK985SuaMGGCEhMT613n448/rtLSUvfr+PHjTboPAADAd1rc7exxcXF67733rrt/UFCQgoKCmrAiAADQXPhV8AkPD1dAQIBKSkpqtZeUlKhz584e2YYxRpKaZq7PuQvrdp0723TbaIEqKyvdP5eVlammpsaH1QAAmqNLx9RLx/H6+FXwcTgc6tu3r3JzczVq1ChJksvlUm5urjIyMjyyjUvzg5p2rs9oSVLowibcRAsVHR3t6xIAAM1YeXm5QkND6/282QWfiooKHT582P3+6NGjKiwsVFhYmLp166bMzEylpaWpX79+SkpK0sKFC1VZWamJEyd6ZPvR0dE6fvy4QkJCZLPZPLLOS8rKyhQTE6Pjx4/L6XR6dN2ojbH2DsbZOxhn72GsvaMpxtkYo/Ly8mv+A7nZBZ+9e/dq8ODB7veZmZmSpLS0NC1fvlxjxozRqVOnNGPGDBUXF6tPnz7auHHjFROeG8tut6tr164eWVd9nE4nf6C8hLH2DsbZOxhn72GsvcPT43y1Mz2XNLvgc88991zz+lxGRobHLm0BAADr8Kvb2QEAAG4EwceLgoKClJWVxe3zXsBYewfj7B2Ms/cw1t7hy3G2mWtdVwIAAGghOOMDAAAsg+ADAAAsg+ADAAAsg+ADAAAsg+DjYdnZ2YqNjVVwcLCSk5O1e/fuq/b/4x//qNtuu03BwcG64447tGHDBi9V6v8aMtYvvviiBg4cqA4dOqhDhw5KSUm55v8bXNDQ3+lLVq1aJZvN5v56GVxdQ8f5zJkzSk9PV1RUlIKCgnTLLbfw98d1auhYL1y4ULfeeqtat26tmJgYTZ06VV988YWXqvVP27dvV2pqqqKjo2Wz2bRu3bprLrNt2zbdeeedCgoK0s0336zly5c3TXEGHrNq1SrjcDjM0qVLzQcffGAmTZpk2rdvb0pKSursv3PnThMQEGB+9atfmaKiIvOLX/zCtGrVyuzfv9/Llfufho712LFjTXZ2tikoKDAHDhww3/ve90xoaKj5xz/+4eXK/UtDx/mSo0ePmi5dupiBAweakSNHeqdYP9bQcT537pzp16+fGTFihNmxY4c5evSo2bZtmyksLPRy5f6noWOdk5NjgoKCTE5Ojjl69Kh58803TVRUlJk6daqXK/cvGzZsME888YRZs2aNkWTWrl171f5Hjhwxbdq0MZmZmaaoqMgsWrTIBAQEmI0bN3q8NoKPByUlJZn09HT3+5qaGhMdHW3mzp1bZ//Ro0ebe++9t1ZbcnKyefjhh5u0zpagoWN9ufPnz5uQkBCzYsWKpiqxRWjMOJ8/f97cdddd5ve//71JS0sj+FyHho7z4sWLTVxcnKmqqvJWiS1GQ8c6PT3dDBkypFZbZmamGTBgQJPW2ZJcT/CZNm2a6dWrV622MWPGmGHDhnm8Hi51eUhVVZXy8/OVkpLibrPb7UpJSVFeXl6dy+Tl5dXqL0nDhg2rtz8uaMxYX+7s2bOqrq5WWFhYU5Xp9xo7zk8//bQiIiL00EMPeaNMv9eYcV6/fr369++v9PR0RUZG6vbbb9ecOXNUU1PjrbL9UmPG+q677lJ+fr77ctiRI0e0YcMGjRgxwis1W4U3j4fN7ru6/NXp06dVU1NzxZelRkZG6uDBg3UuU1xcXGf/4uLiJquzJWjMWF/uZz/7maKjo6/4g4b/15hx3rFjh1566SUVFhZ6ocLr53K5VFVVpeDgYF+XcoXGjPORI0e0ZcsWjRs3Ths2bNDhw4c1ZcoUVVdXKysryxtl+6XGjPXYsWN1+vRp3X333TLG6Pz583rkkUf085//3BslW0Z9x8OysjJ9/vnnat26tce2xRkfWM68efO0atUqrV27tlkeCP1VeXm5xo8frxdffFHh4eFNso2ZM2fKZrPp4MGDGj16tJxOpzp27Kgf//jHtSab2mw2ZWRkKCcnR7169VJQUJA2btwoSfrnP/+pBx98UJGRkQoKClKvXr20dOnSK7a1aNEi9erVS23atFGHDh3Ur18/rVy5skn2q6FcLpciIiL0wgsvqG/fvhozZoyeeOIJLVmyxNeltTjbtm3TnDlz9Pzzz2vfvn1as2aNXn/9dT3zzDO+Lg2NxBkfDwkPD1dAQIBKSkpqtZeUlKhz5851LtO5c+cG9ccFjRnrS+bPn6958+Zp8+bN6t27d1OW6fcaOs4ffvihjh07ptTUVHeby+WSJAUGBurQoUPq0aOHR2obPXq0YmNjNXfuXL377rt69tln9dlnn+m///u/3X22bNmiV155RRkZGQoPD1dsbKxKSkr0la98xR2MOnXqpDfeeEMPPfSQysrK9Oijj0q6cBfgj370I33rW99yh6r3339ff/nLXzR27FiP7MMljfl9joqKUqtWrRQQEOBu69mzp4qLi1VVVSWHw+HRGluKxoz1k08+qfHjx+v73/++JOmOO+5QZWWlJk+erCeeeEJ2O+cPPKG+46HT6fTo2R5J3NXlSUlJSSYjI8P9vqamxnTp0uWqk5vvu+++Wm39+/dncvN1aOhYG2PML3/5S+N0Ok1eXp43SmwRGjLOn3/+udm/f3+t18iRI82QIUPM/v37zblz5264nqysLCPJ3H///bXap0yZYiSZ9957zxhzYTKl3W43H3zwQa1+Dz30kImKijKnT5+u1f6d73zHhIaGmrNnzxpjjBk5cuQVEy2bUkN/nx9//HHTvXt3U1NT425buHChiYqKavJa/V1Dx/rOO+8006ZNq9W2cuVK07p1a3P+/PkmrbWl0HVObr799ttrtX33u99tksnNBB8PWrVqlQkKCjLLly83RUVFZvLkyaZ9+/amuLjYGGPM+PHjzfTp0939d+7caQIDA838+fPNgQMHTFZWFrezX6eGjvW8efOMw+Ewr776qvnkk0/cr/Lycl/tgl9o6DhfztN3dV0KPm+++Wat9gMHDhhJ7oOXJDN48OBafVwul2nfvr2ZPHmyOXXqVK3XsmXLjCSzY8cOd92hoaFm9+7dHqv9aho6zh9//LEJCQkxGRkZ5tChQ+a1114zERERZtasWV6p1581dKyzsrJMSEiI+cMf/mCOHDli3nrrLdOjRw8zevRoX+2CXygvLzcFBQWmoKDASDILFiwwBQUF5qOPPjLGGDN9+nQzfvx4d/9Lt7M/9thj5sCBAyY7O5vb2f3FokWLTLdu3YzD4TBJSUnm3XffdX82aNAgk5aWVqv/K6+8Ym655RbjcDhMr169zOuvv+7liv1XQ8a6e/fuRtIVr6ysLO8X7mca+jv975oq+Bw5cqRWe1VVlbHb7e6zpZLMgw8+WKtPSUlJnb8D//5as2aNMcaYoqIi06VLFyPJ3HzzzWbKlCnuUNRUGjrOu3btMsnJySYoKMjExcWZ2bNncwbiOjVkrKurq83MmTNNjx49THBwsImJiTFTpkwxn332mfcL9yNbt26t88/YpbFNS0szgwYNumKZPn36GIfDYeLi4syyZcuapDabMcZ49uIZADSNmTNn6qmnntKRI0d00003udvPnz+voKAgTZo0SUuWLJHNZlN6erqee+45d5/i4mJFRUXpP//zP5WWllbn+nv37q2IiAhJUmVlpV577TVt3LhRb7zxhkpKSjRjxgw99dRTTbuTAJoUk5sB+J2///3vtYLP4cOH5XK5FBsbW+8ynTp1UkhIiGpqaq7rMQZt27bVmDFjNGbMGFVVVekb3/iGZs+erccff5y7AQE/xnR0AH4nOzu71vtFixZJkoYPH17vMgEBAfrmN7+pP/3pT/rrX/96xeenTp1y//yvf/2r1mcOh0Px8fEyxqi6uvpGSgfgY5zxAeB3jh49qvvvv19f//rXlZeXp//5n//R2LFjlZCQcNXl5s2bp61btyo5OVmTJk1SfHy8Pv30U+3bt0+bN2/Wp59+Kkn62te+ps6dO2vAgAGKjIzUgQMH9Nxzz+nee+9VSEiIN3YRQBMh+ADwO6tXr9aMGTM0ffp0BQYGKiMjQ7/+9a+vuVxkZKR2796tp59+WmvWrNHzzz+vjh07qlevXvrlL3/p7vfwww8rJydHCxYsUEVFhbp27aof/ehH+sUvftGUuwXAC5jcDMBvXJrcfOrUqSZ7OjSAlo05PgAAwDIIPgAAwDIIPgAAwDKY4wMAACyDMz4AAMAyuJ39Mi6XSydOnFBISIhsNpuvywEAANfBGKPy8nJFR0fLbq//vA7B5zInTpxQTEyMr8sAAACNcPz4cXXt2rXezwk+l7n0VNbjx4/L6XT6uBoAAFqGyspKRUdHS7pwkqFt27YeXX9ZWZliYmKu+XR1gs9lLl3ecjqdBB8AADwkICDA/bPT6fR48LnkWtNUmNx8UXZ2tuLj45WYmOjrUgAAQBPhdvbLlJWVKTQ0VKWlpZzxAQDAQyorK9WuXTtJUkVFRZNc6rqe4zdnfAAAgGUQfAAAgGUQfAAAgGVwV5eXxU5/3f3zsXn3+rASAACshzM+AADAMgg+F3E7OwAALR/B56L09HQVFRVpz549vi4FAAA0EYIPAACwDIIPAACwDIIPAACwDIIPAACwDIIPAACwDIIPAACwDILPRTzHBwCAlo/gcxHP8QEAoOUj+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+FzEAwwBAGj5CD4X8QBDAABaPoIPAACwDIIPAACwDIIPAACwDIIPAACwDIIPAACwDIIPAACwDIIPAACwDIIPAACwDILPRTy5GQCAlo/gcxFPbgYAoOUj+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+FzEl5QCANDyEXwu4ktKAQBo+Qg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+AADAMgg+F2VnZys+Pl6JiYm+LgUAADQRgs9F6enpKioq0p49e3xdCgAAaCIEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEHwAAYBkEn4uys7MVHx+vxMREX5cCAACaCMHnovT0dBUVFWnPnj2+LgUAADQRgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALAMgg8AALCMQF8XAKDlqampUXV1ta/L8CutWrVSQECAr8sAWjyCDwCPMcaouLhYZ86c8XUpfql9+/bq3LmzbDabr0sBWiyCDwCPuRR6IiIi1KZNGw7g18kYo7Nnz+rkyZOSpKioKB9XBLRcBB8AHlFTU+MOPR07dvR1OX6ndevWkqSTJ08qIiKCy15AE2FyMwCPuDSnp02bNj6uxH9dGjvmRwFNh+ADwKO4vNV4jB3Q9Ag+AADAMgg+AADAMpjcDKDJxU5/3avbOzbvXq9urz6ffvqpfvjDH+rPf/6z7Ha7vvnNb+p3v/ud2rVr5+vSAMvijA8ANEJVVdU1+4wbN04ffPCBNm3apNdee03bt2/X5MmTvVAdgPoQfABAUnl5ucaNG6e2bdsqKipKv/3tb3XPPffo0UcflSTFxsbqmWee0YQJE+R0Oq8ZYA4cOKCNGzfq97//vZKTk3X33Xdr0aJFWrVqlU6cOOGFPQJQF4IPAEjKzMzUzp07tX79em3atEnvvPOO9u3bV6vP/PnzlZCQoIKCAj355JNXXV9eXp7at2+vfv36udtSUlJkt9v1l7/8pUn2AcC1tcg5PrGxsXI6nbLb7erQoYO2bt3q65IANGPl5eVasWKFVq5cqaFDh0qSli1bpujo6Fr9hgwZop/85CfXtc7i4mJFRETUagsMDFRYWJiKi4s9UziABmuRwUeSdu3axQRCANflyJEjqq6uVlJSkrstNDRUt956a61+/372BoB/4lIXAFyntm3bXnffzp07u79765Lz58/r008/VefOnT1dGoDr1OyCz/bt25Wamqro6GjZbDatW7fuij7Z2dmKjY1VcHCwkpOTtXv37lqf22w2DRo0SImJicrJyfFS5QD8VVxcnFq1aqU9e/a420pLS/W3v/2t0evs37+/zpw5o/z8fHfbli1b5HK5lJycfEP1Ami8Znepq7KyUgkJCXrwwQf1jW9844rPV69erczMTC1ZskTJyclauHChhg0bpkOHDrmvp+/YsUNdunTRJ598opSUFN1xxx3q3bt3nds7d+6czp07535fVlbWNDsGoNkKCQlRWlqaHnvsMYWFhSkiIkJZWVmy2+2N/hqJnj176utf/7omTZqkJUuWqLq6WhkZGfrOd75zxdwhAN7T7M74DB8+XLNmzdIDDzxQ5+cLFizQpEmTNHHiRMXHx2vJkiVq06aNli5d6u7TpUsXSVJUVJRGjBhxxZ0Z/27u3LkKDQ11v2JiYjy7QwD8woIFC9S/f3/dd999SklJ0YABA9SzZ08FBwc3ep05OTm67bbbNHToUI0YMUJ33323XnjhBQ9WDaChmt0Zn6upqqpSfn6+Hn/8cXeb3W5XSkqK8vLyJF04Y+RyuRQSEqKKigpt2bJFo0ePrnedjz/+uDIzM93vy8rKCD+AhzWXJylfTUhISK1L45WVlXrqqafcz+s5duxYg9cZFhamlStXeqpEAB7gV8Hn9OnTqqmpUWRkZK32yMhIHTx4UJJUUlLiPltUU1OjSZMmKTExsd51BgUFKSgoqOmKBuAXCgoKdPDgQSUlJam0tFRPP/20JGnkyJE+rgyAJ/lV8LkecXFxeu+993xdBgA/NH/+fB06dEgOh0N9+/bVO++8o/Dw8Dr7zpkzR3PmzKnzs4EDB+qNN95oylIBNJJfBZ/w8HAFBASopKSkVntJSQm3hwK4IV/+8pdr3YF1LY888ki9l9Fbt27tqbIAeJhfBZ9L/wrLzc3VqFGjJEkul0u5ubnKyMjwbXEALCUsLExhYWG+LgNAAzW74FNRUaHDhw+73x89elSFhYUKCwtTt27dlJmZqbS0NPXr109JSUlauHChKisrNXHixBvabnZ2trKzs1VTU3OjuwAAAJqpZhd89u7dq8GDB7vfX7rjKi0tTcuXL9eYMWN06tQpzZgxQ8XFxerTp482btx4xYTnhkpPT1d6errKysoUGhp6Q+sCAADNU7MLPvfcc4+MMVftk5GRwaUtAADQYM3uAYYAAABNheADAAAsg+ADAAAso9nN8QHQAs308g0DM0u9u716zJ49W6+//roKCwvlcDh05swZX5cEWB5nfC7Kzs5WfHz8Vb/eAgAuqaqquq4+3/72t/WDH/zACxUBuB4En4vS09NVVFSkPXv2+LoUAD5QXl6ucePGqW3btoqKitJvf/tb3XPPPXr00UclSbGxsXrmmWc0YcIEOZ1O95eXXs1TTz2lqVOn6o477mji6gFcL4IPAOjCM8N27typ9evXa9OmTXrnnXe0b9++Wn3mz5+vhIQEFRQU6Mknn/RRpQBuBHN8AFheeXm5VqxYoZUrV2ro0KGSpGXLlik6OrpWvyFDhugnP/mJL0oE4CGc8QFgeUeOHFF1dbWSkpLcbaGhobr11ltr9evXr5+3SwPgYQQfALhObdu29XUJAG4QwQeA5cXFxalVq1a1bm4oLS3V3/72Nx9WBaApMMcHgOWFhIQoLS1Njz32mMLCwhQREaGsrCzZ7XbZbLZGr/fjjz/Wp59+qo8//lg1NTUqLCyUJN18881q166dh6oH0BAEn4uys7OVnZ2tmpoaX5cCwAcWLFigRx55RPfdd5+cTqemTZum48ePKzg4uNHrnDFjhlasWOF+/+Uvf1mStHXrVt1zzz03WjKARrCZa30VusWUlZUpNDRUpaWlcjqdHl9/7PTX3T8fm3evx9cP+MoXX3yho0eP6qabbrqhsNBcVFZWqkuXLvrNb36jhx56yCvbbGljCPy7yspK95nOiooKj8+Zu97jN2d8AEBSQUGBDh48qKSkJJWWlurpp5+WJI0cOdLHlQHwJCY3A8BFlx5QmJKSosrKSr3zzjsKDw+vs++cOXPUrl27Ol/Dhw/3cuUArhdnfABAF+bf5OfnX3f/Rx55RKNHj67zs9atW3uqLAAeRvABgEYICwtTWFiYr8sA0EBc6gIAAJZB8AHgUS6Xy9cl+C3GDmh6XOoC4BEOh0N2u10nTpxQp06d5HA4bujhf1ZijFFVVZVOnTolu90uh8Ph65KAFovgc5FXHmA4M1THgqXYL1Y23TYAH7Hb7brpppv0ySef6MSJE74uxy+1adNG3bp1k93OyXigqRB8LkpPT1d6err7AUgAGs7hcKhbt246f/48T0FvoICAAAUGBnKWDGhiBB8AHmWz2dSqVSu1atXK16UAwBU4nwoAACyD4AMAACyD4AMAACyDOT6XufRl9WVlZZ5f+bkL63adO9t02wAAoBmqrKx0/1xWVubxGyAuHVMvHcfrYzPX6mEx//jHPxQTE+PrMgAAQCMcP35cXbt2rfdzgs9lXC6XTpw4oZCQEI/fVlpWVqaYmBgdP35cTqfTo+tGbYy1dzDO3sE4ew9j7R1NMc7GGJWXlys6Ovqqz8LiUtdl7Hb7VZOiJzidTv5AeQlj7R2Ms3cwzt7DWHuHp8f5ep7Dx+RmAABgGQQfAABgGQQfLwoKClJWVpaCgoJ8XUqLx1h7B+PsHYyz9zDW3uHLcWZyMwAAsAzO+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+AAAAMsg+HhYdna2YmNjFRwcrOTkZO3evfuq/f/4xz/qtttuU3BwsO644w5t2LDBS5X6v4aM9YsvvqiBAweqQ4cO6tChg1JSUq75/wYXNPR3+pJVq1bJZrNp1KhRTVtgC9HQcT5z5ozS09MVFRWloKAg3XLLLfz9cZ0aOtYLFy7UrbfeqtatWysmJkZTp07VF1984aVq/dP27duVmpqq6Oho2Ww2rVu37prLbNu2TXfeeaeCgoJ08803a/ny5U1TnIHHrFq1yjgcDrN06VLzwQcfmEmTJpn27dubkpKSOvvv3LnTBAQEmF/96lemqKjI/OIXvzCtWrUy+/fv93Ll/qehYz127FiTnZ1tCgoKzIEDB8z3vvc9Exoaav7xj394uXL/0tBxvuTo0aOmS5cuZuDAgWbkyJHeKdaPNXScz507Z/r162dGjBhhduzYYY4ePWq2bdtmCgsLvVy5/2noWOfk5JigoCCTk5Njjh49at58800TFRVlpk6d6uXK/cuGDRvME088YdasWWMkmbVr1161/5EjR0ybNm1MZmamKSoqMosWLTIBAQFm48aNHq+N4ONBSUlJJj093f2+pqbGREdHm7lz59bZf/To0ebee++t1ZacnGwefvjhJq2zJWjoWF/u/PnzJiQkxKxYsaKpSmwRGjPO58+fN3fddZf5/e9/b9LS0gg+16Gh47x48WITFxdnqqqqvFVii9HQsU5PTzdDhgyp1ZaZmWkGDBjQpHW2JNcTfKZNm2Z69epVq23MmDFm2LBhHq+HS10eUlVVpfz8fKWkpLjb7Ha7UlJSlJeXV+cyeXl5tfpL0rBhw+rtjwsaM9aXO3v2rKqrqxUWFtZUZfq9xo7z008/rYiICD300EPeKNPvNWac169fr/79+ys9PV2RkZG6/fbbNWfOHNXU1HirbL/UmLG+6667lJ+f774cduTIEW3YsEEjRozwSs1W4c3jId/O7iGnT59WTU2NIiMja7VHRkbq4MGDdS5TXFxcZ//i4uImq7MlaMxYX+5nP/uZoqOjr/iDhv/XmHHesWOHXnrpJRUWFnqhwpahMeN85MgRbdmyRePGjdOGDRt0+PBhTZkyRdXV1crKyvJG2X6pMWM9duxYnT59WnfffbeMMTp//rweeeQR/fznP/dGyZZR3/GwrKxMn3/+uVq3bu2xbXHGB5Yzb948rVq1SmvXrlVwcLCvy2kxysvLNX78eL344osKDw/3dTktmsvlUkREhF544QX17dtXY8aM0RNPPKElS5b4urQWZ9u2bZozZ46ef/557du3T2vWrNHrr7+uZ555xteloZE44+Mh4eHhCggIUElJSa32kpISde7cuc5lOnfu3KD+uKAxY33J/PnzNW/ePG3evFm9e/duyjL9XkPH+cMPP9SxY8eUmprqbnO5XJKkwMBAHTp0SD169Gjaov1QY36fo6Ki1KpVKwUEBLjbevbsqeLiYlVVVcnhcDRpzf6qMWP95JNPavz48fr+978vSbrjjjtUWVmpyZMn64knnpDdzvkDT6jveOh0Oj16tkfijI/HOBwO9e3bV7m5ue42l8ul3Nxc9e/fv85l+vfvX6u/JG3atKne/rigMWMtSb/61a/0zDPPaOPGjerXr583SvVrDR3n2267Tfv371dhYaH7df/992vw4MEqLCxUTEyMN8v3G435fR4wYIAOHz7sDpaS9Le//U1RUVGEnqtozFifPXv2inBzKXAavuPbY7x6PPT4dGkLW7VqlQkKCjLLly83RUVFZvLkyaZ9+/amuLjYGGPM+PHjzfTp0939d+7caQIDA838+fPNgQMHTFZWFrezX6eGjvW8efOMw+Ewr776qvnkk0/cr/Lycl/tgl9o6Dhfjru6rk9Dx/njjz82ISEhJiMjwxw6dMi89tprJiIiwsyaNctXu+A3GjrWWVlZJiQkxPzhD38wR44cMW+99Zbp0aOHGT16tK92wS+Ul5ebgoICU1BQYCSZBQsWmIKCAvPRRx8ZY4yZPn26GT9+vLv/pdvZH3vsMXPgwAGTnZ3N7ez+YtGiRaZbt27G4XCYpKQk8+6777o/GzRokElLS6vV/5VXXjG33HKLcTgcplevXub111/3csX+qyFj3b17dyPpildWVpb3C/czDf2d/ncEn+vX0HHetWuXSU5ONkFBQSYuLs7Mnj3bnD9/3stV+6eGjHV1dbWZOXOm6dGjhwkODjYxMTFmypQp5rPPPvN+4X5k69atdf6de2ls09LSzKBBg65Ypk+fPsbhcJi4uDizbNmyJqnNZgzn6gAAgDUwxwcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFgGwQcAAFjG/wH5IEcnByuqxQAAAABJRU5ErkJggg==", + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n" + ] + }, + { + "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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n" + ] + }, + { + "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: 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" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n", + "5.131713008880615 -1.5593011617660522\n" + ] + }, + { + "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 : 1280\n", + "item counter : 1280\n", + "ratio : 0.9992193598750976\n", + " ratio number predicted/items: 0.0\n", + "current epoch: 9\n" + ] + } + ], + "source": [ + "sym_preprocess.cuda()\n", + "new_prev_nets = []\n", + "for prev_net, (th_abs, th_pres) in prev_nets:\n", + " model = StrengtheningMarge(prev_model=prev_net, th_abs=th_abs, th_pres=th_pres, prev_nets=new_prev_nets)\n", + " model.net.load_state_dict(prev_net.state_dict())\n", + " trainer = pl.Trainer(\n", + " max_epochs=10,\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", + " )\n", + " _ = trainer.fit(model,)\n", + " new_prev_nets.append((model.net, (model.threshold_abs, model.threshold_pres)))\n", + " del model\n", + " del trainer\n", + " pl.utilities.memory.garbage_collection_cuda()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "del model\n", + "del trainer\n", + "pl.utilities.memory.garbage_collection_cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(new_prev_nets)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# for i in range(3):\n", + "# model_checkpoint = ModelCheckpoint(monitor='no_improve_counter')\n", + "# trainer = pl.Trainer(\n", + "# max_epochs=20,\n", + "# accelerator='gpu',\n", + "# devices=1,\n", + "# log_every_n_steps=1,\n", + "# # logger=pl.loggers.CSVLogger(save_dir=\"logs/\"),\n", + "# reload_dataloaders_every_n_epochs=1,\n", + "# logger=tensorboard,\n", + "# callbacks=[model_checkpoint]\n", + "# )\n", + "# print(i)\n", + "# model = SudokuLightning(lr=0.01, prev_nets=prev_nets)\n", + "# _ = trainer.fit(model,)\n", + "# # model = model.load_from_checkpoint(model_checkpoint.best_model_path)\n", + "# # trainer.validate(model=model)\n", + "# prev_nets.append((model.net, (model.threshold_abs, model.threshold_pres)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "trainer.callbacks[-1].best_model_path" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "trainer.callbacks[-1].best_model_score" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prev_nets = prev_nets[:3]\n", + "len(prev_nets)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "sym_preprocess.cpu()\n", + "def predict_from_net(x, net, th_abs, th_pres):\n", + " x = 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 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):\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", + " 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", + " \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", + " x = new_x\n", + " return new_x\n", + "\n", + "def fix_threshold(x,y,prev_nets, margin=0.05):\n", + " x_feature = 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", + " print(max_th_abs)\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", + " print(max_th_pres)\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": 25, + "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": 25, + "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": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(561.)\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": 26, + "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": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(584.)\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": 27, + "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": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(591.)\n", + "tensor(35.)\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": 28, + "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": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(597.)\n", + "tensor(35.)\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": 29, + "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": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(597.)\n", + "tensor(35.)\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": 30, + "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": 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": { + "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, prev_nets=new_prev_nets)\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": [ + "prev_x = new_x.clone()\n", + "new_x = forward_from_prev_nets_all(new_x, test_y, prev_nets=new_prev_nets)\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, prev_nets=new_prev_nets)\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, prev_nets=new_prev_nets)\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, prev_nets=new_prev_nets)\n", + "print(new_x.sum())\n", + "print(new_x[:,1].sum())\n", + "display_as_dataframe(new_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "from sudoku.loader import get_datasets\n", + "from tqdm.notebook import tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "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": "495bafa3245348a69713aef2557d03a1", + "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, prev_nets=prev_nets)\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": [ + "display_as_dataframe(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for x,y in tqdm(train):\n", + " x = x.view(1,2,729)\n", + " y = y.view(1,2,729)\n", + " \n", + " while (x!=y).any():\n", + " new_x = forward_from_prev_nets_all(x, y, raise_if_error=False,prev_nets=new_prev_nets)\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": [ + "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=True, prev_nets=new_prev_nets)\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": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "new_prev_nets" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "new_prev_nets = fix_threshold(x,y,new_prev_nets)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "new_prev_nets" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for x,y in tqdm(train):\n", + " x = x.view(1,2,729)\n", + " y = y.view(1,2,729)\n", + " \n", + " while (x!=y).any():\n", + " new_x = forward_from_prev_nets_all(x, y, raise_if_error=True, prev_nets=new_prev_nets)\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 = fix_threshold(x,y,prev_nets)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for x,y in tqdm(train):\n", + " x = x.view(1,2,729)\n", + " y = y.view(1,2,729)\n", + " \n", + " while (x!=y).any():\n", + " new_x = forward_from_prev_nets_all(x, y, raise_if_error=True,prev_nets=new_prev_nets)\n", + " if (new_x == x).all():\n", + " print(\"No improvment\")\n", + " raise ValueError\n", + " x = new_x" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prev_nets=new_prev_nets" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model_checkpoint = ModelCheckpoint(monitor='ratio_number_predicted_per_items', mode='max')\n", + "trainer = pl.Trainer(\n", + "max_epochs=20,\n", + "accelerator='gpu',\n", + "devices=1,\n", + "log_every_n_steps=1,\n", + "# logger=pl.loggers.CSVLogger(save_dir=\"logs/\"),\n", + "reload_dataloaders_every_n_epochs=1,\n", + "logger=tensorboard,\n", + "callbacks=[model_checkpoint]\n", + ")\n", + "model = SudokuLightning(lr=0.01, prev_nets=prev_nets, )\n", + "_ = trainer.fit(model,)\n", + "# model = model.load_from_checkpoint(model_checkpoint.best_model_path)\n", + "# 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": [ + "new_x = forward_from_prev_nets_all(new_x, y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "new_x.sum(dim=(0,2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model_checkpoint = ModelCheckpoint(monitor='no_improve_counter')\n", + "trainer = pl.Trainer(\n", + "max_epochs=20,\n", + "accelerator='gpu',\n", + "devices=1,\n", + "log_every_n_steps=1,\n", + "# logger=pl.loggers.CSVLogger(save_dir=\"logs/\"),\n", + "reload_dataloaders_every_n_epochs=1,\n", + "logger=tensorboard,\n", + "callbacks=[model_checkpoint]\n", + ")\n", + "print(i)\n", + "model = SudokuLightning(lr=0.01, prev_nets=prev_nets)\n", + "_ = trainer.fit(model,)\n", + "# model = model.load_from_checkpoint(model_checkpoint.best_model_path)\n", + "# trainer.validate(model=model)\n", + "prev_nets.append((model.net, (model.threshold_abs, model.threshold_pres)))" + ] + }, + { + "cell_type": "code", + "execution_count": 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 +}