111. Random_forest_with_VGG16.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bz7UA3m0FsEd",
        "outputId": "ecd14a06-41bc-43d1-bbeb-468b825b14a0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: gdown in /usr/local/lib/python3.8/dist-packages (4.4.0)\n",
            "Collecting gdown\n",
            "  Downloading gdown-4.6.0-py3-none-any.whl (14 kB)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.8/dist-packages (from gdown) (1.15.0)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.8/dist-packages (from gdown) (4.64.1)\n",
            "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.8/dist-packages (from gdown) (4.6.3)\n",
            "Requirement already satisfied: requests[socks] in /usr/local/lib/python3.8/dist-packages (from gdown) (2.25.1)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.8/dist-packages (from gdown) (3.9.0)\n",
            "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests[socks]->gdown) (4.0.0)\n",
            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests[socks]->gdown) (1.24.3)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests[socks]->gdown) (2022.12.7)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests[socks]->gdown) (2.10)\n",
            "Requirement already satisfied: PySocks!=1.5.7,>=1.5.6 in /usr/local/lib/python3.8/dist-packages (from requests[socks]->gdown) (1.7.1)\n",
            "Installing collected packages: gdown\n",
            "  Attempting uninstall: gdown\n",
            "    Found existing installation: gdown 4.4.0\n",
            "    Uninstalling gdown-4.4.0:\n",
            "      Successfully uninstalled gdown-4.4.0\n",
            "Successfully installed gdown-4.6.0\n",
            "/usr/local/lib/python3.8/dist-packages/gdown/cli.py:121: FutureWarning: Option `--id` was deprecated in version 4.3.1 and will be removed in 5.0. You don't need to pass it anymore to use a file ID.\n",
            "  warnings.warn(\n",
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1-Vm4Y4YTPSH_zM3xSTzB9RQvJqiVFwaw\n",
            "To: /content/Tumor.zip\n",
            "100% 156M/156M [00:03<00:00, 43.5MB/s]\n"
          ]
        }
      ],
      "source": [
        "!pip install --upgrade --no-cache-dir gdown\n",
        "!gdown --id 1-Vm4Y4YTPSH_zM3xSTzB9RQvJqiVFwaw"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install segmentation-models\n",
        "!pip install tensorflow"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FOXDJQizGcIk",
        "outputId": "b7e1810b-1de3-4282-f21d-b17b750627bd"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting segmentation-models\n",
            "  Downloading segmentation_models-1.0.1-py3-none-any.whl (33 kB)\n",
            "Collecting keras-applications<=1.0.8,>=1.0.7\n",
            "  Downloading Keras_Applications-1.0.8-py3-none-any.whl (50 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m50.7/50.7 KB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting efficientnet==1.0.0\n",
            "  Downloading efficientnet-1.0.0-py3-none-any.whl (17 kB)\n",
            "Collecting image-classifiers==1.0.0\n",
            "  Downloading image_classifiers-1.0.0-py3-none-any.whl (19 kB)\n",
            "Requirement already satisfied: scikit-image in /usr/local/lib/python3.8/dist-packages (from efficientnet==1.0.0->segmentation-models) (0.18.3)\n",
            "Requirement already satisfied: numpy>=1.9.1 in /usr/local/lib/python3.8/dist-packages (from keras-applications<=1.0.8,>=1.0.7->segmentation-models) (1.21.6)\n",
            "Requirement already satisfied: h5py in /usr/local/lib/python3.8/dist-packages (from keras-applications<=1.0.8,>=1.0.7->segmentation-models) (3.1.0)\n",
            "Requirement already satisfied: imageio>=2.3.0 in /usr/local/lib/python3.8/dist-packages (from scikit-image->efficientnet==1.0.0->segmentation-models) (2.9.0)\n",
            "Requirement already satisfied: scipy>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from scikit-image->efficientnet==1.0.0->segmentation-models) (1.7.3)\n",
            "Requirement already satisfied: PyWavelets>=1.1.1 in /usr/local/lib/python3.8/dist-packages (from scikit-image->efficientnet==1.0.0->segmentation-models) (1.4.1)\n",
            "Requirement already satisfied: pillow!=7.1.0,!=7.1.1,>=4.3.0 in /usr/local/lib/python3.8/dist-packages (from scikit-image->efficientnet==1.0.0->segmentation-models) (7.1.2)\n",
            "Requirement already satisfied: networkx>=2.0 in /usr/local/lib/python3.8/dist-packages (from scikit-image->efficientnet==1.0.0->segmentation-models) (3.0)\n",
            "Requirement already satisfied: tifffile>=2019.7.26 in /usr/local/lib/python3.8/dist-packages (from scikit-image->efficientnet==1.0.0->segmentation-models) (2022.10.10)\n",
            "Requirement already satisfied: matplotlib!=3.0.0,>=2.0.0 in /usr/local/lib/python3.8/dist-packages (from scikit-image->efficientnet==1.0.0->segmentation-models) (3.2.2)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image->efficientnet==1.0.0->segmentation-models) (0.11.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image->efficientnet==1.0.0->segmentation-models) (1.4.4)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image->efficientnet==1.0.0->segmentation-models) (3.0.9)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib!=3.0.0,>=2.0.0->scikit-image->efficientnet==1.0.0->segmentation-models) (2.8.2)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib!=3.0.0,>=2.0.0->scikit-image->efficientnet==1.0.0->segmentation-models) (1.15.0)\n",
            "Installing collected packages: keras-applications, image-classifiers, efficientnet, segmentation-models\n",
            "Successfully installed efficientnet-1.0.0 image-classifiers-1.0.0 keras-applications-1.0.8 segmentation-models-1.0.1\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: tensorflow in /usr/local/lib/python3.8/dist-packages (2.9.2)\n",
            "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (1.51.1)\n",
            "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (0.2.0)\n",
            "Requirement already satisfied: numpy>=1.20 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (1.21.6)\n",
            "Requirement already satisfied: h5py>=2.9.0 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (3.1.0)\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (3.3.0)\n",
            "Requirement already satisfied: flatbuffers<2,>=1.12 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (1.12)\n",
            "Requirement already satisfied: tensorflow-estimator<2.10.0,>=2.9.0rc0 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (2.9.0)\n",
            "Requirement already satisfied: keras-preprocessing>=1.1.1 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (1.1.2)\n",
            "Requirement already satisfied: protobuf<3.20,>=3.9.2 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (3.19.6)\n",
            "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (0.29.0)\n",
            "Requirement already satisfied: keras<2.10.0,>=2.9.0rc0 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (2.9.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.8/dist-packages (from tensorflow) (57.4.0)\n",
            "Requirement already satisfied: gast<=0.4.0,>=0.2.1 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (0.4.0)\n",
            "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (15.0.6.1)\n",
            "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (1.15.0)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (2.2.0)\n",
            "Requirement already satisfied: tensorboard<2.10,>=2.9 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (2.9.1)\n",
            "Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (1.14.1)\n",
            "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (1.6.3)\n",
            "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (4.4.0)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.8/dist-packages (from tensorflow) (21.3)\n",
            "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from tensorflow) (1.3.0)\n",
            "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.8/dist-packages (from astunparse>=1.6.0->tensorflow) (0.38.4)\n",
            "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.8/dist-packages (from tensorboard<2.10,>=2.9->tensorflow) (2.25.1)\n",
            "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.8/dist-packages (from tensorboard<2.10,>=2.9->tensorflow) (1.8.1)\n",
            "Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /usr/local/lib/python3.8/dist-packages (from tensorboard<2.10,>=2.9->tensorflow) (0.6.1)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.8/dist-packages (from tensorboard<2.10,>=2.9->tensorflow) (3.4.1)\n",
            "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.8/dist-packages (from tensorboard<2.10,>=2.9->tensorflow) (0.4.6)\n",
            "Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.8/dist-packages (from tensorboard<2.10,>=2.9->tensorflow) (2.16.0)\n",
            "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from tensorboard<2.10,>=2.9->tensorflow) (1.0.1)\n",
            "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.8/dist-packages (from packaging->tensorflow) (3.0.9)\n",
            "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /usr/local/lib/python3.8/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.10,>=2.9->tensorflow) (5.2.1)\n",
            "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.8/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.10,>=2.9->tensorflow) (4.9)\n",
            "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.8/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.10,>=2.9->tensorflow) (0.2.8)\n",
            "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.8/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard<2.10,>=2.9->tensorflow) (1.3.1)\n",
            "Requirement already satisfied: importlib-metadata>=4.4 in /usr/local/lib/python3.8/dist-packages (from markdown>=2.6.8->tensorboard<2.10,>=2.9->tensorflow) (6.0.0)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3,>=2.21.0->tensorboard<2.10,>=2.9->tensorflow) (2.10)\n",
            "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3,>=2.21.0->tensorboard<2.10,>=2.9->tensorflow) (1.24.3)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3,>=2.21.0->tensorboard<2.10,>=2.9->tensorflow) (2022.12.7)\n",
            "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3,>=2.21.0->tensorboard<2.10,>=2.9->tensorflow) (4.0.0)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.8/dist-packages (from importlib-metadata>=4.4->markdown>=2.6.8->tensorboard<2.10,>=2.9->tensorflow) (3.11.0)\n",
            "Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.8/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.10,>=2.9->tensorflow) (0.4.8)\n",
            "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.8/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard<2.10,>=2.9->tensorflow) (3.2.2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install patool\n",
        "import patoolib\n",
        "patoolib.extract_archive('Tumor.zip')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 192
        },
        "id": "QprkbV8JGefz",
        "outputId": "6e101ada-f109-4e37-c1f0-7c308b03b9e1"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting patool\n",
            "  Downloading patool-1.12-py2.py3-none-any.whl (77 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.5/77.5 KB\u001b[0m \u001b[31m6.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: patool\n",
            "Successfully installed patool-1.12\n",
            "patool: Extracting Tumor.zip ...\n",
            "patool: running /usr/bin/7z x -o./Unpack_ii5wmimp -- Tumor.zip\n",
            "patool: ... Tumor.zip extracted to `Tumor'.\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Tumor'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np \n",
        "import matplotlib.pyplot as plt\n",
        "import glob\n",
        "import cv2\n",
        "\n",
        "from keras.models import Model, Sequential\n",
        "from keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n",
        "from tensorflow.keras.layers import BatchNormalization\n",
        "import os\n",
        "import seaborn as sns\n",
        "from keras.applications.vgg16 import VGG16\n",
        "# from keras.applications.resnet import ResNet34\n",
        "from keras.applications.inception_v3 import InceptionV3"
      ],
      "metadata": {
        "id": "oTmuF_tkGgaA"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "SIZE = 128\n",
        "\n",
        "train_images = []\n",
        "train_labels = [] \n",
        "\n",
        "for directory_path in glob.glob(\"/content/Tumor/Training/*\"):\n",
        "    label = directory_path.split(\"/\")[-1]\n",
        "    print(label)\n",
        "    for img_path in glob.glob(os.path.join(directory_path, \"*.png\")):\n",
        "        #print(img_path)\n",
        "        img = cv2.imread(img_path, cv2.IMREAD_COLOR)       \n",
        "        img = cv2.resize(img, (SIZE, SIZE))\n",
        "        img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)\n",
        "        train_images.append(img)\n",
        "        train_labels.append(label)\n",
        "print(len(train_images))        \n",
        "train_images = np.array(train_images)\n",
        "train_labels = np.array(train_labels)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IgdkX-K_GkLM",
        "outputId": "09d3d730-997d-4f3e-9b49-0d8db28a1982"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "pituitary\n",
            "notumor\n",
            "meningioma\n",
            "glioma\n",
            "5712\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test_images = []\n",
        "test_labels = [] \n",
        "for directory_path in glob.glob(\"/content/Tumor/Testing/*\"):\n",
        "    fruit_label = directory_path.split(\"/\")[-1]\n",
        "    print(fruit_label)\n",
        "    for img_path in glob.glob(os.path.join(directory_path, \"*.png\")):\n",
        "        #print(img_path)\n",
        "        img = cv2.imread(img_path, cv2.IMREAD_COLOR)\n",
        "        img = cv2.resize(img, (SIZE, SIZE))\n",
        "        img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)\n",
        "        test_images.append(img)\n",
        "        test_labels.append(fruit_label)\n",
        "print(len(test_images))            \n",
        "test_images = np.array(test_images)\n",
        "test_labels = np.array(test_labels)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nibn1Xs4Gryt",
        "outputId": "79ba9fe1-c1d2-4db0-ded7-1977419f03d8"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "pituitary\n",
            "notumor\n",
            "meningioma\n",
            "glioma\n",
            "1311\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn import preprocessing\n",
        "le = preprocessing.LabelEncoder()\n",
        "le.fit(test_labels)\n",
        "test_labels_encoded = le.transform(test_labels)\n",
        "le.fit(train_labels)\n",
        "train_labels_encoded = le.transform(train_labels)\n"
      ],
      "metadata": {
        "id": "-kFRwLxYG9X-"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x_train, y_train, x_test, y_test = train_images, train_labels_encoded, test_images, test_labels_encoded"
      ],
      "metadata": {
        "id": "HfMQcJsEHpXD"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x_train, x_test = x_train / 255.0, x_test / 255.0"
      ],
      "metadata": {
        "id": "atKvDUKSHrUg"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.utils import to_categorical\n",
        "y_train_one_hot = to_categorical(y_train)\n",
        "y_test_one_hot = to_categorical(y_test)"
      ],
      "metadata": {
        "id": "ycrNSpKfIb1-"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "VGG_model = VGG16(weights='imagenet', include_top=False, input_shape=(SIZE, SIZE, 3))\n",
        "for layer in VGG_model.layers:\n",
        "\tlayer.trainable = False\n",
        "VGG_model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y0WkmeS1IwZy",
        "outputId": "c1dbf430-275d-4a23-ead4-a1131238ccfd"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
            "58889256/58889256 [==============================] - 2s 0us/step\n",
            "Model: \"vgg16\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_1 (InputLayer)        [(None, 128, 128, 3)]     0         \n",
            "                                                                 \n",
            " block1_conv1 (Conv2D)       (None, 128, 128, 64)      1792      \n",
            "                                                                 \n",
            " block1_conv2 (Conv2D)       (None, 128, 128, 64)      36928     \n",
            "                                                                 \n",
            " block1_pool (MaxPooling2D)  (None, 64, 64, 64)        0         \n",
            "                                                                 \n",
            " block2_conv1 (Conv2D)       (None, 64, 64, 128)       73856     \n",
            "                                                                 \n",
            " block2_conv2 (Conv2D)       (None, 64, 64, 128)       147584    \n",
            "                                                                 \n",
            " block2_pool (MaxPooling2D)  (None, 32, 32, 128)       0         \n",
            "                                                                 \n",
            " block3_conv1 (Conv2D)       (None, 32, 32, 256)       295168    \n",
            "                                                                 \n",
            " block3_conv2 (Conv2D)       (None, 32, 32, 256)       590080    \n",
            "                                                                 \n",
            " block3_conv3 (Conv2D)       (None, 32, 32, 256)       590080    \n",
            "                                                                 \n",
            " block3_pool (MaxPooling2D)  (None, 16, 16, 256)       0         \n",
            "                                                                 \n",
            " block4_conv1 (Conv2D)       (None, 16, 16, 512)       1180160   \n",
            "                                                                 \n",
            " block4_conv2 (Conv2D)       (None, 16, 16, 512)       2359808   \n",
            "                                                                 \n",
            " block4_conv3 (Conv2D)       (None, 16, 16, 512)       2359808   \n",
            "                                                                 \n",
            " block4_pool (MaxPooling2D)  (None, 8, 8, 512)         0         \n",
            "                                                                 \n",
            " block5_conv1 (Conv2D)       (None, 8, 8, 512)         2359808   \n",
            "                                                                 \n",
            " block5_conv2 (Conv2D)       (None, 8, 8, 512)         2359808   \n",
            "                                                                 \n",
            " block5_conv3 (Conv2D)       (None, 8, 8, 512)         2359808   \n",
            "                                                                 \n",
            " block5_pool (MaxPooling2D)  (None, 4, 4, 512)         0         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 14,714,688\n",
            "Trainable params: 0\n",
            "Non-trainable params: 14,714,688\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "feature_extractor=VGG_model.predict(x_train)\n",
        "features = feature_extractor.reshape(feature_extractor.shape[0], -1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h8c1QRh-I38q",
        "outputId": "0e9d7eb7-5174-4d8a-e1bf-aeaf1324ce94"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "179/179 [==============================] - 17s 50ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X_for_RF = features #This is our X input to RF\n",
        "\n",
        "#RANDOM FOREST\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "RF_model = RandomForestClassifier(n_estimators = 50, random_state = 42)"
      ],
      "metadata": {
        "id": "tZGAEIjWI6M1"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "RF_model.fit(X_for_RF, y_train)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "01jXNRc_JUYZ",
        "outputId": "6106a3b9-f48d-4ac2-d39a-b6853d83d1b5"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RandomForestClassifier(n_estimators=50, random_state=42)"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X_test_feature = VGG_model.predict(x_test)\n",
        "X_test_features = X_test_feature.reshape(X_test_feature.shape[0], -1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CSnIcYLNJg-c",
        "outputId": "f19ea073-3036-4a54-acda-c358b0c6135f"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "41/41 [==============================] - 3s 80ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Now predict using the trained RF model. \n",
        "prediction_RF = RF_model.predict(X_test_features)\n",
        "#Inverse le transform to get original label back. \n",
        "prediction_RF = le.inverse_transform(prediction_RF)"
      ],
      "metadata": {
        "id": "KZuBFx8OJk1w"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn import metrics\n",
        "print (\"Accuracy = \", metrics.accuracy_score(test_labels, prediction_RF))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iNwS8U40JmwI",
        "outputId": "5c16affe-adf4-4cc9-be7b-1eaf271a0266"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy =  0.9298245614035088\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "import matplotlib.pyplot as plt   \n",
        "from sklearn import metrics\n",
        "import pandas as pd\n",
        "from sklearn.metrics import classification_report\n",
        "ax= plt.subplot()\n",
        "cm = confusion_matrix(test_labels,  prediction_RF)\n",
        "#print(cm)\n",
        "\n",
        "sns.heatmap(cm, annot=True,cmap=\"Blues\",fmt='g')\n",
        "ax.set_xlabel('Predicted labels');ax.set_ylabel('True labels'); \n",
        "ax.set_title('Confusion Matrix'); \n",
        "ax.xaxis.set_ticklabels([\"Pituitary\", \"Glioma\", \"Notumor\",\"Meningioma\"]); \n",
        "ax.yaxis.set_ticklabels([\"Pituitary\", \"Glioma\", \"Notumor\",\"Meningioma\"]);\n",
        "d = {'Expected': test_labels, 'Predicted':  prediction_RF}\n",
        "results = pd.DataFrame(data=d)\n",
        "print(classification_report(results['Expected'], results['Predicted']))\n",
        "     "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 486
        },
        "id": "N7A_zViUJpog",
        "outputId": "7769f2ce-510d-405c-e209-37f3ba9f4eed"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "      glioma       0.94      0.82      0.88       300\n",
            "  meningioma       0.85      0.89      0.87       306\n",
            "     notumor       0.99      1.00      1.00       405\n",
            "   pituitary       0.92      0.99      0.95       300\n",
            "\n",
            "    accuracy                           0.93      1311\n",
            "   macro avg       0.93      0.92      0.92      1311\n",
            "weighted avg       0.93      0.93      0.93      1311\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n=np.random.randint(0, x_test.shape[0])\n",
        "img = x_test[n]\n",
        "plt.imshow(img)\n",
        "input_img = np.expand_dims(img, axis=0) #Expand dims so the input is (num images, x, y, c)\n",
        "input_img_feature=VGG_model.predict(input_img)\n",
        "input_img_features=input_img_feature.reshape(input_img_feature.shape[0], -1)\n",
        "prediction_RF = RF_model.predict(input_img_features)[0] \n",
        "prediction_RF = le.inverse_transform([prediction_RF])  #Reverse the label encoder to original name\n",
        "print(\"The prediction for this image is: \", prediction_RF)\n",
        "print(\"The actual label for this image is: \", test_labels[n])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 320
        },
        "id": "R1tRjr57J5-9",
        "outputId": "9cad607f-e924-4922-a8e6-05a3b1a4c806"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 1s 562ms/step\n",
            "The prediction for this image is:  ['notumor']\n",
            "The actual label for this image is:  notumor\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "R7Q2btgeYkk0"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}