Defcon4_TFLite_Mobilenet_v2.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/iypc-team/CoLab/blob/master/Defcon4_TFLite_Mobilenet_v2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import shutil\n",
        "try: shutil.rmtree(('/content/sample_data'))\n",
        "except: pass\n",
        "print('Updated: 11/15/2022-3')\n"
      ],
      "metadata": {
        "id": "wMbpdCeVNIQw"
      },
      "id": "wMbpdCeVNIQw",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "    import tflite_model_maker\n",
        "    print('tflite_model_maker:', tflite_model_maker.__version__)\n",
        "except BaseException as err:\n",
        "    print(err, '\\n')\n",
        "    !sudo apt -y install libportaudio2\n",
        "    print()\n",
        "    !sudo apt autoremove libnvidia-common-460\n",
        "    print()\n",
        "    !pip install coremltools\n",
        "    print()\n",
        "    !pip install tflite-model-maker"
      ],
      "metadata": {
        "id": "B_SORg3xqCxO"
      },
      "id": "B_SORg3xqCxO",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# https://www.tensorflow.org/tfmodels/vision/image_classification\n",
        "import tensorflow as tf\n",
        "\n",
        "logical_device_names = [logical_device.name for logical_device in tf.config.list_logical_devices()]\n",
        "\n",
        "# if exp_config.runtime.mixed_precision_dtype == tf.float16: tf.keras.mixed_precision.set_global_policy('mixed_float16')\n",
        "\n",
        "if 'GPU' in ''.join(logical_device_names):\n",
        "    distributionStrategy = tf.distribute.MirroredStrategy()\n",
        "    with distributionStrategy.scope():\n",
        "        print('Running on GPU')\n",
        "\n",
        "elif 'TPU' in ''.join(logical_device_names):\n",
        "    tpu = tf.distribute.cluster_resolver.TPUClusterResolver()  # TPU detection\n",
        "    print(tpu)\n",
        "    tf.config.experimental_connect_to_cluster(tpu)\n",
        "    tf.distribute.TPUStrategy(tpu)\n",
        "    distributionStrategy = tf.distribute.TPUStrategy(tpu)\n",
        "    with distributionStrategy.scope():\n",
        "        print('Running on TPU ', tpu.cluster_spec().as_dict()['worker'])\n",
        "\n",
        "else:\n",
        "    distributionStrategy = tf.distribute.OneDeviceStrategy(logical_device_names[0])\n",
        "    with distributionStrategy.scope():\n",
        "        print('Running on CPU')\n",
        "        print(f'Warning: this will be very slow.')"
      ],
      "metadata": {
        "id": "48ILQJKAmMzL"
      },
      "id": "48ILQJKAmMzL",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from __future__ import absolute_import\n",
        "import os, shutil, tarfile \n",
        "from os.path import abspath, exists, join\n",
        "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '1'\n",
        "\n",
        "from google.colab import drive, files\n",
        "import numpy as np\n",
        "\n",
        "import tensorflow as tf\n",
        "assert tf.__version__.startswith('2')\n",
        "\n",
        "from tflite_model_maker import model_spec\n",
        "from tflite_model_maker import image_classifier\n",
        "from tflite_model_maker.config import ExportFormat\n",
        "from tflite_model_maker.config import QuantizationConfig\n",
        "from tflite_model_maker.image_classifier import DataLoader\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "contentPath=os.getcwd()\n",
        "\n",
        "if exists('/content/sample_data'):\n",
        "    shutil.rmtree('/content/sample_data')\n",
        "\n",
        "drive.mount('/content/drive', force_remount=True)\n",
        "\n",
        "# import required modules\n",
        "if not exists('BashColors.py'):\n",
        "    shutil.copy2(src='/content/drive/MyDrive/PythonFiles/BashColors.py',\n",
        "                 dst=contentPath)\n",
        "    \n",
        "if not exists('TarfileFunctions.py'):\n",
        "    shutil.copy2(src='/content/drive/MyDrive/TarfileFunctions.py',\n",
        "                 dst=contentPath)\n",
        "\n",
        "# if not exists('GetTPU.py'):\n",
        "    # shutil.copy2(src='/content/drive/MyDrive/PythonFiles/GetTPU.py',\n",
        "                 # dst=contentPath)\n",
        "    \n",
        "if not exists('ExceptionHandeler.py'):\n",
        "    shutil.copy2(src='/content/drive/MyDrive/PythonFiles/ExceptionHandeler.py',\n",
        "                 dst=contentPath)\n",
        "    \n",
        "from BashColors import C\n",
        "# from GetTPU import *\n",
        "from TarfileFunctions import *\n",
        "from ExceptionHandeler import *\n",
        "\n",
        "# create image directories \n",
        "if not exists('DataGenerator7.tar.gz'):\n",
        "    shutil.copy2(src='/content/drive/MyDrive/DataGenerator7.tar.gz',\n",
        "                 dst=contentPath)\n",
        "    os.chdir(contentPath)\n",
        "    tff.extractTarfiles('DataGenerator7.tar.gz')\n",
        "\n",
        "if not exists('images.tar.gz'):\n",
        "    shutil.copy2(src='/content/drive/MyDrive/images.tar.gz',\n",
        "                 dst=contentPath)\n",
        "    os.chdir(contentPath)\n",
        "    tff.extractTarfiles('/content/drive/MyDrive/images.tar.gz')\n",
        "    \n",
        "image_path=os.path.join(contentPath, 'images')\n",
        "generatorPath=os.path.join(contentPath, 'DataGenerator')"
      ],
      "metadata": {
        "id": "cOOpAIBkOlAC"
      },
      "id": "cOOpAIBkOlAC",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "q"
      ],
      "metadata": {
        "id": "5DwIpOJoOlhj"
      },
      "id": "5DwIpOJoOlhj",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "testPath='/content/images'\n",
        "print(testPath)\n",
        "test_data=DataLoader.from_folder(filename=testPath, shuffle=True)"
      ],
      "metadata": {
        "id": "-OxbUQB_-ZrV"
      },
      "id": "-OxbUQB_-ZrV",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# A helper function that returns 'red'/'black' depending on if its two input\n",
        "# parameter matches or not.\n",
        "def get_label_color(val1, val2):\n",
        "  if val1 == val2:\n",
        "    return 'black'\n",
        "  else:\n",
        "    return 'red'\n",
        "\n",
        "# Then plot 100 test images and their predicted labels.\n",
        "# If a prediction result is different from the label provided label in \"test\"\n",
        "# dataset, we will highlight it in blue color.\n",
        "try:\n",
        "    plt.figure(figsize=(20, 20))\n",
        "    predicts = model.predict_top_k(test_data)\n",
        "    for i, (image, label) in enumerate(test_data.gen_dataset().unbatch().take(100)):\n",
        "        ax = plt.subplot(10, 10, i+1)\n",
        "        plt.xticks([])\n",
        "        plt.yticks([])\n",
        "        plt.grid(False)\n",
        "        plt.imshow(image.numpy(), cmap=plt.cm.gray)\n",
        "        \n",
        "        predict_label = predicts[i][0][0]\n",
        "        color = get_label_color(predict_label,\n",
        "                                test_data.index_to_label[label.numpy()])\n",
        "        ax.xaxis.label.set_color(color)\n",
        "        plt.xlabel('Predicted: %s' % predict_label)\n",
        "    plt.show()\n",
        "except: pass\n",
        "\n",
        "from tensorflow_examples.lite.model_maker.core.data_util.image_dataloader import ImageClassifierDataLoader\n",
        "def plotDatasetImages(dataset:ImageClassifierDataLoader):\n",
        "    \"\"\" \"\"\"\n",
        "    plt.figure(figsize=(12,12))\n",
        "    for i, (image, label) in enumerate(dataset.gen_dataset().unbatch().take(25)):\n",
        "        plt.subplot(5,5,i+1)\n",
        "        plt.xticks([])\n",
        "        plt.yticks([])\n",
        "        plt.grid(False)\n",
        "        plt.imshow(image.numpy(), cmap=plt.cm.gray)\n",
        "        plt.xlabel(data.index_to_label[label.numpy()])\n",
        "    plt.show()\n",
        "\n",
        "# plotDatasetImages(dataset=train_ds)"
      ],
      "metadata": {
        "id": "LCJeaFxwFo0M"
      },
      "id": "LCJeaFxwFo0M",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fileGlob= glob.glob('**', recursive=True)\n",
        "for fil in fileGlob:\n",
        "    if fil.__contains__('.ipynb_checkpoints'):\n",
        "        print(fil)"
      ],
      "metadata": {
        "id": "geDioPeynk92"
      },
      "id": "geDioPeynk92",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# tff.tarfileFromDirectory(output_filename='DataGenerator7.tar.gz',source_dir='/content/DataGenerator')\n",
        "# shutil.copy2('/content/DataGenerator7.tar.gz', '/content/drive/MyDrive')"
      ],
      "metadata": {
        "id": "M6iBzddXXKon"
      },
      "id": "M6iBzddXXKon",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3505a19b",
      "metadata": {
        "id": "3505a19b"
      },
      "outputs": [],
      "source": [
        "BATCH_SIZE = 16\n",
        "data = DataLoader.from_folder(filename=generatorPath, shuffle=True)\n",
        "train_ds, restData = data.split(0.8)\n",
        "val_ds, test_ds = restData.split(0.5)\n",
        "# if train_ds.index_to_label.__contains__('.ipynb_checkpoints'):\n",
        "    # train_ds.index_to_label.remove('.ipynb_checkpoints')\n",
        "\n",
        "print()\n",
        "print('classes:', train_ds.num_classes)\n",
        "print('class names', train_ds.index_to_label)\n",
        "print(len(train_ds) // BATCH_SIZE, len(val_ds) // BATCH_SIZE)\n",
        "print(train_ds.size // BATCH_SIZE, val_ds.size // BATCH_SIZE)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "33c8a0bb",
      "metadata": {
        "id": "33c8a0bb"
      },
      "outputs": [],
      "source": [
        "help(image_classifier.ImageClassifier.predict_top_k)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c609e96b",
      "metadata": {
        "id": "c609e96b"
      },
      "outputs": [],
      "source": [
        "earlyStop = tf.keras.callbacks.EarlyStopping(\n",
        "    monitor=\"val_loss\",\n",
        "    min_delta=0,\n",
        "    patience=0,\n",
        "    verbose=0,\n",
        "    mode=\"auto\",\n",
        "    baseline=None,\n",
        "    restore_best_weights=True,\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f37114e0",
      "metadata": {
        "id": "f37114e0"
      },
      "outputs": [],
      "source": [
        "from tflite_model_maker import image_classifier\n",
        "BATCH_SIZE = 16\n",
        "EPOCHS = 12\n",
        "DROPOUT_RATE = 0.1\n",
        "LEARNING_RATE = 0.0001\n",
        "WARMUP = len(train_ds) // BATCH_SIZE\n",
        "print('WARMUP:', WARMUP)\n",
        "\n",
        "model = image_classifier.create(\n",
        "    train_data = train_ds,\n",
        "    validation_data = val_ds,\n",
        "    model_spec = model_spec.get('mobilenet_v2'),\n",
        "    learning_rate = LEARNING_RATE,\n",
        "    batch_size = BATCH_SIZE,\n",
        "    epochs = EPOCHS,\n",
        "    dropout_rate = DROPOUT_RATE,\n",
        "    use_augmentation = True, # default=False\n",
        "    use_hub_library = True,  # default=True\n",
        "    momentum = 0.9, # Only used when use_hub_library is True\n",
        "    shuffle = True, # default=False\n",
        "    warmup_steps = WARMUP,\n",
        "    model_dir = contentPath,\n",
        "    train_whole_model = False,\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4dd135b3",
      "metadata": {
        "id": "4dd135b3"
      },
      "outputs": [],
      "source": [
        "loss, accuracy = model.evaluate(data=test_ds)\n",
        "print(loss)\n",
        "accuracyPercent=round(accuracy * 100, 1)\n",
        "print(accuracyPercent, '% accuracy')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.export(export_dir='.')"
      ],
      "metadata": {
        "id": "1JoseOs7tGIY"
      },
      "id": "1JoseOs7tGIY",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "67f8a91b",
      "metadata": {
        "id": "67f8a91b"
      },
      "outputs": [],
      "source": [
        "model.ALLOWED_EXPORT_FORMAT"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# A helper function that returns 'red'/'black' depending on if its two input\n",
        "# parameter matches or not.\n",
        "def get_label_color(val1, val2):\n",
        "  if val1 == val2:\n",
        "    return 'black'\n",
        "  else:\n",
        "    return 'red'\n",
        "\n",
        "# Then plot 100 test images and their predicted labels.\n",
        "# If a prediction result is different from the label provided label in \"test\"\n",
        "# dataset, we will highlight it in red color.\n",
        "plt.figure(figsize=(12, 20))\n",
        "predicts = model.predict_top_k(test_ds)\n",
        "for i, (image, label) in enumerate(test_ds.gen_dataset().unbatch().take(50)):\n",
        "    ax = plt.subplot(10, 5, i+1)\n",
        "    plt.xticks([])\n",
        "    plt.yticks([])\n",
        "    plt.grid(False)\n",
        "    plt.imshow(image.numpy(), cmap=plt.cm.gray)\n",
        "\n",
        "    predict_label = predicts[i][0][0]\n",
        "    percent_label = predicts[i][0][1] * 100\n",
        "    percent_label = round(percent_label, 1)\n",
        "    color = get_label_color(predict_label,\n",
        "                            val_ds.index_to_label[label.numpy()])\n",
        "    ax.xaxis.label.set_color(color)\n",
        "    # plt.xlabel('Predicted: %s' % predict_label)\n",
        "    plt.xlabel('%s %s pct'  % (predict_label, percent_label))\n",
        "plt.show()\n",
        "print()"
      ],
      "metadata": {
        "id": "OCHnBqydJOQp"
      },
      "id": "OCHnBqydJOQp",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "Mxg_vubIf4Z1"
      },
      "id": "Mxg_vubIf4Z1"
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "1IUdS-FW2QyI"
      },
      "id": "1IUdS-FW2QyI"
    },
    {
      "cell_type": "code",
      "source": [
        "type(predict_label)\n",
        "predicts[i][0][1]\n"
      ],
      "metadata": {
        "id": "wmIouaHrvR7Q"
      },
      "id": "wmIouaHrvR7Q",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e7fb13e3",
      "metadata": {
        "id": "e7fb13e3"
      },
      "outputs": [],
      "source": [
        "model.export(export_dir='.',\n",
        "             tflite_filename='Defcon_MobileNetV2.tflite')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "config = QuantizationConfig.for_float16()\n",
        "\n",
        "model.export(export_dir='.',\n",
        "             tflite_filename='Defcon_MobileNetV2_fp16.tflite',\n",
        "             quantization_config=config)"
      ],
      "metadata": {
        "id": "7AZ5LLDgl7_-"
      },
      "id": "7AZ5LLDgl7_-",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7e7f25b1",
      "metadata": {
        "id": "7e7f25b1"
      },
      "outputs": [],
      "source": [
        "testData = DataLoader.from_folder(image_path, shuffle=True)\n",
        "print('\\n', testData, '\\n')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import cv2\n",
        "from google.colab.patches import cv2_imshow"
      ],
      "metadata": {
        "id": "OK614SxBDCve"
      },
      "id": "OK614SxBDCve",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab.patches import cv2_imshow\n",
        "print(cv2_imshow)\n",
        "from os.path import abspath, basename\n",
        "from time import sleep\n",
        "os.chdir('/content/DataGenerator')\n",
        "dataGlob=glob.glob('**', recursive=True)\n",
        "count=0\n",
        "for pth in dataGlob:\n",
        "        fullPath=abspath(pth)\n",
        "        if os.path.isfile(fullPath):\n",
        "            count+=1\n",
        "            print(count, basename(fullPath))\n",
        "            img=cv2.imread(fullPath, cv2.IMREAD_COLOR)\n",
        "            # cv2_imshow(img)\n",
        "            # sleep(0.2)\n",
        "            img=None\n",
        "            print()\n",
        "os.chdir(contentPath)"
      ],
      "metadata": {
        "id": "3B7TYCsB9Bz_"
      },
      "id": "3B7TYCsB9Bz_",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "shutil.copy2('/content/model.tflite',\n",
        "             '/content/drive/MyDrive/TensorflowModels')\n",
        "\n",
        "shutil.copy2('/content/Defcon_MobileNetV2.tflite',\n",
        "             '/content/drive/MyDrive/TensorflowModels')\n",
        "\n",
        "shutil.copy2('/content/Defcon_MobileNetV2_fp16.tflite',\n",
        "             '/content/drive/MyDrive/TensorflowModels')\n"
      ],
      "metadata": {
        "id": "wi4G_VSoo_G9"
      },
      "id": "wi4G_VSoo_G9",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# !pip install -q coremltools\n",
        "from ExceptionHandeler import *\n",
        "try:\n",
        "    import coremltools as ct\n",
        "    tfmodel = tf.keras.applications.MobileNet()\n",
        "    mlmodel = ct.convert('auto', \"/content/model.tflite\")\n",
        "except: exh.printException()"
      ],
      "metadata": {
        "id": "6KID8Aw5BdTo"
      },
      "id": "6KID8Aw5BdTo",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "help(ct.convert)"
      ],
      "metadata": {
        "id": "LrW5VOS9JYIa"
      },
      "id": "LrW5VOS9JYIa",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dir(model)"
      ],
      "metadata": {
        "id": "XzxD2JR2D6TB"
      },
      "id": "XzxD2JR2D6TB",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import coremltools as ct \n",
        "model = MobileNet_flowers (1).h5\n",
        "# float 16 input and output of type multiarray\n",
        "try:\n",
        "    mlmodel = ct.convert(\n",
        "        model,\n",
        "        inputs=[ct.TensorType(shape=input.shape, dtype=np.float16)],\n",
        "        outputs=[ct.TensorType(dtype=np.float16)],\n",
        "        minimum_deployment_target=ct.target.iOS16,)\n",
        "except:\n",
        "    exh.printException()"
      ],
      "metadata": {
        "id": "Wbbx-_HD_1X_"
      },
      "id": "Wbbx-_HD_1X_",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Tested with TensorFlow 2.6.2\n",
        "import tensorflow as tf\n",
        "import coremltools as ct\n",
        "bs=\"\"\"\n",
        "tf_keras_model = tf.keras.Sequential(\n",
        "    [\n",
        "        tf.keras.layers.Flatten(input_shape=(28, 28)),\n",
        "        tf.keras.layers.Dense(128, activation=tf.nn.relu),\n",
        "        tf.keras.layers.Dense(10, activation=tf.nn.softmax),\n",
        "    ]\n",
        ")\n",
        "\"\"\"\n",
        "tf_keras_model = model\n",
        "\n",
        "# Pass in `tf.keras.Model` to the Unified Conversion API\n",
        "mlmodel = ct.convert(tf_keras_model, convert_to=\"mlprogram\")\n",
        "\n",
        "# or save the keras model in SavedModel directory format and then convert\n",
        "tf_keras_model.save('tf_keras_model')\n",
        "mlmodel = ct.convert('tf_keras_model', convert_to=\"mlprogram\")\n",
        "\n",
        "# or load the model from a SavedModel and then convert\n",
        "tf_keras_model = tf.keras.models.load_model('tf_keras_model')\n",
        "mlmodel = ct.convert(tf_keras_model, convert_to=\"mlprogram\")\n",
        "\n",
        "# or save the keras model in HDF5 format and then convert\n",
        "tf_keras_model.save('tf_keras_model.h5')\n",
        "mlmodel = ct.convert('tf_keras_model.h5', convert_to=\"mlprogram\")"
      ],
      "metadata": {
        "id": "rxrj5dOeiWyx"
      },
      "id": "rxrj5dOeiWyx",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "shutil.copy2('/content/drive/MyDrive/MobileNet_flowers.h5',\n",
        "             contentPath)\n",
        "\n",
        "\n",
        "new_model = tf.keras.models.load_model('/content/MobileNet_flowers.h5')\n",
        "\n",
        "\n",
        "# Check its architecture\n",
        "# new_model.summary()\n",
        "\n",
        "import coremltools as ct \n",
        "mlmodel=None\n",
        "# float 16 input and output of type multiarray\n",
        "try:\n",
        "    mlmodel = ct.convert(\n",
        "        new_model,\n",
        "        inputs=[ct.TensorType(dtype=np.float16)],\n",
        "        outputs=[ct.TensorType(dtype=np.float16)],\n",
        "        minimum_deployment_target=ct.target.iOS16,)\n",
        "except:\n",
        "    exh.printException()"
      ],
      "metadata": {
        "id": "FYDnXMwZ0ofo"
      },
      "id": "FYDnXMwZ0ofo",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(mlmodel)"
      ],
      "metadata": {
        "id": "u655IMD4REzr"
      },
      "id": "u655IMD4REzr",
      "execution_count": null,
      "outputs": []
    }
  ],
  "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.7.12"
    },
    "colab": {
      "private_outputs": true,
      "provenance": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "gpuClass": "premium"
  },
  "nbformat": 4,
  "nbformat_minor": 5
}