Monkeypox_08_15_22.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gREwMDOK8Fb1"
      },
      "source": [
        "Importing Necessary Library"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZVGhiCYe775f"
      },
      "outputs": [],
      "source": [
        "\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "#from keras.applications import resnet\n",
        "from tensorflow.keras.applications import VGG16, ResNet50, ResNet101, InceptionResNetV2\n",
        "from tensorflow.keras.layers import AveragePooling2D\n",
        "from tensorflow.keras.layers import Dropout\n",
        "from tensorflow.keras.layers import Flatten\n",
        "from tensorflow.keras.layers import Dense\n",
        "from tensorflow.keras.layers import Input\n",
        "from tensorflow.keras.models import Model\n",
        "from tensorflow.keras.optimizers import Adam, SGD\n",
        "from tensorflow.keras.utils import to_categorical\n",
        "from sklearn.preprocessing import LabelBinarizer\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import classification_report\n",
        "from sklearn.metrics import confusion_matrix\n",
        "from imutils import paths\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import argparse\n",
        "import cv2\n",
        "import os"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Weu7J-y8TFs"
      },
      "source": [
        "Loading the Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6kfsoIj68Pwv",
        "outputId": "3f6a07b7-94ad-4847-9e26-d1905ffbefbc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[INFO] loading images...\n"
          ]
        }
      ],
      "source": [
        "print(\"[INFO] loading images...\")\n",
        "imagePaths =list(paths.list_images(\"/content/drive/MyDrive/monkeypox/gray\"))# give the dataset path\n",
        "data = []\n",
        "labels = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iDrsbhUxDL0o"
      },
      "outputs": [],
      "source": [
        "for imagePath in imagePaths:\n",
        "\t# extract the class label from the filename\n",
        "\tlabel = imagePath.split(os.path.sep)[-2]\n",
        "\t# load the image, swap color channels, and resize it to be a fixed\n",
        "\t# 224x224 pixels while ignoring aspect ratio\n",
        "\timage = cv2.imread(imagePath)\n",
        "\timage = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
        "\timage = cv2.resize(image, (224, 224))\n",
        "\t# update the data and labels lists, respectively\n",
        "\tdata.append(image)\n",
        "\tlabels.append(label)\n",
        "# convert the data and labels to NumPy arrays while scaling the pixel\n",
        "# intensities to the range [0, 1]\n",
        "data = np.array(data) / 255.0\n",
        "labels = np.array(labels)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GHPzBrp98XCc"
      },
      "source": [
        "Image preprocessing and extract the Label"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1Q1DQ7WG8V2n"
      },
      "outputs": [],
      "source": [
        "lb = LabelBinarizer()\n",
        "labels = lb.fit_transform(labels)\n",
        "labels = to_categorical(labels)\n",
        "# from sklearn.preprocessing import LabelEncoder\n",
        "# le = LabelEncoder()\n",
        "# labels = le.fit_transform(labels)\n",
        "# partition the data into training and testing splits using 80% of\n",
        "# the data for training and the remaining 20% for testing\n",
        "(trainX, testX, trainY, testY) = train_test_split(data, labels,\n",
        "\ttest_size=0.20, random_state=42,stratify=labels)\n",
        "# initialize the training data augmentation object\n",
        "trainAug = ImageDataGenerator(\n",
        "\trotation_range=15,\n",
        "\tfill_mode=\"nearest\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rq0HlzUx8kbZ"
      },
      "outputs": [],
      "source": [
        "#baseModel =VGG16(weights=\"imagenet\", include_top=False, input_tensor=Input(shape=(224, 224, 3)))\n",
        "#baseModel =ResNet50(weights=\"imagenet\", include_top=False, input_tensor=Input(shape=(224, 224, 3)))\n",
        "baseModel =ResNet101(weights=\"imagenet\", include_top=False, input_tensor=Input(shape=(224, 224, 3)))\n",
        "#baseModel =InceptionResNetV2(weights=\"imagenet\", include_top=False, input_tensor=Input(shape=(224, 224, 3)))\n",
        "headModel = baseModel.output\n",
        "headModel = AveragePooling2D(pool_size=(4, 4))(headModel)\n",
        "headModel = Flatten(name=\"flatten\")(headModel)\n",
        "headModel = Dense(64, activation=\"relu\")(headModel)\n",
        "headModel = Dropout(0.5)(headModel)\n",
        "headModel = Dense(2, activation=\"softmax\")(headModel)\n",
        "model = Model(inputs=baseModel.input, outputs=headModel)\n",
        "for layer in baseModel.layers:\n",
        "\tlayer.trainable = False\n",
        "\t# compile our model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Z6sNKjxn8q4x"
      },
      "outputs": [],
      "source": [
        "#model.summary()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gCjeCi5QDfGE"
      },
      "outputs": [],
      "source": [
        "INIT_LR = 1e-3\n",
        "EPOCHS = 100\n",
        "BS = 30"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HL-_1WR08sjr"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "#opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)\n",
        "#opt = tf.keras.optimizers.SGD(learning_rate=INIT_LR)\n",
        "opt = tf.keras.optimizers.RMSprop(learning_rate=INIT_LR)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bRldY_9V8uL5",
        "outputId": "127031b3-da86-4cd0-b444-e44c39f7a44f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[INFO] compiling model...\n",
            "[INFO] training head...\n",
            "Epoch 1/100\n",
            "46/46 [==============================] - 23s 378ms/step - loss: 0.6582 - accuracy: 0.6613 - val_loss: 0.6365 - val_accuracy: 0.6667\n",
            "Epoch 2/100\n",
            "46/46 [==============================] - 15s 329ms/step - loss: 0.6489 - accuracy: 0.6664 - val_loss: 0.6356 - val_accuracy: 0.6667\n",
            "Epoch 3/100\n",
            "46/46 [==============================] - 15s 325ms/step - loss: 0.6488 - accuracy: 0.6664 - val_loss: 0.6435 - val_accuracy: 0.6667\n",
            "Epoch 4/100\n",
            "46/46 [==============================] - 15s 326ms/step - loss: 0.6435 - accuracy: 0.6657 - val_loss: 0.6410 - val_accuracy: 0.6667\n",
            "Epoch 5/100\n",
            "46/46 [==============================] - 16s 342ms/step - loss: 0.6482 - accuracy: 0.6642 - val_loss: 0.6332 - val_accuracy: 0.6667\n",
            "Epoch 6/100\n",
            "46/46 [==============================] - 15s 326ms/step - loss: 0.6489 - accuracy: 0.6628 - val_loss: 0.6505 - val_accuracy: 0.6667\n",
            "Epoch 7/100\n",
            "46/46 [==============================] - 15s 325ms/step - loss: 0.6491 - accuracy: 0.6621 - val_loss: 0.6382 - val_accuracy: 0.6667\n",
            "Epoch 8/100\n",
            "46/46 [==============================] - 15s 326ms/step - loss: 0.6455 - accuracy: 0.6664 - val_loss: 0.6357 - val_accuracy: 0.6667\n",
            "Epoch 9/100\n",
            "46/46 [==============================] - 15s 330ms/step - loss: 0.6463 - accuracy: 0.6657 - val_loss: 0.6318 - val_accuracy: 0.6667\n",
            "process time: 158.82207249200002\n",
            "9\n"
          ]
        }
      ],
      "source": [
        "# compile our model\n",
        "print(\"[INFO] compiling model...\")\n",
        "#opt = Adam(learning_rate=INIT_LR, decay=INIT_LR / EPOCHS)\n",
        "model.compile(loss=\"binary_crossentropy\", optimizer=opt,\n",
        "\tmetrics=[\"accuracy\"])\n",
        "#model.compile(loss=\"hinge\", optimizer=opt,\n",
        "\t#metrics=[\"accuracy\"])\n",
        "# train the head of the network\n",
        "print(\"[INFO] training head...\")\n",
        "callback = tf.keras.callbacks.EarlyStopping(monitor='loss', patience=5)\n",
        "import time\n",
        "t1=time.process_time()\n",
        "H = model.fit(\n",
        "\ttrainAug.flow(trainX, trainY, batch_size=BS),\n",
        "\tsteps_per_epoch=len(trainX) // BS,\n",
        "\tvalidation_data=(testX, testY),\n",
        "\tvalidation_steps=len(testX) // BS,\n",
        "\tepochs=EPOCHS,callbacks=[callback])\n",
        "t2 =time.process_time()\n",
        "print(\"process time:\", t2-t1)  \n",
        "#model.save(\"vgg16.h5\")\n",
        "print(len(H.history['loss']))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tIPRvS1ohE9E",
        "outputId": "c52ae5e3-016b-492a-b523-1513fdb00fa5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9\n"
          ]
        }
      ],
      "source": [
        "print(len(H.history['loss']))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "loSuh1pj80Bh"
      },
      "outputs": [],
      "source": [
        "model.save_weights(\"my_model_weights.h5\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5531Zaap82a4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8c3373a8-52e3-4b3b-e0ee-5aa343de8d6f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "                         precision    recall  f1-score   support\n",
            "\n",
            "Monkeypox_total_augment       0.00      0.00      0.00       470\n",
            "                  Other       0.67      1.00      0.80       933\n",
            "\n",
            "               accuracy                           0.67      1403\n",
            "              macro avg       0.33      0.50      0.40      1403\n",
            "           weighted avg       0.44      0.67      0.53      1403\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n",
            "/usr/local/lib/python3.7/dist-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n",
            "/usr/local/lib/python3.7/dist-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n"
          ]
        }
      ],
      "source": [
        "#classification report on training\n",
        "predIdxs = model.predict(trainX)\n",
        "# for each image in the testing set we need to find the index of the\n",
        "# label with corresponding largest predicted probability\n",
        "trainpredict = np.argmax(predIdxs, axis=1)\n",
        "print(classification_report(trainY.argmax(axis=1), trainpredict,\n",
        "\ttarget_names=lb.classes_))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZkPBjnsp9AXv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "62b95ce9-542f-4499-aae0-761c07b2ea73"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[  0 470]\n",
            " [  0 933]]\n",
            "acc: 0.6650\n",
            "sensitivity: 0.0000\n",
            "specificity: 1.0000\n"
          ]
        }
      ],
      "source": [
        "# compute the confusion matrix and and use it to derive the raw\n",
        "# accuracy, sensitivity, and specificity\n",
        "cm = confusion_matrix(trainY.argmax(axis=1), trainpredict)\n",
        "total = sum(sum(cm))\n",
        "print(cm)\n",
        "acc = (cm[0, 0] + cm[1, 1]) / total\n",
        "sensitivity = cm[0, 0] / (cm[0, 0] + cm[0, 1])\n",
        "specificity = cm[1, 1] / (cm[1, 0] + cm[1, 1])\n",
        "# show the confusion matrix, accuracy, sensitivity, and specificity\n",
        "print(\"acc: {:.4f}\".format(acc))\n",
        "print(\"sensitivity: {:.4f}\".format(sensitivity))\n",
        "print(\"specificity: {:.4f}\".format(specificity))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mAhVyaba9C5G",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "854531c2-bf71-423d-c52e-87632d84fee5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[INFO] evaluating network...\n",
            "                         precision    recall  f1-score   support\n",
            "\n",
            "Monkeypox_total_augment       0.00      0.00      0.00       117\n",
            "                  Other       0.67      1.00      0.80       234\n",
            "\n",
            "               accuracy                           0.67       351\n",
            "              macro avg       0.33      0.50      0.40       351\n",
            "           weighted avg       0.44      0.67      0.53       351\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n",
            "/usr/local/lib/python3.7/dist-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n",
            "/usr/local/lib/python3.7/dist-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n"
          ]
        }
      ],
      "source": [
        "# make predictions on the testing set\n",
        "print(\"[INFO] evaluating network...\")\n",
        "predIdys = model.predict(testX, batch_size=BS)\n",
        "testpredict = np.argmax(predIdys, axis=1)\n",
        "print(classification_report(testY.argmax(axis=1), testpredict,\n",
        "\ttarget_names=lb.classes_))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uIw0a_S99JzO",
        "outputId": "91f6e39b-90fe-4a02-9ba8-3dae9d93782e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[  0 117]\n",
            " [  0 234]]\n",
            "acc: 0.6667\n",
            "sensitivity: 0.0000\n",
            "specificity: 1.0000\n"
          ]
        }
      ],
      "source": [
        "# compute the confusion matrix and and use it to derive the raw\n",
        "# accuracy, sensitivity, and specificity\n",
        "cm = confusion_matrix(testY.argmax(axis=1), testpredict)\n",
        "total = sum(sum(cm))\n",
        "print(cm)\n",
        "acc = (cm[0, 0] + cm[1, 1]) / total\n",
        "sensitivity = cm[0, 0] / (cm[0, 0] + cm[0, 1])\n",
        "specificity = cm[1, 1] / (cm[1, 0] + cm[1, 1])\n",
        "# show the confusion matrix, accuracy, sensitivity, and specificity\n",
        "print(\"acc: {:.4f}\".format(acc))\n",
        "print(\"sensitivity: {:.4f}\".format(sensitivity))\n",
        "print(\"specificity: {:.4f}\".format(specificity))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dETu2tjq9MRD",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 232
        },
        "outputId": "c41fa3ee-66a7-489f-f08f-42ebfb90d729"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 288x216 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "from sklearn import metrics\n",
        "from sklearn.metrics import roc_auc_score, auc\n",
        "from sklearn.metrics import roc_curve\n",
        "fig = plt.figure(figsize = (4, 3))\n",
        "fpr1,tpr1,_=roc_curve(np.argmax(trainY, axis=1),np.argmax(predIdxs, axis=1))\n",
        "fpr2,tpr2,_=roc_curve(np.argmax(testY, axis=1),np.argmax(predIdys, axis=1))\n",
        "area_under_curve1=auc(fpr1,tpr1)\n",
        "random_probs=[0 for i in range(len(trainY.ravel()))]\n",
        "p_fpr1,p_tpr1,threshold=roc_curve(trainY.ravel(),random_probs, pos_label=1)\n",
        "plt.plot(fpr1,tpr1, label='Train AUC = {:.3f}'.format(area_under_curve1))\n",
        "plt.plot(p_fpr1, p_tpr1)\n",
        "area_under_curve2=auc(fpr2,tpr2)\n",
        "random_probs2=[0 for i in range(len(testY.ravel()))]\n",
        "p_fpr2,p_tpr2,threshold=roc_curve(testY.ravel(),random_probs2, pos_label=1)\n",
        "plt.plot(fpr2,tpr2, label='Test AUC = {:.3f}'.format(area_under_curve2))\n",
        "plt.plot(p_fpr2, p_tpr2)\n",
        "\n",
        "    # x label\n",
        "plt.xlabel('FPR',fontsize=14, fontdict=dict(weight='bold'))\n",
        "    # y label\n",
        "plt.ylabel('TPR', fontsize=14, fontdict=dict(weight='bold'))\n",
        "plt.xticks( rotation=0, weight = 'bold', )\n",
        "plt.yticks( rotation=0, weight = 'bold')\n",
        "plt.tick_params(rotation=0,axis='y', labelsize=12)\n",
        "plt.tick_params(rotation=0,axis='x', labelsize=12)\n",
        "plt.legend()\n",
        "plt.legend(prop={'size':12})\n",
        "plt.savefig('ROC',dpi=200, bbox_inches='tight')\n",
        "plt.show();"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ufb5qFGA9UzW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 288
        },
        "outputId": "1c5159d7-e778-4068-e22e-12c60e928bcd"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "#import seaborn as sns \n",
        "#plt.style.use('default') \n",
        "from matplotlib.ticker import FormatStrFormatter\n",
        "\n",
        "#fig, ax = plt.subplots()\n",
        "#fig = plt.figure(figsize = (4, 3))\n",
        "#ax.yaxis.set_major_formatter(FormatStrFormatter('%.2f'))\n",
        "import matplotlib\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.ticker import FormatStrFormatter\n",
        "\n",
        "N=len(H.history['loss'])\n",
        "fig, ax = plt.subplots()\n",
        "#plt.rcParams[\"font.family\"] = \"serif\"\n",
        "acc = H.history['accuracy']\n",
        "val_acc = H.history['val_accuracy']\n",
        "#font={'size':10}\n",
        "#matplotlib.rc('font',**font)\n",
        "loss = H.history['loss']\n",
        "val_loss = H.history['val_loss']\n",
        "epochs = range(1, len(acc) + 1)\n",
        "plt.plot(np.arange(0, N), H.history[\"accuracy\"], label=\"TA\")\n",
        "#plt.plot(epochs, loss, label='Training loss')\n",
        "plt.plot(np.arange(0, N), H.history[\"val_accuracy\"], label=\"VA\")\n",
        "plt.plot(epochs, loss, label='TL')\n",
        "#plt.plot(np.arange(0, N), H.history[\"val_accuracy\"], label=\"validation accuracy\")\n",
        "plt.plot(np.arange(0, N), val_loss, label='VS')\n",
        "#plt.plot(epochs, acc, 'bo', label='Training acc')\n",
        "#plt.plot(1, val_acc, 'b', label='Validation acc')\n",
        "#plt.title('Training and validation accuracy')\n",
        "plt.xlabel('Epochs',fontsize=16, fontdict=dict(weight='bold'))\n",
        "    # y label\n",
        "plt.ylabel('Accuracy/Loss', fontsize=16, fontdict=dict(weight='bold'))\n",
        "#plt.ylabel(\"Accuracy\")\n",
        "#plt.xlabel(\"Epochs\")\n",
        "plt.xticks( rotation=0, weight = 'bold' )\n",
        "plt.yticks( rotation=0, weight = 'bold')\n",
        "plt.tick_params(rotation=0,axis='y', labelsize=14)\n",
        "plt.tick_params(rotation=0,axis='x', labelsize=14)\n",
        "#plt.grid('white')\n",
        "#plt.grid(axis='x', color='0.95')\n",
        "plt.legend(loc='best')\n",
        "plt.legend(prop={'size':12})\n",
        "#fig = plt.figure(figsize = (4, 3))\n",
        "plt.savefig('ACC',dpi=200, bbox_inches='tight')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "k_EPjiE99aMU"
      },
      "outputs": [],
      "source": [
        "# import numpy as np\n",
        "# import cv2\n",
        "# from google.colab.patches import cv2_imshow\n",
        "# from skimage import transform, io\n",
        "\n",
        "# import skimage\n",
        "# #xi = cv2.imread(\"/content/drive/MyDrive/monkeypox/gray/Monkeypox_gray/monkeypox00.jpg\")\n",
        "# #xi = cv2.imread(\"/content/2019-novel-Coronavirus-severe-adult-respiratory-dist_2020_International-Jour-p3-89%0.png\")\n",
        "\n",
        "# Xi = io.imread(\"/content/drive/MyDrive/monkeypox/gray/Monkeypox_gray/monkeypox02.jpg\")\n",
        "# #Xi = skimage.io.imread(\"/content/drive/MyDrive/monkeypox/augmentedgray/Normal_image_gray_augmented/normalgray_aug105.jpg\")\n",
        "\n",
        "# #xi=cv2.resize(xi,(299,299))\n",
        "# #cv2_imshow(xi/2+0.5)\n",
        "\n",
        "# Xi = transform.resize(Xi, (299,299)) \n",
        "\n",
        "# Xi = (Xi - 0.5)*2 #Inception pre-processing\n",
        "\n",
        "# skimage.io.imshow(Xi/2+0.5) # Show image before inception preprocessing\n",
        "# plt.xticks([])\n",
        "# plt.yticks([])\n",
        "# plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VcZQsuZ_9jpF"
      },
      "outputs": [],
      "source": [
        "# #Generate segmentation for image\n",
        "\n",
        "# import skimage.segmentation\n",
        "# Xi = skimage.transform.resize(Xi, (299,299,3)) \n",
        "# superpixels = skimage.segmentation.quickshift(Xi, kernel_size=4,max_dist=200, ratio=0.2)\n",
        "\n",
        "# num_superpixels = np.unique(superpixels).shape[0]\n",
        "\n",
        "# skimage.io.imshow(skimage.segmentation.mark_boundaries(Xi/2+0.5, superpixels))\n",
        "\n",
        "\n",
        "\n",
        "# #Generate perturbations\n",
        "\n",
        "# num_perturb = 150\n",
        "\n",
        "# perturbations = np.random.binomial(1, 0.5, size=(num_perturb, num_superpixels))\n",
        "\n",
        "\n",
        "\n",
        "# #Create function to apply perturbations to images\n",
        "\n",
        "# import copy\n",
        "\n",
        "# def perturb_image(img,perturbation,segments): \n",
        "\n",
        "#   active_pixels = np.where(perturbation == 1)[0]\n",
        "\n",
        "#   mask = np.zeros(segments.shape)\n",
        "\n",
        "#   for active in active_pixels:\n",
        "\n",
        "#       mask[segments == active] = 1 \n",
        "\n",
        "#   perturbed_image = copy.deepcopy(img)\n",
        "\n",
        "#   perturbed_image = perturbed_image*mask[:,:,np.newaxis]\n",
        "\n",
        "#   return perturbed_image\n",
        "\n",
        "\n",
        "\n",
        "# #Show example of perturbations\n",
        "\n",
        "# print(perturbations[0]) \n",
        "\n",
        "# skimage.io.imshow(perturb_image(Xi/2+0.5,perturbations[0],superpixels))\n",
        "# plt.xticks([])\n",
        "# plt.yticks([])\n",
        "# plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M_bLti1W9ncV"
      },
      "outputs": [],
      "source": [
        "# from skimage import io\n",
        "# from tensorflow.keras.preprocessing import image\n",
        "\n",
        "# #url = '/content/drive/MyDrive/monkeypox/gray/Monkeypox_gray/monkeypox02.jpg'\n",
        "# #url=\"/content/drive/MyDrive/monkeypox/mixed dataset/Other/measlesgray_aug254.jpg\"\n",
        "# #url=\"/content/drive/MyDrive/monkeypox/gray/Monkeypox_gray/monkeypox04.jpg\"\n",
        "# url=\"/content/drive/MyDrive/monkeypox/augmentedgray/Normal_image_gray_augmented/normalgray_aug105.jpg\"\n",
        "\n",
        "# def read_and_transform_img(url):\n",
        "\n",
        "#     img = skimage.io.imread(url)\n",
        "#     img = skimage.transform.resize(img, (224, 224,3))\n",
        "    \n",
        "#     img = image.img_to_array(img)\n",
        "#     img = np.expand_dims(img, axis=0)\n",
        "\n",
        "#     return img\n",
        "\n",
        "# images = read_and_transform_img(url)\n",
        "\n",
        "# preds = model.predict(images)\n",
        "# prediction = np.argmax(preds)\n",
        "# pct = np.max(preds)\n",
        "\n",
        "# if prediction == 0:\n",
        "#     print('It\\'s a Monkeypox!')\n",
        "# elif prediction == 1:\n",
        "#     print('It\\'s a others!')\n",
        "# else:\n",
        "#     print('Unable to predict!')\n",
        "\n",
        "# print(pct)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SxZBuq-r9p2R"
      },
      "outputs": [],
      "source": [
        "# pip install lime"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DEnISgB79rtL"
      },
      "outputs": [],
      "source": [
        "# from lime import lime_image\n",
        "\n",
        "# explainer = lime_image.LimeImageExplainer()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yKbia9Fw9tfN"
      },
      "outputs": [],
      "source": [
        "# explanation = explainer.explain_instance(images[0].astype('double'), model.predict,  \n",
        "#                                          top_labels=3, hide_color=0, num_samples=200)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TK1EcrAD9vkl"
      },
      "outputs": [],
      "source": [
        "# from skimage.segmentation import mark_boundaries\n",
        "\n",
        "# temp_1, mask_1 = explanation.get_image_and_mask(explanation.top_labels[0], positive_only=True, num_features=5, hide_rest=True)\n",
        "# temp_2, mask_2 = explanation.get_image_and_mask(explanation.top_labels[0], positive_only=False, num_features=10, hide_rest=False)\n",
        "\n",
        "# fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(5,5))\n",
        "# ax1.imshow(mark_boundaries(temp_1, mask_1))\n",
        "# ax2.imshow(mark_boundaries(temp_2, mask_2))\n",
        "# ax1.axis('off')\n",
        "# ax2.axis('off')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1pcVdeWt9xSj"
      },
      "outputs": [],
      "source": [
        "# import numpy as np\n",
        "# import cv2\n",
        "# import matplotlib.pyplot as plt\n",
        "# from scipy.ndimage import zoom\n",
        "# from tensorflow.keras.applications.resnet50 import preprocess_input, decode_predictions\n",
        "# img = cv2.imread('/content/drive/MyDrive/monkeypox/gray/Monkeypox_gray/monkeypox00.jpg')\n",
        "# img = cv2.resize(img, (224, 224))\n",
        "# img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
        "# X = np.expand_dims(img, axis=0).astype(np.float32)\n",
        "# X = preprocess_input(X)"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "Monkeypox_08_15_22.ipynb",
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}