Chest-X-ray-Classificatio / Git / Diff of /Train & Test Code/Test.ipynb

Models:
RichardZick/
Chest-X-ray-Classificatio
Downloads: 1
Diff of /Train & Test Code/Test.ipynb [000000] .. [d71357]
Switch to side-by-side view

--- a
+++ b/Train & Test Code/Test.ipynb
@@ -0,0 +1,1486 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "sxcOtUe4tliU",
+        "outputId": "399c8772-076d-4378-bcd8-a69da2904d3e"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.0/16.0 MB\u001b[0m \u001b[31m25.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.3/13.3 MB\u001b[0m \u001b[31m22.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m2.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m5.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25h"
+          ]
+        }
+      ],
+      "source": [
+        "# Install required libraries\n",
+        "!pip install onnx onnxruntime --quiet"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "import numpy as np\n",
+        "import onnxruntime as ort\n",
+        "from torchvision import datasets, transforms\n",
+        "from torch.utils.data import DataLoader\n",
+        "from sklearn.metrics import accuracy_score\n",
+        "from google.colab import files\n",
+        "from PIL import Image\n"
+      ],
+      "metadata": {
+        "id": "mleBkPJAtmDC"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Upload the model\n",
+        "uploaded_files = files.upload()  # Upload the .onnx model file"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 73
+        },
+        "id": "7N7Q9OALtmFZ",
+        "outputId": "38827dc2-7939-4563-d653-d8cec5ffc5d2"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-9b92dffa-ec9e-444a-bb60-b827abd58565\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-9b92dffa-ec9e-444a-bb60-b827abd58565\">\n",
+              "      Upload widget is only available when the cell has been executed in the\n",
+              "      current browser session. Please rerun this cell to enable.\n",
+              "      </output>\n",
+              "      <script>// Copyright 2017 Google LLC\n",
+              "//\n",
+              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+              "// you may not use this file except in compliance with the License.\n",
+              "// You may obtain a copy of the License at\n",
+              "//\n",
+              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
+              "//\n",
+              "// Unless required by applicable law or agreed to in writing, software\n",
+              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+              "// See the License for the specific language governing permissions and\n",
+              "// limitations under the License.\n",
+              "\n",
+              "/**\n",
+              " * @fileoverview Helpers for google.colab Python module.\n",
+              " */\n",
+              "(function(scope) {\n",
+              "function span(text, styleAttributes = {}) {\n",
+              "  const element = document.createElement('span');\n",
+              "  element.textContent = text;\n",
+              "  for (const key of Object.keys(styleAttributes)) {\n",
+              "    element.style[key] = styleAttributes[key];\n",
+              "  }\n",
+              "  return element;\n",
+              "}\n",
+              "\n",
+              "// Max number of bytes which will be uploaded at a time.\n",
+              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
+              "\n",
+              "function _uploadFiles(inputId, outputId) {\n",
+              "  const steps = uploadFilesStep(inputId, outputId);\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  // Cache steps on the outputElement to make it available for the next call\n",
+              "  // to uploadFilesContinue from Python.\n",
+              "  outputElement.steps = steps;\n",
+              "\n",
+              "  return _uploadFilesContinue(outputId);\n",
+              "}\n",
+              "\n",
+              "// This is roughly an async generator (not supported in the browser yet),\n",
+              "// where there are multiple asynchronous steps and the Python side is going\n",
+              "// to poll for completion of each step.\n",
+              "// This uses a Promise to block the python side on completion of each step,\n",
+              "// then passes the result of the previous step as the input to the next step.\n",
+              "function _uploadFilesContinue(outputId) {\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  const steps = outputElement.steps;\n",
+              "\n",
+              "  const next = steps.next(outputElement.lastPromiseValue);\n",
+              "  return Promise.resolve(next.value.promise).then((value) => {\n",
+              "    // Cache the last promise value to make it available to the next\n",
+              "    // step of the generator.\n",
+              "    outputElement.lastPromiseValue = value;\n",
+              "    return next.value.response;\n",
+              "  });\n",
+              "}\n",
+              "\n",
+              "/**\n",
+              " * Generator function which is called between each async step of the upload\n",
+              " * process.\n",
+              " * @param {string} inputId Element ID of the input file picker element.\n",
+              " * @param {string} outputId Element ID of the output display.\n",
+              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
+              " */\n",
+              "function* uploadFilesStep(inputId, outputId) {\n",
+              "  const inputElement = document.getElementById(inputId);\n",
+              "  inputElement.disabled = false;\n",
+              "\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  outputElement.innerHTML = '';\n",
+              "\n",
+              "  const pickedPromise = new Promise((resolve) => {\n",
+              "    inputElement.addEventListener('change', (e) => {\n",
+              "      resolve(e.target.files);\n",
+              "    });\n",
+              "  });\n",
+              "\n",
+              "  const cancel = document.createElement('button');\n",
+              "  inputElement.parentElement.appendChild(cancel);\n",
+              "  cancel.textContent = 'Cancel upload';\n",
+              "  const cancelPromise = new Promise((resolve) => {\n",
+              "    cancel.onclick = () => {\n",
+              "      resolve(null);\n",
+              "    };\n",
+              "  });\n",
+              "\n",
+              "  // Wait for the user to pick the files.\n",
+              "  const files = yield {\n",
+              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
+              "    response: {\n",
+              "      action: 'starting',\n",
+              "    }\n",
+              "  };\n",
+              "\n",
+              "  cancel.remove();\n",
+              "\n",
+              "  // Disable the input element since further picks are not allowed.\n",
+              "  inputElement.disabled = true;\n",
+              "\n",
+              "  if (!files) {\n",
+              "    return {\n",
+              "      response: {\n",
+              "        action: 'complete',\n",
+              "      }\n",
+              "    };\n",
+              "  }\n",
+              "\n",
+              "  for (const file of files) {\n",
+              "    const li = document.createElement('li');\n",
+              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
+              "    li.append(span(\n",
+              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
+              "        `last modified: ${\n",
+              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
+              "                                    'n/a'} - `));\n",
+              "    const percent = span('0% done');\n",
+              "    li.appendChild(percent);\n",
+              "\n",
+              "    outputElement.appendChild(li);\n",
+              "\n",
+              "    const fileDataPromise = new Promise((resolve) => {\n",
+              "      const reader = new FileReader();\n",
+              "      reader.onload = (e) => {\n",
+              "        resolve(e.target.result);\n",
+              "      };\n",
+              "      reader.readAsArrayBuffer(file);\n",
+              "    });\n",
+              "    // Wait for the data to be ready.\n",
+              "    let fileData = yield {\n",
+              "      promise: fileDataPromise,\n",
+              "      response: {\n",
+              "        action: 'continue',\n",
+              "      }\n",
+              "    };\n",
+              "\n",
+              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
+              "    let position = 0;\n",
+              "    do {\n",
+              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
+              "      const chunk = new Uint8Array(fileData, position, length);\n",
+              "      position += length;\n",
+              "\n",
+              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
+              "      yield {\n",
+              "        response: {\n",
+              "          action: 'append',\n",
+              "          file: file.name,\n",
+              "          data: base64,\n",
+              "        },\n",
+              "      };\n",
+              "\n",
+              "      let percentDone = fileData.byteLength === 0 ?\n",
+              "          100 :\n",
+              "          Math.round((position / fileData.byteLength) * 100);\n",
+              "      percent.textContent = `${percentDone}% done`;\n",
+              "\n",
+              "    } while (position < fileData.byteLength);\n",
+              "  }\n",
+              "\n",
+              "  // All done.\n",
+              "  yield {\n",
+              "    response: {\n",
+              "      action: 'complete',\n",
+              "    }\n",
+              "  };\n",
+              "}\n",
+              "\n",
+              "scope.google = scope.google || {};\n",
+              "scope.google.colab = scope.google.colab || {};\n",
+              "scope.google.colab._files = {\n",
+              "  _uploadFiles,\n",
+              "  _uploadFilesContinue,\n",
+              "};\n",
+              "})(self);\n",
+              "</script> "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saving resnet101_model.onnx to resnet101_model.onnx\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "onnx_path = next(iter(uploaded_files.keys()))\n",
+        "print(f\"Model {onnx_path} uploaded successfully.\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "u88FLmcttmHJ",
+        "outputId": "8f893696-e791-4873-a9cc-bedb112b4989"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Model resnet101_model.onnx uploaded successfully.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Device setup\n",
+        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+        "input_size = 224"
+      ],
+      "metadata": {
+        "id": "IDQ8LAgStmrz"
+      },
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Test dataset transformations\n",
+        "transform_test = transforms.Compose([\n",
+        "    transforms.Resize((input_size, input_size)),\n",
+        "    transforms.ToTensor(),\n",
+        "    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
+        "])"
+      ],
+      "metadata": {
+        "id": "3xY6VU-itmuL"
+      },
+      "execution_count": 6,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Test dataset directory\n",
+        "test_dir = '/content/drive/MyDrive/update dataset/New Chest(5 class)/Test'\n",
+        "test_dataset = datasets.ImageFolder(test_dir, transform=transform_test)\n",
+        "test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)"
+      ],
+      "metadata": {
+        "id": "HOPBGsUBtmwb"
+      },
+      "execution_count": 7,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Class names\n",
+        "class_names = test_dataset.classes\n",
+        "print(f\"Classes: {class_names}\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "XjqjWiwftmys",
+        "outputId": "1e3e7d02-66f3-4fb0-fd60-769a6141acc3"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Classes: ['Covid-19', 'Emphysema', 'Healthy', 'Pneumonia', 'Tuberculosis', 'random']\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Load ONNX model\n",
+        "ort_session = ort.InferenceSession(onnx_path)"
+      ],
+      "metadata": {
+        "id": "4cCxZVQgtm0y"
+      },
+      "execution_count": 9,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Prediction function for ONNX\n",
+        "def predict_onnx(ort_session, image):\n",
+        "    input_tensor = image.astype(np.float32)\n",
+        "    outputs = ort_session.run(None, {\"input\": input_tensor})\n",
+        "    return outputs[0]\n"
+      ],
+      "metadata": {
+        "id": "wUQud0mmtm3T"
+      },
+      "execution_count": 10,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Evaluate the model on the test set\n",
+        "total_loss = 0.0\n",
+        "correct = 0\n",
+        "total_samples = 0\n",
+        "class_correct = [0] * len(class_names)\n",
+        "class_total = [0] * len(class_names)\n",
+        "criterion = torch.nn.CrossEntropyLoss()\n",
+        "\n",
+        "all_preds = []\n",
+        "all_labels = []\n"
+      ],
+      "metadata": {
+        "id": "viF9C-50tnlU"
+      },
+      "execution_count": 11,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "for images, labels in test_loader:\n",
+        "    images_np = images.numpy()\n",
+        "    batch_loss = 0.0\n",
+        "\n",
+        "    for i, img in enumerate(images_np):\n",
+        "        img_np = np.expand_dims(img, axis=0)  # Expand dimensions for ONNX input\n",
+        "        preds = predict_onnx(ort_session, img_np)\n",
+        "        predicted_label = np.argmax(preds)\n",
+        "\n",
+        "        # Track loss\n",
+        "        loss = criterion(torch.tensor(preds), torch.tensor([labels[i]]))\n",
+        "        batch_loss += loss.item()\n",
+        "\n",
+        "        # Update class-wise metrics\n",
+        "        class_correct[labels[i]] += (predicted_label == labels[i])\n",
+        "        class_total[labels[i]] += 1\n",
+        "\n",
+        "        # Track overall metrics\n",
+        "        correct += (predicted_label == labels[i])\n",
+        "        total_samples += 1\n",
+        "\n",
+        "        all_preds.append(predicted_label)\n",
+        "        all_labels.append(labels[i])\n",
+        "\n",
+        "    total_loss += batch_loss\n",
+        "\n",
+        "# Calculate overall metrics\n",
+        "total_accuracy = 100 * correct / total_samples\n",
+        "average_loss = total_loss / total_samples\n",
+        "\n",
+        "# Print results\n",
+        "print(f\"Total Accuracy: {total_accuracy:.2f}%\")\n",
+        "print(f\"Total Loss: {average_loss:.4f}\\n\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "7VukbcORtnnm",
+        "outputId": "443773f4-4fb3-46fb-fd51-9711459f4bf4"
+      },
+      "execution_count": 12,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Total Accuracy: 96.92%\n",
+            "Total Loss: 0.1005\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Class-wise metrics\n",
+        "for i, class_name in enumerate(class_names):\n",
+        "    class_accuracy = 100 * class_correct[i] / class_total[i]\n",
+        "    print(f\"{class_name}: Accuracy: {class_accuracy:.2f}%, Loss: {class_correct[i]:.4f}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "sDsdeqVxtnpT",
+        "outputId": "c5aea366-3906-45da-c2eb-24ae124a999d"
+      },
+      "execution_count": 13,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Covid-19: Accuracy: 95.00%, Loss: 190.0000\n",
+            "Emphysema: Accuracy: 97.50%, Loss: 195.0000\n",
+            "Healthy: Accuracy: 97.00%, Loss: 194.0000\n",
+            "Pneumonia: Accuracy: 97.50%, Loss: 195.0000\n",
+            "Tuberculosis: Accuracy: 94.50%, Loss: 189.0000\n",
+            "random: Accuracy: 100.00%, Loss: 200.0000\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Upload and predict single image\n",
+        "uploaded_image = files.upload()\n",
+        "image_path = next(iter(uploaded_image.keys()))\n",
+        "image = Image.open(image_path).convert(\"RGB\")\n",
+        "image_tensor = transform_test(image).unsqueeze(0).numpy()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 73
+        },
+        "id": "_yKBPU7ruLWE",
+        "outputId": "f30e0d20-c1a3-4153-8f73-d670caf06e3e"
+      },
+      "execution_count": 14,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-92c391e6-9928-4b56-8ed5-ef3fa7a5fca9\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-92c391e6-9928-4b56-8ed5-ef3fa7a5fca9\">\n",
+              "      Upload widget is only available when the cell has been executed in the\n",
+              "      current browser session. Please rerun this cell to enable.\n",
+              "      </output>\n",
+              "      <script>// Copyright 2017 Google LLC\n",
+              "//\n",
+              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+              "// you may not use this file except in compliance with the License.\n",
+              "// You may obtain a copy of the License at\n",
+              "//\n",
+              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
+              "//\n",
+              "// Unless required by applicable law or agreed to in writing, software\n",
+              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+              "// See the License for the specific language governing permissions and\n",
+              "// limitations under the License.\n",
+              "\n",
+              "/**\n",
+              " * @fileoverview Helpers for google.colab Python module.\n",
+              " */\n",
+              "(function(scope) {\n",
+              "function span(text, styleAttributes = {}) {\n",
+              "  const element = document.createElement('span');\n",
+              "  element.textContent = text;\n",
+              "  for (const key of Object.keys(styleAttributes)) {\n",
+              "    element.style[key] = styleAttributes[key];\n",
+              "  }\n",
+              "  return element;\n",
+              "}\n",
+              "\n",
+              "// Max number of bytes which will be uploaded at a time.\n",
+              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
+              "\n",
+              "function _uploadFiles(inputId, outputId) {\n",
+              "  const steps = uploadFilesStep(inputId, outputId);\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  // Cache steps on the outputElement to make it available for the next call\n",
+              "  // to uploadFilesContinue from Python.\n",
+              "  outputElement.steps = steps;\n",
+              "\n",
+              "  return _uploadFilesContinue(outputId);\n",
+              "}\n",
+              "\n",
+              "// This is roughly an async generator (not supported in the browser yet),\n",
+              "// where there are multiple asynchronous steps and the Python side is going\n",
+              "// to poll for completion of each step.\n",
+              "// This uses a Promise to block the python side on completion of each step,\n",
+              "// then passes the result of the previous step as the input to the next step.\n",
+              "function _uploadFilesContinue(outputId) {\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  const steps = outputElement.steps;\n",
+              "\n",
+              "  const next = steps.next(outputElement.lastPromiseValue);\n",
+              "  return Promise.resolve(next.value.promise).then((value) => {\n",
+              "    // Cache the last promise value to make it available to the next\n",
+              "    // step of the generator.\n",
+              "    outputElement.lastPromiseValue = value;\n",
+              "    return next.value.response;\n",
+              "  });\n",
+              "}\n",
+              "\n",
+              "/**\n",
+              " * Generator function which is called between each async step of the upload\n",
+              " * process.\n",
+              " * @param {string} inputId Element ID of the input file picker element.\n",
+              " * @param {string} outputId Element ID of the output display.\n",
+              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
+              " */\n",
+              "function* uploadFilesStep(inputId, outputId) {\n",
+              "  const inputElement = document.getElementById(inputId);\n",
+              "  inputElement.disabled = false;\n",
+              "\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  outputElement.innerHTML = '';\n",
+              "\n",
+              "  const pickedPromise = new Promise((resolve) => {\n",
+              "    inputElement.addEventListener('change', (e) => {\n",
+              "      resolve(e.target.files);\n",
+              "    });\n",
+              "  });\n",
+              "\n",
+              "  const cancel = document.createElement('button');\n",
+              "  inputElement.parentElement.appendChild(cancel);\n",
+              "  cancel.textContent = 'Cancel upload';\n",
+              "  const cancelPromise = new Promise((resolve) => {\n",
+              "    cancel.onclick = () => {\n",
+              "      resolve(null);\n",
+              "    };\n",
+              "  });\n",
+              "\n",
+              "  // Wait for the user to pick the files.\n",
+              "  const files = yield {\n",
+              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
+              "    response: {\n",
+              "      action: 'starting',\n",
+              "    }\n",
+              "  };\n",
+              "\n",
+              "  cancel.remove();\n",
+              "\n",
+              "  // Disable the input element since further picks are not allowed.\n",
+              "  inputElement.disabled = true;\n",
+              "\n",
+              "  if (!files) {\n",
+              "    return {\n",
+              "      response: {\n",
+              "        action: 'complete',\n",
+              "      }\n",
+              "    };\n",
+              "  }\n",
+              "\n",
+              "  for (const file of files) {\n",
+              "    const li = document.createElement('li');\n",
+              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
+              "    li.append(span(\n",
+              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
+              "        `last modified: ${\n",
+              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
+              "                                    'n/a'} - `));\n",
+              "    const percent = span('0% done');\n",
+              "    li.appendChild(percent);\n",
+              "\n",
+              "    outputElement.appendChild(li);\n",
+              "\n",
+              "    const fileDataPromise = new Promise((resolve) => {\n",
+              "      const reader = new FileReader();\n",
+              "      reader.onload = (e) => {\n",
+              "        resolve(e.target.result);\n",
+              "      };\n",
+              "      reader.readAsArrayBuffer(file);\n",
+              "    });\n",
+              "    // Wait for the data to be ready.\n",
+              "    let fileData = yield {\n",
+              "      promise: fileDataPromise,\n",
+              "      response: {\n",
+              "        action: 'continue',\n",
+              "      }\n",
+              "    };\n",
+              "\n",
+              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
+              "    let position = 0;\n",
+              "    do {\n",
+              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
+              "      const chunk = new Uint8Array(fileData, position, length);\n",
+              "      position += length;\n",
+              "\n",
+              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
+              "      yield {\n",
+              "        response: {\n",
+              "          action: 'append',\n",
+              "          file: file.name,\n",
+              "          data: base64,\n",
+              "        },\n",
+              "      };\n",
+              "\n",
+              "      let percentDone = fileData.byteLength === 0 ?\n",
+              "          100 :\n",
+              "          Math.round((position / fileData.byteLength) * 100);\n",
+              "      percent.textContent = `${percentDone}% done`;\n",
+              "\n",
+              "    } while (position < fileData.byteLength);\n",
+              "  }\n",
+              "\n",
+              "  // All done.\n",
+              "  yield {\n",
+              "    response: {\n",
+              "      action: 'complete',\n",
+              "    }\n",
+              "  };\n",
+              "}\n",
+              "\n",
+              "scope.google = scope.google || {};\n",
+              "scope.google.colab = scope.google.colab || {};\n",
+              "scope.google.colab._files = {\n",
+              "  _uploadFiles,\n",
+              "  _uploadFilesContinue,\n",
+              "};\n",
+              "})(self);\n",
+              "</script> "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saving person543_bacteria_2284.jpeg to person543_bacteria_2284.jpeg\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Predict using ONNX model\n",
+        "output = predict_onnx(ort_session, image_tensor)\n",
+        "predicted_class = np.argmax(output)\n"
+      ],
+      "metadata": {
+        "id": "0TuxUr-8uLYN"
+      },
+      "execution_count": 15,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print(\"\\nSingle Image Prediction:\")\n",
+        "print(f\"Predicted Class: {class_names[predicted_class]}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "o496dakcuLaP",
+        "outputId": "23e50874-28c9-46df-d067-a6b258be2b0b"
+      },
+      "execution_count": 16,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Single Image Prediction:\n",
+            "Predicted Class: Pneumonia\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "ltNcx3pG8jtd"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n"
+      ],
+      "metadata": {
+        "id": "woxWdvNf8jv1"
+      },
+      "execution_count": 17,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Convert class_correct and class_total to NumPy arrays\n",
+        "class_correct = np.array(class_correct)\n",
+        "class_total = np.array(class_total)\n"
+      ],
+      "metadata": {
+        "id": "mvvP9ytH8191"
+      },
+      "execution_count": 22,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Prepare class-wise metrics\n",
+        "class_metrics = {\n",
+        "    \"Class\": class_names,\n",
+        "    \"Accuracy (%)\": [100 * class_correct[i] / class_total[i] for i in range(len(class_names))],\n",
+        "    \"Samples\": class_total.tolist()\n",
+        "}"
+      ],
+      "metadata": {
+        "id": "go_8TXDx8jx8"
+      },
+      "execution_count": 23,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Convert to DataFrame\n",
+        "df_metrics = pd.DataFrame(class_metrics)\n",
+        "\n",
+        "# Print metrics as a table\n",
+        "print(df_metrics)\n",
+        "\n",
+        "# Visualize class-wise metrics\n",
+        "plt.figure(figsize=(12, 6))\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 173
+        },
+        "id": "rC5HFCjn8j0x",
+        "outputId": "39f04af5-51d2-4e32-e729-7e50a18b53a3"
+      },
+      "execution_count": 24,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "          Class  Accuracy (%)  Samples\n",
+            "0      Covid-19          95.0      200\n",
+            "1     Emphysema          97.5      200\n",
+            "2       Healthy          97.0      200\n",
+            "3     Pneumonia          97.5      200\n",
+            "4  Tuberculosis          94.5      200\n",
+            "5        random         100.0      200\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x600 with 0 Axes>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 24
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x600 with 0 Axes>"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Plot Accuracy\n",
+        "sns.barplot(x=\"Class\", y=\"Accuracy (%)\", data=df_metrics, hue=\"Class\", dodge=False, palette=\"viridis\")\n",
+        "plt.title(\"Class-wise Accuracy\")\n",
+        "plt.ylabel(\"Accuracy (%)\")\n",
+        "plt.xticks(rotation=45)\n",
+        "plt.grid(axis=\"y\", linestyle=\"--\", alpha=0.7)\n",
+        "plt.legend([], [], frameon=False)  # Remove legend\n",
+        "plt.show()\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 528
+        },
+        "id": "moyzLYdz8oHs",
+        "outputId": "81640d4b-a4b2-4fc4-e031-0cc27a8b28f5"
+      },
+      "execution_count": 25,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Plot Samples Count\n",
+        "plt.figure(figsize=(12, 6))\n",
+        "sns.barplot(x=\"Class\", y=\"Samples\", data=df_metrics, hue=\"Class\", dodge=False, palette=\"coolwarm\")\n",
+        "plt.title(\"Class-wise Samples Count\")\n",
+        "plt.ylabel(\"Samples\")\n",
+        "plt.xticks(rotation=45)\n",
+        "plt.grid(axis=\"y\", linestyle=\"--\", alpha=0.7)\n",
+        "plt.legend([], [], frameon=False)  # Remove legend\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 621
+        },
+        "id": "uBXDoxtV8oJ7",
+        "outputId": "5659b3fd-6162-43fd-a70e-bdf8fcdcec08"
+      },
+      "execution_count": 26,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Confusion Matrix**"
+      ],
+      "metadata": {
+        "id": "sRbr9nfQ9dat"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
+        "\n",
+        "# Generate confusion matrix\n",
+        "cm = confusion_matrix(all_labels, all_preds, labels=list(range(len(class_names))))\n",
+        "\n",
+        "# Display confusion matrix\n",
+        "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=class_names)\n",
+        "plt.figure(figsize=(10, 8))\n",
+        "disp.plot(cmap=\"Blues\", values_format=\".0f\")\n",
+        "plt.title(\"Confusion Matrix\")\n",
+        "plt.show()\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 489
+        },
+        "id": "BJMNz7lP8oMU",
+        "outputId": "2810af8a-ba72-4f08-9069-b1fff101c321"
+      },
+      "execution_count": 27,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x800 with 0 Axes>"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "** Precision, Recall, and F1-Score for Each Class**"
+      ],
+      "metadata": {
+        "id": "RWQQMoyq9igl"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.metrics import classification_report\n",
+        "\n",
+        "# Generate classification report\n",
+        "report = classification_report(all_labels, all_preds, target_names=class_names)\n",
+        "print(\"Classification Report:\\n\")\n",
+        "print(report)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "qFrxCDBq8oO7",
+        "outputId": "917f140a-2cfe-4002-a6a7-f7a9f62a3c3e"
+      },
+      "execution_count": 28,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Classification Report:\n",
+            "\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "    Covid-19       0.93      0.95      0.94       200\n",
+            "   Emphysema       0.96      0.97      0.97       200\n",
+            "     Healthy       0.96      0.97      0.97       200\n",
+            "   Pneumonia       0.97      0.97      0.97       200\n",
+            "Tuberculosis       0.99      0.94      0.97       200\n",
+            "      random       1.00      1.00      1.00       200\n",
+            "\n",
+            "    accuracy                           0.97      1200\n",
+            "   macro avg       0.97      0.97      0.97      1200\n",
+            "weighted avg       0.97      0.97      0.97      1200\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**ROC Curve and AUC**"
+      ],
+      "metadata": {
+        "id": "pT7EYlZD9oV1"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.metrics import roc_curve, auc\n",
+        "from sklearn.preprocessing import label_binarize\n",
+        "\n",
+        "# Binarize labels for multi-class ROC curve\n",
+        "n_classes = len(class_names)\n",
+        "labels_bin = label_binarize(all_labels, classes=list(range(n_classes)))\n",
+        "preds_bin = label_binarize(all_preds, classes=list(range(n_classes)))\n",
+        "\n",
+        "# Compute ROC curve and AUC for each class\n",
+        "for i in range(n_classes):\n",
+        "    fpr, tpr, _ = roc_curve(labels_bin[:, i], preds_bin[:, i])\n",
+        "    roc_auc = auc(fpr, tpr)\n",
+        "    plt.plot(fpr, tpr, label=f\"{class_names[i]} (AUC = {roc_auc:.2f})\")\n",
+        "\n",
+        "# Plot ROC curve\n",
+        "plt.plot([0, 1], [0, 1], 'k--')  # Diagonal line\n",
+        "plt.title(\"ROC Curve\")\n",
+        "plt.xlabel(\"False Positive Rate\")\n",
+        "plt.ylabel(\"True Positive Rate\")\n",
+        "plt.legend()\n",
+        "plt.grid()\n",
+        "plt.show()\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 472
+        },
+        "id": "vUdCPQYluLcf",
+        "outputId": "b6a1628d-e036-4b58-b633-77037530d46b"
+      },
+      "execution_count": 29,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Grad-CAM (Class Activation Maps)**"
+      ],
+      "metadata": {
+        "id": "2HZes3e99v0V"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install pytorch-grad-cam --quiet\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "E8QAmF1k-L3v",
+        "outputId": "4982e5e7-63ed-42aa-dbcf-6589e2d63f88"
+      },
+      "execution_count": 36,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\u001b[31mERROR: Could not find a version that satisfies the requirement pytorch-grad-cam (from versions: none)\u001b[0m\u001b[31m\n",
+            "\u001b[0m\u001b[31mERROR: No matching distribution found for pytorch-grad-cam\u001b[0m\u001b[31m\n",
+            "\u001b[0m"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from pytorch_grad_cam import GradCAM\n",
+        "from pytorch_grad_cam.utils.image import show_cam_on_image\n",
+        "\n",
+        "print(\"pytorch-grad-cam installed and imported successfully.\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 366
+        },
+        "id": "s9GfkdPV-WpP",
+        "outputId": "ac0a2490-6346-49eb-fb7b-5c756c3721ca"
+      },
+      "execution_count": 35,
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "ModuleNotFoundError",
+          "evalue": "No module named 'pytorch_grad_cam'",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-35-f9e26225fd59>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mpytorch_grad_cam\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mGradCAM\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpytorch_grad_cam\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimage\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mshow_cam_on_image\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"pytorch-grad-cam installed and imported successfully.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'pytorch_grad_cam'",
+            "",
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0;32m\nNOTE: If your import is failing due to a missing package, you can\nmanually install dependencies using either !pip or !apt.\n\nTo view examples of installing some common dependencies, click the\n\"Open Examples\" button below.\n\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n"
+          ],
+          "errorDetails": {
+            "actions": [
+              {
+                "action": "open_url",
+                "actionText": "Open Examples",
+                "url": "/notebooks/snippets/importing_libraries.ipynb"
+              }
+            ]
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from pytorch_grad_cam import GradCAM\n",
+        "from pytorch_grad_cam.utils.image import show_cam_on_image\n",
+        "\n",
+        "# Initialize Grad-CAM\n",
+        "target_layers = [model.layer4[-1]]  # Last convolutional layer\n",
+        "cam = GradCAM(model=model, target_layers=target_layers, use_cuda=torch.cuda.is_available())\n",
+        "\n",
+        "# Run Grad-CAM for a single image\n",
+        "image_tensor = images[0].unsqueeze(0).to(device)  # Example: first image in the batch\n",
+        "target_category = preds[0]  # Predicted class for the first image\n",
+        "grayscale_cam = cam(input_tensor=image_tensor, target_category=target_category)\n",
+        "\n",
+        "# Visualize Grad-CAM overlay\n",
+        "grayscale_cam = grayscale_cam[0, :]\n",
+        "visualization = show_cam_on_image(images[0].permute(1, 2, 0).cpu().numpy(), grayscale_cam)\n",
+        "plt.imshow(visualization)\n",
+        "plt.title(f\"Grad-CAM for Class: {class_names[target_category]}\")\n",
+        "plt.show()\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 383
+        },
+        "id": "sxHSJCJu9l7-",
+        "outputId": "a4a23907-e518-44fd-cda1-f1f95b3c9000"
+      },
+      "execution_count": 34,
+      "outputs": [
+        {
+          "output_type": "error",
+          "ename": "ModuleNotFoundError",
+          "evalue": "No module named 'pytorch_grad_cam'",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-34-5daa3351f029>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mpytorch_grad_cam\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mGradCAM\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mpytorch_grad_cam\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimage\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mshow_cam_on_image\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# Initialize Grad-CAM\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mtarget_layers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayer4\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m  \u001b[0;31m# Last convolutional layer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'pytorch_grad_cam'",
+            "",
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0;32m\nNOTE: If your import is failing due to a missing package, you can\nmanually install dependencies using either !pip or !apt.\n\nTo view examples of installing some common dependencies, click the\n\"Open Examples\" button below.\n\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n"
+          ],
+          "errorDetails": {
+            "actions": [
+              {
+                "action": "open_url",
+                "actionText": "Open Examples",
+                "url": "/notebooks/snippets/importing_libraries.ipynb"
+              }
+            ]
+          }
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Misclassification Analysis**"
+      ],
+      "metadata": {
+        "id": "YcfPXQkH91TF"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Find misclassified samples\n",
+        "misclassified_indices = [i for i, (pred, label) in enumerate(zip(all_preds, all_labels)) if pred != label]\n",
+        "\n",
+        "# Display a few misclassified images\n",
+        "plt.figure(figsize=(12, 8))\n",
+        "for i, idx in enumerate(misclassified_indices[:5]):  # Display first 5 misclassified images\n",
+        "    plt.subplot(1, 5, i + 1)\n",
+        "    img = test_dataset[idx][0].permute(1, 2, 0).numpy()\n",
+        "    plt.imshow(img)\n",
+        "    plt.title(f\"True: {class_names[all_labels[idx]]}\\nPred: {class_names[all_preds[idx]]}\")\n",
+        "    plt.axis(\"off\")\n",
+        "plt.show()\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 327
+        },
+        "id": "ntMz2E_o9l-X",
+        "outputId": "83677b45-962b-45f4-be08-19954091136f"
+      },
+      "execution_count": 31,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
+            "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
+            "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
+            "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
+            "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x800 with 5 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Matthews Correlation Coefficient (MCC)**"
+      ],
+      "metadata": {
+        "id": "m1BQnV5K99UW"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.metrics import matthews_corrcoef\n",
+        "\n",
+        "mcc = matthews_corrcoef(all_labels, all_preds)\n",
+        "print(f\"Matthews Correlation Coefficient (MCC): {mcc:.4f}\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "gNEAgjmD9mAe",
+        "outputId": "18ca1128-2ec1-47ea-db12-40bc96269ef9"
+      },
+      "execution_count": 37,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Matthews Correlation Coefficient (MCC): 0.9630\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Cohen's Kappa**"
+      ],
+      "metadata": {
+        "id": "fO8r3e6w-n1v"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.metrics import cohen_kappa_score\n",
+        "\n",
+        "kappa = cohen_kappa_score(all_labels, all_preds)\n",
+        "print(f\"Cohen's Kappa: {kappa:.4f}\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "gzyMMKde962_",
+        "outputId": "0c66cf1a-e9ec-4f4e-c0a6-4d3c85bf0c60"
+      },
+      "execution_count": 38,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Cohen's Kappa: 0.9630\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Balanced Accuracy**"
+      ],
+      "metadata": {
+        "id": "m9UsUc0c-saP"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.metrics import balanced_accuracy_score\n",
+        "\n",
+        "balanced_acc = balanced_accuracy_score(all_labels, all_preds)\n",
+        "print(f\"Balanced Accuracy: {balanced_acc:.4f}\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "A6JVInHZ965X",
+        "outputId": "ee2530e3-ca50-42ad-d9be-9a52fa52b59d"
+      },
+      "execution_count": 39,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Balanced Accuracy: 0.9692\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Class-Wise Sensitivity and Specificity**"
+      ],
+      "metadata": {
+        "id": "58DJd8_I--G4"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.metrics import recall_score\n",
+        "\n",
+        "# Sensitivity (Recall)\n",
+        "sensitivity = recall_score(all_labels, all_preds, average=None)\n",
+        "print(f\"Class-wise Sensitivity (Recall): {sensitivity}\")\n",
+        "\n",
+        "# Specificity Calculation\n",
+        "specificity = []\n",
+        "for i in range(len(class_names)):\n",
+        "    tp = cm[i, i]\n",
+        "    tn = cm.sum() - (cm[i, :].sum() + cm[:, i].sum() - tp)\n",
+        "    fp = cm[:, i].sum() - tp\n",
+        "    fn = cm[i, :].sum() - tp\n",
+        "    specificity.append(tn / (tn + fp))\n",
+        "\n",
+        "print(f\"Class-wise Specificity: {specificity}\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "W8UzoV_y-td5",
+        "outputId": "3da786fd-db66-440b-f5af-42e745ee0cc4"
+      },
+      "execution_count": 41,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Class-wise Sensitivity (Recall): [0.95  0.975 0.97  0.975 0.945 1.   ]\n",
+            "Class-wise Specificity: [0.986, 0.992, 0.992, 0.995, 0.998, 1.0]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print(f\"Batch shape: {batch.shape}\")\n",
+        "print(f\"Probs shape: {probs.shape}\")\n",
+        "print(f\"ONNX input shape: {input_shape}\")\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "xpjH2rFrE324",
+        "outputId": "d37c1bef-991a-486a-bcce-365a4fbd95be"
+      },
+      "execution_count": 56,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Batch shape: (1, 3, 224, 224)\n",
+            "Probs shape: (1200, 6)\n",
+            "ONNX input shape: [1, 3, 224, 224]\n"
+          ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file