Confusion_Matrix.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\Users\\souri\\anaconda3\\Lib\\site-packages\\tf_keras\\src\\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import PIL\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import tensorflow_hub as hub\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Load test cases\n",
    "test_cases_df = pd.read_csv(\"testcases.csv\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define image processing function\n",
    "def image_processing(image):\n",
    "    model_url = 'https://tfhub.dev/google/on_device_vision/classifier/landmarks_classifier_asia_V1/1'\n",
    "    labels_path = 'landmarks_classifier_asia_V1_label_map.csv'\n",
    "\n",
    "    # Load labels\n",
    "    df = pd.read_csv(labels_path)\n",
    "    labels = dict(zip(df.id, df.name))\n",
    "\n",
    "    img_shape = (321, 321)\n",
    "    classifier = hub.load(model_url)\n",
    "\n",
    "    # Extract the specific signature we need\n",
    "    signature = classifier.signatures['default']\n",
    "\n",
    "    # Resize and normalize image\n",
    "    img = tf.image.resize(image, img_shape) / 255.0\n",
    "\n",
    "    # Predict\n",
    "    result = signature(tf.expand_dims(img, axis=0))\n",
    "    prediction = labels[np.argmax(result['predictions:logits'][0])]\n",
    "\n",
    "    # Convert the image to PIL format for display\n",
    "    img_pil = PIL.Image.fromarray((image * 255).astype(np.uint8))\n",
    "\n",
    "    return prediction, img_pil\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to predict landmark\n",
    "def predict_landmark(image_path):\n",
    "    img = PIL.Image.open(image_path)\n",
    "    img_array = np.array(img)\n",
    "    prediction, _ = image_processing(img_array)\n",
    "    return prediction\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to generate image paths based on image names\n",
    "def generate_image_path(image_name):\n",
    "    return os.path.join(\"Images\", f\"{image_name}.jpg\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\Users\\souri\\anaconda3\\Lib\\site-packages\\tensorflow_hub\\resolver.py:120: The name tf.gfile.MakeDirs is deprecated. Please use tf.io.gfile.makedirs instead.\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\Users\\souri\\anaconda3\\Lib\\site-packages\\tensorflow_hub\\resolver.py:120: The name tf.gfile.MakeDirs is deprecated. Please use tf.io.gfile.makedirs instead.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\Users\\souri\\anaconda3\\Lib\\site-packages\\tensorflow_hub\\module_v2.py:126: The name tf.saved_model.load_v2 is deprecated. Please use tf.compat.v2.saved_model.load instead.\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\Users\\souri\\anaconda3\\Lib\\site-packages\\tensorflow_hub\\module_v2.py:126: The name tf.saved_model.load_v2 is deprecated. Please use tf.compat.v2.saved_model.load instead.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True Positive (TP): 19\n",
      "True Negative (TN): 0\n",
      "False Positive (FP): 1\n",
      "False Negative (FN): 0\n"
     ]
    }
   ],
   "source": [
    "# Initialize variables for TP, TN, FP, FN\n",
    "TP = TN = FP = FN = 0\n",
    "\n",
    "# Perform test cases\n",
    "for index, row in test_cases_df.iterrows():\n",
    "    image_name = f\"image{row['id']}\"\n",
    "    expected_landmark = row['output']\n",
    "    image_path = generate_image_path(image_name)\n",
    "    predicted_landmark = predict_landmark(image_path)\n",
    "    \n",
    "    # Update TP, TN, FP, FN based on prediction\n",
    "    if predicted_landmark == expected_landmark:\n",
    "        if predicted_landmark == \"Unknown\":\n",
    "            TN += 1  # True Negative\n",
    "        else:\n",
    "            TP += 1  # True Positive\n",
    "    else:\n",
    "        if predicted_landmark == \"Unknown\":\n",
    "            FN += 1  # False Negative\n",
    "        else:\n",
    "            FP += 1  # False Positive\n",
    "\n",
    "# Calculate accuracy\n",
    "accuracy = (TP + TN) / (TP + TN + FP + FN)\n",
    "\n",
    "# Display TP, TN, FP, FN and accuracy\n",
    "print(\"True Positive (TP):\", TP)\n",
    "print(\"True Negative (TN):\", TN)\n",
    "print(\"False Positive (FP):\", FP)\n",
    "print(\"False Negative (FN):\", FN)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 95.0 %\n",
      "Precision: 95.0 %\n",
      "Recall: 100.0 %\n",
      "F1 Score: 97.43589743589743 %\n"
     ]
    }
   ],
   "source": [
    "def calculate_metrics(TP, TN, FP, FN):\n",
    "    # Accuracy\n",
    "    accuracy = (TP + TN) / (TP + TN + FP + FN)\n",
    "\n",
    "    # Precision\n",
    "    precision = TP / (TP + FP) if TP + FP != 0 else 0\n",
    "\n",
    "    # Recall\n",
    "    recall = TP / (TP + FN) if TP + FN != 0 else 0\n",
    "\n",
    "    # F1 Score\n",
    "    f1_score = 2 * precision * recall / (precision + recall) if precision + recall != 0 else 0\n",
    "\n",
    "    return accuracy, precision, recall, f1_score\n",
    "\n",
    "\n",
    "accuracy, precision, recall, f1_score = calculate_metrics(TP, TN, FP, FN)\n",
    "\n",
    "print(\"Accuracy:\", accuracy*100,\"%\")\n",
    "print(\"Precision:\", precision*100,\"%\")\n",
    "print(\"Recall:\", recall*100,\"%\")\n",
    "print(\"F1 Score:\", f1_score*100,\"%\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create confusion matrix\n",
    "conf_matrix = np.array([[TP, FP],\n",
    "                        [FN, TN]])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot confusion matrix\n",
    "plt.imshow(conf_matrix, interpolation='nearest', cmap=plt.cm.Blues)\n",
    "plt.title('Confusion Matrix')\n",
    "plt.colorbar()\n",
    "\n",
    "# Add labels\n",
    "classes = ['Negative', 'Positive']\n",
    "tick_marks = np.arange(len(classes))\n",
    "plt.xticks(tick_marks, classes)\n",
    "plt.yticks(tick_marks, classes)\n",
    "\n",
    "# Add text annotations\n",
    "thresh = conf_matrix.max() / 2.\n",
    "for i in range(conf_matrix.shape[0]):\n",
    "    for j in range(conf_matrix.shape[1]):\n",
    "        # Add TP, TN, FP, FN values in appropriate boxes\n",
    "        if i == 0 and j == 0:\n",
    "            plt.text(j, i, f'TP: {conf_matrix[i, j]}',\n",
    "                     horizontalalignment=\"center\",\n",
    "                     color=\"white\" if conf_matrix[i, j] > thresh else \"black\")\n",
    "        elif i == 0 and j == 1:\n",
    "            plt.text(j, i, f'FN: {conf_matrix[i, j]}',\n",
    "                     horizontalalignment=\"center\",\n",
    "                     color=\"white\" if conf_matrix[i, j] > thresh else \"black\")\n",
    "        elif i == 1 and j == 0:\n",
    "            plt.text(j, i, f'FP: {conf_matrix[i, j]}',\n",
    "                     horizontalalignment=\"center\",\n",
    "                     color=\"white\" if conf_matrix[i, j] > thresh else \"black\")\n",
    "        elif i == 1 and j == 1:\n",
    "            plt.text(j, i, f'TN: {conf_matrix[i, j]}',\n",
    "                     horizontalalignment=\"center\",\n",
    "                     color=\"white\" if conf_matrix[i, j] > thresh else \"black\")\n",
    "\n",
    "plt.ylabel('Actual label')\n",
    "plt.xlabel('Predicted label')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}