{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# [VQ-VAE](https://arxiv.org/abs/1711.00937) by [AƤron van den Oord](https://twitter.com/avdnoord) et al. in PyTorch\n", "\n", "## Introduction\n", "\n", "Variational Auto Encoders (VAEs) can be thought of as what all but the last layer of a neural network is doing, namely feature extraction or seperating out the data. Thus given some data we can think of using a neural network for representation generation. \n", "\n", "Recall that the goal of a generative model is to estimate the probability distribution of high dimensional data such as images, videos, audio or even text by learning the underlying structure in the data as well as the dependencies between the different elements of the data. This is very useful since we can then use this representation to generate new data with similar properties. This way we can also learn useful features from the data in an unsupervised fashion.\n", "\n", "The VQ-VAE uses a discrete latent representation mostly because many important real-world objects are discrete. For example in images we might have categories like \"Cat\", \"Car\", etc. and it might not make sense to interpolate between these categories. Discrete representations are also easier to model since each category has a single value whereas if we had a continous latent space then we will need to normalize this density function and learn the dependencies between the different variables which could be very complex.\n", "\n", "### Code\n", "\n", "I have followed the code from the TensorFlow implementation by the author which you can find here [vqvae.py](https://github.com/deepmind/sonnet/blob/master/sonnet/python/modules/nets/vqvae.py) and [vqvae_example.ipynb](https://github.com/deepmind/sonnet/blob/master/sonnet/examples/vqvae_example.ipynb). \n", "\n", "Another PyTorch implementation is found at [pytorch-vqvae](https://github.com/ritheshkumar95/pytorch-vqvae).\n", "\n", "\n", "## Basic Idea\n", "\n", "The overall architecture is summarized in the diagram below:\n", "\n", "![](images/vq-vae.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We start by defining a latent embedding space of dimension `[K, D]` where `K` are the number of embeddings and `D` is the dimensionality of each latent embeddng vector, i.e. $e_i \\in \\mathbb{R}^{D}$. The model is comprised of an encoder and a decoder. The encoder will map the input to a sequence of discrete latent variables, whereas the decoder will try to reconstruct the input from these latent sequences. \n", "\n", "More preciesly, the model will take in batches of RGB images, say $x$, each of size 32x32 for our example, and pass it through a ConvNet encoder producing some output $E(x)$, where we make sure the channels are the same as the dimensionality of the latent embedding vectors. To calculate the discrete latent variable we find the nearest embedding vector and output it's index. \n", "\n", "The input to the decoder is the embedding vector corresponding to the index which is passed through the decoder to produce the reconstructed image. \n", "\n", "Since the nearest neighbour lookup has no real gradient in the backward pass we simply pass the gradients from the decoder to the encoder unaltered. The intuition is that since the output representation of the encoder and the input to the decoder share the same `D` channel dimensional space, the gradients contain useful information for how the encoder has to change its output to lower the reconstruction loss.\n", "\n", "## Loss\n", "\n", "The total loss is actually composed of three components\n", "\n", "1. **reconstruction loss**: which optimizes the decoder and encoder\n", "1. **codebook loss**: due to the fact that gradients bypass the embedding, we use a dictionary learning algorithm which uses an $l_2$ error to move the embedding vectors $e_i$ towards the encoder output\n", "1. **commitment loss**: since the volume of the embedding space is dimensionless, it can grow arbirtarily if the embeddings $e_i$ do not train as fast as the encoder parameters, and thus we add a commitment loss to make sure that the encoder commits to an embedding" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "#!pip3 install -U -r requirements.txt" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from __future__ import print_function\n", "\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from scipy.signal import savgol_filter\n", "\n", "\n", "from six.moves import xrange\n", "\n", "import umap\n", "\n", "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "from torch.utils.data import DataLoader\n", "import torch.optim as optim\n", "\n", "import torchvision.datasets as datasets\n", "import torchvision.transforms as transforms\n", "from torchvision.utils import make_grid" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Load Data" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Files already downloaded and verified\n", "Files already downloaded and verified\n" ] } ], "source": [ "training_data = datasets.CIFAR10(root=\"data\", train=True, download=True,\n", " transform=transforms.Compose([\n", " transforms.ToTensor(),\n", " transforms.Normalize((0.5,0.5,0.5), (1.0,1.0,1.0))\n", " ]))\n", "\n", "validation_data = datasets.CIFAR10(root=\"data\", train=False, download=True,\n", " transform=transforms.Compose([\n", " transforms.ToTensor(),\n", " transforms.Normalize((0.5,0.5,0.5), (1.0,1.0,1.0))\n", " ]))" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "data_variance = np.var(training_data.data / 255.0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Vector Quantizer Layer\n", "\n", "This layer takes a tensor to be quantized. The channel dimension will be used as the space in which to quantize. All other dimensions will be flattened and will be seen as different examples to quantize.\n", "\n", "The output tensor will have the same shape as the input.\n", "\n", "As an example for a `BCHW` tensor of shape `[16, 64, 32, 32]`, we will first convert it to an `BHWC` tensor of shape `[16, 32, 32, 64]` and then reshape it into `[16384, 64]` and all `16384` vectors of size `64` will be quantized independently. In otherwords, the channels are used as the space in which to quantize. All other dimensions will be flattened and be seen as different examples to quantize, `16384` in this case." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "class VectorQuantizer(nn.Module):\n", " def __init__(self, num_embeddings, embedding_dim, commitment_cost):\n", " super(VectorQuantizer, self).__init__()\n", " \n", " self._embedding_dim = embedding_dim\n", " self._num_embeddings = num_embeddings\n", " \n", " self._embedding = nn.Embedding(self._num_embeddings, self._embedding_dim)\n", " self._embedding.weight.data.uniform_(-1/self._num_embeddings, 1/self._num_embeddings)\n", " self._commitment_cost = commitment_cost\n", "\n", " def forward(self, inputs):\n", " # convert inputs from BCHW -> BHWC\n", " inputs = inputs.permute(0, 2, 3, 1).contiguous()\n", " input_shape = inputs.shape\n", " \n", " # Flatten input\n", " flat_input = inputs.view(-1, self._embedding_dim)\n", " \n", " # Calculate distances\n", " distances = (torch.sum(flat_input**2, dim=1, keepdim=True) \n", " + torch.sum(self._embedding.weight**2, dim=1)\n", " - 2 * torch.matmul(flat_input, self._embedding.weight.t()))\n", " \n", " # Encoding\n", " encoding_indices = torch.argmin(distances, dim=1).unsqueeze(1)\n", " encodings = torch.zeros(encoding_indices.shape[0], self._num_embeddings, device=inputs.device)\n", " encodings.scatter_(1, encoding_indices, 1)\n", " \n", " # Quantize and unflatten\n", " quantized = torch.matmul(encodings, self._embedding.weight).view(input_shape)\n", " \n", " # Loss\n", " e_latent_loss = F.mse_loss(quantized.detach(), inputs)\n", " q_latent_loss = F.mse_loss(quantized, inputs.detach())\n", " loss = q_latent_loss + self._commitment_cost * e_latent_loss\n", " \n", " quantized = inputs + (quantized - inputs).detach()\n", " avg_probs = torch.mean(encodings, dim=0)\n", " perplexity = torch.exp(-torch.sum(avg_probs * torch.log(avg_probs + 1e-10)))\n", " \n", " # convert quantized from BHWC -> BCHW\n", " return loss, quantized.permute(0, 3, 1, 2).contiguous(), perplexity, encodings" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will also implement a slightly modified version which will use exponential moving averages to update the embedding vectors instead of an auxillary loss. This has the advantage that the embedding updates are independent of the choice of optimizer for the encoder, decoder and other parts of the architecture. For most experiments the EMA version trains faster than the non-EMA version." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "class VectorQuantizerEMA(nn.Module):\n", " def __init__(self, num_embeddings, embedding_dim, commitment_cost, decay, epsilon=1e-5):\n", " super(VectorQuantizerEMA, self).__init__()\n", " \n", " self._embedding_dim = embedding_dim\n", " self._num_embeddings = num_embeddings\n", " \n", " self._embedding = nn.Embedding(self._num_embeddings, self._embedding_dim)\n", " self._embedding.weight.data.normal_()\n", " self._commitment_cost = commitment_cost\n", " \n", " self.register_buffer('_ema_cluster_size', torch.zeros(num_embeddings))\n", " self._ema_w = nn.Parameter(torch.Tensor(num_embeddings, self._embedding_dim))\n", " self._ema_w.data.normal_()\n", " \n", " self._decay = decay\n", " self._epsilon = epsilon\n", "\n", " def forward(self, inputs):\n", " # convert inputs from BCHW -> BHWC\n", " inputs = inputs.permute(0, 2, 3, 1).contiguous()\n", " input_shape = inputs.shape\n", " \n", " # Flatten input\n", " flat_input = inputs.view(-1, self._embedding_dim)\n", " \n", " # Calculate distances\n", " distances = (torch.sum(flat_input**2, dim=1, keepdim=True) \n", " + torch.sum(self._embedding.weight**2, dim=1)\n", " - 2 * torch.matmul(flat_input, self._embedding.weight.t()))\n", " \n", " # Encoding\n", " encoding_indices = torch.argmin(distances, dim=1).unsqueeze(1)\n", " encodings = torch.zeros(encoding_indices.shape[0], self._num_embeddings, device=inputs.device)\n", " encodings.scatter_(1, encoding_indices, 1)\n", " \n", " # Quantize and unflatten\n", " quantized = torch.matmul(encodings, self._embedding.weight).view(input_shape)\n", " \n", " # Use EMA to update the embedding vectors\n", " if self.training:\n", " self._ema_cluster_size = self._ema_cluster_size * self._decay + \\\n", " (1 - self._decay) * torch.sum(encodings, 0)\n", " \n", " # Laplace smoothing of the cluster size\n", " n = torch.sum(self._ema_cluster_size.data)\n", " self._ema_cluster_size = (\n", " (self._ema_cluster_size + self._epsilon)\n", " / (n + self._num_embeddings * self._epsilon) * n)\n", " \n", " dw = torch.matmul(encodings.t(), flat_input)\n", " self._ema_w = nn.Parameter(self._ema_w * self._decay + (1 - self._decay) * dw)\n", " \n", " self._embedding.weight = nn.Parameter(self._ema_w / self._ema_cluster_size.unsqueeze(1))\n", " \n", " # Loss\n", " e_latent_loss = F.mse_loss(quantized.detach(), inputs)\n", " loss = self._commitment_cost * e_latent_loss\n", " \n", " # Straight Through Estimator\n", " quantized = inputs + (quantized - inputs).detach()\n", " avg_probs = torch.mean(encodings, dim=0)\n", " perplexity = torch.exp(-torch.sum(avg_probs * torch.log(avg_probs + 1e-10)))\n", " \n", " # convert quantized from BHWC -> BCHW\n", " return loss, quantized.permute(0, 3, 1, 2).contiguous(), perplexity, encodings" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Encoder & Decoder Architecture\n", "\n", "The encoder and decoder architecture is based on a ResNet and is implemented below:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "class Residual(nn.Module):\n", " def __init__(self, in_channels, num_hiddens, num_residual_hiddens):\n", " super(Residual, self).__init__()\n", " self._block = nn.Sequential(\n", " nn.ReLU(True),\n", " nn.Conv2d(in_channels=in_channels,\n", " out_channels=num_residual_hiddens,\n", " kernel_size=3, stride=1, padding=1, bias=False),\n", " nn.ReLU(True),\n", " nn.Conv2d(in_channels=num_residual_hiddens,\n", " out_channels=num_hiddens,\n", " kernel_size=1, stride=1, bias=False)\n", " )\n", " \n", " def forward(self, x):\n", " return x + self._block(x)\n", "\n", "\n", "class ResidualStack(nn.Module):\n", " def __init__(self, in_channels, num_hiddens, num_residual_layers, num_residual_hiddens):\n", " super(ResidualStack, self).__init__()\n", " self._num_residual_layers = num_residual_layers\n", " self._layers = nn.ModuleList([Residual(in_channels, num_hiddens, num_residual_hiddens)\n", " for _ in range(self._num_residual_layers)])\n", "\n", " def forward(self, x):\n", " for i in range(self._num_residual_layers):\n", " x = self._layers[i](x)\n", " return F.relu(x)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "class Encoder(nn.Module):\n", " def __init__(self, in_channels, num_hiddens, num_residual_layers, num_residual_hiddens):\n", " super(Encoder, self).__init__()\n", "\n", " self._conv_1 = nn.Conv2d(in_channels=in_channels,\n", " out_channels=num_hiddens//2,\n", " kernel_size=4,\n", " stride=2, padding=1)\n", " self._conv_2 = nn.Conv2d(in_channels=num_hiddens//2,\n", " out_channels=num_hiddens,\n", " kernel_size=4,\n", " stride=2, padding=1)\n", " self._conv_3 = nn.Conv2d(in_channels=num_hiddens,\n", " out_channels=num_hiddens,\n", " kernel_size=3,\n", " stride=1, padding=1)\n", " self._residual_stack = ResidualStack(in_channels=num_hiddens,\n", " num_hiddens=num_hiddens,\n", " num_residual_layers=num_residual_layers,\n", " num_residual_hiddens=num_residual_hiddens)\n", "\n", " def forward(self, inputs):\n", " x = self._conv_1(inputs)\n", " x = F.relu(x)\n", " \n", " x = self._conv_2(x)\n", " x = F.relu(x)\n", " \n", " x = self._conv_3(x)\n", " return self._residual_stack(x)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "class Decoder(nn.Module):\n", " def __init__(self, in_channels, num_hiddens, num_residual_layers, num_residual_hiddens):\n", " super(Decoder, self).__init__()\n", " \n", " self._conv_1 = nn.Conv2d(in_channels=in_channels,\n", " out_channels=num_hiddens,\n", " kernel_size=3, \n", " stride=1, padding=1)\n", " \n", " self._residual_stack = ResidualStack(in_channels=num_hiddens,\n", " num_hiddens=num_hiddens,\n", " num_residual_layers=num_residual_layers,\n", " num_residual_hiddens=num_residual_hiddens)\n", " \n", " self._conv_trans_1 = nn.ConvTranspose2d(in_channels=num_hiddens, \n", " out_channels=num_hiddens//2,\n", " kernel_size=4, \n", " stride=2, padding=1)\n", " \n", " self._conv_trans_2 = nn.ConvTranspose2d(in_channels=num_hiddens//2, \n", " out_channels=3,\n", " kernel_size=4, \n", " stride=2, padding=1)\n", "\n", " def forward(self, inputs):\n", " x = self._conv_1(inputs)\n", " \n", " x = self._residual_stack(x)\n", " \n", " x = self._conv_trans_1(x)\n", " x = F.relu(x)\n", " \n", " return self._conv_trans_2(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Train\n", "\n", "We use the hyperparameters from the author's code:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "batch_size = 256\n", "num_training_updates = 15000\n", "\n", "num_hiddens = 128\n", "num_residual_hiddens = 32\n", "num_residual_layers = 2\n", "\n", "embedding_dim = 64\n", "num_embeddings = 512\n", "\n", "commitment_cost = 0.25\n", "\n", "decay = 0.99\n", "\n", "learning_rate = 1e-3" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "training_loader = DataLoader(training_data, \n", " batch_size=batch_size, \n", " shuffle=True,\n", " pin_memory=True)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "validation_loader = DataLoader(validation_data,\n", " batch_size=32,\n", " shuffle=True,\n", " pin_memory=True)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "class Model(nn.Module):\n", " def __init__(self, num_hiddens, num_residual_layers, num_residual_hiddens, \n", " num_embeddings, embedding_dim, commitment_cost, decay=0):\n", " super(Model, self).__init__()\n", " \n", " self._encoder = Encoder(3, num_hiddens,\n", " num_residual_layers, \n", " num_residual_hiddens)\n", " self._pre_vq_conv = nn.Conv2d(in_channels=num_hiddens, \n", " out_channels=embedding_dim,\n", " kernel_size=1, \n", " stride=1)\n", " if decay > 0.0:\n", " self._vq_vae = VectorQuantizerEMA(num_embeddings, embedding_dim, \n", " commitment_cost, decay)\n", " else:\n", " self._vq_vae = VectorQuantizer(num_embeddings, embedding_dim,\n", " commitment_cost)\n", " self._decoder = Decoder(embedding_dim,\n", " num_hiddens, \n", " num_residual_layers, \n", " num_residual_hiddens)\n", "\n", " def forward(self, x):\n", " z = self._encoder(x)\n", " z = self._pre_vq_conv(z)\n", " loss, quantized, perplexity, _ = self._vq_vae(z)\n", " x_recon = self._decoder(quantized)\n", "\n", " return loss, x_recon, perplexity" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "model = Model(num_hiddens, num_residual_layers, num_residual_hiddens,\n", " num_embeddings, embedding_dim, \n", " commitment_cost, decay).to(device)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "optimizer = optim.Adam(model.parameters(), lr=learning_rate, amsgrad=False)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "model.train()\n", "train_res_recon_error = []\n", "train_res_perplexity = []\n", "\n", "for i in xrange(num_training_updates):\n", " (data, _) = next(iter(training_loader))\n", " data = data.to(device)\n", " optimizer.zero_grad()\n", "\n", " vq_loss, data_recon, perplexity = model(data)\n", " recon_error = F.mse_loss(data_recon, data) / data_variance\n", " loss = recon_error + vq_loss\n", " loss.backward()\n", "\n", " optimizer.step()\n", " \n", " train_res_recon_error.append(recon_error.item())\n", " train_res_perplexity.append(perplexity.item())\n", "\n", " if (i+1) % 100 == 0:\n", " print('%d iterations' % (i+1))\n", " print('recon_error: %.3f' % np.mean(train_res_recon_error[-100:]))\n", " print('perplexity: %.3f' % np.mean(train_res_perplexity[-100:]))\n", " print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plot Loss" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "train_res_recon_error_smooth = savgol_filter(train_res_recon_error, 201, 7)\n", "train_res_perplexity_smooth = savgol_filter(train_res_perplexity, 201, 7)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0.5, 0, 'iteration')" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "f = plt.figure(figsize=(16,8))\n", "ax = f.add_subplot(1,2,1)\n", "ax.plot(train_res_recon_error_smooth)\n", "ax.set_yscale('log')\n", "ax.set_title('Smoothed NMSE.')\n", "ax.set_xlabel('iteration')\n", "\n", "ax = f.add_subplot(1,2,2)\n", "ax.plot(train_res_perplexity_smooth)\n", "ax.set_title('Smoothed Average codebook usage (perplexity).')\n", "ax.set_xlabel('iteration')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## View Reconstructions" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "model.eval()\n", "\n", "(valid_originals, _) = next(iter(validation_loader))\n", "valid_originals = valid_originals.to(device)\n", "\n", "vq_output_eval = model._pre_vq_conv(model._encoder(valid_originals))\n", "_, valid_quantize, _, _ = model._vq_vae(vq_output_eval)\n", "valid_reconstructions = model._decoder(valid_quantize)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "(train_originals, _) = next(iter(training_loader))\n", "train_originals = train_originals.to(device)\n", "_, train_reconstructions, _, _ = model._vq_vae(train_originals)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "def show(img):\n", " npimg = img.numpy()\n", " fig = plt.imshow(np.transpose(npimg, (1,2,0)), interpolation='nearest')\n", " fig.axes.get_xaxis().set_visible(False)\n", " fig.axes.get_yaxis().set_visible(False)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "show(make_grid(valid_reconstructions.cpu().data)+0.5, )" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "show(make_grid(valid_originals.cpu()+0.5))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## View Embedding" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "proj = umap.UMAP(n_neighbors=3,\n", " min_dist=0.1,\n", " metric='cosine').fit_transform(model._vq_vae._embedding.weight.data.cpu())" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.scatter(proj[:,0], proj[:,1], alpha=0.3)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "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.6.7" } }, "nbformat": 4, "nbformat_minor": 2 }