Evaluation_Model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "af59e4f3-cfa8-401f-b260-3c62b7891122",
   "metadata": {},
   "source": [
    "\"\"\"\n",
    "~ task: Evaluate classification confussion matrix ~\n",
    "\n",
    "@ author: Teodora Trandafir \n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1d868cb4-fc95-40a1-af42-66ffcaf305f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' Update '"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\" Update \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4d673d80-d260-4472-9fcc-29bf122a1005",
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "import numpy as np \n",
    "%matplotlib inline\n",
    "import math\n",
    "import random\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import datetime\n",
    "import json\n",
    "import pandas as pd\n",
    "import six\n",
    "import csv\n",
    "\n",
    "import os\n",
    "import glob \n",
    "import sys\n",
    "import shutil\n",
    "from skimage import io\n",
    "from scipy import misc\n",
    "\n",
    "#import cv2\n",
    "from PIL import Image\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow.python.framework import tensor_util\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.models import *\n",
    "from tensorflow.keras.models import model_from_json, Sequential\n",
    "from tensorflow.keras.applications import InceptionResNetV2, ResNet50 \n",
    "from tensorflow.keras.layers import *\n",
    "from tensorflow.keras.layers import Lambda, Dense, Flatten, GlobalAveragePooling2D\n",
    "from tensorflow.keras.optimizers import *\n",
    "from tensorflow.keras.losses import *\n",
    "from tensorflow.keras.activations import softmax\n",
    "from tensorflow.keras.callbacks import ModelCheckpoint, LearningRateScheduler, History, EarlyStopping, ReduceLROnPlateau\n",
    "from tensorflow.keras.utils import load_img\n",
    "from tensorflow.keras.preprocessing.image import DirectoryIterator, ImageDataGenerator\n",
    "\n",
    "\n",
    "import sklearn\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, cohen_kappa_score, roc_auc_score, multilabel_confusion_matrix, classification_report, confusion_matrix,RocCurveDisplay\n",
    "from sklearn.model_selection import StratifiedGroupKFold, GroupKFold\n",
    "from sklearn.utils import class_weight\n",
    "from sklearn.preprocessing import LabelEncoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "aa1de9c6-afdc-406c-a336-73efdd78e622",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.8.0\n",
      "1.1.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-08-01 14:16:01.690549: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-08-01 14:16:01.713742: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-08-01 14:16:01.713842: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n"
     ]
    }
   ],
   "source": [
    "print(tf.__version__)\n",
    "tf.config.list_physical_devices('GPU')\n",
    "print(sklearn.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7ca8b301-37e1-45d1-b193-c016804596e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thu Aug  1 14:16:01 2024       \n",
      "+-----------------------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 550.67                 Driver Version: 550.67         CUDA Version: 12.4     |\n",
      "|-----------------------------------------+------------------------+----------------------+\n",
      "| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |\n",
      "|                                         |                        |               MIG M. |\n",
      "|=========================================+========================+======================|\n",
      "|   0  NVIDIA GeForce RTX 3090        Off |   00000000:01:00.0 Off |                  N/A |\n",
      "|  0%   32C    P8             16W /  420W |     277MiB /  24576MiB |      0%      Default |\n",
      "|                                         |                        |                  N/A |\n",
      "+-----------------------------------------+------------------------+----------------------+\n",
      "                                                                                         \n",
      "+-----------------------------------------------------------------------------------------+\n",
      "| Processes:                                                                              |\n",
      "|  GPU   GI   CI        PID   Type   Process name                              GPU Memory |\n",
      "|        ID   ID                                                               Usage      |\n",
      "|=========================================================================================|\n",
      "|    0   N/A  N/A      5850      G   /usr/lib/xorg/Xorg                              4MiB |\n",
      "|    0   N/A  N/A      5939    C+G   ...libexec/gnome-remote-desktop-daemon        258MiB |\n",
      "+-----------------------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6656e333-b257-4535-a957-a9619765df78",
   "metadata": {},
   "source": [
    "#### Session settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ac45af42-510a-49ff-919a-374601873216",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-08-01 14:16:01.890989: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2024-08-01 14:16:01.891552: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-08-01 14:16:01.891695: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-08-01 14:16:01.891783: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-08-01 14:16:02.194298: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-08-01 14:16:02.194494: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-08-01 14:16:02.194602: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-08-01 14:16:02.194673: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 22029 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:01:00.0, compute capability: 8.6\n"
     ]
    }
   ],
   "source": [
    "config = tf.compat.v1.ConfigProto()\n",
    "config.gpu_options.allow_growth=True\n",
    "session = tf.compat.v1.Session(config=config)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37f47428-b81e-4050-8393-91845d135bef",
   "metadata": {},
   "source": [
    "#### Work directory configurations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e03e5336-1373-43c3-b452-658b02031068",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/mnt/storage/Projects/04_LCNEC/Principal\n",
      "/mnt/storage/Projects/04_LCNEC\n"
     ]
    }
   ],
   "source": [
    "print(os.getcwd())\n",
    "os.chdir('..')\n",
    "print(os.getcwd())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db69b34e-c63a-4c4d-a45c-aaec02534f27",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Experiment date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c8933f9d-0347-4fce-a5a1-b398349ca7b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-08-01_\n"
     ]
    }
   ],
   "source": [
    "current_date = datetime.datetime.today().strftime('%Y-%m-%d')+\"_\"\n",
    "print(current_date)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a8bb7d5-0628-470e-8c8f-5614b14e5e4c",
   "metadata": {},
   "source": [
    "#### Input ocation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "67f527f8-dabf-4660-964a-1fbfd189426f",
   "metadata": {},
   "outputs": [],
   "source": [
    "project_path = os.getcwd()\n",
    "\n",
    "root_path = project_path + os.sep + 'Principal'\n",
    "data_path = project_path + os.sep + 'LCNEC_128_Consensus'\n",
    "folds_path = project_path + os.sep + 'LCNEC_128_Consensus_4folds'\n",
    "save_path = project_path + os.sep + 'augument'\n",
    "\n",
    "test_path_validation = folds_path + os.sep + 'Fold31/Validation'\n",
    "test_path_biopsies =  project_path + os.sep + 'Test_biopsies'\n",
    "test_path_all =  project_path + os.sep + 'Test_all'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9966418-c037-4055-901c-ac4cc341f1fe",
   "metadata": {},
   "source": [
    "#### Input settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4476f51e-0610-4d09-a041-c856cb0eb539",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '0']\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Set data info \"\"\"\n",
    "\n",
    "DISEASE = 'LCNEC_RB_consensus4'\n",
    "\n",
    "CLASSES = ([name for name in os.listdir(data_path)])\n",
    "print(CLASSES)\n",
    "N_CLASSES = len(CLASSES)\n",
    "class_weights = None\n",
    "\n",
    "\"\"\" Set experiments repeats \"\"\"\n",
    "N_FOLDS = 4\n",
    "N_RUNS = 1\n",
    "\n",
    "\"\"\"Evaluated fold\"\"\"\n",
    "#foldN = 3\n",
    "runN = 1\n",
    "\n",
    "\n",
    "\"\"\" Set model parameters \"\"\"\n",
    "MODEL_ARCH = 'teonet_u2'\n",
    "LOSS_FUNC = 'BBCE'\n",
    "PATCH_SIZE = 128\n",
    "DOWNSIZING_FACTOR = 1 # 1 for original image size\n",
    "PATCH_SIZE = int(PATCH_SIZE/DOWNSIZING_FACTOR) # both height and width\n",
    "BATCH_SIZE = 128 * DOWNSIZING_FACTOR * DOWNSIZING_FACTOR\n",
    "LR = 1e-4\n",
    "\n",
    "\"\"\" Set randomization parameters \"\"\"\n",
    "SHUFFLE = False\n",
    "SEED = 1\n",
    "\n",
    "\"\"\" Set required metrics evaluation \"\"\"\n",
    "METRICS = ['Accuracy']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a3857acf-658f-43b9-a4d5-e410553e5eb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "exp_path = '{}/Experiments/{}_{}_{}_{}_{}/'.format(project_path,DISEASE,MODEL_ARCH,LOSS_FUNC,N_CLASSES,PATCH_SIZE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a6b7815-efeb-4059-a233-a50eb0d41c92",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Output location"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "bfc42178-6da8-434c-9eeb-bcc8c13461fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "weights_path = '{}/Experiments/{}_{}_{}_{}_{}/weights_data/'.format(project_path,DISEASE,MODEL_ARCH,LOSS_FUNC,N_CLASSES,PATCH_SIZE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cf90854-7a93-450b-967a-24421d6fbfbb",
   "metadata": {},
   "source": [
    "#### Import model weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3fa08204-5de8-4b49-89aa-b1c0deeb5216",
   "metadata": {},
   "outputs": [],
   "source": [
    "model_weights = weights_path+\"Fold31/Weights_LCNEC_RB_consensus4_V11_teonet_u2_BBCE_2_128_31_42_1.05.hdf5\" ### this is fold 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecbc900a-4577-4703-bc68-76c9fecbb7a1",
   "metadata": {},
   "source": [
    "#### Test data evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a9f7a13-fd18-44dc-9d77-bfb396e18720",
   "metadata": {},
   "source": [
    "#### Generator setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ff896cd1-3569-4f91-9675-2eee07296078",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 6762 images belonging to 2 classes.\n",
      "Found 20161 images belonging to 2 classes.\n",
      "Found 8878 images belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "augmentation_arguments_test = dict(featurewise_center = False,\n",
    "                                    samplewise_center = False,\n",
    "                                    featurewise_std_normalization = False,\n",
    "                                    samplewise_std_normalization = False,\n",
    "                                    rotation_range = None,\n",
    "                                    brightness_range = None,\n",
    "                                    horizontal_flip = False,\n",
    "                                    vertical_flip = False,\n",
    "                                    rescale = 1./255.,\n",
    "                                    # fill_mode = \"constant\",\n",
    "                                    # cval = 255.0,\n",
    "                                    preprocessing_function = None)  #    tf.keras.applications.resnet_v2.preprocess_input)\n",
    "\n",
    "test_datagen_validation = ImageDataGenerator(**augmentation_arguments_test).flow_from_directory(directory = test_path_validation,\n",
    "                                                                                    batch_size = BATCH_SIZE, \n",
    "                                                                                    target_size = (PATCH_SIZE,PATCH_SIZE),\n",
    "                                                                                    color_mode= \"rgb\",\n",
    "                                                                                    class_mode = \"binary\", \n",
    "                                                                                    #classes = CLASSES,\n",
    "                                                                                    seed= SEED,\n",
    "                                                                                    shuffle = SHUFFLE)\n",
    "\n",
    "test_datagen_all = ImageDataGenerator(**augmentation_arguments_test).flow_from_directory(directory = test_path_all,\n",
    "                                                                                    batch_size = BATCH_SIZE, \n",
    "                                                                                    target_size = (PATCH_SIZE,PATCH_SIZE),\n",
    "                                                                                    color_mode= \"rgb\",\n",
    "                                                                                    class_mode = \"binary\", \n",
    "                                                                                    #classes = CLASSES,\n",
    "                                                                                    seed= SEED,\n",
    "                                                                                    shuffle = SHUFFLE)\n",
    "\n",
    "test_datagen_biopsies = ImageDataGenerator(**augmentation_arguments_test).flow_from_directory(directory = test_path_biopsies,\n",
    "                                                                                    batch_size = BATCH_SIZE, \n",
    "                                                                                    target_size = (PATCH_SIZE,PATCH_SIZE),\n",
    "                                                                                    color_mode= \"rgb\",\n",
    "                                                                                    class_mode = \"binary\", \n",
    "                                                                                    #classes = CLASSES,\n",
    "                                                                                    seed= SEED,\n",
    "                                                                                    shuffle = SHUFFLE)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b491464e-524c-4d1f-9f79-c430f24a30b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Set required functions \"\"\"\n",
    "OPTIMIZER = Adam(learning_rate=LR, beta_1=0.9, beta_2=0.999, epsilon=None, decay=1e-4, amsgrad=False, name='Adam') \n",
    "\n",
    "LOSS = 'binary_crossentropy'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74510d55-0d34-4d18-9305-cb631be6afe7",
   "metadata": {},
   "source": [
    "#### Fit Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "fed1f1a8-a36c-4832-a7bf-53564bb42f75",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-08-01 14:16:02.533684: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-08-01 14:16:02.533865: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-08-01 14:16:02.533964: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-08-01 14:16:02.534089: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-08-01 14:16:02.534182: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
      "2024-08-01 14:16:02.534247: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 22029 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:01:00.0, compute capability: 8.6\n"
     ]
    }
   ],
   "source": [
    "from model_u2 import *\n",
    "\n",
    "model = create_binary_classification_model(input_shape=(PATCH_SIZE, PATCH_SIZE, 3))\n",
    "\n",
    "model.compile(optimizer = OPTIMIZER, loss = LOSS, metrics = METRICS)\n",
    "\n",
    "# Summary of the model architecture\n",
    "#model_1.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "175c126a-28ef-44eb-ab6f-dfbbc2af8cf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.load_weights(model_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2cee445d-c0f2-4753-aed6-d51458a0d79b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['0', '1']\n"
     ]
    }
   ],
   "source": [
    "target_names = []\n",
    "for key in test_datagen_all.class_indices:\n",
    "    target_names.append(key)\n",
    "print(target_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "188eb9f3-5ff8-4a19-8bdf-8cf48d663f21",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-08-01 14:16:03.165354: I tensorflow/stream_executor/cuda/cuda_dnn.cc:368] Loaded cuDNN version 8200\n",
      "2024-08-01 14:16:04.494492: I tensorflow/stream_executor/cuda/cuda_blas.cc:1786] TensorFloat-32 will be used for the matrix multiplication. This will only be logged once.\n"
     ]
    }
   ],
   "source": [
    "#Confution Matrix\n",
    "\n",
    "Y_pred_validation = model.predict(test_datagen_validation)\n",
    "y_pred_validation = (Y_pred_validation>0.5)\n",
    "\n",
    "#y_pred = np.argmax(Y_pred, axis=1)\n",
    "Y_pred_all = model.predict(test_datagen_all)\n",
    "y_pred_all = (Y_pred_all>0.5)\n",
    "\n",
    "Y_pred_biopsies = model.predict(test_datagen_biopsies)\n",
    "y_pred_biopsies = (Y_pred_biopsies>0.5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6de5bfbd-1305-4b57-9678-92f985899e7f",
   "metadata": {},
   "source": [
    "## Patchwise Confusion Matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f0b09f24-9241-4717-8155-470821fde393",
   "metadata": {},
   "outputs": [],
   "source": [
    "cm_validation = confusion_matrix(test_datagen_validation.classes, y_pred_validation)\n",
    "cm_normalized_validation = cm_validation.astype('float') / cm_validation.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "cm_all = confusion_matrix(test_datagen_all.classes, y_pred_all)\n",
    "cm_normalized_all = cm_all.astype('float') / cm_all.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "cm_biopsies = confusion_matrix(test_datagen_biopsies.classes, y_pred_biopsies)\n",
    "cm_normalized_biopsies = cm_biopsies.astype('float') / cm_biopsies.sum(axis=1)[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ee923c92-ad7a-48ff-9572-c0b0f7919be3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combine unnormalized and normalized values in one matrix\n",
    "combined_matrix_validation = np.array([[\n",
    "    f'{value}\\n({normalized:.2%})' for value, normalized in zip(row, normalized_row)\n",
    "] for row, normalized_row in zip(cm_validation, cm_normalized_validation)])\n",
    "\n",
    "combined_matrix_all = np.array([[\n",
    "    f'{value}\\n({normalized:.2%})' for value, normalized in zip(row, normalized_row)\n",
    "] for row, normalized_row in zip(cm_all, cm_normalized_all)])\n",
    "\n",
    "combined_matrix_biopsies = np.array([[\n",
    "    f'{value}\\n({normalized:.2%})' for value, normalized in zip(row, normalized_row)\n",
    "] for row, normalized_row in zip(cm_biopsies, cm_normalized_biopsies)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "06b094ba-d57a-4827-8761-3d867a70d3d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "# Create a figure with 5 subplots arranged horizontally\n",
    "fig, axes = plt.subplots(1, 3, figsize=(13, 4))\n",
    "\n",
    "sns.heatmap(cm_validation, annot=combined_matrix_validation, fmt='', cmap='Blues', cbar=True, ax=axes[0], xticklabels=['Pred pRb neg', 'Pred pRb pos'], yticklabels=['True pRb neg', 'True pRb pos'])\n",
    "axes[0].set_title('Validation')\n",
    "# axes[0].set_xlabel('Predicted')\n",
    "# axes[0].set_ylabel('True')\n",
    "\n",
    "sns.heatmap(cm_all, annot=combined_matrix_all, fmt='', cmap='Blues', cbar=True, ax=axes[1], xticklabels=['Pred pRb neg', 'Pred pRb pos'], yticklabels=['True pRb neg', 'True pRb pos'])\n",
    "axes[1].set_title('Test')\n",
    "# axes[0].set_xlabel('Predicted')\n",
    "# axes[0].set_ylabel('True')\n",
    "\n",
    "sns.heatmap(cm_biopsies, annot=combined_matrix_biopsies, fmt='', cmap='Blues', cbar=True, ax=axes[2], xticklabels=['Pred pRb neg', 'Pred pRb pos'], yticklabels=['True pRb neg', 'True pRb pos'])\n",
    "axes[2].set_title('Biopsies')\n",
    "# axes[0].set_xlabel('Predicted')\n",
    "# axes[0].set_ylabel('True')\n",
    "\n",
    "plt.suptitle('Tile-Wise Performance Evaluation', fontsize=16)\n",
    "plt.tight_layout(rect=[0, 0, 1, 0.96])\n",
    "plt.savefig(exp_path + \"/All_tiles_Confusion_Matrices.png\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55481038-1a31-4ba6-a4b3-ca9454c7ba71",
   "metadata": {},
   "source": [
    "## Patchwise ROC-AUCs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3d9a49dc-894b-4e5f-b4aa-4bfa491fea6f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 4))\n",
    "RocCurveDisplay.from_predictions(test_datagen_validation.classes, Y_pred_validation, name=f\"Validation\", color=\"magenta\", ax=plt.gca())\n",
    "RocCurveDisplay.from_predictions(test_datagen_all.classes, Y_pred_all, name=f\"Test\", color=\"blue\", ax=plt.gca())\n",
    "RocCurveDisplay.from_predictions(test_datagen_biopsies.classes, Y_pred_biopsies, name=f\"Biopsies\", color=\"green\", ax=plt.gca())\n",
    "\n",
    "plt.xlabel(\"False Positive Rate\")\n",
    "plt.ylabel(\"True Positive Rate\")\n",
    "\n",
    "plt.plot([0, 1], [0, 1], \"k--\", label=\"chance level (AUC = 0.5)\")\n",
    "plt.title(\"Tile-wise Rb Positive vs pRb Negative AUC-ROC\")\n",
    "plt.legend()\n",
    "plt.savefig(exp_path + \"/All_tiles_ROC_AUC.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4fd12f7-4dee-434f-a819-69a2d4cd3d4b",
   "metadata": {},
   "source": [
    "# Patient level implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "39ab4996-5097-4f76-bb1b-d4e86dac1ce5",
   "metadata": {},
   "outputs": [],
   "source": [
    "excel_file_validation = exp_path + \"Validation_Patient_Prediction_Consensus.xlsx\"\n",
    "excel_file_all = exp_path + \"Test_Patient_Prediction_Consensus.xlsx\"\n",
    "excel_file_biopsies = exp_path + \"Biopsies_Patient_Prediction_Consensus.xlsx\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "6276498c-35e6-4c9c-9a0a-4cd31966d3e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_validation = pd.read_excel(excel_file_validation, sheet_name='Fold_3')\n",
    "class_true_validation = data_validation['Class_true'].tolist()\n",
    "class_pred_validation = data_validation['Class_predicted'].tolist()\n",
    "\n",
    "data_all = pd.read_excel(excel_file_all, sheet_name='Fold_3')\n",
    "class_true_all = data_all['Class_true'].tolist()\n",
    "class_pred_all = data_all['Class_predicted'].tolist()\n",
    "\n",
    "data_biopsies = pd.read_excel(excel_file_biopsies, sheet_name='Fold_3')\n",
    "class_true_biopsies = data_biopsies['Class_true'].tolist()\n",
    "class_pred_biopsies = data_biopsies['Class_predicted'].tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00c4a39b-6cc0-4d96-af9f-46beb9506910",
   "metadata": {},
   "source": [
    "## Patientwise Confusion Matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c39b2938-b34c-446b-8b96-02d55c1ccf4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "cm_pvalidation = confusion_matrix(class_true_validation, class_pred_validation)\n",
    "cm_normalized_pvalidation = cm_pvalidation.astype('float') / cm_pvalidation.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "cm_pall = confusion_matrix(class_true_all, class_pred_all)\n",
    "cm_normalized_pall = cm_pall.astype('float') / cm_pall.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "cm_pbiopsies = confusion_matrix(class_true_biopsies, class_pred_biopsies)\n",
    "cm_normalized_pbiopsies = cm_pbiopsies.astype('float') / cm_pbiopsies.sum(axis=1)[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0e0c3593-1fa3-4855-8485-731edb1c743e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combine unnormalized and normalized values in one matrix\n",
    "combined_matrix_pvalidation = np.array([[\n",
    "    f'{value}\\n({normalized:.2%})' for value, normalized in zip(row, normalized_row)\n",
    "] for row, normalized_row in zip(cm_pvalidation, cm_normalized_pvalidation)])\n",
    "\n",
    "combined_matrix_pall = np.array([[\n",
    "    f'{value}\\n({normalized:.2%})' for value, normalized in zip(row, normalized_row)\n",
    "] for row, normalized_row in zip(cm_pall, cm_normalized_pall)])\n",
    "\n",
    "combined_matrix_pbiopsies = np.array([[\n",
    "    f'{value}\\n({normalized:.2%})' for value, normalized in zip(row, normalized_row)\n",
    "] for row, normalized_row in zip(cm_pbiopsies, cm_normalized_pbiopsies)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "b9664416-9713-429b-be04-4c3d604df1d6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "# Create a figure with 5 subplots arranged horizontally\n",
    "fig, axes = plt.subplots(1, 3, figsize=(13, 4))\n",
    "\n",
    "sns.heatmap(cm_pvalidation, annot=combined_matrix_pvalidation, fmt='', cmap='Blues', cbar=True, ax=axes[0], xticklabels=['Pred pRb neg', 'Pred pRb pos'], yticklabels=['True pRb neg', 'True pRb pos'])\n",
    "axes[0].set_title('Validation')\n",
    "# axes[0].set_xlabel('Predicted')\n",
    "# axes[0].set_ylabel('True')\n",
    "\n",
    "sns.heatmap(cm_pall, annot=combined_matrix_pall, fmt='', cmap='Blues', cbar=True, ax=axes[1], xticklabels=['Pred pRb neg', 'Pred pRb pos'], yticklabels=['True pRb neg', 'True pRb pos'])\n",
    "axes[1].set_title('Test')\n",
    "# axes[0].set_xlabel('Predicted')\n",
    "# axes[0].set_ylabel('True')\n",
    "\n",
    "sns.heatmap(cm_pbiopsies, annot=combined_matrix_pbiopsies, fmt='', cmap='Blues', cbar=True, ax=axes[2], xticklabels=['Pred pRb neg', 'Pred pRb pos'], yticklabels=['True pRb neg', 'True pRb pos'])\n",
    "axes[2].set_title('Biopsies')\n",
    "# axes[0].set_xlabel('Predicted')\n",
    "# axes[0].set_ylabel('True')\n",
    "\n",
    "plt.suptitle('Patient-Wise Performance Evaluation', fontsize=16)\n",
    "plt.tight_layout(rect=[0, 0, 1, 0.96])\n",
    "plt.savefig(exp_path + \"/All_patients_Confusion_Matrices.png\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a4b65e9-0fce-44c2-b69c-1904c992a02d",
   "metadata": {},
   "source": [
    "## Patientwise ROC-AUCs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f4975938-f373-4cf1-86a8-a979347956b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "number_patches_validation = data_validation['Number_patches'].tolist()\n",
    "class_1_validation = data_validation['Class_1'].tolist()\n",
    "\n",
    "probability_prediction_validation = []\n",
    "for i in range(0,len(number_patches_validation)):\n",
    "    probability_prediction_validation.append(class_1_validation[i]/number_patches_validation[i])\n",
    "   \n",
    "    \n",
    "number_patches_all = data_all['Number_patches'].tolist()\n",
    "class_1_all = data_all['Class_1'].tolist()\n",
    "\n",
    "probability_prediction_all = []\n",
    "for i in range(0,len(number_patches_all)):\n",
    "    probability_prediction_all.append(class_1_all[i]/number_patches_all[i])\n",
    "    \n",
    "    \n",
    "number_patches_biopsies = data_biopsies['Number_patches'].tolist()\n",
    "class_1_biopsies = data_biopsies['Class_1'].tolist()\n",
    "\n",
    "probability_prediction_biopsies = []\n",
    "for i in range(0,len(number_patches_biopsies)):\n",
    "    probability_prediction_biopsies.append(class_1_biopsies[i]/number_patches_biopsies[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "0f8f12ed-8b15-4f3a-8eed-6440b849f47f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 4))\n",
    "RocCurveDisplay.from_predictions(class_true_validation, probability_prediction_validation, name=f\"Validation\", color=\"magenta\", ax=plt.gca())\n",
    "RocCurveDisplay.from_predictions(class_true_all, probability_prediction_all, name=f\"Test\", color=\"blue\", ax=plt.gca())\n",
    "RocCurveDisplay.from_predictions(class_true_biopsies, probability_prediction_biopsies, name=f\"Biopsies\", color=\"green\", ax=plt.gca())\n",
    "\n",
    "plt.xlabel(\"False Positive Rate\")\n",
    "plt.ylabel(\"True Positive Rate\")\n",
    "\n",
    "plt.plot([0, 1], [0, 1], \"k--\", label=\"chance level (AUC = 0.5)\")\n",
    "plt.title(\"Patient-wise pRb Positive vs pRb Negative AUC-ROC\")\n",
    "plt.legend()\n",
    "plt.savefig(exp_path + \"/All_patients_ROC_AUC.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2360a20e-51db-410a-9301-80814034f547",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26889eb9-d184-4d93-bf0f-96bcf21de767",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "DL_img",
   "language": "python",
   "name": "dl_img"
  },
  "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}