CognitiveRobotics_DeepLearning.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "40lpJYISQ4fp"
      },
      "source": [
        "# 34212-Lab-S-Report \n",
        "This notebook will explore the use of a Deep Neural Network to classify objects in the iCubWorld robotics vision dataset."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1c5t_G-RRV77"
      },
      "source": [
        "## Obtaining datasets\n",
        "\n",
        "Dataset consists of 200 objects divided into 20 categories. Each object has 10 aquisitions (~3600 images per object). \n",
        "\n",
        "Objects:\n",
        "\n",
        "'body lotion', 'book', 'cellphone', 'flower', 'glass', 'hairbrush', 'hair clip', 'mouse', 'mug', 'oven glove', 'pencil case', 'perfume', 'remote', 'ring binder', 'soap dispenser', 'soda bottle', 'sprayer', 'squeezer', 'sunglasses', 'wallet'."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9Sg3bJozQs_N",
        "outputId": "4655bc51-df22-4968-b298-37e03382a396"
      },
      "outputs": [],
      "source": [
        "!wget -nc https://zenodo.org/record/835510/files/part1_cropped.tar.gz https://zenodo.org/record/835510/files/part2_cropped.tar.gz \n",
        "\n",
        "#https://zenodo.org/record/835510/files/part3_cropped.tar.gz https://zenodo.org/record/835510/files/part4_cropped.tar.gz"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "87NiOBGNSRtd"
      },
      "outputs": [],
      "source": [
        "!tar -xf part1_cropped.tar.gz  --skip-old-files \n",
        "!tar -xf part2_cropped.tar.gz  --skip-old-files \n",
        "#!tar -xf /content/part3_cropped.tar.gz  --skip-old-files \n",
        "#!tar -xf /content/part4_cropped.tar.gz  --skip-old-files "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "BpO9a0LVLTED"
      },
      "outputs": [],
      "source": [
        "#!rm -r /content/data /content/struct_data /content/train_val_test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "BDMWU522ndyN"
      },
      "outputs": [],
      "source": [
        "!mkdir data\n",
        "!mv part1_cropped/* data\n",
        "!mv part2_cropped/* data\n",
        "#!mv part3_cropped/* data\n",
        "#!mv part4_cropped/* data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oj46Bh6uMbZk"
      },
      "source": [
        "Following block moves all images of objects in the MIX aquisition into new folder structure where all objects are grouped by their category."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "UpZtuxpkE_65"
      },
      "outputs": [],
      "source": [
        "import shutil\n",
        "import os\n",
        "import numpy as np\n",
        "\n",
        "data_dir = \"data\"\n",
        "struct_data_dir = \"struct_data\"\n",
        "\n",
        "for root, dirs, files in os.walk(data_dir, topdown=False):\n",
        "  for name in files:\n",
        "    if \".ipynb\" not in root and \"MIX\" in root and \".txt\" not in name:\n",
        "      obj_name = root.split(\"/\")[1]\n",
        "\n",
        "      src = os.path.join(root, name)\n",
        "\n",
        "      path_to_move = f\"{struct_data_dir}/{obj_name}\"\n",
        "      \n",
        "      if not os.path.exists(path_to_move):\n",
        "        os.makedirs(path_to_move)\n",
        "      \n",
        "      dst = f\"{path_to_move}/{name}\"\n",
        "\n",
        "      shutil.move(src, dst)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OZjmCUZ7OHXo"
      },
      "source": [
        "Now we split our obtained data into a training and testing images. The train-val-test split can be specified in the ratio paramter below! The original folder will remain to be used to testing and the new folder created will contain all of the training images. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YTADFQ3YOG_r",
        "outputId": "5eb03191-0594-46cc-8a2d-392721365901"
      },
      "outputs": [],
      "source": [
        "%pip install split-folders\n",
        "\n",
        "import splitfolders\n",
        "\n",
        "output_dir = \"train_val_test\"\n",
        "\n",
        "splitfolders.ratio(struct_data_dir, output=output_dir,seed=1337, ratio=(.8, .1, .1), group_prefix=None, move=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hqA233G2n37q"
      },
      "source": [
        "## Initialisation and Preprocessing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uwE7vvq7n3kn",
        "outputId": "3da43623-22a0-48b6-d9b1-5d12d71f3548"
      },
      "outputs": [],
      "source": [
        "from tensorflow.keras import utils\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten, Rescaling\n",
        "from tensorflow.keras.layers import Conv2D, MaxPooling2D\n",
        "from tensorflow.keras.optimizers import SGD, Adam, RMSprop\n",
        "\n",
        "# importing of service libraries\n",
        "import csv\n",
        "\n",
        "print('Libraries imported.')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tja9DJgvoACl",
        "outputId": "b933e3d4-8c32-4b9c-a826-2e3892850e84"
      },
      "outputs": [],
      "source": [
        "#training constants\n",
        "BATCH_SIZE = 32\n",
        "N_EPOCH = 3 \n",
        "N_CLASSES = 10\n",
        "VERBOSE = 1\n",
        "#VALIDATION_SPLIT = 0.2\n",
        "OPTIM = RMSprop()\n",
        "IMG_ROWS = 256\n",
        "IMG_COLS = 256\n",
        "IMG_CHANNELS = 3\n",
        "LABEL_MODE = 'categorical'\n",
        "\n",
        "train_dir = \"train_val_test/train\"\n",
        "val_dir = \"train_val_test/val\"\n",
        "test_dir = \"train_val_test/test\"\n",
        "\n",
        "print('Main variables initialised.')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xxqnA7E-RDL_",
        "outputId": "8f7f69d4-e2d4-476a-93f2-f800888353d2"
      },
      "outputs": [],
      "source": [
        "# Training dataset\n",
        "train_ds = utils.image_dataset_from_directory(\n",
        "  train_dir,\n",
        "  seed=123,\n",
        "  label_mode = LABEL_MODE,\n",
        "  image_size=(IMG_ROWS, IMG_COLS),\n",
        "  batch_size=BATCH_SIZE)\n",
        "\n",
        "# Validation dataset\n",
        "val_ds = utils.image_dataset_from_directory(\n",
        "  val_dir,\n",
        "  seed=123,\n",
        "  label_mode = LABEL_MODE,\n",
        "  image_size=(IMG_ROWS, IMG_COLS),\n",
        "  batch_size=BATCH_SIZE)\n",
        "\n",
        "# Testing dataset\n",
        "test_ds = utils.image_dataset_from_directory(\n",
        "  test_dir,\n",
        "  seed=123,\n",
        "  label_mode = LABEL_MODE,\n",
        "  image_size=(IMG_ROWS, IMG_COLS),\n",
        "  batch_size=BATCH_SIZE)\n",
        "\n",
        "print(train_ds.class_names)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hBhBp8jebXQh"
      },
      "source": [
        "## Visualisation of training data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 963
        },
        "id": "efnPqLNUSLQX",
        "outputId": "2645cf9b-5e28-49ba-f30a-878fa69ed99b"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(10, 10))\n",
        "for images, labels in train_ds.take(1):\n",
        "  for i in range(9):\n",
        "    ax = plt.subplot(3, 3, i + 1)\n",
        "    plt.imshow(images[i].numpy().astype(\"uint8\"))\n",
        "    print(labels[i])\n",
        "    #plt.title(str(labels[i]))\n",
        "    plt.axis(\"off\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7audnIbMeiB0",
        "outputId": "e3bc97f8-eaa4-4fc0-e55a-327e61c9cff3"
      },
      "outputs": [],
      "source": [
        "for image_batch, labels_batch in train_ds:\n",
        "  print(image_batch.shape)\n",
        "  print(labels_batch.shape)\n",
        "  break"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jg0BQlBsgEw7"
      },
      "source": [
        "## Configuration of datasets for perfomance!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "id": "jnGoJVS9gEWn"
      },
      "outputs": [],
      "source": [
        "#train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)\n",
        "#val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I4LzBEMgIN0y"
      },
      "source": [
        "# Experimental Hyperparameter Definition!\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "id": "QsKDywhiINl9"
      },
      "outputs": [],
      "source": [
        "KERNEL_SIZE = 3\n",
        "HIDDEN_DROPOUT_RATE = 0.25\n",
        "NUM_EPOCS = 3 "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BGQwlzwdd8iw"
      },
      "source": [
        "## CNN Definition"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "yxEwGa_DeAAT"
      },
      "outputs": [],
      "source": [
        "# Complex DNN model definition\n",
        "model = Sequential()\n",
        "\n",
        "# Normalisation layer \n",
        "model.add(Rescaling(1./255)),\n",
        " \n",
        "model.add(Conv2D(32, kernel_size=KERNEL_SIZE, padding='same', input_shape=(IMG_ROWS, IMG_COLS, IMG_CHANNELS)))\n",
        "model.add(Activation('relu'))\n",
        "model.add(Conv2D(32, kernel_size=KERNEL_SIZE, padding='same'))\n",
        "model.add(Activation('relu'))\n",
        "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "model.add(Dropout(HIDDEN_DROPOUT_RATE))\n",
        " \n",
        "model.add(Conv2D(64, kernel_size=KERNEL_SIZE, padding='same'))\n",
        "model.add(Activation('relu'))\n",
        "model.add(Conv2D(64, 3, 3))\n",
        "model.add(Activation('relu'))\n",
        "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "model.add(Dropout(HIDDEN_DROPOUT_RATE))\n",
        " \n",
        "model.add(Flatten())\n",
        "model.add(Dense(512))\n",
        "model.add(Activation('relu'))\n",
        "model.add(Dropout(0.5))\n",
        "model.add(Dense(N_CLASSES))\n",
        "model.add(Activation('softmax'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6scVYsNahCKa",
        "outputId": "061a6a3c-729b-4297-d338-7d916eaebaa5"
      },
      "outputs": [],
      "source": [
        "model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
        "\n",
        "model.build(input_shape=(None, IMG_ROWS, IMG_COLS, IMG_CHANNELS))\n",
        "model.summary()"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Visualise the Model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "#%pip install visualkeras\n",
        "\n",
        "import visualkeras \n",
        "from PIL import ImageFont\n",
        "\n",
        "from collections import defaultdict\n",
        "\n",
        "color_map = defaultdict(dict)\n",
        "color_map[Conv2D]['fill'] = 'orange'\n",
        "color_map[Dropout]['fill'] = 'pink'\n",
        "color_map[MaxPooling2D]['fill'] = 'red'\n",
        "color_map[Dense]['fill'] = 'green'\n",
        "color_map[Flatten]['fill'] = 'teal'\n",
        "\n",
        "font = ImageFont.truetype(\"arial.ttf\", 20)  # using comic sans is strictly prohibited!\n",
        "visualkeras.layered_view(model, legend=True, scale_xy=1, scale_z=1, max_xy=1000, color_map=color_map, font=font)  # font is optional!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hfaxSBp0jK4W"
      },
      "source": [
        "## Training Model!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 415
        },
        "id": "mPBj-Eq_jGQf",
        "outputId": "a105a96e-2686-4feb-9e81-602f4e9b30d4"
      },
      "outputs": [],
      "source": [
        "history = model.fit(\n",
        "  train_ds,\n",
        "  validation_data=val_ds,\n",
        "  epochs=NUM_EPOCS,\n",
        "  verbose = VERBOSE\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ULPyPHcDVcbC"
      },
      "source": [
        "## Evaluating Model!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "rMm32nl2Vbfb",
        "outputId": "1d30ff90-d2f8-4462-8f4c-fe494a28c8bf"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "score = model.evaluate(test_ds, verbose=VERBOSE)\n",
        "print(\"\\nTest score/loss:\", score[0])\n",
        "print('Test accuracy:', score[1])\n",
        "\n",
        "# list all data in history\n",
        "print(history.history.keys())\n",
        "\n",
        "# summarize history for accuracy\n",
        "#plt.plot(mo)\n",
        "plt.plot(history.history['accuracy'])\n",
        "plt.plot(history.history['val_accuracy'])\n",
        "plt.title('model accuracy')\n",
        "plt.ylabel('accuracy')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'val'], loc='upper left')\n",
        "plt.show()\n",
        "\n",
        "# summarize history for loss\n",
        "plt.plot(history.history['loss'])\n",
        "plt.plot(history.history['val_loss'])\n",
        "plt.title('model loss')\n",
        "plt.ylabel('loss')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'val'], loc='upper left')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ccKUF0sPUviQ"
      },
      "source": [
        "# MAIN EXPERIMENT!\n",
        "Hyperparamters: Kernel Size, Dropout Rate, Batch Size"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qqiJJyTKfrPo"
      },
      "outputs": [],
      "source": [
        "# DATA FILE SETUP \n",
        "\n",
        "FILEPATH = 'experimental_data.csv'\n",
        "header = ['exp_num', 'kernel_size', 'dropout_rate', 'batch_size', 'test_acc', 'test_loss', 'train_acc', 'val_acc', 'train_loss', 'val_loss']\n",
        "\n",
        "\n",
        "with open(FILEPATH, 'w', encoding='UTF8', newline='') as f:\n",
        "    writer = csv.writer(f)\n",
        "    # write the header\n",
        "    writer.writerow(header)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FUO07qviUvW2",
        "outputId": "d724cfe5-2c4f-4056-fb8d-83c7f4bd6511"
      },
      "outputs": [],
      "source": [
        "# TRAINING CONSTANTS \n",
        "N_EPOCH = 3 \n",
        "N_CLASSES = 10\n",
        "VERBOSE = 1\n",
        "#VALIDATION_SPLIT = 0.2\n",
        "OPTIM = RMSprop()\n",
        "IMG_ROWS = 256\n",
        "IMG_COLS = 256\n",
        "IMG_CHANNELS = 3\n",
        "LABEL_MODE = 'categorical'\n",
        "\n",
        "train_dir = \"train_val_test/train\"\n",
        "val_dir = \"train_val_test/val\"\n",
        "test_dir = \"train_val_test/test\"\n",
        "\n",
        "# EXPERIMENTAL HYPER PARAMS\n",
        "KERNEL_SIZES = [3, 5, 7]\n",
        "HIDDEN_DROPOUT_RATES = [0.25, 0.35, 0.45]\n",
        "BATCH_SIZES = [64, 128]\n",
        "\n",
        "print('Main variables initialised.')\n",
        "\n",
        "i = 9\n",
        "\n",
        "for BATCH_SIZE in BATCH_SIZES:\n",
        "  for HIDDEN_DROPOUT_RATE in HIDDEN_DROPOUT_RATES:\n",
        "    for KERNEL_SIZE in KERNEL_SIZES:\n",
        "\n",
        "      # SETUP DATASETS\n",
        "      # Training dataset\n",
        "      train_ds = utils.image_dataset_from_directory(\n",
        "        train_dir,\n",
        "        seed=123,\n",
        "        label_mode = LABEL_MODE,\n",
        "        image_size=(IMG_ROWS, IMG_COLS),\n",
        "        batch_size=BATCH_SIZE)\n",
        "\n",
        "      # Validation dataset\n",
        "      val_ds = utils.image_dataset_from_directory(\n",
        "        val_dir,\n",
        "        seed=123,\n",
        "        label_mode = LABEL_MODE,\n",
        "        image_size=(IMG_ROWS, IMG_COLS),\n",
        "        batch_size=BATCH_SIZE)\n",
        "\n",
        "      # Testing dataset\n",
        "      test_ds = utils.image_dataset_from_directory(\n",
        "        test_dir,\n",
        "        seed=123,\n",
        "        label_mode = LABEL_MODE,\n",
        "        image_size=(IMG_ROWS, IMG_COLS),\n",
        "        batch_size=BATCH_SIZE)\n",
        "\n",
        "      # Complex DNN model definition\n",
        "      model = Sequential()\n",
        "\n",
        "      # Normalisation layer \n",
        "      model.add(Rescaling(1./255)),\n",
        "      \n",
        "      model.add(Conv2D(32, kernel_size=KERNEL_SIZE, padding='same', input_shape=(IMG_ROWS, IMG_COLS, IMG_CHANNELS)))\n",
        "      model.add(Activation('relu'))\n",
        "      model.add(Conv2D(32, kernel_size=KERNEL_SIZE, padding='same'))\n",
        "      model.add(Activation('relu'))\n",
        "      model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "      model.add(Dropout(HIDDEN_DROPOUT_RATE))\n",
        "      \n",
        "      model.add(Conv2D(64, kernel_size=KERNEL_SIZE, padding='same'))\n",
        "      model.add(Activation('relu'))\n",
        "      model.add(Conv2D(64, 3, 3))\n",
        "      model.add(Activation('relu'))\n",
        "      model.add(MaxPooling2D(pool_size=(2, 2)))\n",
        "      model.add(Dropout(HIDDEN_DROPOUT_RATE))\n",
        "      \n",
        "      model.add(Flatten())\n",
        "      model.add(Dense(512))\n",
        "      model.add(Activation('relu'))\n",
        "      model.add(Dropout(0.5))\n",
        "      model.add(Dense(N_CLASSES))\n",
        "      model.add(Activation('softmax'))\n",
        "\n",
        "      model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
        "\n",
        "      model.build(input_shape=(None, IMG_ROWS, IMG_COLS, IMG_CHANNELS))\n",
        "\n",
        "      # TRAIN MODEL\n",
        "      history = model.fit(\n",
        "        train_ds,\n",
        "        validation_data=val_ds,\n",
        "        epochs=NUM_EPOCS,\n",
        "        verbose = VERBOSE\n",
        "      )\n",
        "\n",
        "      # EVALUATE MODEL \n",
        "      score = model.evaluate(test_ds, verbose=VERBOSE)\n",
        "      test_loss = score[0]\n",
        "      test_acc = score[1]\n",
        "      train_acc = history.history['accuracy'][2]\n",
        "      val_acc = history.history['val_accuracy'][2]\n",
        "      train_loss = history.history['loss'][2]\n",
        "      val_loss = history.history['val_loss'][2]\n",
        "\n",
        "\n",
        "      ## EXPORT DATA\n",
        "      i += 1\n",
        "      data = [i, KERNEL_SIZE, HIDDEN_DROPOUT_RATE, BATCH_SIZE, test_acc, test_loss, train_acc, val_acc, train_loss, val_loss]\n",
        "\n",
        "      FILEPATH = 'experimental_data.csv'\n",
        "\n",
        "      with open(FILEPATH, 'a', encoding='UTF8', newline='') as f:\n",
        "        writer = csv.writer(f)\n",
        "        # write the data\n",
        "        writer.writerow(data)\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 252
        },
        "id": "UZnNzX4-aApc",
        "outputId": "30be4f5f-e3c6-4adc-f642-20695611eb49"
      },
      "outputs": [],
      "source": [
        "\n",
        "header = ['exp_num', 'kernel_size', 'dropout_rate', 'batch_size', 'train_acc', 'val_acc', 'train_loss', 'val_loss']\n",
        "data = [i, k_size, d_rate, b_size, train_acc, val_acc, train_loss, val_loss]\n",
        "\n",
        "\n",
        "with open('/content/experimental_data.csv', 'w', encoding='UTF8', newline='') as f:\n",
        "    writer = csv.writer(f)\n",
        "\n",
        "    # write the header\n",
        "    writer.writerow(header)\n",
        "\n",
        "    # write the data\n",
        "    writer.writerow(data)\n",
        "\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "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.16"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}