MURA_DenseNet_Prediction_v1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "MURA-DenseNet-Prediction.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyNK5nMwCYqeAu2A4REsd2EA"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VPz1RlDzUQL0"
      },
      "source": [
        "# MURA-Densenet-v1.7-Humerus\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zL4-xYNJQNMb"
      },
      "source": [
        "!pip install focal-loss\n",
        "!pip install keras-radam"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mkjRfywGQWRn"
      },
      "source": [
        "import os\n",
        "import numpy as np\n",
        "import cv2\n",
        "import random\n",
        "import pandas as pd\n",
        "from tqdm import tqdm\n",
        "import keras.backend as K\n",
        "import matplotlib.pyplot as plt\n",
        "import keras\n",
        "import keras.backend as K\n",
        "from keras.models import Model\n",
        "from keras.layers import Input, Dense, Conv2D, Conv3D, DepthwiseConv2D, SeparableConv2D, Conv3DTranspose\n",
        "from keras.layers import Flatten, MaxPool2D, AvgPool2D, GlobalAvgPool2D, UpSampling2D, BatchNormalization\n",
        "from keras.layers import Concatenate, Add, Dropout, ReLU, Lambda, Activation, LeakyReLU, PReLU\n",
        "from keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint, Callback\n",
        "from keras.preprocessing.image import ImageDataGenerator, load_img#, image\n",
        "from keras import regularizers\n",
        "from IPython.display import SVG\n",
        "from keras.utils.vis_utils import model_to_dot\n",
        "from keras.applications.densenet import DenseNet169, DenseNet121, preprocess_input\n",
        "from time import time\n",
        "\n",
        "\n",
        "from focal_loss import BinaryFocalLoss\n",
        "from keras_radam import RAdam\n",
        "\n",
        "import datetime"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SE2tMLbKQZsU"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "txkV3l09Qdij"
      },
      "source": [
        "!unzip '/content/drive/My Drive/Dataset/MURA-v1.1.zip' "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-sa-ji_TQmmV"
      },
      "source": [
        "def listdir_nohidden(path):\n",
        "    '''\n",
        "    Utility function to find the list of files in a directory excluding the hidden files.\n",
        "    Args:\n",
        "        path: contains the path of the directory containing the images\n",
        "\n",
        "    '''\n",
        "    for f in os.listdir(path):\n",
        "        if not f.startswith('.'):\n",
        "            yield f"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4iU6lPsjQ4Qy"
      },
      "source": [
        "def create_images_metadata_csv(category,study_types):\n",
        "    '''\n",
        "    This function creates a csv file containing the path of images, label.\n",
        "    Args:\n",
        "        category: train or valid, depending on which csv is needed\n",
        "        study_types: the type of the body part in MURA Dataset, eg:  XR_SHOULDER\n",
        "    '''\n",
        "    image_data = {}\n",
        "    study_label = {'positive': 1, 'negative': 0}\n",
        "    #study_types = ['XR_ELBOW','XR_FINGER','XR_FOREARM','XR_HAND','XR_HUMERUS','XR_SHOULDER','XR_WRIST']\n",
        "    #study_types = ['XR_ELBOW']\n",
        "    i = 0\n",
        "    image_data[category] = pd.DataFrame(columns=['Path','Count', 'Label'])\n",
        "    for study_type in study_types: # Iterate throught every study types\n",
        "        DATA_DIR = 'MURA-v1.1/%s/%s/' % (category, study_type)\n",
        "        patients = list(os.walk(DATA_DIR))[0][1]  # list of patient folder names\n",
        "        for patient in tqdm(patients):  # for each patient folder\n",
        "            for study in os.listdir(DATA_DIR + patient):  # for each study in that patient folder\n",
        "                if(study != '.DS_Store'):\n",
        "                    label = study_label[study.split('_')[1]]  # get label 0 or 1\n",
        "                    path = DATA_DIR + patient + '/' + study + '/'  # path to this study\n",
        "                    for j in range(len(list(listdir_nohidden(path)))):\n",
        "                        image_path = path + 'image%s.png' % (j + 1)\n",
        "                        image_data[category].loc[i] = [image_path,1, label]  # add new row\n",
        "                        i += 1\n",
        "    image_data[category].to_csv(category+\"_image_data.csv\",index = None, header=False)"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x0KgZTeDQ7ib"
      },
      "source": [
        "def getImageLabels(dataframe):\n",
        "  '''\n",
        "  This function is to get the labels of the images from the dataframe\n",
        "  Args:\n",
        "      dataframe: pandas dataframe containing the labels of the images\n",
        "\n",
        "  '''\n",
        "  labels = []\n",
        "  for i, data in tqdm(dataframe.iterrows()):\n",
        "#        img = cv2.imread(data['Path'])\n",
        "#         #random rotation\n",
        "#         angle = random.randint(-30,30)\n",
        "#         M = cv2.getRotationMatrix2D((img_width/2,img_height/2),angle,1)\n",
        "#         img = cv2.warpAffine(img,M,(img_width,img_height))\n",
        "      #resize\n",
        "#        img = cv2.resize(img,(img_width,img_height))    \n",
        "#        img = img[...,::-1].astype(np.float32)\n",
        "#        images.append(img)\n",
        "      labels.append(data['Label'])\n",
        "#    images = np.asarray(images).astype('float32') \n",
        "  #normalization\n",
        "#    mean = np.mean(images[:, :, :])\n",
        "#    std = np.std(images[:, :, :])\n",
        "#    images[:, :, :] = (images[:, :, :] - mean) / std\n",
        "  labels = np.asarray(labels)\n",
        "  return labels"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZLbE7a2NQ-rO"
      },
      "source": [
        "def getImage(dataframe, size):\n",
        "    '''\n",
        "    Function to process the images\n",
        "    Args:\n",
        "        dataframe: contains the path to the images in the directory\n",
        "        size: contains the value to which the shape of the image will resized\n",
        "    '''\n",
        "    Images = []\n",
        "    for i, data in tqdm(dataframe.iterrows()):\n",
        "      try:\n",
        "        image = cv2.imread(data['Path'])#cv2.IMREAD_GRAYSCALE)\n",
        "        image = cv2.resize(image,(size,size))\n",
        "        #image = randome_rotation_flip(image,size)\n",
        "        Images.append(image)\n",
        "\n",
        "      except Exception as e:\n",
        "        print(str(e))\n",
        "\n",
        "    Images = np.asarray(Images).astype('float32')\n",
        "\n",
        "    mean = np.mean(Images)\t\t\t#normalization\n",
        "    std = np.std(Images)\n",
        "    Images = (Images - mean) / std\n",
        "    \n",
        "    #if K.image_data_format() == \"channels_first\":\n",
        "    #  Images = np.expand_dims(Images,axis=3)\t\t   #Extended dimension 1\n",
        "    #if K.image_data_format() == \"channels_last\":\n",
        "    #  Images = np.expand_dims(Images,axis=3)             #Extended dimension 3(usebackend tensorflow:aixs=3; theano:axixs=1) \n",
        "    return Images\n"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5DfIyvgFREaz"
      },
      "source": [
        "def build_model():\n",
        "    base_model = DenseNet169(input_shape=(None, None,3),\n",
        "                             weights='imagenet',\n",
        "                             include_top=False,\n",
        "                             pooling='avg')\n",
        "\n",
        "\n",
        "    x = base_model.output\n",
        "\n",
        "    predictions = Dense(n_classes,activation='sigmoid')(x)\n",
        "    model = Model(inputs=base_model.input, outputs=predictions)\n",
        "    return model"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XSGVIWqDUCfr"
      },
      "source": [
        "### Data Preprocessing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S-rZwni8Rizb",
        "outputId": "49a4fb48-db03-4975-ac67-5f8006fe8542"
      },
      "source": [
        "###################\n",
        "# Data processing #\n",
        "###################\n",
        "\n",
        "img_width, img_height = 224, 224\n",
        "#Keras ImageDataGenerator to load, transform the images of the dataset\n",
        "\n",
        "IMG_DATA_DIR = 'MURA-v1.1/'\n",
        "train_data_dir = IMG_DATA_DIR + 'train/XR_HUMERUS'\n",
        "valid_data_dir = IMG_DATA_DIR + 'valid/XR_HUMERUS'\n",
        "\n",
        "train_datagen = ImageDataGenerator(\n",
        "    rotation_range=30,\n",
        "    horizontal_flip=True\n",
        ")\n",
        "\n",
        "test_datagen = ImageDataGenerator(\n",
        "    rotation_range=30,\n",
        "    horizontal_flip=True\n",
        "\n",
        ")\n",
        "study_types = ['XR_HUMERUS']\n",
        "\n",
        "#TRAIN DATA\n",
        "create_images_metadata_csv('train',study_types)\n",
        "#VALID DATA\n",
        "create_images_metadata_csv('valid',study_types)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "100%|██████████| 587/587 [00:03<00:00, 168.30it/s]\n",
            "100%|██████████| 132/132 [00:00<00:00, 174.79it/s]\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LJztmkXwRn6Z"
      },
      "source": [
        "valid_image_df = pd.read_csv('valid_image_data.csv', names=['Path','Count', 'Label'])\n",
        "train_image_df = pd.read_csv('train_image_data.csv', names=['Path', 'Count','Label'])\n",
        "\n",
        "dd={}\n",
        "\n",
        "dd['train'] = train_image_df\n",
        "dd['valid'] = valid_image_df"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aujYyGwQRr7H",
        "outputId": "eebc49ea-cc9f-4c23-b3cc-3553eff9d635"
      },
      "source": [
        "train_image_labels = getImageLabels(train_image_df)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1272it [00:00, 14185.88it/s]\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9z7Onjv-Ruoa",
        "outputId": "712e36b6-c14f-4bbb-d826-2f955b6f91f4"
      },
      "source": [
        "train_images = getImage(train_image_df, size = 224)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1272it [00:04, 275.51it/s]\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-vjDo-M65Bvp",
        "outputId": "e0c9ff63-1aac-405d-d7e0-0e80b6ffeb39"
      },
      "source": [
        "train_images.shape\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1272, 224, 224, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_TxiT79kRyGc"
      },
      "source": [
        "train_datagen.fit(train_images,augment=True)"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VCSwarbzR0rB"
      },
      "source": [
        "train_generator = train_datagen.flow(\n",
        "    x=train_images,\n",
        "    y=train_image_labels,\n",
        "    batch_size = 32\n",
        ")"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_L6c6SP2R624",
        "outputId": "0e5ecda7-c666-46a9-8787-211717d0acf2"
      },
      "source": [
        "valid_image_labels = getImageLabels(valid_image_df)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "288it [00:00, 12859.12it/s]\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OLvYk_lhR_Dv",
        "outputId": "5da09bd4-afc4-49ff-bae6-8cfa921efe35"
      },
      "source": [
        "valid_images = getImage(valid_image_df, size = 224)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "288it [00:01, 238.97it/s]\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sM_-sFxfSDK9"
      },
      "source": [
        "test_datagen.fit(valid_images,augment=True)"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yTdsSZXaSF-l"
      },
      "source": [
        "validation_generator = test_datagen.flow(\n",
        "    x=valid_images,\n",
        "    y=valid_image_labels,\n",
        "    batch_size = 1\n",
        ")"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cxdZ6l6kf-un"
      },
      "source": [
        "### Recontructed Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DHUKibR_f8jQ"
      },
      "source": [
        "from keras.models import load_model\n",
        "#reconstructed_model = load_model('MURA-DenseNet-v1.7-Humerus.h5')\n",
        "reconstructed_model = load_model('/content/drive/My Drive/Models/MURA-DenseNet-v1.7-Humerus.h5') "
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k82w-Nj9h3BE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5170626f-c92c-4ba9-e85a-2e2be9842c04"
      },
      "source": [
        "nb_validation_samples = len(valid_images)\n",
        "ev = reconstructed_model.evaluate(validation_generator, steps=nb_validation_samples,  workers=0, use_multiprocessing=False)\n",
        "ev[1]"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "288/288 [==============================] - 44s 27ms/step - loss: 0.1080 - acc: 0.8368 - mse: 0.1420\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.8368055820465088"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZL0V-EJzhcFR"
      },
      "source": [
        "validation_generator.reset()\n",
        "pred_batch = reconstructed_model.predict_on_batch(valid_images)"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PR6VSCjkhlbm"
      },
      "source": [
        "predictions = []\n",
        "for p in pred_batch:\n",
        "    if(p > 0.5):\n",
        "        predictions+=[1]\n",
        "    else:\n",
        "        predictions+=[0]"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C_KIapKihmeB"
      },
      "source": [
        "error = np.sum(np.not_equal(predictions, valid_image_labels)) / valid_image_labels.shape[0]  \n",
        "pred = predictions"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JASSNiwATgQR"
      },
      "source": [
        "### Confusion Matric"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 841
        },
        "id": "F95xLw23SNwZ",
        "outputId": "825c5de9-86fb-4602-baf8-7702abf13c96"
      },
      "source": [
        "print('Confusion Matrix')\n",
        "from sklearn.metrics import confusion_matrix, classification_report, cohen_kappa_score\n",
        "import seaborn as sn\n",
        "cm = confusion_matrix( pred ,valid_image_labels)\n",
        "plt.figure(figsize = (30,20))\n",
        "sn.set(font_scale=1.4) #for label size\n",
        "sn.heatmap(cm, annot=True, annot_kws={\"size\": 20},cmap=\"YlGnBu\") # font size\n",
        "plt.show()"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Confusion Matrix\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 2160x1440 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j5ol92wUBImh"
      },
      "source": [
        "def make_confusion_matrix(cf,\n",
        "                          group_names=None,\n",
        "                          categories='auto',\n",
        "                          count=True,\n",
        "                          percent=True,\n",
        "                          cbar=True,\n",
        "                          xyticks=True,\n",
        "                          xyplotlabels=True,\n",
        "                          sum_stats=True,\n",
        "                          figsize=None,\n",
        "                          cmap='Blues',\n",
        "                          title=None):\n",
        "    '''\n",
        "    This function will make a pretty plot of an sklearn Confusion Matrix cm using a Seaborn heatmap visualization.\n",
        "    Arguments\n",
        "    ---------\n",
        "    cf:            confusion matrix to be passed in\n",
        "    group_names:   List of strings that represent the labels row by row to be shown in each square.\n",
        "    categories:    List of strings containing the categories to be displayed on the x,y axis. Default is 'auto'\n",
        "    count:         If True, show the raw number in the confusion matrix. Default is True.\n",
        "    normalize:     If True, show the proportions for each category. Default is True.\n",
        "    cbar:          If True, show the color bar. The cbar values are based off the values in the confusion matrix.\n",
        "                   Default is True.\n",
        "    xyticks:       If True, show x and y ticks. Default is True.\n",
        "    xyplotlabels:  If True, show 'True Label' and 'Predicted Label' on the figure. Default is True.\n",
        "    sum_stats:     If True, display summary statistics below the figure. Default is True.\n",
        "    figsize:       Tuple representing the figure size. Default will be the matplotlib rcParams value.\n",
        "    cmap:          Colormap of the values displayed from matplotlib.pyplot.cm. Default is 'Blues'\n",
        "                   See http://matplotlib.org/examples/color/colormaps_reference.html\n",
        "                   \n",
        "    title:         Title for the heatmap. Default is None.\n",
        "    '''\n",
        "\n",
        "\n",
        "    # CODE TO GENERATE TEXT INSIDE EACH SQUARE\n",
        "    blanks = ['' for i in range(cf.size)]\n",
        "\n",
        "    if group_names and len(group_names)==cf.size:\n",
        "        group_labels = [\"{}\\n\".format(value) for value in group_names]\n",
        "    else:\n",
        "        group_labels = blanks\n",
        "\n",
        "    if count:\n",
        "        group_counts = [\"{0:0.0f}\\n\".format(value) for value in cf.flatten()]\n",
        "    else:\n",
        "        group_counts = blanks\n",
        "\n",
        "    if percent:\n",
        "        group_percentages = [\"{0:.2%}\".format(value) for value in cf.flatten()/np.sum(cf)]\n",
        "    else:\n",
        "        group_percentages = blanks\n",
        "\n",
        "    box_labels = [f\"{v1}{v2}{v3}\".strip() for v1, v2, v3 in zip(group_labels,group_counts,group_percentages)]\n",
        "    box_labels = np.asarray(box_labels).reshape(cf.shape[0],cf.shape[1])\n",
        "\n",
        "\n",
        "    # CODE TO GENERATE SUMMARY STATISTICS & TEXT FOR SUMMARY STATS\n",
        "    if sum_stats:\n",
        "        #Accuracy is sum of diagonal divided by total observations\n",
        "        accuracy  = np.trace(cf) / float(np.sum(cf))\n",
        "\n",
        "        #if it is a binary confusion matrix, show some more stats\n",
        "        if len(cf)==2:\n",
        "            #Metrics for Binary Confusion Matrices\n",
        "            recall = cf[1,1] / sum(cf[:,1])\n",
        "            precision    = cf[1,1] / sum(cf[1,:])\n",
        "            f1_score  = 2*precision*recall / (precision + recall)\n",
        "            stats_text = \"\\n\\nAccuracy={:0.3f}\\nPrecision={:0.3f}\\nRecall={:0.3f}\\nF1 Score={:0.3f}\".format(\n",
        "                accuracy,precision,recall,f1_score)\n",
        "        else:\n",
        "            stats_text = \"\\n\\nAccuracy={:0.3f}\".format(accuracy)\n",
        "    else:\n",
        "        stats_text = \"\"\n",
        "\n",
        "\n",
        "    # SET FIGURE PARAMETERS ACCORDING TO OTHER ARGUMENTS\n",
        "    if figsize==None:\n",
        "        #Get default figure size if not set\n",
        "        figsize = plt.rcParams.get('figure.figsize')\n",
        "\n",
        "    if xyticks==False:\n",
        "        #Do not show categories if xyticks is False\n",
        "        categories=False\n",
        "\n",
        "\n",
        "    # MAKE THE HEATMAP VISUALIZATION\n",
        "    plt.figure(figsize=figsize)\n",
        "    sn.heatmap(cf,annot=box_labels,fmt=\"\",cmap=cmap,cbar=cbar,xticklabels=categories,yticklabels=categories)\n",
        "\n",
        "    if xyplotlabels:\n",
        "        plt.ylabel('True label')\n",
        "        plt.xlabel('Predicted label' + stats_text)\n",
        "    else:\n",
        "        plt.xlabel(stats_text)\n",
        "    \n",
        "    if title:\n",
        "        plt.title(title)"
      ],
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 399
        },
        "id": "t-LoYltHBVAp",
        "outputId": "fa3753c7-37bf-40c9-e148-2a87070c5491"
      },
      "source": [
        "labels = ['True Neg','False Pos','False Neg','True Pos']\n",
        "categories = ['Zero', 'One']\n",
        "make_confusion_matrix(cm, \n",
        "                      group_names=labels,\n",
        "                      categories=categories, \n",
        "                      cmap='binary')\n"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RqhrvxQiS-SE"
      },
      "source": [
        "### Kappa score"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HRJV6FhcSQnx",
        "outputId": "8522de7c-7ea3-4ccc-b767-54d8517867cd"
      },
      "source": [
        "from sklearn.metrics import confusion_matrix, classification_report, cohen_kappa_score\n",
        "cohen_kappa_score(valid_image_labels, pred)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.6800618238021638"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q2vCGxRT_FIk"
      },
      "source": [
        "### Classification report"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zf5Q9YhvSaYO",
        "outputId": "07c7fe05-6d7f-449e-a553-dae6e4b4b76b"
      },
      "source": [
        "print()\n",
        "print('Classification Report')\n",
        "print(classification_report(valid_image_labels, pred, target_names=[\"0\",\"1\"]))"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Classification Report\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.84      0.86      0.85       148\n",
            "           1       0.85      0.82      0.83       140\n",
            "\n",
            "    accuracy                           0.84       288\n",
            "   macro avg       0.84      0.84      0.84       288\n",
            "weighted avg       0.84      0.84      0.84       288\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xG2ozPVsTCBz"
      },
      "source": [
        "### ROC score"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nLx_MV7pS2sd"
      },
      "source": [
        "from sklearn.metrics import roc_curve\n",
        "fpr_keras, tpr_keras, thresholds_keras = roc_curve(valid_image_labels, pred_batch)"
      ],
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "crergcMnTOIH"
      },
      "source": [
        "from sklearn.metrics import auc\n",
        "auc_keras = auc(fpr_keras, tpr_keras)"
      ],
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 613
        },
        "id": "_D71aDlDTUMj",
        "outputId": "79c490a0-0e48-479c-a120-e35d6260ae95"
      },
      "source": [
        "plt.figure(1)\n",
        "plt.plot([0, 1], [0, 1], 'k--')\n",
        "plt.plot(fpr_keras, tpr_keras, label='Proposed Model (area = {:.3f})'.format(auc_keras))\n",
        "plt.xlabel('False positive rate')\n",
        "plt.ylabel('True positive rate')\n",
        "plt.title('ROC curve')\n",
        "plt.legend(loc='best')\n",
        "plt.show()\n",
        "\n",
        "plt.figure(2)\n",
        "plt.xlim(0.0, 0.2)\n",
        "plt.ylim(0.65, 0.9)\n",
        "plt.plot([0, 1], [0, 1], 'k--')\n",
        "plt.plot(fpr_keras, tpr_keras, label='Proposed Model (area = {:.3f})'.format(auc_keras))\n",
        "plt.xlabel('False positive rate')\n",
        "plt.ylabel('True positive rate')\n",
        "plt.title('ROC curve (zoomed in at top left)')\n",
        "plt.legend(loc='best')\n",
        "plt.show()"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    }
  ]
}