vgg16_augmentation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4af7d8d2",
   "metadata": {},
   "source": [
    "# Augmenting vggnet with new classes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c58d2c45",
   "metadata": {},
   "source": [
    "## Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0c9a73b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "185dadef",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/youi/.local/lib/python3.10/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow_datasets as tfds\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from tensorflow.keras.applications.vgg16 import VGG16\n",
    "from tensorflow.keras.applications.vgg16 import preprocess_input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fa54e902",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Loading images and labels\n",
    "((train_ds, train_labels), (test_ds, test_labels)), dataset_info = tfds.load(\n",
    "    \"tf_flowers\",\n",
    "    split=[\"train[:70%]\", \"train[70%:]\"], ## Train test split\n",
    "    shuffle_files=True,\n",
    "    with_info=True,\n",
    "    batch_size=-1,\n",
    "    as_supervised=True,  # Include labels\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b16f4df3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2569, 442, 1024, 3)\n",
      "(1101, 441, 640, 3)\n"
     ]
    }
   ],
   "source": [
    "print(train_ds.shape)\n",
    "print(test_ds.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "20eaa4de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dandelion', 'daisy', 'tulips', 'sunflowers', 'roses']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset_info.features['label'].names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f29a8e32",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import matplotlib.pyplot as plt\n",
    "# plt.figure()\n",
    "# plt.imshow(test_ds[0].numpy().astype(\"uint8\"))\n",
    "# #plt.title(test_labels[0])\n",
    "# plt.axis(\"off\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e7f970d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Resizing images\n",
    "train_ds = tf.image.resize(train_ds, (224, 224))\n",
    "test_ds = tf.image.resize(test_ds, (224, 224))\n",
    "\n",
    "## Transforming labels to correct format\n",
    "train_labels = to_categorical(train_labels, num_classes=5)\n",
    "test_labels = to_categorical(test_labels, num_classes=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ed950cab",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Preprocessing input\n",
    "train_ds = preprocess_input(train_ds) \n",
    "test_ds = preprocess_input(test_ds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25a3ed52",
   "metadata": {},
   "source": [
    "## Load model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "283e0136",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Loading VGG16 model\n",
    "base_model = VGG16(weights=\"imagenet\", include_top=False)#, input_shape=train_ds[0].shape)\n",
    "base_model.trainable = False ## Not trainable weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5e56c3ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Loading VGG16 model\n",
    "base_model = VGG16(weights=\"imagenet\", include_top=True, input_shape=train_ds[0].shape)\n",
    "base_model.trainable = False ## Not trainable weights\n",
    "\n",
    "## Preprocessing input\n",
    "train_ds = preprocess_input(train_ds) \n",
    "test_ds = preprocess_input(test_ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "73589f7e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"vgg16\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_2 (InputLayer)        [(None, 224, 224, 3)]     0         \n",
      "                                                                 \n",
      " block1_conv1 (Conv2D)       (None, 224, 224, 64)      1792      \n",
      "                                                                 \n",
      " block1_conv2 (Conv2D)       (None, 224, 224, 64)      36928     \n",
      "                                                                 \n",
      " block1_pool (MaxPooling2D)  (None, 112, 112, 64)      0         \n",
      "                                                                 \n",
      " block2_conv1 (Conv2D)       (None, 112, 112, 128)     73856     \n",
      "                                                                 \n",
      " block2_conv2 (Conv2D)       (None, 112, 112, 128)     147584    \n",
      "                                                                 \n",
      " block2_pool (MaxPooling2D)  (None, 56, 56, 128)       0         \n",
      "                                                                 \n",
      " block3_conv1 (Conv2D)       (None, 56, 56, 256)       295168    \n",
      "                                                                 \n",
      " block3_conv2 (Conv2D)       (None, 56, 56, 256)       590080    \n",
      "                                                                 \n",
      " block3_conv3 (Conv2D)       (None, 56, 56, 256)       590080    \n",
      "                                                                 \n",
      " block3_pool (MaxPooling2D)  (None, 28, 28, 256)       0         \n",
      "                                                                 \n",
      " block4_conv1 (Conv2D)       (None, 28, 28, 512)       1180160   \n",
      "                                                                 \n",
      " block4_conv2 (Conv2D)       (None, 28, 28, 512)       2359808   \n",
      "                                                                 \n",
      " block4_conv3 (Conv2D)       (None, 28, 28, 512)       2359808   \n",
      "                                                                 \n",
      " block4_pool (MaxPooling2D)  (None, 14, 14, 512)       0         \n",
      "                                                                 \n",
      " block5_conv1 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
      "                                                                 \n",
      " block5_conv2 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
      "                                                                 \n",
      " block5_conv3 (Conv2D)       (None, 14, 14, 512)       2359808   \n",
      "                                                                 \n",
      " block5_pool (MaxPooling2D)  (None, 7, 7, 512)         0         \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 25088)             0         \n",
      "                                                                 \n",
      " fc1 (Dense)                 (None, 4096)              102764544 \n",
      "                                                                 \n",
      " fc2 (Dense)                 (None, 4096)              16781312  \n",
      "                                                                 \n",
      " predictions (Dense)         (None, 1000)              4097000   \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 138,357,544\n",
      "Trainable params: 0\n",
      "Non-trainable params: 138,357,544\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "base_model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec8164aa",
   "metadata": {},
   "source": [
    "### create headless model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4b3c94ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "headless_model=tf.keras.models.Sequential()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e62a5929",
   "metadata": {},
   "outputs": [],
   "source": [
    "for layer in base_model.layers[:-1]:\n",
    "    headless_model.add(layer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b7d18438",
   "metadata": {},
   "outputs": [],
   "source": [
    "headless_model.trainable=False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ec9fbec4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# train_ds.shape[1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ce8b804",
   "metadata": {},
   "source": [
    "### create finetune model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "73c03c9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "headless_inputs=tf.keras.Input(shape=train_ds.shape[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "45b179ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=headless_model(headless_inputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "1a2471ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "outputs= tf.keras.layers.Dense(5)(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "5cebefa9",
   "metadata": {},
   "outputs": [],
   "source": [
    "finetune_model=tf.keras.Model(headless_inputs,outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "ec7857f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<keras.engine.input_layer.InputLayer object at 0x7fa709312ec0>                             trainable\n",
      "<keras.engine.sequential.Sequential object at 0x7fa709343a00>                              non-trainable\n",
      "<keras.layers.core.dense.Dense object at 0x7fa6fdf161a0>                                   trainable\n"
     ]
    }
   ],
   "source": [
    "for layer in finetune_model.layers:\n",
    "    print('{:90s} {}'.format(str(layer),'trainable' if layer.trainable else 'non-trainable'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "fa5c6210",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_3 (InputLayer)        [(None, 224, 224, 3)]     0         \n",
      "                                                                 \n",
      " sequential (Sequential)     (None, 4096)              134260544 \n",
      "                                                                 \n",
      " dense (Dense)               (None, 5)                 20485     \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 134,281,029\n",
      "Trainable params: 20,485\n",
      "Non-trainable params: 134,260,544\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "finetune_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "5545557f",
   "metadata": {},
   "outputs": [],
   "source": [
    "finetune_model.compile(optimizer=tf.keras.optimizers.Adam(),\n",
    "              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),\n",
    "              metrics=[tf.keras.metrics.CategoricalAccuracy()])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0bd590b7",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "81/81 [==============================] - 12s 108ms/step - loss: 1.1913 - categorical_accuracy: 0.5761\n",
      "Epoch 2/10\n",
      "81/81 [==============================] - 9s 106ms/step - loss: 0.7278 - categorical_accuracy: 0.7182\n",
      "Epoch 3/10\n",
      "81/81 [==============================] - 8s 105ms/step - loss: 0.6760 - categorical_accuracy: 0.7450\n",
      "Epoch 4/10\n",
      "81/81 [==============================] - 9s 105ms/step - loss: 0.5768 - categorical_accuracy: 0.7820\n",
      "Epoch 5/10\n",
      "81/81 [==============================] - 10s 126ms/step - loss: 0.4883 - categorical_accuracy: 0.8139\n",
      "Epoch 6/10\n",
      "81/81 [==============================] - 9s 105ms/step - loss: 0.4374 - categorical_accuracy: 0.8392\n",
      "Epoch 7/10\n",
      "81/81 [==============================] - 9s 106ms/step - loss: 0.4176 - categorical_accuracy: 0.8478\n",
      "Epoch 8/10\n",
      "81/81 [==============================] - 8s 104ms/step - loss: 0.3736 - categorical_accuracy: 0.8645\n",
      "Epoch 9/10\n",
      "81/81 [==============================] - 8s 104ms/step - loss: 0.3416 - categorical_accuracy: 0.8805\n",
      "Epoch 10/10\n",
      "81/81 [==============================] - 8s 103ms/step - loss: 0.3059 - categorical_accuracy: 0.8898\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x7fa70816f6d0>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "finetune_model.fit(train_ds,train_labels,epochs=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "efd3614c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35/35 [==============================] - 5s 116ms/step - loss: 0.9705 - categorical_accuracy: 0.7184\n"
     ]
    }
   ],
   "source": [
    "results = finetune_model.evaluate(test_ds,test_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "b08e391d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "411328a1",
   "metadata": {},
   "source": [
    "### Rebuild vgg model with new classes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d30b4cf4",
   "metadata": {},
   "source": [
    "can be done in two ways:\n",
    "- using concatenate layer, requires the use of a functional model (the method we use)\n",
    "- using weight transfer (via get_weights() and set_weights()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "04be020a",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=tf.keras.Input(shape=train_ds.shape[1:])\n",
    "headless_inputs=x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "e08ab9fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "for layer in base_model.layers[:-1]:\n",
    "    x=layer(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "1a36b432",
   "metadata": {},
   "outputs": [],
   "source": [
    "# concat headless_outputs w/ base_model outputs\n",
    "new_outputs=tf.keras.layers.Concatenate()([base_model.layers[-1](x),finetune_model.layers[-1](x)])\n",
    "new_outputs=tf.nn.softmax(new_outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "daf6bba0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<KerasTensor: shape=(None, 1005) dtype=float32 (created by layer 'tf.nn.softmax')>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "247d251a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#new_model.add(new_outputs)#\n",
    "new_model=tf.keras.Model(headless_inputs,new_outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "ae5ba4d8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_1\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_4 (InputLayer)           [(None, 224, 224, 3  0           []                               \n",
      "                                )]                                                                \n",
      "                                                                                                  \n",
      " input_2 (InputLayer)           multiple             0           ['input_4[0][0]']                \n",
      "                                                                                                  \n",
      " block1_conv1 (Conv2D)          (None, 224, 224, 64  1792        ['input_2[1][0]']                \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " block1_conv2 (Conv2D)          (None, 224, 224, 64  36928       ['block1_conv1[2][0]']           \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " block1_pool (MaxPooling2D)     (None, 112, 112, 64  0           ['block1_conv2[2][0]']           \n",
      "                                )                                                                 \n",
      "                                                                                                  \n",
      " block2_conv1 (Conv2D)          (None, 112, 112, 12  73856       ['block1_pool[2][0]']            \n",
      "                                8)                                                                \n",
      "                                                                                                  \n",
      " block2_conv2 (Conv2D)          (None, 112, 112, 12  147584      ['block2_conv1[2][0]']           \n",
      "                                8)                                                                \n",
      "                                                                                                  \n",
      " block2_pool (MaxPooling2D)     (None, 56, 56, 128)  0           ['block2_conv2[2][0]']           \n",
      "                                                                                                  \n",
      " block3_conv1 (Conv2D)          (None, 56, 56, 256)  295168      ['block2_pool[2][0]']            \n",
      "                                                                                                  \n",
      " block3_conv2 (Conv2D)          (None, 56, 56, 256)  590080      ['block3_conv1[2][0]']           \n",
      "                                                                                                  \n",
      " block3_conv3 (Conv2D)          (None, 56, 56, 256)  590080      ['block3_conv2[2][0]']           \n",
      "                                                                                                  \n",
      " block3_pool (MaxPooling2D)     (None, 28, 28, 256)  0           ['block3_conv3[2][0]']           \n",
      "                                                                                                  \n",
      " block4_conv1 (Conv2D)          (None, 28, 28, 512)  1180160     ['block3_pool[2][0]']            \n",
      "                                                                                                  \n",
      " block4_conv2 (Conv2D)          (None, 28, 28, 512)  2359808     ['block4_conv1[2][0]']           \n",
      "                                                                                                  \n",
      " block4_conv3 (Conv2D)          (None, 28, 28, 512)  2359808     ['block4_conv2[2][0]']           \n",
      "                                                                                                  \n",
      " block4_pool (MaxPooling2D)     (None, 14, 14, 512)  0           ['block4_conv3[2][0]']           \n",
      "                                                                                                  \n",
      " block5_conv1 (Conv2D)          (None, 14, 14, 512)  2359808     ['block4_pool[2][0]']            \n",
      "                                                                                                  \n",
      " block5_conv2 (Conv2D)          (None, 14, 14, 512)  2359808     ['block5_conv1[2][0]']           \n",
      "                                                                                                  \n",
      " block5_conv3 (Conv2D)          (None, 14, 14, 512)  2359808     ['block5_conv2[2][0]']           \n",
      "                                                                                                  \n",
      " block5_pool (MaxPooling2D)     (None, 7, 7, 512)    0           ['block5_conv3[2][0]']           \n",
      "                                                                                                  \n",
      " flatten (Flatten)              (None, 25088)        0           ['block5_pool[2][0]']            \n",
      "                                                                                                  \n",
      " fc1 (Dense)                    (None, 4096)         102764544   ['flatten[2][0]']                \n",
      "                                                                                                  \n",
      " fc2 (Dense)                    (None, 4096)         16781312    ['fc1[2][0]']                    \n",
      "                                                                                                  \n",
      " predictions (Dense)            (None, 1000)         4097000     ['fc2[2][0]']                    \n",
      "                                                                                                  \n",
      " dense (Dense)                  (None, 5)            20485       ['fc2[2][0]']                    \n",
      "                                                                                                  \n",
      " concatenate (Concatenate)      (None, 1005)         0           ['predictions[1][0]',            \n",
      "                                                                  'dense[1][0]']                  \n",
      "                                                                                                  \n",
      " tf.nn.softmax (TFOpLambda)     (None, 1005)         0           ['concatenate[0][0]']            \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 138,378,029\n",
      "Trainable params: 20,485\n",
      "Non-trainable params: 138,357,544\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "new_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "cd41de26",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(None, 1005)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_model.layers[-1].output_shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "28cd0080",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_image=tf.expand_dims(train_ds[0], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "1ab6b4c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "res=new_model(test_image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "d78f1cb2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1001"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.math.argmax(res,axis=1)[0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "db030c45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.math.argmax(train_labels[0]).numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4507c04",
   "metadata": {},
   "source": [
    "### additional tasks\n",
    "now that the model is complete, better accuracy can be obtained by unfreezing the classification network and fine-tuning it on a dataset containing all labels.\n",
    "other utility functions can also be implemented (e.g. decode_predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e49b2d70",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}