TestResNet.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "\n",
        "# Mount Google Drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7kMdNlxESxv8",
        "outputId": "efba358b-50cd-45d2-ffc1-d411c701d5ce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b5dm4-qdSo5y"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow.keras import datasets, layers, models\n",
        "from tensorflow.keras.applications import ResNet152V2\n",
        "from tensorflow.keras.callbacks import EarlyStopping\n",
        "from sklearn.metrics import confusion_matrix, classification_report\n",
        "from sklearn.metrics import classification_report, confusion_matrix, average_precision_score\n",
        "import matplotlib.pyplot as plt\n",
        "import cv2\n",
        "import os\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def load_glaucoma_dataset(data_dir, image_size):\n",
        "    images = []\n",
        "    labels = []\n",
        "    class_names = ['Glaucoma_Positive', 'Glaucoma_Negative']\n",
        "\n",
        "    for class_name in class_names:\n",
        "        class_dir = os.path.join(data_dir, class_name)\n",
        "        class_label = class_names.index(class_name)\n",
        "\n",
        "        for filename in os.listdir(class_dir):\n",
        "            if filename.endswith(\".jpg\"):\n",
        "                img_path = os.path.join(class_dir, filename)\n",
        "                img = cv2.imread(img_path)\n",
        "                img = cv2.resize(img, (image_size, image_size))\n",
        "                img = img / 255.0\n",
        "                images.append(img)\n",
        "                labels.append(class_label)\n",
        "\n",
        "    return np.array(images), np.array(labels)"
      ],
      "metadata": {
        "id": "62qW1JCmS0o9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.models import load_model\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "from sklearn.metrics import confusion_matrix, classification_report\n",
        "import numpy as np\n",
        "import os\n",
        "\n",
        "def load_glaucoma_dataset_generator(dataset_path, image_size, batch_size=32):\n",
        "    datagen = ImageDataGenerator(rescale=1./255)\n",
        "\n",
        "    generator = datagen.flow_from_directory(\n",
        "        dataset_path,\n",
        "        target_size=(image_size, image_size),\n",
        "        batch_size=batch_size,\n",
        "        class_mode='binary',  # Assuming it's a binary classification task\n",
        "        shuffle=False  # Ensure that the order is preserved\n",
        "    )\n",
        "\n",
        "    # Retrieve the total number of samples\n",
        "    num_samples = generator.samples\n",
        "\n",
        "    return generator, num_samples\n",
        "\n",
        "# Example usage:\n",
        "your_dataset_path = r\"/content/drive/MyDrive/Dataset_Sardjito\"\n",
        "your_image_size = 224\n",
        "batch_size = 32\n",
        "\n",
        "# Define the path to the test dataset\n",
        "test_dataset_path = os.path.join(your_dataset_path, 'test')\n",
        "\n",
        "# Create a generator for the test dataset\n",
        "test_generator, num_test_samples = load_glaucoma_dataset_generator(test_dataset_path, your_image_size, batch_size)\n",
        "\n",
        "# Define the path to your pre-trained model\n",
        "model_path = \"/content/drive/MyDrive/final_mode223.h5\"  # Change this to the path of your saved model\n",
        "\n",
        "# Load the pre-trained model\n",
        "loaded_model = load_model(model_path)\n",
        "\n",
        "# Initialize variables for confusion matrix\n",
        "all_true_labels = []\n",
        "all_predicted_labels = []\n",
        "\n",
        "# Calculate the total number of batches\n",
        "total_batches = num_test_samples // batch_size\n",
        "\n",
        "# Iterate over batches\n",
        "for i in range(total_batches + 1):  # +1 to include the last batch\n",
        "    batch_images, batch_labels = test_generator.next()\n",
        "\n",
        "    # Perform predictions on the batch\n",
        "    predictions = loaded_model.predict(batch_images)\n",
        "    predicted_labels = np.round(predictions).flatten()\n",
        "\n",
        "    # Append true and predicted labels for confusion matrix\n",
        "    all_true_labels.extend(batch_labels)\n",
        "    all_predicted_labels.extend(predicted_labels)\n",
        "\n",
        "    # Calculate loading and prediction process\n",
        "    process_percentage = (i + 1) / (total_batches + 1) * 100\n",
        "    print(f\"Processing: {process_percentage:.2f}%\")\n",
        "\n",
        "# Convert true and predicted labels to numpy arrays\n",
        "all_true_labels = np.array(all_true_labels)\n",
        "all_predicted_labels = np.array(all_predicted_labels)\n",
        "\n",
        "# Evaluate the model on the entire test set\n",
        "test_loss, test_accuracy = loaded_model.evaluate(test_generator)\n",
        "\n",
        "# Print test accuracy, test loss, confusion matrix, and classification report\n",
        "print(f\"\\nTest Accuracy: {test_accuracy}\")\n",
        "print(f\"Test Loss: {test_loss}\")\n",
        "print(\"\\nConfusion Matrix:\")\n",
        "conf_matrix = confusion_matrix(all_true_labels, all_predicted_labels)\n",
        "print(conf_matrix)\n",
        "print(\"\\nClassification Report:\")\n",
        "class_report = classification_report(all_true_labels, all_predicted_labels)\n",
        "print(class_report)\n",
        "\n",
        "# Save the confusion matrix\n",
        "conf_matrix_save_path = \"/content/drive/MyDrive/confusion_matrix.npy\"\n",
        "np.save(conf_matrix_save_path, conf_matrix)\n",
        "print(f\"\\nConfusion Matrix saved at: {conf_matrix_save_path}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2NZqmH4WTIKV",
        "outputId": "c2c27579-1b02-4a9a-9d3b-287ef152a5f2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 196 images belonging to 2 classes.\n",
            "1/1 [==============================] - 12s 12s/step\n",
            "Processing: 14.29%\n",
            "1/1 [==============================] - 9s 9s/step\n",
            "Processing: 28.57%\n",
            "1/1 [==============================] - 9s 9s/step\n",
            "Processing: 42.86%\n",
            "1/1 [==============================] - 11s 11s/step\n",
            "Processing: 57.14%\n",
            "1/1 [==============================] - 10s 10s/step\n",
            "Processing: 71.43%\n",
            "1/1 [==============================] - 9s 9s/step\n",
            "Processing: 85.71%\n",
            "1/1 [==============================] - 3s 3s/step\n",
            "Processing: 100.00%\n",
            "7/7 [==============================] - 65s 9s/step - loss: 1.5860 - accuracy: 0.5204\n",
            "\n",
            "Test Accuracy: 0.5204081535339355\n",
            "Test Loss: 1.5860118865966797\n",
            "\n",
            "Confusion Matrix:\n",
            "[[16 18]\n",
            " [76 86]]\n",
            "\n",
            "Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "         0.0       0.17      0.47      0.25        34\n",
            "         1.0       0.83      0.53      0.65       162\n",
            "\n",
            "    accuracy                           0.52       196\n",
            "   macro avg       0.50      0.50      0.45       196\n",
            "weighted avg       0.71      0.52      0.58       196\n",
            "\n",
            "\n",
            "Confusion Matrix saved at: /content/drive/MyDrive/confusion_matrix.npy\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import shutil\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "def split_data(input_folder, output_folder, train_percent=0.9, test_percent=0.05, val_percent=0.05):\n",
        "    # Create train, test, and val folders in the output directory\n",
        "    train_folder = os.path.join(output_folder, 'train')\n",
        "    test_folder = os.path.join(output_folder, 'test')\n",
        "    val_folder = os.path.join(output_folder, 'val')\n",
        "\n",
        "    os.makedirs(train_folder, exist_ok=True)\n",
        "    os.makedirs(test_folder, exist_ok=True)\n",
        "    os.makedirs(val_folder, exist_ok=True)\n",
        "\n",
        "    for class_folder in os.listdir(input_folder):\n",
        "        input_class_folder = os.path.join(input_folder, class_folder)\n",
        "\n",
        "        if os.path.isdir(input_class_folder):\n",
        "            # Create class-specific train, test, and val folders\n",
        "            train_class_folder = os.path.join(train_folder, class_folder)\n",
        "            test_class_folder = os.path.join(test_folder, class_folder)\n",
        "            val_class_folder = os.path.join(val_folder, class_folder)\n",
        "\n",
        "            os.makedirs(train_class_folder, exist_ok=True)\n",
        "            os.makedirs(test_class_folder, exist_ok=True)\n",
        "            os.makedirs(val_class_folder, exist_ok=True)\n",
        "\n",
        "            # List all files in the input folder\n",
        "            all_files = os.listdir(input_class_folder)\n",
        "            total_files = len(all_files)\n",
        "\n",
        "            # Split files into train, test, and val sets\n",
        "            train_files, test_val_files = train_test_split(all_files, test_size=(test_percent + val_percent), random_state=42)\n",
        "            test_files, val_files = train_test_split(test_val_files, test_size=val_percent/(test_percent + val_percent), random_state=42)\n",
        "\n",
        "            # Copy files to the corresponding class-specific folders\n",
        "            for file_name in train_files:\n",
        "                shutil.copy(os.path.join(input_class_folder, file_name), os.path.join(train_class_folder, file_name))\n",
        "\n",
        "            for file_name in test_files:\n",
        "                shutil.copy(os.path.join(input_class_folder, file_name), os.path.join(test_class_folder, file_name))\n",
        "\n",
        "            for file_name in val_files:\n",
        "                shutil.copy(os.path.join(input_class_folder, file_name), os.path.join(val_class_folder, file_name))\n",
        "\n",
        "# Example usage:\n",
        "input_folder = r\"/content/drive/MyDrive/Dataset_LAG/bare\"\n",
        "output_folder = r\"/content/drive/MyDrive/Dataset_LAG\"  # Change this to the desired output path\n",
        "\n",
        "split_data(input_folder, output_folder)\n",
        "\n"
      ],
      "metadata": {
        "id": "CXq9I8MmuZfb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Load the confusion matrix\n",
        "data = np.load('/content/drive/MyDrive/confusion_matrix.npy')\n",
        "\n",
        "# Display the confusion matrix as an image\n",
        "plt.imshow(data, cmap='viridis', interpolation='nearest')\n",
        "plt.colorbar()\n",
        "plt.title('Confusion Matrix')\n",
        "plt.xlabel('Predicted Label')\n",
        "plt.ylabel('True Label')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "E_NblYySxS_z",
        "outputId": "2d8e10a2-f8be-482a-cacb-37679bfecf55"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from tensorflow.keras.models import load_model\n",
        "from sklearn.metrics import confusion_matrix, classification_report\n",
        "import numpy as np\n",
        "\n",
        "# Define the path to your pre-trained model\n",
        "model_path = \"/content/drive/MyDrive/Dataset_Latihan/best_model.h5\"  # Change this to the path of your saved model\n",
        "\n",
        "# Load the pre-trained model\n",
        "loaded_model = load_model(model_path)\n",
        "\n",
        "# Assuming you have loaded your test datasets: glaucoma_test_images, glaucoma_test_labels\n",
        "\n",
        "# Perform predictions on the test set\n",
        "predictions = loaded_model.predict(glaucoma_test_images)\n",
        "predicted_labels = np.round(predictions).flatten()\n",
        "\n",
        "# Convert true labels to binary (assuming it's not binary already)\n",
        "true_labels = np.array(glaucoma_test_labels).flatten()\n",
        "\n",
        "# Evaluate the model on the test set\n",
        "test_loss, test_accuracy = loaded_model.evaluate(glaucoma_test_images, glaucoma_test_labels)\n",
        "\n",
        "# Print test accuracy, test loss, confusion matrix, and classification report\n",
        "print(f\"Test Accuracy: {test_accuracy}\")\n",
        "print(f\"Test Loss: {test_loss}\")\n",
        "print(\"\\nConfusion Matrix:\")\n",
        "print(confusion_matrix(true_labels, predicted_labels))\n",
        "print(\"\\nClassification Report:\")\n",
        "print(classification_report(true_labels, predicted_labels))"
      ],
      "metadata": {
        "id": "YPOVA_PuyUKg"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}