Tuberculosis Detection Using CNN .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
   },
   "outputs": [],
   "source": [
    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
    "# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n",
    "# For example, here's several helpful packages to load\n",
    "\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "\n",
    "# Input data files are available in the read-only \"../input/\" directory\n",
    "# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n",
    "\n",
    "import os\n",
    "for dirname, _, filenames in os.walk('/kaggle/input'):\n",
    "    for filename in filenames:\n",
    "        print(os.path.join(dirname, filename))\n",
    "\n",
    "# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n",
    "# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-25T04:50:08.675700Z",
     "iopub.status.busy": "2024-02-25T04:50:08.675039Z",
     "iopub.status.idle": "2024-02-25T04:50:08.681758Z",
     "shell.execute_reply": "2024-02-25T04:50:08.680284Z",
     "shell.execute_reply.started": "2024-02-25T04:50:08.675661Z"
    }
   },
   "source": [
    "# <font color='red'>Part 1: Loading Dataset<font color='red'> 📦"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "import os\n",
    "import cv2\n",
    "from pathlib import Path\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from skimage.io import imread\n",
    "\n",
    "from tqdm import tqdm\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers, models\n",
    "from sklearn.metrics import classification_report, confusion_matrix\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import f1_score\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Path and Directories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the path to the dataset\n",
    "data_dir = Path('../input/tuberculosis-tb-chest-xray-dataset/TB_Chest_Radiography_Database/')\n",
    "\n",
    "data_dir\n",
    "\n",
    "# Specify directories for normal and tuberculosis cases\n",
    "normal_cases_dir = data_dir / 'Normal'\n",
    "Tuberculosis_cases_dir = data_dir / 'Tuberculosis'\n",
    "\n",
    "# Get the list of all the images\n",
    "normal_cases = normal_cases_dir.glob('*.png')\n",
    "Tuberculosis_cases = Tuberculosis_cases_dir.glob('*.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load Image Paths and Labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create lists to store image paths and labels\n",
    "train_data = []\n",
    "\n",
    "# Load image paths and assign labels for normal cases (label: 0)\n",
    "for img in normal_cases_dir.glob('*.png'):\n",
    "    train_data.append((img, 0))\n",
    "\n",
    "# Load image paths and assign labels for tuberculosis cases (label: 1)\n",
    "for img in Tuberculosis_cases_dir.glob('*.png'):\n",
    "    train_data.append((img, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-25T04:55:42.955471Z",
     "iopub.status.busy": "2024-02-25T04:55:42.955059Z",
     "iopub.status.idle": "2024-02-25T04:55:42.961941Z",
     "shell.execute_reply": "2024-02-25T04:55:42.960553Z",
     "shell.execute_reply.started": "2024-02-25T04:55:42.955441Z"
    }
   },
   "source": [
    "### Create DataFrame, Shuffle Data, and Display Class Distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a DataFrame from the list\n",
    "train_data = pd.DataFrame(train_data, columns=['image', 'label'])\n",
    "\n",
    "# Shuffle the data\n",
    "train_data = train_data.sample(frac=1.).reset_index(drop=True)\n",
    "\n",
    "# Display class distribution\n",
    "cases_count = train_data['label'].value_counts()\n",
    "print(cases_count)\n",
    "\n",
    "# How the dataframe looks like?\n",
    "train_data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot Class Distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot class distribution\n",
    "plt.figure(figsize=(10, 8))\n",
    "sns.barplot(x=cases_count.index, y=cases_count.values)\n",
    "plt.title('Number of cases', fontsize=14)\n",
    "plt.xlabel('Case type', fontsize=12)\n",
    "plt.ylabel('Count', fontsize=12)\n",
    "plt.xticks(range(len(cases_count.index)), ['Normal(0)', 'Tuberculosis(1)'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-25T05:00:48.490936Z",
     "iopub.status.busy": "2024-02-25T05:00:48.490418Z",
     "iopub.status.idle": "2024-02-25T05:00:48.497282Z",
     "shell.execute_reply": "2024-02-25T05:00:48.495458Z",
     "shell.execute_reply.started": "2024-02-25T05:00:48.490897Z"
    }
   },
   "source": [
    "# <font color='red'>Part 2: Data Preprocessing<font color='red'> 🧐"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get Few Samples for Both Classes and Plot Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get few samples for both the classes\n",
    "Tuberculosis_samples = (train_data[train_data['label']==1]['image'].iloc[:5]).tolist()\n",
    "normal_samples = (train_data[train_data['label']==0]['image'].iloc[:5]).tolist()\n",
    "\n",
    "# Concatenate the data in a single list and delete the above two lists\n",
    "samples = Tuberculosis_samples + normal_samples\n",
    "del Tuberculosis_samples, normal_samples\n",
    "\n",
    "# Plot the data\n",
    "f, ax = plt.subplots(2, 5, figsize=(30, 10))\n",
    "for i in range(10):\n",
    "    img = imread(samples[i])\n",
    "    ax[i//5, i%5].imshow(img, cmap='gray')\n",
    "    if i < 5:\n",
    "        ax[i//5, i%5].set_title(\"Tuberculosis\")\n",
    "    else:\n",
    "        ax[i//5, i%5].set_title(\"Normal\")\n",
    "    ax[i//5, i%5].axis('off')\n",
    "    ax[i//5, i%5].set_aspect('auto')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "execution": {
     "iopub.status.idle": "2024-02-25T08:07:49.068481Z",
     "shell.execute_reply": "2024-02-25T08:07:49.067351Z",
     "shell.execute_reply.started": "2024-02-25T08:07:10.031973Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "3500it [00:32, 106.41it/s]\n",
      "700it [00:06, 114.84it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of validation examples:  (4200, 28, 28, 3)\n",
      "Total number of labels: (4200,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Define directories for normal and tuberculosis cases\n",
    "normal_cases_dir = data_dir / 'Normal'\n",
    "Tuberculosis_cases_dir = data_dir / 'Tuberculosis'\n",
    "\n",
    "# Initialize lists for data and labels\n",
    "train_data = []\n",
    "train_labels = []\n",
    "\n",
    "# Load and preprocess normal cases\n",
    "for img in tqdm(normal_cases_dir.glob('*.png')):\n",
    "    img = cv2.imread(str(img))\n",
    "    img = cv2.resize(img, (28, 28))\n",
    "    if img.shape[2] == 1:\n",
    "        img = np.dstack([img, img, img])\n",
    "    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "    img = np.array(img) / 255\n",
    "    label = 'normal'\n",
    "    train_data.append(img)\n",
    "    train_labels.append(label)\n",
    "\n",
    "# Load and preprocess tuberculosis cases\n",
    "for img in tqdm(Tuberculosis_cases_dir.glob('*.png')):\n",
    "    img = cv2.imread(str(img))\n",
    "    img = cv2.resize(img, (28, 28))\n",
    "    if img.shape[2] == 1:\n",
    "        img = np.dstack([img, img, img])\n",
    "    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "    img = np.array(img) / 255\n",
    "    label = 'Tuberculosis'\n",
    "    train_data.append(img)\n",
    "    train_labels.append(label)\n",
    "\n",
    "# Convert lists to numpy arrays\n",
    "train_data1 = np.array(train_data)\n",
    "train_labels1 = np.array(train_labels)\n",
    "\n",
    "print(\"Total number of validation examples: \", train_data1.shape)\n",
    "print(\"Total number of labels:\", train_labels1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-25T08:07:49.070820Z",
     "iopub.status.busy": "2024-02-25T08:07:49.070374Z",
     "iopub.status.idle": "2024-02-25T08:07:49.082457Z",
     "shell.execute_reply": "2024-02-25T08:07:49.081234Z",
     "shell.execute_reply.started": "2024-02-25T08:07:49.070782Z"
    }
   },
   "outputs": [
    {
     "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>label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>normal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>normal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>normal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>normal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>normal</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    label\n",
       "0  normal\n",
       "1  normal\n",
       "2  normal\n",
       "3  normal\n",
       "4  normal"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_labels1 = pd.DataFrame(train_labels1, columns=[ 'label'],index=None)\n",
    "train_labels1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-25T08:07:49.086081Z",
     "iopub.status.busy": "2024-02-25T08:07:49.085624Z",
     "iopub.status.idle": "2024-02-25T08:07:49.099126Z",
     "shell.execute_reply": "2024-02-25T08:07:49.097807Z",
     "shell.execute_reply.started": "2024-02-25T08:07:49.086043Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_labels1['label']=train_labels1['label'].map({'normal':0,'Tuberculosis':1})\n",
    "train_labels1['label'].unique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-25T05:05:41.602782Z",
     "iopub.status.busy": "2024-02-25T05:05:41.602281Z",
     "iopub.status.idle": "2024-02-25T05:05:41.608571Z",
     "shell.execute_reply": "2024-02-25T05:05:41.607627Z",
     "shell.execute_reply.started": "2024-02-25T05:05:41.602734Z"
    }
   },
   "source": [
    "### Reshape Data and Perform SMOTE Oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-25T08:07:49.100596Z",
     "iopub.status.busy": "2024-02-25T08:07:49.100280Z",
     "iopub.status.idle": "2024-02-25T08:07:49.565135Z",
     "shell.execute_reply": "2024-02-25T08:07:49.563693Z",
     "shell.execute_reply.started": "2024-02-25T08:07:49.100571Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class distribution after SMOTE:\n",
      "label\n",
      "0    3500\n",
      "1    3500\n",
      "Name: count, dtype: int64\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Import necessary libraries\n",
    "from imblearn.over_sampling import SMOTE\n",
    "\n",
    "# Initialize SMOTE (Synthetic Minority Over-sampling Technique)\n",
    "smt = SMOTE()\n",
    "\n",
    "# Get the number of rows in the original training data\n",
    "train_rows = len(train_data1)\n",
    "\n",
    "# Reshape the original training data to 1D array (flattening)\n",
    "train_data1 = train_data1.reshape(train_rows, -1)\n",
    "\n",
    "# Apply SMOTE to generate synthetic samples for balancing classes\n",
    "train_data2, train_labels2 = smt.fit_resample(train_data1, train_labels1)\n",
    "\n",
    "# Count class distribution after applying SMOTE\n",
    "cases_count1 = train_labels2['label'].value_counts()\n",
    "\n",
    "# Print the class distribution after SMOTE\n",
    "print(\"Class distribution after SMOTE:\")\n",
    "print(cases_count1)\n",
    "\n",
    "# Plot the results \n",
    "plt.figure(figsize=(10,8))\n",
    "sns.barplot(x=cases_count1.index, y= cases_count1.values)\n",
    "plt.title('Number of cases', fontsize=14)\n",
    "plt.xlabel('Case type', fontsize=12)\n",
    "plt.ylabel('Count', fontsize=12)\n",
    "plt.xticks(range(len(cases_count.index)), ['Normal(0)', 'Tuberculosis(1)'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare Data for Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-25T08:07:49.566848Z",
     "iopub.status.busy": "2024-02-25T08:07:49.566477Z",
     "iopub.status.idle": "2024-02-25T08:07:49.616419Z",
     "shell.execute_reply": "2024-02-25T08:07:49.615182Z",
     "shell.execute_reply.started": "2024-02-25T08:07:49.566817Z"
    }
   },
   "outputs": [],
   "source": [
    "# Reshape data back to image dimensions\n",
    "train_data2 = train_data2.reshape(-1, 28, 28, 3)\n",
    "\n",
    "# Split data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(train_data2, train_labels2, test_size=0.13, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color='red'>3. Modelling<font color='red'> 🤖"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Augmentation Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-25T08:07:49.618110Z",
     "iopub.status.busy": "2024-02-25T08:07:49.617769Z",
     "iopub.status.idle": "2024-02-25T08:07:49.796096Z",
     "shell.execute_reply": "2024-02-25T08:07:49.795038Z",
     "shell.execute_reply.started": "2024-02-25T08:07:49.618082Z"
    }
   },
   "outputs": [],
   "source": [
    "# Set up data augmentation\n",
    "data_augmentation = keras.Sequential(\n",
    "  [\n",
    "    layers.RandomFlip(\"horizontal\", input_shape=(28, 28, 3)),\n",
    "    layers.RandomRotation(0.1),\n",
    "    layers.RandomZoom(0.1),\n",
    "  ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-25T08:07:49.797765Z",
     "iopub.status.busy": "2024-02-25T08:07:49.797409Z",
     "iopub.status.idle": "2024-02-25T08:07:50.036320Z",
     "shell.execute_reply": "2024-02-25T08:07:50.035247Z",
     "shell.execute_reply.started": "2024-02-25T08:07:49.797735Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_5\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " sequential_4 (Sequential)   (None, 28, 28, 3)         0         \n",
      "                                                                 \n",
      " conv2d_6 (Conv2D)           (None, 26, 26, 28)        784       \n",
      "                                                                 \n",
      " max_pooling2d_4 (MaxPoolin  (None, 13, 13, 28)        0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " conv2d_7 (Conv2D)           (None, 11, 11, 64)        16192     \n",
      "                                                                 \n",
      " max_pooling2d_5 (MaxPoolin  (None, 5, 5, 64)          0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " conv2d_8 (Conv2D)           (None, 3, 3, 64)          36928     \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 53904 (210.56 KB)\n",
      "Trainable params: 53904 (210.56 KB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Initialize the model\n",
    "model = models.Sequential([\n",
    "    data_augmentation,\n",
    "    layers.Conv2D(28, (3, 3), activation='relu', input_shape=(28, 28, 3)),\n",
    "    layers.MaxPooling2D((2, 2)),\n",
    "    layers.Conv2D(64, (3, 3), activation='relu'),\n",
    "    layers.MaxPooling2D((2, 2)),\n",
    "    layers.Conv2D(64, (3, 3), activation='relu')\n",
    "])\n",
    "\n",
    "# Display model summary\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-25T08:07:50.037983Z",
     "iopub.status.busy": "2024-02-25T08:07:50.037632Z",
     "iopub.status.idle": "2024-02-25T08:07:50.183131Z",
     "shell.execute_reply": "2024-02-25T08:07:50.182052Z",
     "shell.execute_reply.started": "2024-02-25T08:07:50.037956Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_5\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " sequential_4 (Sequential)   (None, 28, 28, 3)         0         \n",
      "                                                                 \n",
      " conv2d_6 (Conv2D)           (None, 26, 26, 28)        784       \n",
      "                                                                 \n",
      " max_pooling2d_4 (MaxPoolin  (None, 13, 13, 28)        0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " conv2d_7 (Conv2D)           (None, 11, 11, 64)        16192     \n",
      "                                                                 \n",
      " max_pooling2d_5 (MaxPoolin  (None, 5, 5, 64)          0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " conv2d_8 (Conv2D)           (None, 3, 3, 64)          36928     \n",
      "                                                                 \n",
      " flatten_3 (Flatten)         (None, 576)               0         \n",
      "                                                                 \n",
      " dense_15 (Dense)            (None, 640)               369280    \n",
      "                                                                 \n",
      " dropout_6 (Dropout)         (None, 640)               0         \n",
      "                                                                 \n",
      " dense_16 (Dense)            (None, 564)               361524    \n",
      "                                                                 \n",
      " dropout_7 (Dropout)         (None, 564)               0         \n",
      "                                                                 \n",
      " dense_17 (Dense)            (None, 64)                36160     \n",
      "                                                                 \n",
      " dense_18 (Dense)            (None, 64)                4160      \n",
      "                                                                 \n",
      " dense_19 (Dense)            (None, 2)                 130       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 825158 (3.15 MB)\n",
      "Trainable params: 825158 (3.15 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Add dense layers to the model\n",
    "model.add(layers.Flatten())\n",
    "model.add(layers.Dense(640, activation='tanh'))\n",
    "model.add(layers.Dropout(0.5))\n",
    "model.add(layers.Dense(564, activation='tanh'))\n",
    "model.add(layers.Dropout(0.5))\n",
    "model.add(layers.Dense(64, activation='tanh'))\n",
    "model.add(layers.Dense(64, activation='sigmoid'))\n",
    "model.add(layers.Dense(2))\n",
    "\n",
    "# Display updated model summary\n",
    "model.summary()\n",
    "\n",
    "# Compile the model\n",
    "model.compile(optimizer='adam',\n",
    "              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train the model\n",
    "model.fit(np.array(X_train), np.array(y_train), epochs=200, validation_data=(np.array(X_test), np.array(y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color='red'>4. Model Evaluation<font color='red'> 📊"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train the model with history to track metrics\n",
    "history = model.fit(np.array(X_train), np.array(y_train), epochs=200, validation_data=(np.array(X_test), np.array(y_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-02-25T08:53:16.227962Z",
     "iopub.status.busy": "2024-02-25T08:53:16.227571Z",
     "iopub.status.idle": "2024-02-25T08:53:17.279271Z",
     "shell.execute_reply": "2024-02-25T08:53:17.278125Z",
     "shell.execute_reply.started": "2024-02-25T08:53:16.227935Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29/29 [==============================] - 0s 8ms/step\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.87      1.00      0.93       475\n",
      "           1       1.00      0.83      0.91       435\n",
      "\n",
      "    accuracy                           0.92       910\n",
      "   macro avg       0.93      0.92      0.92       910\n",
      "weighted avg       0.93      0.92      0.92       910\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot validation loss and accuracy\n",
    "plt.figure(figsize=(12, 4))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(history.history['val_loss'], label='Validation Loss')\n",
    "plt.title('Validation Loss Over Epochs')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.ylim(0, 1)  # Set y-axis range between 0 and 1\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(history.history['val_accuracy'], label='Validation Accuracy', color='orange')\n",
    "plt.title('Validation Accuracy Over Epochs')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.ylim(0, 1)  # Set y-axis range between 0 and 1\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# Predict on the test set\n",
    "y_pred = np.argmax(model.predict(np.array(X_test)), axis=1)\n",
    "\n",
    "# Generate classification report\n",
    "class_report = classification_report(np.array(y_test), y_pred)\n",
    "print(\"Classification Report:\")\n",
    "print(class_report)\n",
    "\n",
    "# Generate confusion matrix\n",
    "cm = confusion_matrix(np.array(y_test), y_pred)\n",
    "\n",
    "# Plot heatmap of confusion matrix with annotations\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(cm, annot=True, fmt='g', cmap='Blues', xticklabels=['Normal', 'Tuberculosis'], yticklabels=['Normal', 'Tuberculosis'])\n",
    "plt.title('Confusion Matrix')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('True')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "none",
   "dataSources": [
    {
     "datasetId": 891819,
     "sourceId": 2332307,
     "sourceType": "datasetVersion"
    }
   ],
   "dockerImageVersionId": 30646,
   "isGpuEnabled": false,
   "isInternetEnabled": false,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}