Isolation_Forest.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",
        "# Mount Google Drive\n",
        "drive.mount('/content/gdrive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QH6df5k9CAP_",
        "outputId": "939ae054-7b94-41e5-d00c-98a23169ae29"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#extract dataset\n",
        "import zipfile\n",
        "import os\n",
        "\n",
        "#MSI_MSS\n",
        "ZIP_PATH = \"/content/gdrive/MyDrive/MSI_MSS_zips/Train/MSI.zip\"\n",
        "IMAGE_FOLDER = \"/content/gdrive/MyDrive/MSI_MSS/Train/\"\n",
        "\n",
        "# Ensure that the extraction folder exists\n",
        "if not os.path.exists(IMAGE_FOLDER):\n",
        "    os.makedirs(IMAGE_FOLDER)\n",
        "\n",
        "# Open the zip file and extract its contents without creating a new folder\n",
        "with zipfile.ZipFile(ZIP_PATH, 'r') as zip_ref:\n",
        "    for file_info in zip_ref.infolist():\n",
        "        print(f\"Extracting: {file_info.filename}\")\n",
        "        zip_ref.extract(file_info, path=IMAGE_FOLDER)"
      ],
      "metadata": {
        "id": "jlwEtVDACHS5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision.models as models\n",
        "import torchvision.transforms as transforms\n",
        "from torchvision.datasets import ImageFolder\n",
        "from torch.utils.data import DataLoader\n",
        "import numpy as np\n",
        "from sklearn.ensemble import IsolationForest\n",
        "from joblib import dump"
      ],
      "metadata": {
        "id": "zPP0vsovC7ug"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
      ],
      "metadata": {
        "id": "1fVDb7ZfEbpa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load dataset\n",
        "data_dir = '/content/gdrive/MyDrive/MSI_MSS/Train'"
      ],
      "metadata": {
        "id": "_0mr2bQEC-DW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#preprocess data\n",
        "transform = transforms.Compose([\n",
        "    transforms.Resize((224, 224)),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
        "])\n",
        "dataset = ImageFolder(root=data_dir, transform=transform)\n",
        "dataloader = DataLoader(dataset, batch_size=32, shuffle=True)"
      ],
      "metadata": {
        "id": "VcUIxpzVENj3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Feature extraction model (ResNet50)\n",
        "feature_extractor = models.resnet50(pretrained=True)\n",
        "feature_extractor.fc = torch.nn.Sequential()  # Remove the final layer\n",
        "feature_extractor.to(device)\n",
        "feature_extractor.eval()\n",
        "\n",
        "# Extract features\n",
        "features = []\n",
        "for inputs, _ in dataloader:\n",
        "    inputs = inputs.to(device)\n",
        "    with torch.no_grad():\n",
        "        outputs = feature_extractor(inputs)\n",
        "        features.append(outputs.cpu().numpy())\n",
        "features = np.concatenate(features, axis=0)\n",
        "\n",
        "# Save the feature extractor model\n",
        "feature_extractor_path = '/content/gdrive/MyDrive/feature_extractor.pth'\n",
        "torch.save(feature_extractor.state_dict(), feature_extractor_path)"
      ],
      "metadata": {
        "id": "5tEW3srHEm4l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train Isolation Forest\n",
        "clf = IsolationForest(random_state=0, contamination='auto')\n",
        "clf.fit(features)\n",
        "\n",
        "# Save the trained model\n",
        "isolation_forest_model_path = '/content/gdrive/MyDrive/Anomaly_MSI_MSS_Isolation_Forest_model.joblib'\n",
        "dump(clf, isolation_forest_model_path)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7FY0f5fPEqoM",
        "outputId": "7763b7d3-869b-4ddf-a3a1-5f2b6507e433"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['/content/gdrive/MyDrive/Anomaly_MSI_MSS_Isolation_Forest_model.joblib']"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!ls /content/gdrive/MyDrive/MSI_MSS_2/Test_Final/MSI/MSI"
      ],
      "metadata": {
        "id": "7VmW7wf4K9bq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from joblib import load\n",
        "from PIL import Image\n",
        "\n",
        "# Load the trained Isolation Forest model\n",
        "isolation_forest_model_path = '/content/gdrive/MyDrive/Anomaly_MSI_MSS_Isolation_Forest_model.joblib'\n",
        "clf = load(isolation_forest_model_path)\n",
        "\n",
        "# Anomaly detection function\n",
        "def is_anomaly(image_path, clf, feature_extractor, transform):\n",
        "    image = Image.open(image_path).convert('RGB')\n",
        "    input_image = transform(image).unsqueeze(0).to(device)\n",
        "\n",
        "    feature_extractor.to(device)\n",
        "    with torch.no_grad():\n",
        "        image_features = feature_extractor(input_image)\n",
        "\n",
        "    is_outlier = clf.predict(image_features.cpu().numpy().reshape(1, -1))\n",
        "    return is_outlier[0] == -1\n",
        "\n",
        "feature_extractor_path = '/content/gdrive/MyDrive/feature_extractor.pth'\n",
        "# Define the model architecture\n",
        "feature_extractor = models.resnet50(pretrained=False)  # pretrained=False since loading custom weights\n",
        "feature_extractor.fc = torch.nn.Sequential()  # Ensure this matches the saved model's structure\n",
        "\n",
        "# Load the saved weights\n",
        "feature_extractor.load_state_dict(torch.load(feature_extractor_path))\n",
        "\n",
        "# Move to the appropriate device (GPU or CPU)\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "feature_extractor.to(device)\n",
        "feature_extractor.eval()\n",
        "\n",
        "# Example usage\n",
        "image_path = '/content/gdrive/MyDrive/Cow.png'\n",
        "if is_anomaly(image_path, clf, feature_extractor, transform):\n",
        "    print(\"Anomaly detected. Image will not be classified.\")\n",
        "else:\n",
        "    print(\"No anomaly detected. Proceeding with classification.\")\n",
        "    # Load and use your MSI_MSS classification model here\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O6jgMBGXEWiZ",
        "outputId": "e0387f25-758b-4820-c386-cd74c490e669"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=None`.\n",
            "  warnings.warn(msg)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Anomaly detected. Image will not be classified.\n"
          ]
        }
      ]
    }
  ]
}