02_train_tcn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.vision.all import *\n",
    "from moving_mnist.models.tcn import *\n",
    "from moving_mnist.models.conv_rnn import *\n",
    "from moving_mnist.data import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.backends.cudnn.benchmark = False\n",
    "torch.backends.cudnn.deterministic = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quadro RTX 8000\n"
     ]
    }
   ],
   "source": [
    "if torch.cuda.is_available():\n",
    "    torch.cuda.set_device(0)\n",
    "    print(torch.cuda.get_device_name())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train TCN Example:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We wil predict:\n",
    "- `n_in`: 5 images\n",
    "- `n_out`: 5 images  \n",
    "- `n_obj`: up to 3 objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Path('/home/tcapelle/SteadySun/moving_mnist')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Path.cwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = Path.cwd()/'data'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds = MovingMNIST(DATA_PATH, n_in=5, n_out=5, n_obj=[1,2], th=0.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_tl = TfmdLists(range(7500), ImageTupleTransform(ds, cl_type=TensorMask))\n",
    "valid_tl = TfmdLists(range(100), ImageTupleTransform(ds, cl_type=TensorMask))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "dls = DataLoaders.from_dsets(train_tl, valid_tl, bs=64,\n",
    "                             after_batch=[Normalize.from_stats(imagenet_stats[0][0], \n",
    "                                                               imagenet_stats[1][0])]).cuda()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_func = StackLoss(CrossEntropyLossFlat(axis=1))\n",
    "metrics = [MultiImageDice(axis=1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Left: Input, Right: Target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x777.6 with 18 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dls.show_batch()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Baseline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`StackUnstack` takes cares of stacking the list of images into a fat tensor, and unstacking them at the end, we will need to modify our loss function to take a list of tensors as input and target."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "stcn = SimpleTCN2(n_out=2, ks=3, dilation=1, debug=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SimpleTCN2(\n",
       "  (coord): TimeDistributed(CoordConv(\n",
       "    (addcoords): AddCoords()\n",
       "    (conv): Conv2d(4, 8, kernel_size=(1, 1), stride=(1, 1))\n",
       "  ))\n",
       "  (conv0): TimeDistributed(ConvLayer(\n",
       "    (0): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "    (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "  ))\n",
       "  (tcn1): TemporalBlock3D(\n",
       "    (conv1): Conv3d(16, 16, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "    (chomp1): Chomp(2)\n",
       "    (relu1): ReLU()\n",
       "    (dropout1): Dropout(p=0.2, inplace=False)\n",
       "    (conv2): Conv3d(16, 16, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "    (chomp2): Chomp(2)\n",
       "    (relu2): ReLU()\n",
       "    (dropout2): Dropout(p=0.2, inplace=False)\n",
       "    (net): Sequential(\n",
       "      (0): Conv3d(16, 16, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "      (1): Chomp(2)\n",
       "      (2): ReLU()\n",
       "      (3): Dropout(p=0.2, inplace=False)\n",
       "      (4): Conv3d(16, 16, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "      (5): Chomp(2)\n",
       "      (6): ReLU()\n",
       "      (7): Dropout(p=0.2, inplace=False)\n",
       "    )\n",
       "    (relu): ReLU()\n",
       "  )\n",
       "  (conv1): TimeDistributed(ConvLayer(\n",
       "    (0): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "    (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "  ))\n",
       "  (tcn2): TemporalBlock3D(\n",
       "    (conv1): Conv3d(32, 32, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "    (chomp1): Chomp(2)\n",
       "    (relu1): ReLU()\n",
       "    (dropout1): Dropout(p=0.2, inplace=False)\n",
       "    (conv2): Conv3d(32, 32, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "    (chomp2): Chomp(2)\n",
       "    (relu2): ReLU()\n",
       "    (dropout2): Dropout(p=0.2, inplace=False)\n",
       "    (net): Sequential(\n",
       "      (0): Conv3d(32, 32, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "      (1): Chomp(2)\n",
       "      (2): ReLU()\n",
       "      (3): Dropout(p=0.2, inplace=False)\n",
       "      (4): Conv3d(32, 32, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "      (5): Chomp(2)\n",
       "      (6): ReLU()\n",
       "      (7): Dropout(p=0.2, inplace=False)\n",
       "    )\n",
       "    (relu): ReLU()\n",
       "  )\n",
       "  (conv2): TimeDistributed(ConvLayer(\n",
       "    (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "    (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "  ))\n",
       "  (tcn3): TemporalBlock3D(\n",
       "    (conv1): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "    (chomp1): Chomp(2)\n",
       "    (relu1): ReLU()\n",
       "    (dropout1): Dropout(p=0.2, inplace=False)\n",
       "    (conv2): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "    (chomp2): Chomp(2)\n",
       "    (relu2): ReLU()\n",
       "    (dropout2): Dropout(p=0.2, inplace=False)\n",
       "    (net): Sequential(\n",
       "      (0): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "      (1): Chomp(2)\n",
       "      (2): ReLU()\n",
       "      (3): Dropout(p=0.2, inplace=False)\n",
       "      (4): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "      (5): Chomp(2)\n",
       "      (6): ReLU()\n",
       "      (7): Dropout(p=0.2, inplace=False)\n",
       "    )\n",
       "    (relu): ReLU()\n",
       "  )\n",
       "  (tcn1_u): TemporalBlock3D(\n",
       "    (conv1): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "    (chomp1): Chomp(2)\n",
       "    (relu1): ReLU()\n",
       "    (dropout1): Dropout(p=0.2, inplace=False)\n",
       "    (conv2): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "    (chomp2): Chomp(2)\n",
       "    (relu2): ReLU()\n",
       "    (dropout2): Dropout(p=0.2, inplace=False)\n",
       "    (net): Sequential(\n",
       "      (0): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "      (1): Chomp(2)\n",
       "      (2): ReLU()\n",
       "      (3): Dropout(p=0.2, inplace=False)\n",
       "      (4): Conv3d(64, 64, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "      (5): Chomp(2)\n",
       "      (6): ReLU()\n",
       "      (7): Dropout(p=0.2, inplace=False)\n",
       "    )\n",
       "    (relu): ReLU()\n",
       "  )\n",
       "  (conv1_u): TimeDistributed(ConvLayer(\n",
       "    (0): Conv2d(64, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "    (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "  ))\n",
       "  (tcn2_u): TemporalBlock3D(\n",
       "    (conv1): Conv3d(32, 32, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "    (chomp1): Chomp(2)\n",
       "    (relu1): ReLU()\n",
       "    (dropout1): Dropout(p=0.2, inplace=False)\n",
       "    (conv2): Conv3d(32, 32, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "    (chomp2): Chomp(2)\n",
       "    (relu2): ReLU()\n",
       "    (dropout2): Dropout(p=0.2, inplace=False)\n",
       "    (net): Sequential(\n",
       "      (0): Conv3d(32, 32, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "      (1): Chomp(2)\n",
       "      (2): ReLU()\n",
       "      (3): Dropout(p=0.2, inplace=False)\n",
       "      (4): Conv3d(32, 32, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "      (5): Chomp(2)\n",
       "      (6): ReLU()\n",
       "      (7): Dropout(p=0.2, inplace=False)\n",
       "    )\n",
       "    (relu): ReLU()\n",
       "  )\n",
       "  (conv2_u): TimeDistributed(ConvLayer(\n",
       "    (0): Conv2d(32, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "    (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "  ))\n",
       "  (tcn3_u): TemporalBlock3D(\n",
       "    (conv1): Conv3d(16, 16, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "    (chomp1): Chomp(2)\n",
       "    (relu1): ReLU()\n",
       "    (dropout1): Dropout(p=0.2, inplace=False)\n",
       "    (conv2): Conv3d(16, 16, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "    (chomp2): Chomp(2)\n",
       "    (relu2): ReLU()\n",
       "    (dropout2): Dropout(p=0.2, inplace=False)\n",
       "    (net): Sequential(\n",
       "      (0): Conv3d(16, 16, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "      (1): Chomp(2)\n",
       "      (2): ReLU()\n",
       "      (3): Dropout(p=0.2, inplace=False)\n",
       "      (4): Conv3d(16, 16, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(2, 1, 1))\n",
       "      (5): Chomp(2)\n",
       "      (6): ReLU()\n",
       "      (7): Dropout(p=0.2, inplace=False)\n",
       "    )\n",
       "    (relu): ReLU()\n",
       "  )\n",
       "  (conv3_u): TimeDistributed(ConvLayer(\n",
       "    (0): Conv2d(16, 2, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "    (1): BatchNorm2d(2, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (2): ReLU()\n",
       "  ))\n",
       ")"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stcn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = StackUnstack(stcn, dim=2).cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the `ImageSeq` is a `tuple` of images, we will need to stack them to compute loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = Learner(dls, model, loss_func=loss_func, metrics=metrics, cbs=[]).to_fp16(clip=0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I have a weird bug that if I use `nn.LeakyReLU` after doing `learn.lr_find()` the model does not train (the loss get stucked)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "SuggestedLRs(lr_min=0.025118863582611083, lr_steep=0.2089296132326126)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.lr_find()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>multi_image_dice</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.571504</td>\n",
       "      <td>0.588817</td>\n",
       "      <td>0.075377</td>\n",
       "      <td>02:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.347385</td>\n",
       "      <td>0.470351</td>\n",
       "      <td>0.089331</td>\n",
       "      <td>02:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.255519</td>\n",
       "      <td>0.358165</td>\n",
       "      <td>0.092990</td>\n",
       "      <td>02:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.167979</td>\n",
       "      <td>0.159381</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>02:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.149714</td>\n",
       "      <td>0.148397</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>02:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>0.140571</td>\n",
       "      <td>0.138163</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>02:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>0.140633</td>\n",
       "      <td>0.137556</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>02:25</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>0.141677</td>\n",
       "      <td>0.145260</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>02:25</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.fit_one_cycle(8, 1e-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p,t = learn.get_preds(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the results is a list of 5 tensors with 100 samples each."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, torch.Size([100, 2, 64, 64]))"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(p), p[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_res(t, idx, argmax=False):\n",
    "    if argmax:\n",
    "        im_seq = ImageSeq.create([t[i][idx].argmax(0).unsqueeze(0) for i in range(5)], TensorMask)\n",
    "    else:\n",
    "        im_seq = ImageSeq.create([t[i][idx] for i in range(5)])\n",
    "    im_seq.show(figsize=(8,4));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcwAAABnCAYAAACNd3IfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAABxElEQVR4nO3XsQ3CQBBFQYwohH5oiMwioyH6oZOlAWS9CBtpJrxLfva0y8ycAIBt570HAMA/EEwACAQTAALBBIBAMAEgEEwACC5bn9f7a/3VEAA4gvfz9vj27sIEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAAsEEgEAwASAQTAAIBBMAgmVm9t4AAIfnwgSAQDABIBBMAAgEEwACwQSAQDABIPgA1csKyc+RHVoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "k = random.randint(0,99)\n",
    "show_res(t,k)\n",
    "show_res(p,k, True)"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}