Custom_Loss_Function.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "#HOW TO SOLVE THE Scipy ERROR IN PYTHON 3, SEE ON CELL NO 7 SOLUTION\n",
        "!git clone https://github.com/niazwazir/SRCNN-Keras.git"
      ],
      "metadata": {
        "id": "KfAApzHU_OAn",
        "outputId": "6de5f241-cfa5-4e58-91a0-f80ea29ae6e5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cloning into 'SRCNN-Keras'...\n",
            "remote: Enumerating objects: 81, done.\u001b[K\n",
            "remote: Counting objects: 100% (9/9), done.\u001b[K\n",
            "remote: Compressing objects: 100% (9/9), done.\u001b[K\n",
            "remote: Total 81 (delta 2), reused 0 (delta 0), pack-reused 72\u001b[K\n",
            "Unpacking objects: 100% (81/81), done.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cd SRCNN-Keras"
      ],
      "metadata": {
        "id": "NnaS3t_Q_OEF",
        "outputId": "4ee5fdc1-41a5-49ab-be2d-ed5e26fab667",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/SRCNN-Keras\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!unzip yang91.zip"
      ],
      "metadata": {
        "id": "sXdYNKP3_OHV",
        "outputId": "d514c504-2285-4b0b-e8aa-d1a847e2d332",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Archive:  yang91.zip\n",
            "   creating: yang91/\n",
            "  inflating: yang91/tt9.bmp          \n",
            "  inflating: yang91/tt8.bmp          \n",
            "  inflating: yang91/tt7.bmp          \n",
            "  inflating: yang91/tt6.bmp          \n",
            "  inflating: yang91/tt5.bmp          \n",
            "  inflating: yang91/tt4.bmp          \n",
            "  inflating: yang91/tt3.bmp          \n",
            "  inflating: yang91/tt27.bmp         \n",
            "  inflating: yang91/tt26.bmp         \n",
            "  inflating: yang91/tt25.bmp         \n",
            "  inflating: yang91/tt24.bmp         \n",
            "  inflating: yang91/tt23.bmp         \n",
            "  inflating: yang91/tt22.bmp         \n",
            "  inflating: yang91/tt21.bmp         \n",
            "  inflating: yang91/tt20.bmp         \n",
            "  inflating: yang91/tt2.bmp          \n",
            "  inflating: yang91/tt19.bmp         \n",
            "  inflating: yang91/tt18.bmp         \n",
            "  inflating: yang91/tt17.bmp         \n",
            "  inflating: yang91/tt16.bmp         \n",
            "  inflating: yang91/tt15.bmp         \n",
            "  inflating: yang91/tt14.bmp         \n",
            "  inflating: yang91/tt13.bmp         \n",
            "  inflating: yang91/tt12.bmp         \n",
            "  inflating: yang91/tt10.bmp         \n",
            "  inflating: yang91/tt1.bmp          \n",
            "  inflating: yang91/t66.bmp          \n",
            "  inflating: yang91/t65.bmp          \n",
            "  inflating: yang91/t64.bmp          \n",
            "  inflating: yang91/t63.bmp          \n",
            "  inflating: yang91/t62.bmp          \n",
            "  inflating: yang91/t61.bmp          \n",
            "  inflating: yang91/t60.bmp          \n",
            "  inflating: yang91/t59.bmp          \n",
            "  inflating: yang91/t58.bmp          \n",
            "  inflating: yang91/t57.bmp          \n",
            "  inflating: yang91/t56.bmp          \n",
            "  inflating: yang91/t55.bmp          \n",
            "  inflating: yang91/t54.bmp          \n",
            "  inflating: yang91/t53.bmp          \n",
            "  inflating: yang91/t52.bmp          \n",
            "  inflating: yang91/t51.bmp          \n",
            "  inflating: yang91/t50.bmp          \n",
            "  inflating: yang91/t49.bmp          \n",
            "  inflating: yang91/t48.bmp          \n",
            "  inflating: yang91/t47.bmp          \n",
            "  inflating: yang91/t46.bmp          \n",
            "  inflating: yang91/t45.bmp          \n",
            "  inflating: yang91/t44.bmp          \n",
            "  inflating: yang91/t43.bmp          \n",
            "  inflating: yang91/t42.bmp          \n",
            "  inflating: yang91/t40.bmp          \n",
            "  inflating: yang91/t39.bmp          \n",
            "  inflating: yang91/t38.bmp          \n",
            "  inflating: yang91/t37.bmp          \n",
            "  inflating: yang91/t36.bmp          \n",
            "  inflating: yang91/t35.bmp          \n",
            "  inflating: yang91/t34.bmp          \n",
            "  inflating: yang91/t33.bmp          \n",
            "  inflating: yang91/t32.bmp          \n",
            "  inflating: yang91/t31.bmp          \n",
            "  inflating: yang91/t30.bmp          \n",
            "  inflating: yang91/t29.bmp          \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!ls"
      ],
      "metadata": {
        "id": "vhHlMMjy_by8",
        "outputId": "dc02834c-7b71-4c20-a9e3-aaa3a68f3028",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "baby_GT.bmp\n",
            "baby_x2_GT.png\n",
            "bird_GT.bmp\n",
            "butterfly_GT.bmp\n",
            "head_GT.bmp\n",
            "Image_Super_Resolution.ipynb\n",
            "MOUNT_SRCNN_37_PSNR.ipynb\n",
            "prepare_data.py\n",
            "project.gif\n",
            "PSNR_SSIM_MSE_SRCNN_Super_Resolution_.ipynb\n",
            "SRCNN_COLOR_IMAGE_GENERATED.ipynb\n",
            "SRCNN_KERAS_2nd.ipynb\n",
            "SRCNN_KERAS_IN_Python3_Curves.ipynb\n",
            "SRCNN_KERAS_IN_Python3.ipynb\n",
            "SRCNN_KERAS.ipynb\n",
            "SRCNNMODIFIEDPYTHON2.ipynb\n",
            "subpixel.py\n",
            "text\n",
            "woman_GT.bmp\n",
            "yang91\n",
            "yang91.zip\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt, glob\n",
        "import tensorflow.keras as K\n",
        "import cv2\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "6Zu5ohTh_OKm"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "gGuU7I-cAW5D"
      },
      "outputs": [],
      "source": [
        "input_size=128\n",
        "scale = 2\n",
        "batch_size=16"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RNl2W1QzAW5J",
        "outputId": "f3af129f-3560-4ab4-8c42-ebea507672f2"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "63"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ],
      "source": [
        "train_list = glob.glob('yang91/*.*', recursive=True)\n",
        "n = len(train_list); n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mdKSmtIdAW5Y",
        "outputId": "06d2c0b7-e7f6-4c3c-bfbd-46daf7bf4c70"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "63"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ],
      "source": [
        "val_list = glob.glob('yang91/*.*', recursive=True)\n",
        "len(val_list)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2b4aji2kAW5t"
      },
      "source": [
        "## Super Resolution Model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "skJE6OTdAW5u"
      },
      "outputs": [],
      "source": [
        "def conv_block(x, filters, kernel, stride=(1,1), mode='same', act=True):\n",
        "    x = K.layers.Conv2D(filters, kernel_size=kernel, strides=stride, padding=mode)(x)\n",
        "    return K.layers.Activation('relu')(x) if act else x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "oQthXhsMAW50"
      },
      "outputs": [],
      "source": [
        "def res_block(ip,nf=16):\n",
        "    x = conv_block(ip, nf, 3, (1,1))\n",
        "    x = conv_block(x, nf, 3, (1,1), act=False)\n",
        "    return K.layers.Add()([x,ip])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "nW_fKc6PAW54"
      },
      "outputs": [],
      "source": [
        "def up_block(x,nf):\n",
        "    x = K.layers.UpSampling2D()(x)\n",
        "    x = conv_block(x,nf,kernel=(1,1))\n",
        "    return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "6F2R0qlxAW59",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "def get_srmodel(shape=(None,None,3)):\n",
        "    inp=K.Input(shape)\n",
        "\n",
        "    x=conv_block(inp, 16, 3, (1,1))\n",
        "    for i in range(5): x=res_block(x,16)\n",
        "    \n",
        "\n",
        "    x=up_block(x,nf=32)\n",
        "#     for i in range(2): x=res_block(x,32)\n",
        "\n",
        "#     x=up_block(x,nf=64)\n",
        "#     for i in range(1): x=res_block(x,64)\n",
        "    \n",
        "    x = K.layers.Conv2D(3,(3,3),padding='same')(x)\n",
        "    return inp,x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rJlc-GxbAW6C",
        "outputId": "01f33fce-f6e6-4b87-f45c-a880e34c8bc1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "______________________________________________________________________________________________________________\n",
            " Layer (type)                       Output Shape            Param #      Connected to                         \n",
            "==============================================================================================================\n",
            " input_1 (InputLayer)               [(None, None, None, 3)  0            []                                   \n",
            "                                    ]                                                                         \n",
            "                                                                                                              \n",
            " conv2d (Conv2D)                    (None, None, None, 16)  448          ['input_1[0][0]']                    \n",
            "                                                                                                              \n",
            " activation (Activation)            (None, None, None, 16)  0            ['conv2d[0][0]']                     \n",
            "                                                                                                              \n",
            " conv2d_1 (Conv2D)                  (None, None, None, 16)  2320         ['activation[0][0]']                 \n",
            "                                                                                                              \n",
            " activation_1 (Activation)          (None, None, None, 16)  0            ['conv2d_1[0][0]']                   \n",
            "                                                                                                              \n",
            " conv2d_2 (Conv2D)                  (None, None, None, 16)  2320         ['activation_1[0][0]']               \n",
            "                                                                                                              \n",
            " add (Add)                          (None, None, None, 16)  0            ['conv2d_2[0][0]',                   \n",
            "                                                                          'activation[0][0]']                 \n",
            "                                                                                                              \n",
            " conv2d_3 (Conv2D)                  (None, None, None, 16)  2320         ['add[0][0]']                        \n",
            "                                                                                                              \n",
            " activation_2 (Activation)          (None, None, None, 16)  0            ['conv2d_3[0][0]']                   \n",
            "                                                                                                              \n",
            " conv2d_4 (Conv2D)                  (None, None, None, 16)  2320         ['activation_2[0][0]']               \n",
            "                                                                                                              \n",
            " add_1 (Add)                        (None, None, None, 16)  0            ['conv2d_4[0][0]',                   \n",
            "                                                                          'add[0][0]']                        \n",
            "                                                                                                              \n",
            " conv2d_5 (Conv2D)                  (None, None, None, 16)  2320         ['add_1[0][0]']                      \n",
            "                                                                                                              \n",
            " activation_3 (Activation)          (None, None, None, 16)  0            ['conv2d_5[0][0]']                   \n",
            "                                                                                                              \n",
            " conv2d_6 (Conv2D)                  (None, None, None, 16)  2320         ['activation_3[0][0]']               \n",
            "                                                                                                              \n",
            " add_2 (Add)                        (None, None, None, 16)  0            ['conv2d_6[0][0]',                   \n",
            "                                                                          'add_1[0][0]']                      \n",
            "                                                                                                              \n",
            " conv2d_7 (Conv2D)                  (None, None, None, 16)  2320         ['add_2[0][0]']                      \n",
            "                                                                                                              \n",
            " activation_4 (Activation)          (None, None, None, 16)  0            ['conv2d_7[0][0]']                   \n",
            "                                                                                                              \n",
            " conv2d_8 (Conv2D)                  (None, None, None, 16)  2320         ['activation_4[0][0]']               \n",
            "                                                                                                              \n",
            " add_3 (Add)                        (None, None, None, 16)  0            ['conv2d_8[0][0]',                   \n",
            "                                                                          'add_2[0][0]']                      \n",
            "                                                                                                              \n",
            " conv2d_9 (Conv2D)                  (None, None, None, 16)  2320         ['add_3[0][0]']                      \n",
            "                                                                                                              \n",
            " activation_5 (Activation)          (None, None, None, 16)  0            ['conv2d_9[0][0]']                   \n",
            "                                                                                                              \n",
            " conv2d_10 (Conv2D)                 (None, None, None, 16)  2320         ['activation_5[0][0]']               \n",
            "                                                                                                              \n",
            " add_4 (Add)                        (None, None, None, 16)  0            ['conv2d_10[0][0]',                  \n",
            "                                                                          'add_3[0][0]']                      \n",
            "                                                                                                              \n",
            " up_sampling2d (UpSampling2D)       (None, None, None, 16)  0            ['add_4[0][0]']                      \n",
            "                                                                                                              \n",
            " conv2d_11 (Conv2D)                 (None, None, None, 32)  544          ['up_sampling2d[0][0]']              \n",
            "                                                                                                              \n",
            " activation_6 (Activation)          (None, None, None, 32)  0            ['conv2d_11[0][0]']                  \n",
            "                                                                                                              \n",
            " conv2d_12 (Conv2D)                 (None, None, None, 3)   867          ['activation_6[0][0]']               \n",
            "                                                                                                              \n",
            "==============================================================================================================\n",
            "Total params: 25,059\n",
            "Trainable params: 25,059\n",
            "Non-trainable params: 0\n",
            "______________________________________________________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "inp,outp=get_srmodel((None,None,3))\n",
        "Wazir_model=K.Model(inp,outp)\n",
        "Wazir_model.summary(110)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "hVlTS7IUIG4n",
        "outputId": "40ab85ef-1073-42cf-c059-b31f774345b1"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ],
      "source": [
        "import keras\n",
        "import tensorflow as tf\n",
        "tf.keras.utils.plot_model(Wazir_model, 'Wazir_first1_model.png')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "XmY4I5ZuAW6k"
      },
      "outputs": [],
      "source": [
        "def randomHorizontalFlip(img, u=0.5):\n",
        "    if np.random.random() < u:\n",
        "        img = cv2.flip(img, 1)\n",
        "    return img\n",
        "def randomVerticalFlip(img, u=0.5):\n",
        "    if np.random.random() < u:\n",
        "        img = cv2.flip(img, 0)\n",
        "    return img"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "V_7oZd06AW6r"
      },
      "outputs": [],
      "source": [
        "def randomCrop(img):\n",
        "    global input_size\n",
        "    h=input_size*2\n",
        "    assert img.shape[0] >= h\n",
        "    assert img.shape[1] >= h\n",
        "    x = random.randint(0, img.shape[1] - h)\n",
        "    y = random.randint(0, img.shape[0] - h)\n",
        "    img = img[y:y+h, x:x+h]\n",
        "    return img"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "Xuo9E5cJAW6v"
      },
      "outputs": [],
      "source": [
        "def train_generator():\n",
        "    global batch_size\n",
        "    global input_size\n",
        "    while True:\n",
        "        for start in range(0, len(train_list), batch_size):\n",
        "            x_batch = []\n",
        "            y_batch = []\n",
        "            end = min(start + batch_size, len(train_list))\n",
        "            ids_train_batch = train_list[start:end]\n",
        "            for i,ids in enumerate(ids_train_batch):\n",
        "                img = cv2.imread(ids)\n",
        "                img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
        "                tar = cv2.resize(img, (input_size*2, input_size*2),interpolation=cv2.INTER_CUBIC)  #####\n",
        "                tar = randomHorizontalFlip(tar)\n",
        "                tar = randomVerticalFlip(tar)\n",
        "                img1 = cv2.resize(tar, (input_size, input_size),interpolation=cv2.INTER_CUBIC)\n",
        "                x_batch.append(img1)\n",
        "                y_batch.append(tar)\n",
        "            x_batch = np.array(x_batch, np.float32) / 255.\n",
        "            y_batch = np.array(y_batch, np.float32) / 255.\n",
        "            yield x_batch, y_batch\n",
        "\n",
        "# i am using Set5 dataset for validation please download the data\n",
        "def valid_generator():\n",
        "    global batch_size\n",
        "    global input_size\n",
        "    while True:\n",
        "        for start in range(0, len(val_list), batch_size):\n",
        "            x_batch = []\n",
        "            y_batch = []\n",
        "            end = min(start + batch_size, len(val_list))\n",
        "            ids_valid_batch = val_list[start:end]            \n",
        "            for i,ids in enumerate(ids_valid_batch):\n",
        "                img = cv2.imread(ids)\n",
        "                img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
        "                img1 = cv2.resize(img, (input_size, input_size),interpolation=cv2.INTER_CUBIC)\n",
        "                img2 = cv2.resize(img, (input_size*2, input_size*2),interpolation=cv2.INTER_CUBIC)\n",
        "                x_batch.append(img1)\n",
        "                y_batch.append(img2)\n",
        "            x_batch = np.array(x_batch, np.float32) / 255.\n",
        "            y_batch = np.array(y_batch, np.float32) / 255.\n",
        "            yield x_batch, y_batch"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "OVdidIfmAW6z"
      },
      "outputs": [],
      "source": [
        "l=next(valid_generator())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "bl1YRpjD_DC3"
      },
      "outputs": [],
      "source": [
        "def wazir_loss(y_true, y_pred):\n",
        "    squared_difference = tf.square(y_true - y_pred)\n",
        "    return tf.reduce_mean(squared_difference, axis=-1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "xVjRzl1_AW62"
      },
      "outputs": [],
      "source": [
        "def psnr(y_true,y_pred):\n",
        "    return tf.image.psnr(y_true,y_pred,1.0)\n",
        "def ssim(y_true,y_pred):\n",
        "    return tf.image.ssim(y_true,y_pred,1.0)\n",
        "def mean_squared_error(y_true, y_pred):\n",
        "    return tf.keras.metrics.mean_squared_error(y_true, y_pred)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "YxpdmUuO_DC4",
        "outputId": "241e4f0a-082f-4b8e-eaa4-ec7c8bd2eb7f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/keras/optimizer_v2/adam.py:105: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
            "  super(Adam, self).__init__(name, **kwargs)\n"
          ]
        }
      ],
      "source": [
        "learning_rate=0.001\n",
        "adam=K.optimizers.Adam(lr=learning_rate)\n",
        "Wazir_model.compile(optimizer=adam,loss='mse',metrics=[psnr,ssim,mean_squared_error,wazir_loss])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "CWy4-DSu_DC4"
      },
      "outputs": [],
      "source": [
        "def fit(model,epoch=5):\n",
        "    model.fit_generator(generator=train_generator(),\n",
        "                    steps_per_epoch=np.ceil(float(len(train_list)) / float(batch_size)),\n",
        "                    epochs=epoch,\n",
        "                    verbose=1,\n",
        "                    validation_data=valid_generator(),\n",
        "                    shuffle=True,\n",
        "                    validation_steps=np.ceil(float(len(val_list)) / float(batch_size)))\n",
        "    return model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WCWQ2uDsAW7L",
        "outputId": "1bd227d1-a87b-47b1-ee57-621021b630cc",
        "scrolled": false
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:8: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n",
            "  \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n"
          ]
        }
      ],
      "source": [
        "Wazir_model=fit(Wazir_model,5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "o4oeaopf_DC5"
      },
      "outputs": [],
      "source": [
        ""
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "anaconda-cloud": {},
    "colab": {
      "name": "Custom Loss Function.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "cuda_tf",
      "language": "python",
      "name": "cuda_tf"
    },
    "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.9.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}