{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# \"Triplet Training for Generative Adversarial Networks\"\n", "- toc: true\n", "- categories: [\"deep-learning\"]\n", "- image: images/copied_from_nb/images/gan/gan-triplet.png\n", "- comments: true\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## What will I get from this blog?\n", "\n", "By the end of this blog we'll be able to make a model that can generate the below numers from random noise\n", "\n", "![](images/gan/gan-diagram.jpg)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Introduction\n", "\n", "> This is an implementation of the paper: Zieba, Maciej, and Lei Wang. \"Training triplet networks with gan.\" arXiv preprint arXiv:1704.02227 (2017). \n", "\n", "\n", "### What is triplet training?\n", "Triplet training helps us learn distributed embeddings by the notion of similarity and dissimilarity. Read more about it [here](https://towardsdatascience.com/image-similarity-using-triplet-loss-3744c0f67973)\n", "\n", "This paper replaces triplet loss with the classification losss of the discriminator and compares the results.\n", "\n", "## Approach \n", "\n", "I initially pretrained the GAN with the original GAN objective, for 50 epochs. Post that I train with the Improved GAN objective for 10 epochs. \n", "\n", "The discriminator of the GAN generates M features, we take these M features and put it into the classifier. For classification I have used a 9-nearest neighbour classifier." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "id": "IKR-DnPTXcX7", "outputId": "5f495e89-55bf-46a5-b19e-e950398c1a15" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Archive: results.zip\n", " inflating: models/D_16_100.pkl \n", " inflating: models/D_16_200.pkl \n", " inflating: models/D_32_100.pkl \n", " inflating: models/G_16_100.pkl \n", " inflating: models/G_16_200.pkl \n", " inflating: models/G_32_100.pkl \n", " inflating: models/pretrain_D_16.pkl \n", " inflating: models/pretrain_D_32.pkl \n", " inflating: models/pretrain_G_16.pkl \n", " inflating: models/pretrain_G_32.pkl \n" ] } ], "source": [ "#hide\n", "# Pretrained models. download them later if you want to compare the results\n", "!wget -N --quiet --load-cookies /tmp/cookies.txt \"https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1ufF0r_fs64wjCHITE7GsGdAh7BKMNfTk' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\\1\\n/p')&id=1ufF0r_fs64wjCHITE7GsGdAh7BKMNfTk\" -O results.zip && rm -rf /tmp/cookies.txt > /tmp/xxy\n", "!unzip -o results.zip" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Imports" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "id": "Y4VmTy46XcX_" }, "outputs": [], "source": [ "#collapse-hide\n", "# Reference\n", "# https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier.score\n", "# https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_score.html\n", "# https://github.com/andreasveit/triplet-network-pytorch\n", "!pip install livelossplot > /tmp/xxy\n", "\n", "import math\n", "import os\n", "import sys\n", "from pathlib import Path\n", "from pprint import pprint\n", "\n", "import numpy as np\n", "from PIL import Image\n", "from scipy.spatial.distance import cdist\n", "# from torch import cdist\n", "from sklearn import preprocessing\n", "from sklearn.metrics import average_precision_score\n", "from sklearn.neighbors import KNeighborsClassifier\n", "from tqdm.auto import tqdm as tq\n", "\n", "import torch\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "from livelossplot import PlotLosses\n", "from torch.nn import functional as F\n", "from torch.nn.parameter import Parameter\n", "from torch.utils.data import DataLoader, Dataset, TensorDataset\n", "from torchvision import datasets, transforms\n", "from torchvision.utils import save_image\n", "import matplotlib.pyplot as plt\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## References" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "id": "hvHUT5S6XcYC" }, "outputs": [], "source": [ "#collapse-hide\n", "# https://github.com/eriklindernoren/PyTorch-GAN/blob/master/implementations/gan/gan.py\n", "# https://www.kaggle.com/hirotaka0122/triplet-loss-with-pytorch\n", "# https://github.com/openai/improved-gan/blob/master/mnist_svhn_cifar10/train_mnist_feature_matching.py\n", "# https://github.com/adambielski/siamese-triplet/blob/master/Experiments_MNIST.ipynb\n", "# https://github.com/eladhoffer/TripletNet\n", "# https://stackoverflow.com/questions/26210471/scikit-learn-gridsearch-giving-valueerror-multiclass-format-is-not-supported" ] }, { "cell_type": "markdown", "metadata": { "id": "Zmp93XL5XcYF" }, "source": [ "## Utils\n", "\n", "I combined all the handy functions used throughout the notebook into one place, for easier access." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "id": "gdwBALC5XcYG" }, "outputs": [], "source": [ "#collapse-hide\n", "class Arguments():\n", " def __init__(self):\n", " self.batch_size=100\n", " self.epochs=10\n", " self.lr=0.003\n", " self.momentum=0.5\n", " self.cuda=torch.cuda.is_available()\n", " self.seed=1\n", " self.log_interval=100\n", " self.save_interval=5\n", " self.unlabel_weight=1\n", " self.logdir='./logfile'\n", " self.savedir='./models'\n", " self.load_saved=True\n", "\n", "args = Arguments()\n", "np.random.seed(args.seed)\n", "torch.manual_seed(args.seed)\n", "\n", "results = {}\n", "def log_sum_exp(x, axis = 1):\n", " m = torch.max(x, dim = 1)[0]\n", " return m + torch.log(torch.sum(torch.exp(x - m.unsqueeze(1)), dim = axis))\n", "\n", "def reset_normal_param(L, stdv, weight_scale = 1.):\n", " assert type(L) == torch.nn.Linear\n", " torch.nn.init.normal(L.weight, std=weight_scale / math.sqrt(L.weight.size()[0]))\n", "\n", "def show_gen_images(gan):\n", " num_images=4\n", " arr = gan.draw(num_images)\n", " square_dim = num_images//2\n", " f, axarr = plt.subplots(square_dim,square_dim)\n", " # f.set_figheight(10)\n", " # f.set_figwidth(10)\n", " for i in range(square_dim):\n", " for j in range(square_dim):\n", " axarr[i,j].imshow(arr[i*square_dim+j],cmap='gray')\n", " axarr[i,j].axis('off')\n", "\n", "# https://github.com/Sleepychord/ImprovedGAN-pytorch/blob/master/functional.py#L13\n", "class LinearWeightNorm(torch.nn.Module):\n", " def __init__(self, in_features, out_features, bias=True, weight_scale=None, weight_init_stdv=0.1):\n", " super(LinearWeightNorm, self).__init__()\n", " self.in_features = in_features\n", " self.out_features = out_features\n", " self.weight = Parameter(torch.randn(out_features, in_features) * weight_init_stdv)\n", " if bias:\n", " self.bias = Parameter(torch.zeros(out_features))\n", " else:\n", " self.register_parameter('bias', None)\n", " if weight_scale is not None:\n", " assert type(weight_scale) == int\n", " self.weight_scale = Parameter(torch.ones(out_features, 1) * weight_scale)\n", " else:\n", " self.weight_scale = 1\n", " def forward(self, x):\n", " W = self.weight * self.weight_scale / torch.sqrt(torch.sum(self.weight ** 2, dim = 1, keepdim = True))\n", " return F.linear(x, W, self.bias)\n", " def __repr__(self):\n", " return self.__class__.__name__ + '(' \\\n", " + 'in_features=' + str(self.in_features) \\\n", " + ', out_features=' + str(self.out_features) \\\n", " + ', weight_scale=' + str(self.weight_scale) + ')'" ] }, { "cell_type": "markdown", "metadata": { "id": "ghGmjdNJXcYI" }, "source": [ "## Datasets\n", "\n", "Below is the MNIST dataset. It has 60,000 training and 10,000 testing samples. The labelled set has N (100 or 200) samples and the unlabelled set had all 60,000 samples. " ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "id": "RZCHKj8-XcYJ", "outputId": "d50ba8d1-1476-4ee9-cee3-ee977f8ecb41" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ../data/MNIST/raw/train-images-idx3-ubyte.gz\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8f966c3006734a2aa86cf9960a3f3fad", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Extracting ../data/MNIST/raw/train-images-idx3-ubyte.gz to ../data/MNIST/raw\n", "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ../data/MNIST/raw/train-labels-idx1-ubyte.gz\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ec7c7b1b5bdf45ae96b43644309a7e94", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Extracting ../data/MNIST/raw/train-labels-idx1-ubyte.gz to ../data/MNIST/raw\n", "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ../data/MNIST/raw/t10k-images-idx3-ubyte.gz\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "da991ed9f2cd44ffa15613ca4eccd0f0", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Extracting ../data/MNIST/raw/t10k-images-idx3-ubyte.gz to ../data/MNIST/raw\n", "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ../data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n", "\n", "\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "50ea4da8a1a143ad8e5d7f115d8a48ac", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Extracting ../data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ../data/MNIST/raw\n", "Processing...\n", "Done!\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/opt/conda/conda-bld/pytorch_1587428398394/work/torch/csrc/utils/tensor_numpy.cpp:141: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program.\n" ] }, { "data": { "text/plain": [ "Dataset MNIST\n", " Number of datapoints: 10000\n", " Root location: ../data\n", " Split: Test\n", " StandardTransform\n", "Transform: Compose(\n", " ToTensor()\n", " )" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#collapse-hide\n", "# Reference https://github.com/Sleepychord/ImprovedGAN-pytorch/blob/master/Datasets.py\n", "def MNISTLabel(class_num):\n", " raw_dataset = datasets.MNIST('../data', train=True, download=True,\n", " transform=transforms.Compose([\n", " transforms.ToTensor(),\n", " ]))\n", " class_tot = [0] * 10\n", " data = []\n", " labels = []\n", " tot = 0\n", " perm = np.random.permutation(raw_dataset.__len__())\n", " for i in range(raw_dataset.__len__()):\n", " datum, label = raw_dataset.__getitem__(perm[i])\n", " if class_tot[label] < class_num:\n", " data.append(datum.numpy())\n", " labels.append(label)\n", " class_tot[label] += 1\n", " tot += 1\n", " if tot >= 10 * class_num:\n", " break\n", " \n", " times = int(np.ceil(60_000 / len(data)))\n", " return TensorDataset(torch.FloatTensor(np.array(data)).repeat(times,1,1,1), torch.LongTensor(np.array(labels)).repeat(times))\n", "\n", "def MNISTUnlabel():\n", " raw_dataset = datasets.MNIST('../data', train=True, download=True,\n", " transform=transforms.Compose([\n", " transforms.ToTensor(),\n", " ]))\n", " return raw_dataset\n", "def MNISTTest():\n", " return datasets.MNIST('../data', train=False, download=True,\n", " transform=transforms.Compose([\n", " transforms.ToTensor(),\n", " ]))\n", "# Reference https://github.com/adambielski/siamese-triplet/blob/master/datasets.py#L79\n", "class MNISTTriplet(Dataset):\n", " def __init__(self, mnist_dataset):\n", " self.mnist_dataset = mnist_dataset.tensors\n", " self.train_labels = self.mnist_dataset[1]\n", " self.train_data = self.mnist_dataset[0]\n", " self.labels_set = set(self.train_labels.numpy())\n", " self.label_to_indices = {}\n", " for label in self.labels_set:\n", " self.label_to_indices[label] = np.where(self.train_labels.numpy() == label)[0]\n", "\n", " def __getitem__(self, index):\n", " img1, label1 = self.train_data[index], self.train_labels[index].item()\n", " positive_index = index\n", " while positive_index == index:\n", " positive_index = np.random.choice(self.label_to_indices[label1])\n", " negative_label = np.random.choice(list(self.labels_set - set([label1])))\n", " negative_index = np.random.choice(self.label_to_indices[negative_label])\n", " img3 = self.train_data[negative_index]\n", " img2 = self.train_data[positive_index]\n", " return img1, img2, img3\n", "\n", " def __len__(self):\n", " return len(self.mnist_dataset[1])\n", "# Reference https://github.com/adambielski/siamese-triplet/blob/master/losses.py\n", "class TripletLoss(nn.Module):\n", " def __init__(self):\n", " super(TripletLoss, self).__init__()\n", "\n", " def forward(self, anchor, positive, negative, size_average=True):\n", " d_positive = torch.sqrt(torch.sum((anchor - positive).pow(2),axis=1))\n", " d_negative = torch.sqrt(torch.sum((anchor - negative).pow(2),axis=1))\n", " z = torch.cat((d_positive.unsqueeze(1),d_negative.unsqueeze(1)),axis=1)\n", " z = log_sum_exp(z)\n", " return -torch.mean(d_negative) + torch.mean(z)\n", "\n", "MNISTUnlabel()\n", "MNISTTest()" ] }, { "cell_type": "markdown", "metadata": { "id": "fe8FDZbJXcYP" }, "source": [ "## GAN" ] }, { "cell_type": "markdown", "metadata": { "id": "bKsaR_b7XcYQ" }, "source": [ "### Architecture: Generator and Discriminator\n", "\n", "This notebook follows the architecture used in Improved GAN (Salimans et al. 2016). The discriminator outputs M (16 or 32) features. The hyperparameters are same as in TripletGAN. " ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "id": "FWEjCPFiXcYQ" }, "outputs": [], "source": [ "#collapse-hide\n", "# https://github.com/Sleepychord/ImprovedGAN-pytorch/blob/master/Nets.py\n", "class Discriminator(nn.Module):\n", " def __init__(self, input_dim = 28 ** 2, output_dim = 10):\n", " super(Discriminator, self).__init__()\n", " self.input_dim = input_dim\n", " self.output_dim = output_dim\n", " self.layers = torch.nn.ModuleList([\n", " LinearWeightNorm(input_dim, 1000),\n", " LinearWeightNorm(1000, 500),\n", " LinearWeightNorm(500, 250),\n", " LinearWeightNorm(250, 250),\n", " LinearWeightNorm(250, 250)]\n", " )\n", " self.final = LinearWeightNorm(250, output_dim, weight_scale=1)\n", " self.reduce = nn.Sequential(\n", " nn.Linear(self.output_dim, 1),\n", " nn.Sigmoid(),\n", " )\n", "\n", " def forward(self, x, feature = False, pretrain=False):\n", " x = x.view(-1, self.input_dim)\n", " noise = torch.randn(x.size()) * 0.3 if self.training else torch.Tensor([0])\n", " if args.cuda:\n", " noise = noise.cuda()\n", " x = x + noise\n", " for i in range(len(self.layers)):\n", " m = self.layers[i]\n", " x_f = F.relu(m(x))\n", " noise = torch.randn(x_f.size()) * 0.5 if self.training else torch.Tensor([0])\n", " if args.cuda:\n", " noise = noise.cuda()\n", " x = (x_f + noise)\n", " if feature:\n", " return x_f\n", " out = self.final(x)\n", " if pretrain:\n", " out = self.reduce(out)\n", " return out\n", "\n", "\n", "class Generator(nn.Module):\n", " def __init__(self, z_dim, output_dim = 28 * 28):\n", " super(Generator, self).__init__()\n", " self.z_dim = z_dim\n", " self.fc1 = nn.Linear(z_dim, 500, bias = False)\n", " self.bn1 = nn.BatchNorm1d(500, affine = False, eps=1e-6, momentum = 0.5)\n", " self.fc2 = nn.Linear(500, 500, bias = False)\n", " self.bn2 = nn.BatchNorm1d(500, affine = False, eps=1e-6, momentum = 0.5)\n", " self.fc3 = LinearWeightNorm(500, output_dim, weight_scale = 1)\n", " self.bn1_b = Parameter(torch.zeros(500))\n", " self.bn2_b = Parameter(torch.zeros(500))\n", " nn.init.xavier_uniform_(self.fc1.weight)\n", " nn.init.xavier_uniform_(self.fc2.weight)\n", "\n", " def forward(self, batch_size, draw=None):\n", " if draw is None:\n", " x = torch.rand(batch_size, self.z_dim)\n", " else:\n", " x = draw\n", " if args.cuda:\n", " x = x.cuda()\n", " x = F.softplus(self.bn1(self.fc1(x)) + self.bn1_b)\n", " x = F.softplus(self.bn2(self.fc2(x)) + self.bn2_b)\n", " x = F.softplus(self.fc3(x))\n", " return x" ] }, { "cell_type": "markdown", "metadata": { "id": "ValQ0-UuXcYU" }, "source": [ "## GAN Class\n", "\n", "For pretraining the GAN, I have followed the standard objective (Goodfellow, Ian, et al. 2014) \n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "id": "7SCqOSAdXcYV" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "#collapse-hide\n", "# Reference: https://github.com/Sleepychord/ImprovedGAN-pytorch/blob/master/ImprovedGAN.py\n", "class ImprovedGAN(object):\n", " def __init__(self, G, D, labeled, unlabeled, test):\n", " self.G = G\n", " self.D = D\n", " # if(args.mode == 'train'):\n", " g_name = 'G_'+str(D.output_dim)+'_'+str(args.labeled)+'.pkl'\n", " d_name = 'D_'+str(D.output_dim)+'_'+str(args.labeled)+'.pkl'\n", " # else:\n", " g_name_pretrain = 'pretrain' + '_G_'+str(D.output_dim)+'.pkl'\n", " d_name_pretrain = 'pretrain' + '_D_'+str(D.output_dim)+'.pkl'\n", "\n", " if args.mode == 'pretrain':\n", " self.g_path = Path(args.savedir) / g_name_pretrain\n", " self.d_path = Path(args.savedir) / d_name_pretrain\n", " else:\n", " self.g_path = Path(args.savedir) / g_name\n", " self.d_path = Path(args.savedir) / d_name\n", "\n", " if os.path.exists(args.savedir) and args.load_saved:\n", " print('Loading model ' + args.savedir)\n", " if False and os.path.exists(self.g_path):\n", " self.G.load_state_dict(torch.load(self.g_path))\n", " self.D.load_state_dict(torch.load(self.d_path))\n", " else:\n", " print('Loaded pretrain')\n", " self.G.load_state_dict(torch.load(Path(args.savedir) / g_name_pretrain))\n", " self.D.load_state_dict(torch.load(Path(args.savedir) / d_name_pretrain))\n", " else:\n", " print('Creating model')\n", " if not os.path.exists(args.savedir):\n", " os.makedirs(args.savedir)\n", " torch.save(self.G.state_dict(), self.g_path)\n", " torch.save(self.D.state_dict(), self.d_path)\n", " # self.writer = tensorboardX.SummaryWriter(log_dir=args.logdir)\n", " if args.cuda:\n", " self.G.cuda()\n", " self.D.cuda()\n", " \n", " self.Doptim = optim.Adam(self.D.parameters(), lr=args.lr, betas= (args.momentum, 0.999))\n", " self.Goptim = optim.Adam(self.G.parameters(), lr=args.lr, betas = (args.momentum,0.999))\n", " self.knn = KNeighborsClassifier(n_neighbors=9)\n", " self.tripletloss = TripletLoss()\n", " self.drawnoise = torch.rand(4, self.G.z_dim)\n", " self.labeled = labeled\n", " self.unlabeled = unlabeled\n", " self.test = test\n", "\n", " def get_features(self,dataset):\n", " loader = DataLoader(dataset, batch_size = args.batch_size, shuffle=True, drop_last=True, num_workers = 4)\n", " X = []\n", " y = []\n", " for (data,label) in loader:\n", " data = data.cuda()\n", " X += self.D(data)\n", " y += label\n", " # del data\n", " del loader,data\n", " X = torch.stack(X).data.cpu().numpy()\n", " y = torch.LongTensor(y).data.cpu().numpy()\n", " # X = torch.stack(X)\n", " # y = torch.LongTensor(y)\n", " return X,y\n", "\n", " def trainknn(self):\n", " X,y = self.get_features(self.unlabeled)\n", " self.knn.fit(X,y)\n", " print(\"Fit done\")\n", " del X,y\n", " \n", " def calc_mAP(self,test_features, testy, train_features, trainy):\n", " Y = cdist(test_features,train_features)\n", " ind = np.argsort(Y,axis=1)\n", " print(\"Done argsort\")\n", " del Y,train_features\n", " prec = 0.0\n", " num_classes = 10\n", " acc = [0.0] * num_classes\n", " test_len = len(test_features)\n", " # print(\"testlen\",test_len)\n", " for k in range(test_len):\n", " class_values = trainy[ind[k,:]]\n", " y_true = (testy[k] == class_values)\n", " # print(\"ylen\",y_true.shape[0])\n", " y_scores = np.arange(y_true.shape[0],0,-1)\n", " prec += average_precision_score(y_true, y_scores)\n", "\n", " for n in range(num_classes):\n", " a = class_values[0:(n+1)]\n", " counts = np.bincount(a)\n", " b = np.where(counts==np.max(counts))[0]\n", " if testy[k] in b:\n", " acc[n] = acc[n] + (1.0/float(len(b)))\n", " prec = prec/float(test_len)\n", " acc= [x / float(test_len) for x in acc]\n", " del ind,class_values,y_true,y_scores\n", " return np.mean(acc)*100,prec\n", "\n", " def evalknn(self,results):\n", " test_features, testy = self.get_features(self.test)\n", " train_features, trainy = self.get_features(self.unlabeled)\n", " accuracy,mAP = self.calc_mAP(test_features, testy, train_features, trainy)\n", " del test_features,testy,train_features,trainy\n", " results[args.mode+'_'+str(args.features)+'_'+str(args.labeled)] = [accuracy,mAP]\n", " return accuracy,mAP\n", " \n", " def draw(self, batch_size):\n", " self.G.eval()\n", " return self.G(batch_size,draw=self.drawnoise).view((batch_size,28,28)).data.cpu().numpy()" ] }, { "cell_type": "markdown", "metadata": { "id": "IO_geDVUXcYY" }, "source": [ "### Pretrain GAN\n", "\n", "We'll first pretrain the GAN for 50 epochs" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Original GAN objective" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "id": "5LBVmBOHXcYY" }, "outputs": [], "source": [ "#collapse-hide\n", "def pretrain(self):\n", " # Reference: https://github.com/eriklindernoren/PyTorch-GAN/blob/master/implementations/gan/gan.py\n", " plotlosses = PlotLosses(groups={'loss': ['generator', 'discriminator']})\n", " # Tensor = torch.cuda.FloatTensor if args.cuda else torch.FloatTensor\n", " bce_loss = torch.nn.BCELoss()\n", " if args.cuda:\n", " bce_loss.cuda()\n", "\n", " dataloader = DataLoader(self.unlabeled, batch_size = args.batch_size, shuffle=True, drop_last=True, num_workers = 4)\n", " for epoch in tq(range(args.epochs)):\n", " losses = {'discriminator':0,'generator':0}\n", " for i, (imgs, _) in enumerate(dataloader):\n", " valid = torch.ones((imgs.size(0), 1))\n", " fake = torch.zeros((imgs.size(0), 1))\n", "\n", " train_imgs = imgs\n", "\n", " generated_images = self.G(args.batch_size)\n", " \n", " if args.cuda:\n", " valid, fake, train_imgs, generated_images = valid.cuda(), fake.cuda(), train_imgs.cuda(), generated_images.cuda()\n", "\n", " generator_loss = bce_loss(self.D(generated_images,pretrain=True), valid)\n", " \n", " self.Goptim.zero_grad()\n", " generator_loss.backward()\n", " self.Goptim.step()\n", "\n", " real_loss = bce_loss(self.D(train_imgs,pretrain=True), valid)\n", " fake_loss = bce_loss(self.D(generated_images.detach(),pretrain=True), fake)\n", " \n", " discriminator_loss = (fake_loss + real_loss) / 2\n", "\n", " self.Doptim.zero_grad()\n", " discriminator_loss.backward()\n", " self.Doptim.step()\n", "\n", " losses['generator'] += generator_loss.item()\n", " losses['discriminator'] += discriminator_loss.item()\n", " \n", " num_batches = len(self.unlabeled) / args.batch_size\n", " for key in losses:\n", " losses[key] /= num_batches\n", " \n", " plotlosses.update(losses)\n", " plotlosses.send()\n", " \n", " if (epoch + 1) % args.save_interval == 0:\n", " torch.save(self.G.state_dict(), self.g_path)\n", " torch.save(self.D.state_dict(), self.d_path)\n", "\n", "ImprovedGAN.pretrain = pretrainargs.load_saved=False\n", "args.epochs=50\n", "args.mode = 'pretrain'\n", "\n", "# m=16 n=100\n", "args.labeled=100\n", "args.features=16\n", "gan = ImprovedGAN(Generator(z_dim=100), Discriminator(output_dim=args.features), MNISTLabel(args.labeled/10), MNISTUnlabel(), MNISTTest())\n", "gan.pretrain()\n", "# gan.trainknn()\n", "print(gan.evalknn(results))\n", "show_gen_images(gan)" ] }, { "cell_type": "markdown", "metadata": { "id": "6xUFQiiRXcYa" }, "source": [ "#### m=16\n", "Here we pretrain a model that would generate 16 features given an input image. To generate the images, I created an array with noise and sent it to the generator to get the image.\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "id": "RxNHZS3cXcYb", "outputId": "6ba1db35-4eb4-44f7-f6ea-d1f41ab48bb9", "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Loss\n", "\tgenerator \t (min: 1.549, max: 2.075, cur: 1.775)\n", "\tdiscriminator \t (min: 0.391, max: 0.429, cur: 0.409)\n", "\n", "Done w cdist\n", "(30.023548015873082, 0.15303857492111891)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#collapse-hide\n", "\n", "args.load_saved=True\n", "args.epochs=50\n", "args.mode = 'pretrain'\n", "\n", "# m=16 n=100\n", "args.labeled=100\n", "args.features=16\n", "gan = ImprovedGAN(Generator(z_dim=100), Discriminator(output_dim=args.features), MNISTLabel(args.labeled/10), MNISTUnlabel(), MNISTTest())\n", "gan.pretrain()\n", "# gan.trainknn()\n", "print(gan.evalknn(results))\n", "show_gen_images(gan)" ] }, { "cell_type": "markdown", "metadata": { "id": "hMMrj6GwXcYd" }, "source": [ "#### m=32" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "id": "a1nd5XpxXcYe", "outputId": "df5d9313-df4d-4dbc-aab9-a3aa33a621fd", "scrolled": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Loss\n", "\tgenerator \t (min: 1.724, max: 2.207, cur: 1.793)\n", "\tdiscriminator \t (min: 0.373, max: 0.414, cur: 0.406)\n", "\n", "Done w cdist\n", "(44.4227202380953, 0.1734273342974863)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#collapse-hide\n", "# m=32 n=100\n", "args.features=32\n", "gan = ImprovedGAN(Generator(z_dim=100), Discriminator(output_dim=args.features), MNISTLabel(args.labeled/10), MNISTUnlabel(), MNISTTest())\n", "gan.pretrain()\n", "# gan.trainknn()\n", "print(gan.evalknn(results))\n", "show_gen_images(gan)" ] }, { "cell_type": "markdown", "metadata": { "id": "c36f8R-VXcYi" }, "source": [ "## Main Training" ] }, { "cell_type": "markdown", "metadata": { "id": "wH8z24czXcYi" }, "source": [ "#### Improved GAN Objective + Triplet loss\n", "\n", "For training the Improved GAN with Triplet loss, I have followed the Improved GAN objective (Salimans et al. 2016) with Triplet Loss in the Discriminator. " ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "id": "eBc-UErZXcYj", "outputId": "235512a0-56e0-421f-a68e-b5db4e99d756" }, "outputs": [], "source": [ "#collapse-hide\n", "\n", "# Reference: https://github.com/Sleepychord/ImprovedGAN-pytorch/blob/master/ImprovedGAN.py\n", "def train_Discriminator(self, x1, x2, x3, x_unlabel):\n", " output_unlabel, output_fake = self.D(x_unlabel), self.D(self.G(x_unlabel.size()[0]).view(x_unlabel.size()).detach()) \n", " loss_supervised = self.tripletloss(self.D(x1), self.D(x2), self.D(x3))\n", " logz_unlabel, logz_fake = log_sum_exp(output_unlabel), log_sum_exp(output_fake)\n", " loss_unsupervised = 0.5 * torch.mean(F.softplus(logz_fake)) + 0.5 * -torch.mean(logz_unlabel) + 0.5 * torch.mean(F.softplus(logz_unlabel))\n", " loss = args.unlabel_weight * loss_unsupervised + loss_supervised\n", " self.Doptim.zero_grad()\n", " loss.backward()\n", " self.Doptim.step()\n", " return loss_supervised.item(), loss_unsupervised.item()\n", " \n", "def train_Generator(self, x_unlabel):\n", " fake = self.G(args.batch_size).view(x_unlabel.size())\n", " mom_gen = self.D(fake, feature=True).mean(dim=0)\n", " mom_unlabel = self.D(x_unlabel, feature=True).mean(dim=0)\n", " loss_feature_matching = torch.mean((mom_gen - mom_unlabel).pow(2))\n", " self.Goptim.zero_grad()\n", " self.Doptim.zero_grad()\n", " loss_feature_matching.backward()\n", " self.Goptim.step()\n", " return loss_feature_matching.item()\n", " \n", "def train(self):\n", " plotlosses = PlotLosses(groups={'loss': ['supervised', 'unsupervised','generator']})\n", " for epoch in tq(range(args.epochs)):\n", " self.G.train()\n", " self.D.train()\n", " unlabel_loader1 = DataLoader(self.unlabeled, batch_size = args.batch_size, shuffle=True, drop_last=True, num_workers = 4)\n", " unlabel_loader2 = DataLoader(self.unlabeled, batch_size = args.batch_size, shuffle=True, drop_last=True, num_workers = 4).__iter__()\n", " label_loader = DataLoader(self.labeled, batch_size = args.batch_size, shuffle=True, drop_last=True, num_workers = 4).__iter__()\n", " \n", " # loss_supervised = loss_unsupervised = loss_generator = 0.\n", " losses = {'supervised':0,'unsupervised':0,'generator':0}\n", " for (unlabel1, _) in unlabel_loader1:\n", " unlabel2, _ = unlabel_loader2.next()\n", " x1,x2,x3 = label_loader.next()\n", " if args.cuda:\n", " x1, x2, x3, unlabel1, unlabel2 = x1.cuda(), x2.cuda(), x3.cuda(), unlabel1.cuda(), unlabel2.cuda()\n", " \n", " l_supervised, l_unsupervised = self.train_Discriminator(x1, x2, x3, unlabel1)\n", " \n", " losses['unsupervised'] += l_unsupervised\n", " losses['supervised'] += l_supervised\n", " \n", " generator_loss = self.train_Generator(unlabel2)\n", " if epoch > 1 and generator_loss > 1:\n", " generator_loss = self.train_Generator(unlabel2)\n", " losses['generator'] += generator_loss\n", "\n", " batch_num = len(self.unlabeled) // args.batch_size\n", " for key in losses:\n", " losses[key] /= batch_num\n", "\n", " plotlosses.update(losses)\n", " plotlosses.send()\n", " if (epoch + 1) % args.save_interval == 0:\n", " torch.save(self.D.state_dict(), self.d_path)\n", " torch.save(self.G.state_dict(), self.g_path)\n", "\n", "ImprovedGAN.train = train\n", "ImprovedGAN.train_Discriminator = train_Discriminator\n", "ImprovedGAN.train_Generator = train_Generator" ] }, { "cell_type": "markdown", "metadata": { "id": "Aq-wRoLEXcYl" }, "source": [ "#### Triplet Loss and M=16 N=100\n", "\n", "Here M is the number of features generated by the discriminator and N is the number of samples on which we did supervised training, on rest of the samples we do unsupervised training." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "id": "PTajOMULXcYl", "outputId": "b1cdd47e-1a4b-41b0-ecd6-207b420d90b8" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Loss\n", "\tsupervised \t (min: 0.000, max: 0.079, cur: 0.000)\n", "\tunsupervised \t (min: 0.351, max: 0.453, cur: 0.422)\n", "\tgenerator \t (min: 0.511, max: 1.353, cur: 0.511)\n", "\n", "Done argsort\n", "(96.17309999999998, 0.9155653700006265)\n", "CPU times: user 53min, sys: 2min 10s, total: 55min 11s\n", "Wall time: 1h 5min 43s\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#collapse-hide\n", "\n", "%%time\n", "args.load_saved=True\n", "args.epochs=70\n", "args.labeled=100\n", "args.features=16\n", "args.mode = 'train'\n", "gan = ImprovedGAN(Generator(z_dim=100), Discriminator(output_dim=args.features), MNISTTriplet(MNISTLabel(args.labeled/10)), MNISTUnlabel(), MNISTTest())\n", "\n", "gan.train()\n", "# gan.trainknn()\n", "print(gan.evalknn(results))\n", "show_gen_images(gan)" ] }, { "cell_type": "markdown", "metadata": { "id": "lfSL_f39XcYo" }, "source": [ "#### Triplet Loss and M=16 N=200" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "id": "drYCnOpaXcYo", "outputId": "3641dd80-91ed-4d5d-fdb8-4264ccd894a4" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Loss\n", "\tsupervised \t (min: 0.000, max: 0.106, cur: 0.000)\n", "\tunsupervised \t (min: 0.368, max: 0.463, cur: 0.413)\n", "\tgenerator \t (min: 0.487, max: 1.185, cur: 0.487)\n", "\n", "Done argsort\n", "(96.44481666666665, 0.931573062438397)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#collapse-hide\n", "\n", "args.load_saved=True\n", "args.epochs=70\n", "args.labeled=200\n", "args.features=16\n", "\n", "gan = ImprovedGAN(Generator(z_dim=100), Discriminator(output_dim=args.features), MNISTTriplet(MNISTLabel(args.labeled/10)), MNISTUnlabel(), MNISTTest())\n", "gan.train()\n", "# gan.trainknn()\n", "print(gan.evalknn(results))\n", "show_gen_images(gan)" ] }, { "cell_type": "markdown", "metadata": { "id": "7ttRXSclXcYt" }, "source": [ "#### Triplet Loss and M=32 N=100" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "id": "9Cs8tvz_XcYt", "outputId": "7399675c-6580-486d-98e7-854938e046a0" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Loss\n", "\tsupervised \t (min: 0.000, max: 0.098, cur: 0.000)\n", "\tunsupervised \t (min: 0.355, max: 0.485, cur: 0.430)\n", "\tgenerator \t (min: 0.680, max: 2.149, cur: 0.699)\n", "\n", "Done argsort\n", "(95.97931666666668, 0.9031129058147167)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "#collapse-hide\n", "\n", "args.load_saved=True\n", "args.epochs=70\n", "args.labeled=100\n", "args.features=32\n", "\n", "gan = ImprovedGAN(Generator(z_dim=100), Discriminator(output_dim=args.features), MNISTTriplet(MNISTLabel(args.labeled/10)), MNISTUnlabel(), MNISTTest())\n", "gan.train()\n", "# gan.trainknn()\n", "print(gan.evalknn(results))\n", "show_gen_images(gan)" ] }, { "cell_type": "markdown", "metadata": { "id": "NF8mUdp4XcYy" }, "source": [ "### Results" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "id": "TeLdoPVbXcYy", "tags": [] }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": "Features Supervised samples Accuracy mAP\n---------- -------------------- ---------- --------\n 16 100 96.1731 0.915565\n 16 200 96.4448 0.931573\n 32 100 95.9793 0.903113\n" } ], "source": [ "#collapse-hide\n", "from tabulate import tabulate\n", "\n", "results = [[16, 100, 96.17309999999998, 0.9155653700006265],\n", " [16, 200, 96.44481666666665, 0.931573062438397],\n", " [32, 100, 95.97931666666668, 0.9031129058147167]]\n", "print(tabulate(results,headers=['Features','Supervised samples','Accuracy','mAP']))" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.7.6" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { "083137ae2e4e4df89372b3f7312b0df6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "initial" } }, "108cbf55deb34806be80a9c19e50ec5f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_451b542c4b364e2fb5d063a3a8c80510", "placeholder": "​", "style": "IPY_MODEL_fdb3cbac77c045259da0e546a4f343ea", "value": " 8192/? [00:00<00:00, 18073.84it/s]" } }, "127dd236058b49479d99e5a2491683cc": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "initial" } }, "15e2ed7ab25f4fa091d4911962c67539": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_1b8f808ffab0449482d1b09c4d7c14ea", "placeholder": "​", "style": "IPY_MODEL_2b39760025b541ba9a9b60927d23ea19", "value": " 70/70 [1:04:14<00:00, 55.07s/it]" } }, "19f81b3816dc4f73a7a8f07ee05f3015": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "1b8f808ffab0449482d1b09c4d7c14ea": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "1e8467600e7a46faa63233df862f00b1": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "20b7c0530f3840ea9a862ea39f6eae03": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_cf79fd4a1bfc45bca317205cfe18f5f8", "max": 1, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_083137ae2e4e4df89372b3f7312b0df6", "value": 1 } }, "230d03b4d8d14ae895a790c6f5d4df3a": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "244e2280b23a4ae8b34a8153b56b0647": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "2b39760025b541ba9a9b60927d23ea19": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "2cdba883945b4638b308203cdcc249de": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_73787f08d8d04b198006b130b4e1cbd4", "max": 1, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_127dd236058b49479d99e5a2491683cc", "value": 1 } }, "33277bfc9ae6499b9e308a522e40d56a": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "350763325d50438881e8ca475fed4f87": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "initial" } }, "39a2d4a4e54a4363840f80db86620b37": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "3bb696c3138f40a5867b3ffb531bd3dd": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "info", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_73067c77fa614cf1bab5bcb68ae4f388", "max": 1, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_c7c3c828e8ce4056b7dc3e72560379c0", "value": 1 } }, "3bcf6dad2c1c4fe59964c4f2abc66b54": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_5a888895301a41ba84b4b6659e6e60ce", "placeholder": "​", "style": "IPY_MODEL_244e2280b23a4ae8b34a8153b56b0647", "value": " 70/70 [1:03:33<00:00, 54.47s/it]" } }, "43630c9c1bac43e9ad394abdf93a6d9d": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "451b542c4b364e2fb5d063a3a8c80510": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "4c2a62cad3e745c48c44758757c3b5ae": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "initial" } }, "4d253d23fd9c4a158c72ba3e1b67ea18": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_85fd1071d78f4562b80f502c11f81f7d", "placeholder": "​", "style": "IPY_MODEL_8a43ec739f9746cbbf83c2fc32e29dff", "value": " 9920512/? [00:20<00:00, 1137523.28it/s]" } }, "50ea4da8a1a143ad8e5d7f115d8a48ac": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_a5c62cb711074c1284015ce876350855", "IPY_MODEL_108cbf55deb34806be80a9c19e50ec5f" ], "layout": "IPY_MODEL_cb7d6f6d5ade44c1b06b5476f09a87b6" } }, "5809f284371a491bb50597eb6642df24": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "5a888895301a41ba84b4b6659e6e60ce": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "5f777d764f764d7d865fcb865d954160": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "607f34bdf0b14b1a91caf6d9844bad4e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "65f5dda52bd146f0b2f78f96c8c2ff79": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "6f409f71dd4449f39d15276b855ad1fb": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_93ba603c2e0146539d0154a6e5198170", "IPY_MODEL_3bcf6dad2c1c4fe59964c4f2abc66b54" ], "layout": "IPY_MODEL_bdebf5da52914d3499569f23b8351ad5" } }, "73067c77fa614cf1bab5bcb68ae4f388": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "73787f08d8d04b198006b130b4e1cbd4": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "78d3878825004a538a00f7a3937d796a": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "796ea965633e48659f231a6a824c0bd6": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_43630c9c1bac43e9ad394abdf93a6d9d", "placeholder": "​", "style": "IPY_MODEL_dca919422dde4dbbae20de762b3a38b0", "value": " 70/70 [1:12:05<00:00, 61.79s/it]" } }, "7d4525322a514a09a22cabb40b0da51a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "initial" } }, "84ab96b85f8c4d1b9a83ec346ccd64d0": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "85fd1071d78f4562b80f502c11f81f7d": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "87db4a7ff49c449b92f64b2c04fbe707": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_ecadb2ef3d7d44f189b0d9c4285c477b", "IPY_MODEL_15e2ed7ab25f4fa091d4911962c67539" ], "layout": "IPY_MODEL_65f5dda52bd146f0b2f78f96c8c2ff79" } }, "8a43ec739f9746cbbf83c2fc32e29dff": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "8f966c3006734a2aa86cf9960a3f3fad": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_3bb696c3138f40a5867b3ffb531bd3dd", "IPY_MODEL_4d253d23fd9c4a158c72ba3e1b67ea18" ], "layout": "IPY_MODEL_1e8467600e7a46faa63233df862f00b1" } }, "93ba603c2e0146539d0154a6e5198170": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "100%", "description_tooltip": null, "layout": "IPY_MODEL_b8f6540af8624f298f182a953f239daa", "max": 70, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_f2a105a8e0a64dc9bf149434a943ef43", "value": 70 } }, "98b310c7caa046aba9a0980ac3408b96": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "100%", "description_tooltip": null, "layout": "IPY_MODEL_f22799009ed94f1a81522d40e38832a2", "max": 70, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_350763325d50438881e8ca475fed4f87", "value": 70 } }, "a5c62cb711074c1284015ce876350855": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_19f81b3816dc4f73a7a8f07ee05f3015", "max": 1, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_7d4525322a514a09a22cabb40b0da51a", "value": 1 } }, "b8f6540af8624f298f182a953f239daa": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "bdebf5da52914d3499569f23b8351ad5": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "c4eeacff33494712900584e14e2c4b26": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_98b310c7caa046aba9a0980ac3408b96", "IPY_MODEL_796ea965633e48659f231a6a824c0bd6" ], "layout": "IPY_MODEL_84ab96b85f8c4d1b9a83ec346ccd64d0" } }, "c7c3c828e8ce4056b7dc3e72560379c0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "initial" } }, "caa5754b2ab24b759ea04e0f5635016c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_33277bfc9ae6499b9e308a522e40d56a", "placeholder": "​", "style": "IPY_MODEL_5f777d764f764d7d865fcb865d954160", "value": " 32768/? [00:01<00:00, 32486.74it/s]" } }, "cb7d6f6d5ade44c1b06b5476f09a87b6": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "cdd6461270d6459c8d0110dbd66a0dac": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HTMLView", "description": "", "description_tooltip": null, "layout": "IPY_MODEL_230d03b4d8d14ae895a790c6f5d4df3a", "placeholder": "​", "style": "IPY_MODEL_607f34bdf0b14b1a91caf6d9844bad4e", "value": " 1654784/? [00:00<00:00, 2238998.56it/s]" } }, "cf79fd4a1bfc45bca317205cfe18f5f8": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "da991ed9f2cd44ffa15613ca4eccd0f0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_2cdba883945b4638b308203cdcc249de", "IPY_MODEL_cdd6461270d6459c8d0110dbd66a0dac" ], "layout": "IPY_MODEL_78d3878825004a538a00f7a3937d796a" } }, "dca919422dde4dbbae20de762b3a38b0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } }, "ec7c7b1b5bdf45ae96b43644309a7e94": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_20b7c0530f3840ea9a862ea39f6eae03", "IPY_MODEL_caa5754b2ab24b759ea04e0f5635016c" ], "layout": "IPY_MODEL_39a2d4a4e54a4363840f80db86620b37" } }, "ecadb2ef3d7d44f189b0d9c4285c477b": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "1.5.0", "_view_name": "ProgressView", "bar_style": "success", "description": "100%", "description_tooltip": null, "layout": "IPY_MODEL_5809f284371a491bb50597eb6642df24", "max": 70, "min": 0, "orientation": "horizontal", "style": "IPY_MODEL_4c2a62cad3e745c48c44758757c3b5ae", "value": 70 } }, "f22799009ed94f1a81522d40e38832a2": { "model_module": "@jupyter-widgets/base", "model_module_version": "1.2.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "1.2.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "overflow_x": null, "overflow_y": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "f2a105a8e0a64dc9bf149434a943ef43": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "bar_color": null, "description_width": "initial" } }, "fdb3cbac77c045259da0e546a4f343ea": { "model_module": "@jupyter-widgets/controls", "model_module_version": "1.5.0", "model_name": "DescriptionStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", "_model_name": "DescriptionStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "1.2.0", "_view_name": "StyleView", "description_width": "" } } }, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 4 }