Diabetic_Retinopathy_Keras_Tuner.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Diabetic_Retinopathy_Keras_Tuner.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "8VsHUf8socjh",
        "4XQpDim8od8W"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Kushagratandon12/Diabetic_retinopathy/blob/main/Diabetic_Retinopathy_Keras_Tuner.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0Xz5p807dVF4"
      },
      "source": [
        "# %%capture\n",
        "!pip install -q -U keras-tuner\n",
        "!rm -rf /content/sample_data\n",
        "# !mkdir -p ~/.kaggle\n",
        "# !cp kaggle.json ~/.kaggle/\n",
        "# !chmod 600 ~/.kaggle/kaggle.json"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WxAzWmaLASuA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1f1e58a6-8a1e-464b-f5bf-5858242dbaf9"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aNGXjCRRnOGp"
      },
      "source": [
        "# Downloading The Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mRJJXYi4movj"
      },
      "source": [
        "%%capture\n",
        "# !kaggle datasets download -d kushagratandon12/diabetic-retinopathy-processed-data\n",
        "!unzip /content/drive/MyDrive/Diabetic_Balanced_Data.zip\n",
        "!rm -rf /content/diabetic-retinopathy-processed-data.zip"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TtrxJRbKKg9e"
      },
      "source": [
        "import os \n",
        "import gc\n",
        "import cv2\n",
        "import glob\n",
        "import random\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from os import path\n",
        "from tqdm import tqdm\n",
        "import seaborn as sns\n",
        "import tensorflow as tf\n",
        "from google.colab import drive\n",
        "from google.colab import files\n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras.preprocessing import image\n",
        "from tensorflow.keras.optimizers import Adam , SGD , RMSprop\n",
        "from tensorflow.keras.callbacks import ModelCheckpoint\n",
        "from tensorflow.keras.callbacks import ReduceLROnPlateau \n",
        "from tensorflow.keras.applications.vgg16 import VGG16\n",
        "from tensorflow.keras.applications.resnet_v2 import ResNet50V2\n",
        "from tensorflow.keras.applications.inception_v3 import InceptionV3"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9IiHCTiOUJQR"
      },
      "source": [
        "def show_data(path_dataset):\n",
        "  images_data = glob.glob(path_dataset)\n",
        "  random.shuffle(images_data)\n",
        "  plt.figure(figsize=(10,10))\n",
        "  for i in range(9):\n",
        "    plt.subplot(3,3,i+1)\n",
        "    img = plt.imread(images_data[i-1])\n",
        "    plt.imshow(img)\n",
        "\n",
        "def plot_data(dataset):\n",
        "  print('Total Number Of Images {}'.format(len(dataset)))\n",
        "  img_files = [os.path.basename(name) for name in dataset]\n",
        "  data_label = [str(name.split('/')[-2]) for name in dataset]\n",
        "  df = pd.DataFrame({'filename':img_files,'label':data_label})\n",
        "  sns.countplot(df['label'])\n",
        "  df['label'].value_counts()\n",
        "  return df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JjlgbSgPlvmu"
      },
      "source": [
        "# dataset = glob.glob('/content/content/processed_data/*/*.jpeg')\n",
        "# df = plot_data(dataset)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WNIA-z-VebFd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "53add062-4920-4c06-c028-ab4ca81550e9"
      },
      "source": [
        "classes=['No_Dr','Mild','Moderate','severe','Proliferative DR']\n",
        "class_dict = {}\n",
        "for i,label in enumerate(classes):\n",
        "  class_dict[i]=label\n",
        "print(class_dict)\n",
        "\n",
        "# label_1 = glob.glob('/content/processed_data/4/*.jpeg')\n",
        "# label_1 = list(label_1[10000::])\n",
        "# print(len(label_1))\n",
        "# for i in range(len(label_1)):\n",
        "#   os.remove(label_1[i])"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{0: 'No_Dr', 1: 'Mild', 2: 'Moderate', 3: 'severe', 4: 'Proliferative DR'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Skk99m4mfUah"
      },
      "source": [
        "Plot Images In A Directory -> Function"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8VsHUf8socjh"
      },
      "source": [
        "## Image Aug using IMAGAUG "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sm1DSjG1qrOI"
      },
      "source": [
        "dataset = glob.glob('/content/processed_data/*/*.jpeg')\n",
        "print('Total Number Of Images {}'.format(len(dataset)))\n",
        "img_files = [os.path.basename(name) for name in dataset]\n",
        "data_label = [int(name.split('/')[-2]) for name in dataset]\n",
        "\n",
        "df = pd.DataFrame({'filename':img_files,'label':data_label})"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_bj9UTSIt_Eu"
      },
      "source": [
        "df_minor = df.loc[(df['label'] !=0) & (df['label'] !=2) & (df['label'] !=1) ]\n",
        "# df_minor.head()\n",
        "\n",
        "minor_imgs =[]\n",
        "for iter,row in df_minor.iterrows():\n",
        "    fname = os.path.join(os.path.join('/content/processed_data',str(row.label)),\n",
        "                         row.filename)\n",
        "    minor_imgs.append(fname)\n",
        "print(len(minor_imgs))\n",
        "gc.collect()\n",
        "\n",
        "diabetic_imgs= minor_imgs\n",
        "diabetic_imgs = np.asarray(diabetic_imgs)\n",
        "np.random.shuffle(diabetic_imgs)\n",
        "print(diabetic_imgs.shape)\n",
        "\n",
        "\n",
        "from google.colab.patches import cv2_imshow\n",
        "plt.figure(figsize=(10, 10))\n",
        "\n",
        "\n",
        "def decode_img(filename,shape=(512,512)):\n",
        "    img = image.load_img(filename,target_size=(shape))\n",
        "    img  = image.img_to_array(img)\n",
        "    img = np.expand_dims(img,axis=0)\n",
        "    print(img.shape)\n",
        "    return img\n",
        "\n",
        "data_augmentation = tf.keras.Sequential([\n",
        "     layers.experimental.preprocessing.RandomRotation((0.1,0.3),fill_mode='nearest'),\n",
        "      layers.experimental.preprocessing.RandomZoom(0.2),\n",
        "      layers.experimental.preprocessing.RandomContrast(0.2)])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kPKEEbyGV8My"
      },
      "source": [
        "import imageio\n",
        "import warnings\n",
        "from imgaug import augmenters as iaa\n",
        "from google.colab.patches import cv2_imshow\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "plt.figure(figsize=(10, 10))\n",
        "\n",
        "seq = iaa.Sequential([\n",
        "    \t\tiaa.Crop(px=(0, 16)),\n",
        "    \t\tiaa.Fliplr(0.5),\n",
        "            iaa.Affine(rotate=(-25,25)),\n",
        "            iaa.LinearContrast(alpha=1.2),\n",
        "            iaa.GaussianBlur(sigma=1.5)\n",
        "    \t\t])\n",
        "\n",
        "def read_img(filename,shape=(512,512)):\n",
        "    img = image.load_img(filename,target_size=(shape))\n",
        "    img  = image.img_to_array(img)\n",
        "    return img\n",
        "\n",
        "def load_batch(img_list,batch=32,count=0):\n",
        "    imgs = [] \n",
        "    fnames  = []\n",
        "    i = count*batch\n",
        "    for filename in img_list[i:batch*(count+1)]:\n",
        "        img = read_img(filename)\n",
        "        imgs.append(img)\n",
        "        fnames.append(filename)\n",
        "    return imgs,fnames\n",
        "\n",
        "nb_batches  =  len(diabetic_imgs)//32\n",
        "# print(nb_batches)\n",
        "\n",
        "for idx in tqdm(range(nb_batches),position=0):\n",
        "    images,fnames = load_batch(diabetic_imgs,count=idx)\n",
        "    images_aug = seq(images=images)\n",
        "    for im, im_aug in enumerate(images_aug):\n",
        "        name = fnames[im][:-4]+'_aug_'+str(im)+'.jpeg'\n",
        "        imageio.imwrite(name, im_aug)\n",
        "\n",
        "gc.collect()\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CeHCbP2Fac9I"
      },
      "source": [
        "***Spliting Dataset***"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kKJn_i4mafLR"
      },
      "source": [
        "input_data = '/content/processed_data'\n",
        "output_data = '/content/Diabetic_Balanced_Data'\n",
        "! mkdir /content/Diabetic_Balanced_Data\n",
        "if len(os.listdir(output_data))==0:\n",
        "  splitfolders.ratio(input_data, output=output_data,seed=100, ratio=(.7, .2, .1), group_prefix=None)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4P-Fn8ylyZLL"
      },
      "source": [
        "# !zip -r /content/Diabetic_Balanced_Data.zip /content/\n",
        "!mv /content/Diabetic_Balanced_Data.zip /content/drive/MyDrive/"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X7EuBMcKC0Oj"
      },
      "source": [
        "#Model Creation\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cs05sc2ACf7f"
      },
      "source": [
        "#Hyper-Parameter Declarations \n",
        "IMG_WIDTH = 256\n",
        "IMG_HEIGHT = 256\n",
        "IMG_SHAPE=(IMG_WIDTH,IMG_HEIGHT)\n",
        "test_data = '/content/content/Diabetic_Balanced_Data/test'\n",
        "training_data = '/content/content/Diabetic_Balanced_Data/train'\n",
        "validation_data = '/content/content/Diabetic_Balanced_Data/val'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K3JR6z_5GVjQ"
      },
      "source": [
        "image_data_generator = tf.keras.preprocessing.image.ImageDataGenerator(\n",
        "  rescale = 1.0/255.0,\n",
        "  )\n",
        "\n",
        "training_datagen = image_data_generator.flow_from_directory(\n",
        "    training_data,\n",
        "    target_size=IMG_SHAPE,\n",
        "    shuffle=True,\n",
        ")\n",
        "\n",
        "validation_datagen = image_data_generator.flow_from_directory(\n",
        "    validation_data,\n",
        "    target_size=IMG_SHAPE,\n",
        "    shuffle = True\n",
        ")\n",
        "\n",
        "test_datagen = image_data_generator.flow_from_directory(\n",
        "    test_data,\n",
        "    target_size=IMG_SHAPE,\n",
        "    shuffle=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4XQpDim8od8W"
      },
      "source": [
        "# KERAS HYPERTUNER\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h4GRCmRoGFo5"
      },
      "source": [
        "# !rm -rf /content/drive/MyDrive/Diabetic_Hypertuner"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XEQga0_xohg8"
      },
      "source": [
        "import kerastuner as kt\n",
        "import tensorflow\n",
        "from tensorflow import keras\n",
        "def model_builder(hp):\n",
        "  model_type = hp.Choice('model_type',['ResNet50V2'])\n",
        "\n",
        "  if model_type == 'ResNet50V2':\n",
        "    base_model = ResNet50V2(input_shape=(IMG_WIDTH,IMG_HEIGHT,3),include_top=False,weights='imagenet')\n",
        "    head_model = base_model\n",
        "    for layers in base_model.layers[:45]:\n",
        "      layers.trainable=True\n",
        "    head_model = head_model.output\n",
        "    head_model = tf.keras.layers.GlobalMaxPooling2D()(head_model)\n",
        "    head_model = tf.keras.layers.Flatten(name=\"Flatten\")(head_model)\n",
        "    hp_units = hp.Int('units', min_value=1300, max_value=1750, step=150)\n",
        "    head_model = tf.keras.layers.Dense(hp_units,activation='relu')(head_model)\n",
        "    head_model = tf.keras.layers.Dropout(0.3)(head_model)\n",
        "    prediction_layer = tf.keras.layers.Dense(len(classes), activation='relu')(head_model)\n",
        "    model = tf.keras.Model(inputs=base_model.input,outputs=prediction_layer)\n",
        "    hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])\n",
        "    model.compile(optimizer=keras.optimizers.Adam(learning_rate=hp_learning_rate),\n",
        "                loss=tf.keras.losses.categorical_crossentropy,\n",
        "                metrics=['accuracy'])\n",
        "\n",
        "  return model\n",
        "\n",
        "\n",
        "tuner = kt.Hyperband(model_builder,\n",
        "                     objective='val_accuracy',\n",
        "                     max_epochs=10,\n",
        "                     factor=5,\n",
        "                     directory='/content/drive/MyDrive/Diabetic_Hypertuner',\n",
        "                     project_name='diabetic_parameters')\n",
        "\n",
        "stop_early = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=5)\n",
        "tuner.search(training_datagen, \n",
        "             epochs=5, \n",
        "             verbose=1,\n",
        "             shuffle=True,\n",
        "             validation_data=validation_datagen, \n",
        "             callbacks=[stop_early]\n",
        "             )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DxhxAVtYOgE-"
      },
      "source": [
        "best_hps=tuner.get_best_hyperparameters(num_trials=1)[0]\n",
        "print(best_hps)\n",
        "model = tuner.hypermodel.build(best_hps)\n",
        "history = model.fit(training_datagen, epochs=20,validation_data=validation_datagen)\n",
        "\n",
        "val_acc_per_epoch = history.history['val_accuracy']\n",
        "best_epoch = val_acc_per_epoch.index(max(val_acc_per_epoch)) + 1\n",
        "print('Best epoch: %d' % (best_epoch,))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9AhoBnHlrCpd"
      },
      "source": [
        "# Model "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "725vqnQpaSGF"
      },
      "source": [
        "%load_ext tensorboard\n",
        "from datetime import datetime\n",
        "import os"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "no7dKu98rAb9"
      },
      "source": [
        "def define_model(n_layers=45,BASE_MODEL='ResNet50V2'):\n",
        "    if BASE_MODEL =='ResNet50V2':\n",
        "        # Pre-trained model with MobileNetV2\n",
        "        base_model = ResNet50V2(input_shape=(IMG_WIDTH,IMG_HEIGHT,3),include_top=False,weights='imagenet')\n",
        "        head_model = base_model\n",
        "        for layers in base_model.layers[:n_layers]:\n",
        "            layers.trainable=True\n",
        "        head_model = head_model.output\n",
        "        head_model = tf.keras.layers.GlobalMaxPooling2D()(head_model)\n",
        "        head_model = tf.keras.layers.Flatten(name=\"Flatten\")(head_model)\n",
        "        head_model = tf.keras.layers.Dense(1600,activation='relu')(head_model)\n",
        "        head_model = tf.keras.layers.Dropout(0.2)(head_model)\n",
        "        prediction_layer = tf.keras.layers.Dense(len(classes), activation='softmax')(head_model)\n",
        "        model = tf.keras.Model(inputs=base_model.input,outputs=prediction_layer)\n",
        "    \n",
        "    if BASE_MODEL =='InceptionV3':\n",
        "        base_model = InceptionV3(input_shape=(IMG_WIDTH,IMG_HEIGHT,3),include_top=False,weights='imagenet')\n",
        "        head_model = base_model\n",
        "        for layers in base_model.layers[:n_layers]:\n",
        "            layers.trainable=False\n",
        "        \n",
        "        head_model = head_model.output\n",
        "        head_model = tf.keras.layers.GlobalMaxPooling2D()(head_model)\n",
        "        head_model = tf.keras.layers.Flatten(name=\"Flatten\")(head_model)\n",
        "        head_model = tf.keras.layers.Dense(1024,activation='relu')(head_model)\n",
        "        head_model = tf.keras.layers.Dropout(0.5)(head_model)\n",
        "        prediction_layer = tf.keras.layers.Dense(len(classes), activation='softmax')(head_model)\n",
        "        model = tf.keras.Model(inputs=base_model.input,outputs=prediction_layer)\n",
        "    return model\n",
        "\n",
        "# define Model \n",
        "model= define_model(BASE_MODEL='ResNet50V2')\n",
        "\n",
        "#Compilation of the model\n",
        "model.compile(\n",
        "    loss='categorical_crossentropy', \n",
        "    optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001), \n",
        "    metrics=['accuracy'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "saPifif4Jujw"
      },
      "source": [
        "checkpoint_path = \"/content/drive/MyDrive/Custom_Weights\"\n",
        "\n",
        "cp_callback = ModelCheckpoint(\n",
        "                              filepath=checkpoint_path,\n",
        "                              save_weights_only=True,\n",
        "                              monitor='val_loss',\n",
        "                              verbose=1,\n",
        "                              save_best_only=True,mode='min')\n",
        "\n",
        "learning_rate_reduction = ReduceLROnPlateau(\n",
        "                                            monitor='val_accuracy', \n",
        "                                            patience = 2, \n",
        "                                            verbose=1,\n",
        "                                            factor=0.3,\n",
        "                                            min_lr=0.00001)\n",
        "\n",
        "logdir = \"logs/scalars/\" + datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
        "tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=logdir)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JmmCC4OyKoYQ"
      },
      "source": [
        "%tensorboard --logdir logs/scalars\n",
        "history = model.fit(\n",
        "    training_datagen,\n",
        "    epochs=12,\n",
        "    steps_per_epoch=1000, \n",
        "    shuffle=True,\n",
        "    validation_data=validation_datagen,\n",
        "    callbacks=[cp_callback,learning_rate_reduction,tensorboard_callback])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dEy3CX5cWkGl"
      },
      "source": [
        "import gc\n",
        "gc.collect()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uCUNJvwgV4Hp"
      },
      "source": [
        "import tensorflow as tf\n",
        "tf.saved_model.save(model,'/content/drive/MyDrive/Diabetic_Weight')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_kp-6f5bjnbr"
      },
      "source": [
        "from tensorflow.keras.models import load_model\n",
        "from tensorflow.keras.preprocessing import image\n",
        "from os.path import join\n",
        "diab_model = load_model('/content/drive/MyDrive/Diabetic_Weight')\n",
        "shape = (256,256)\n",
        "def decode_img(image_path,shape):\n",
        "    img = tf.keras.preprocessing.image.load_img(filename,target_size=(shape))\n",
        "    img = tf.keras.preprocessing.image.img_to_array(img) # converted to ndarray \n",
        "    img = img.astype(np.float32)/255.0\n",
        "    img = np.expand_dims(img,axis=0)\n",
        "    return img"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WMjp7MfBpkaq",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 305
        },
        "outputId": "bccfae61-4caa-46e8-8d89-9263dd04399f"
      },
      "source": [
        "import glob\n",
        "import random\n",
        "test_img = glob.glob('/content/content/Diabetic_Balanced_Data/test/*/*.jpeg')\n",
        "img_select = random.randint(1,len(test_img))\n",
        "\n",
        "print(test_img[img_select])\n",
        "img = plt.imread(test_img[img_select])\n",
        "plt.imshow(img,cmap = 'gray')"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/content/content/Diabetic_Balanced_Data/test/3/12014_left._aug_26.jpeg\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fcf85ca0490>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z_ko0omgjriV",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 425
        },
        "outputId": "7ac1a7a1-e36b-4ae1-de39-25117bc7437f"
      },
      "source": [
        "test_data =glob.glob('/content/content/Diabetic_Balanced_Data/test/*/*.jpeg')\n",
        "print(\"Test data \",len(test_data))\n",
        "img_files = [os.path.basename(name) for name in test_data]\n",
        "test_label = [name.split('/')[-2] for name in test_data]\n",
        "test_df = pd.DataFrame({'filename':img_files,'label':test_label,})\n",
        "test_df.to_csv('test_data.csv')\n",
        "test_df\n",
        "\n",
        "\n",
        "# img_select = random.randint(1,len(test_data))\n",
        "# from google.colab import files\n",
        "# print(test_data[img_select])\n",
        "# files.download(test_data[img_select])"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Test data  4971\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>filename</th>\n",
              "      <th>label</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>2536_left.jpeg</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>15154_left.jpeg</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>10043_right._aug_3.jpeg</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>21184_right.jpeg</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>28629_right.jpeg</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4966</th>\n",
              "      <td>33535_left._aug_26._aug_8.jpeg</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4967</th>\n",
              "      <td>41739_left._aug_6._aug_22.jpeg</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4968</th>\n",
              "      <td>35748_right._aug_19._aug_11.jpeg</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4969</th>\n",
              "      <td>21978_right._aug_26.jpeg</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4970</th>\n",
              "      <td>22349_right.jpeg</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>4971 rows × 2 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "                              filename label\n",
              "0                       2536_left.jpeg     2\n",
              "1                      15154_left.jpeg     2\n",
              "2              10043_right._aug_3.jpeg     2\n",
              "3                     21184_right.jpeg     2\n",
              "4                     28629_right.jpeg     2\n",
              "...                                ...   ...\n",
              "4966    33535_left._aug_26._aug_8.jpeg     1\n",
              "4967    41739_left._aug_6._aug_22.jpeg     1\n",
              "4968  35748_right._aug_19._aug_11.jpeg     1\n",
              "4969          21978_right._aug_26.jpeg     1\n",
              "4970                  22349_right.jpeg     1\n",
              "\n",
              "[4971 rows x 2 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5BTzcjKdk9tQ"
      },
      "source": [
        "predictions = []\n",
        "for iter,row in test_df.iterrows():\n",
        "  filename = join('/content/content/Diabetic_Balanced_Data/test/',join(row.label,row.filename))\n",
        "  img = decode_img(filename,shape)\n",
        "  pred = diab_model.predict(img)\n",
        "  y_classes = np.argmax(pred)\n",
        "  #print(y_classes)\n",
        "  predictions.append(pred)"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-TPLL32FlXUd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 235
        },
        "outputId": "702a1b80-0128-4b3d-dc2c-3510d6b3a6e4"
      },
      "source": [
        "test_df['pred_label']=predictions\n",
        "print(predictions[0])\n",
        "test_df.head()"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1.05468184e-01 8.88308227e-01 6.17207866e-03 5.14195199e-05\n",
            "  5.67653800e-08]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>filename</th>\n",
              "      <th>label</th>\n",
              "      <th>pred_label</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>2536_left.jpeg</td>\n",
              "      <td>2</td>\n",
              "      <td>[[0.105468184, 0.8883082, 0.0061720787, 5.1419...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>15154_left.jpeg</td>\n",
              "      <td>2</td>\n",
              "      <td>[[0.9537435, 0.0045988676, 0.0416576, 7.447361...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>10043_right._aug_3.jpeg</td>\n",
              "      <td>2</td>\n",
              "      <td>[[0.013901692, 0.00025202942, 0.22800773, 8.31...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>21184_right.jpeg</td>\n",
              "      <td>2</td>\n",
              "      <td>[[0.15736373, 0.83371973, 0.008916474, 8.25949...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>28629_right.jpeg</td>\n",
              "      <td>2</td>\n",
              "      <td>[[0.001959907, 0.0005634585, 0.99747664, 1.420...</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                  filename  ...                                         pred_label\n",
              "0           2536_left.jpeg  ...  [[0.105468184, 0.8883082, 0.0061720787, 5.1419...\n",
              "1          15154_left.jpeg  ...  [[0.9537435, 0.0045988676, 0.0416576, 7.447361...\n",
              "2  10043_right._aug_3.jpeg  ...  [[0.013901692, 0.00025202942, 0.22800773, 8.31...\n",
              "3         21184_right.jpeg  ...  [[0.15736373, 0.83371973, 0.008916474, 8.25949...\n",
              "4         28629_right.jpeg  ...  [[0.001959907, 0.0005634585, 0.99747664, 1.420...\n",
              "\n",
              "[5 rows x 3 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "903THP0ImaJw"
      },
      "source": [
        "y_test = test_df['label'].astype(int)\n",
        "y_pred = test_df['pred_label']"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c56BS8bOon4z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "61f7da5f-9ddb-40a2-b39b-2f7ba7e7d576"
      },
      "source": [
        "y_pred = test_df.apply(lambda row: np.argmax(list(row['pred_label'])) , axis=1)\n",
        "print(y_test)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0       2\n",
            "1       2\n",
            "2       2\n",
            "3       2\n",
            "4       2\n",
            "       ..\n",
            "4966    1\n",
            "4967    1\n",
            "4968    1\n",
            "4969    1\n",
            "4970    1\n",
            "Name: label, Length: 4971, dtype: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CPI9My4Soo10",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0ab81830-5bad-424d-cf25-e9ede17206e9"
      },
      "source": [
        "import itertools\n",
        "from sklearn.metrics import classification_report,confusion_matrix,accuracy_score\n",
        "print(classification_report(y_test, y_pred))\n",
        "cnf_matrix = confusion_matrix(y_test,y_pred)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.61      0.57      0.59      1000\n",
            "           1       0.62      0.68      0.65       971\n",
            "           2       0.58      0.59      0.58      1000\n",
            "           3       0.91      0.86      0.89      1000\n",
            "           4       0.94      0.93      0.93      1000\n",
            "\n",
            "    accuracy                           0.73      4971\n",
            "   macro avg       0.73      0.73      0.73      4971\n",
            "weighted avg       0.73      0.73      0.73      4971\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5SwrRTd9sNxg",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 713
        },
        "outputId": "2575a485-42be-412a-c969-cd0d750e8844"
      },
      "source": [
        "def plot_confusion_matrix(cm, classes, title='Confusion matrix', cmap=plt.cm.Blues):\n",
        "    cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
        "    plt.figure(figsize=(10,10))\n",
        "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
        "    plt.title(title)\n",
        "    plt.colorbar()\n",
        "    tick_marks = np.arange(len(classes))\n",
        "    plt.xticks(tick_marks, classes, rotation=45)\n",
        "    plt.yticks(tick_marks, classes)\n",
        "\n",
        "    fmt = '.2f'\n",
        "    thresh = cm.max() / 2.\n",
        "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
        "        plt.text(j, i, format(cm[i, j], fmt),\n",
        "                 horizontalalignment=\"center\",\n",
        "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
        "\n",
        "    plt.ylabel('True label')\n",
        "    plt.xlabel('Predicted label')\n",
        "    plt.tight_layout()\n",
        "\n",
        "np.set_printoptions(precision=2)\n",
        "\n",
        "\n",
        "# plot normalized confusion matrix\n",
        "plt.figure()\n",
        "plot_confusion_matrix(cnf_matrix, classes=classes, title='Normalized confusion matrix')\n",
        "plt.show()"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DBU_bak1Ub7P"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}