Model_latest.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Model_latest.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GpY-ArzB1rH-",
        "colab_type": "text"
      },
      "source": [
        "# **Disease Detection using Symptoms and Treatment recommendation**\n",
        "\n",
        "This notebook contains all the models applied on the scraped dataset and contains the accuracy comparison plot.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lEsjGGNblruf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# all necessary imports\n",
        "import warnings\n",
        "from decimal import Decimal\n",
        "import pandas as pd\n",
        "from sklearn.tree import DecisionTreeClassifier\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.metrics import accuracy_score\n",
        "from sklearn.model_selection import train_test_split, cross_val_score\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.naive_bayes import MultinomialNB\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.neural_network import MLPClassifier\n",
        "from xgboost import XGBClassifier\n",
        "import matplotlib.pyplot as plt\n",
        "# ignore warnings generated due to usage of old version of tensorflow\n",
        "warnings.simplefilter(\"ignore\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t1sbUx8C22zG",
        "colab_type": "text"
      },
      "source": [
        "**Disease Symptom dataset** was created in a separate python program.\n",
        "\n",
        "**Dataset scrapping** was done using **NHP website** and **wikipedia data**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xTIhMk1Ilz7O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Load Dataset scraped from NHP (https://www.nhp.gov.in/disease-a-z) & Wikipedia\n",
        "# Scrapping and creation of dataset csv is done in a separate program\n",
        "df_comb = pd.read_csv(\"/content/drive/My Drive/Python Project data/IR_Project/dis_sym_dataset_comb.csv\")\n",
        "\n",
        "# creation of features and label for training the models\n",
        "X = df_comb.iloc[:, 1:]\n",
        "Y = df_comb.iloc[:, 0:1]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wB98cbQc3kX1",
        "colab_type": "text"
      },
      "source": [
        "*Train Test Split*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "43edxNr-l37s",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# splitting data for training the classifiers and testing\n",
        "x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.10)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NFWxSoKRl6iU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# lists used for accuracy plots\n",
        "accuracy_list = []\n",
        "cross_accuracy_list = []\n",
        "model_list = []"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "50u3FJaH3r0k",
        "colab_type": "text"
      },
      "source": [
        "# **Multinomial Naive Bayes Classifier**\n",
        "\n",
        "MNB works better on discrete features and the multinomial distribution usually requires integer counts. However, it also works with fractional counts such tf-idf."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OUrShCRcl8Gs",
        "colab_type": "code",
        "outputId": "fa8d8306-89bf-4c5d-e23f-58a60d0bf647",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "# Multinomial NB Classifier\n",
        "mnb = MultinomialNB()\n",
        "mnb = mnb.fit(X, Y)\n",
        "# prediction of labels for the test data\n",
        "mnb_pred = mnb.predict(x_test)\n",
        "# calculation of accuracy score based on predictions performed\n",
        "# converting to Decimal as rounding with float is inaccurate\n",
        "acc_mnb = round(Decimal(accuracy_score(y_test, mnb_pred) * 100), 2)\n",
        "accuracy_list.append(acc_mnb)\n",
        "model_list.append(\"MNB\")\n",
        "print(f\"Accuracy (MNB) : {acc_mnb}%\")\n",
        "\n",
        "# Cross Validation Accuracy MNB\n",
        "# performing cross validation with 5 different splits\n",
        "scores_mnb = cross_val_score(mnb, X, Y, cv=5)\n",
        "# mean of cross val score (accuracy)\n",
        "score = round(Decimal(scores_mnb.mean() * 100), 2)\n",
        "cross_accuracy_list.append(score)\n",
        "print(f\"Cross Validation Accuracy (MNB): {score}%\")"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy (MNB) : 83.94%\n",
            "Cross Validation Accuracy (MNB): 84.50%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gEJWlm2u3yRc",
        "colab_type": "text"
      },
      "source": [
        "# **Random Forest Classifier**\n",
        "\n",
        "RF classifier is an estimator that fits a number of decision tree classifiers on various sub-samples of the dataset and take the average to improve predicting accuracy."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "owiCcnlvmAP9",
        "colab_type": "code",
        "outputId": "0e011b23-5965-4fa7-ee6d-416ebc2070ed",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "# RF Classifier\n",
        "rf = RandomForestClassifier(n_estimators=10, criterion='entropy')\n",
        "rf = rf.fit(X, Y)\n",
        "# prediction of labels for the test data\n",
        "rf_pred = rf.predict(x_test)\n",
        "acc_rf = round(Decimal(accuracy_score(y_test, rf_pred) * 100), 2)\n",
        "accuracy_list.append(acc_rf)\n",
        "model_list.append(\"RF\")\n",
        "print(f\"Accuracy (RF) : {acc_rf}%\")\n",
        "\n",
        "# Cross Validation Accuracy RF\n",
        "# performing cross validation with 5 different splits\n",
        "scores_rf = cross_val_score(rf, X, Y, cv=5)\n",
        "# mean of cross val score (accuracy)\n",
        "score = round(Decimal(scores_rf.mean() * 100), 2)\n",
        "cross_accuracy_list.append(score)\n",
        "print(f\"Cross Validation Accuracy (RF): {score}%\")"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy (RF) : 90.05%\n",
            "Cross Validation Accuracy (RF): 87.13%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xxdvB5Bz9yEx",
        "colab_type": "text"
      },
      "source": [
        "# **K-Nearest Neighbor Classifier**\n",
        "\n",
        "The principle behind nearest neighbor method is to find a predefined number of training samples closest in distance to the new point, and predict the label from these. No. of samples used here is 7."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OfIMLCfPmCqr",
        "colab_type": "code",
        "outputId": "2040dc76-c519-433e-e558-504b38f9d227",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "# KNN Classifier\n",
        "knn = KNeighborsClassifier(n_neighbors=7, weights='distance', n_jobs=4)\n",
        "knn = knn.fit(X, Y)\n",
        "# prediction of labels for the test data\n",
        "knn_pred = knn.predict(x_test)\n",
        "acc_knn = round(Decimal(accuracy_score(y_test, knn_pred) * 100), 2)\n",
        "accuracy_list.append(acc_knn)\n",
        "model_list.append(\"KNN\")\n",
        "print(f\"Accuracy (KNN) : {acc_knn}%\")\n",
        "\n",
        "# Cross Validation Accuracy KNN\n",
        "# performing cross validation with 5 different splits\n",
        "scores_knn = cross_val_score(knn, X, Y, cv=5)\n",
        "# mean of cross val score (accuracy)\n",
        "score = round(Decimal(scores_knn.mean() * 100), 2)\n",
        "cross_accuracy_list.append(score)\n",
        "print(f\"Cross Validation Accuracy (KNN): {score}%\")"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy (KNN) : 91.29%\n",
            "Cross Validation Accuracy (KNN): 87.03%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x4j2f2dH94dU",
        "colab_type": "text"
      },
      "source": [
        "# **Logistic Regression Classifier**\n",
        "\n",
        "Logistic Regression uses OvR (One Vs Rest) approach when classification is multi class."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-ZBVt3BlmE7c",
        "colab_type": "code",
        "outputId": "173b9591-29c3-4ad4-9139-1bcf2102b9e6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "# LR Classifier\n",
        "lr = LogisticRegression()\n",
        "lr = lr.fit(X, Y)\n",
        "# prediction of labels for the test data\n",
        "lr_pred = lr.predict(x_test)\n",
        "acc_lr = round(Decimal(accuracy_score(y_test, lr_pred) * 100), 2)\n",
        "accuracy_list.append(acc_lr)\n",
        "model_list.append(\"LR\")\n",
        "print(f\"Accuracy (LR) : {acc_lr}%\")\n",
        "\n",
        "# Cross Validation Accuracy LR\n",
        "# performing cross validation with 5 different splits\n",
        "scores_lr = cross_val_score(lr, X, Y, cv=5)\n",
        "# mean of cross val score (accuracy)\n",
        "score = round(Decimal(scores_lr.mean() * 100), 2)\n",
        "cross_accuracy_list.append(score)\n",
        "print(f\"Cross Validation Accuracy (LR): {score}%\")"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy (LR) : 90.72%\n",
            "Cross Validation Accuracy (LR): 89.19%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zbz-aL_Q9_U0",
        "colab_type": "text"
      },
      "source": [
        "# **Support Vector Machine Classifier**\n",
        "\n",
        "SVM follows OvO (One Vs One) scheme when dealing with multi class classification. SVM classifier works by drawing a straight line between two classes. All the data points that fall on one side of the line will be labeled as one class and all the points that fall on the other side will be labeled as the second. This seems simple for binary class but the complexity is increased when we have multiple classes. In our classification problem we have 261 classes (equal to diseases)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JDSJc0RlmG-0",
        "colab_type": "code",
        "outputId": "ee7dc68c-51a3-4630-ed30-9a421fb43ba4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "# SVM Classifier\n",
        "svm = SVC()\n",
        "svm = svm.fit(X, Y)\n",
        "# prediction of labels for the test data\n",
        "svm_pred = svm.predict(x_test)\n",
        "acc_svm = round(Decimal(accuracy_score(y_test, svm_pred) * 100), 2)\n",
        "accuracy_list.append(acc_svm)\n",
        "model_list.append(\"SVM\")\n",
        "print(f\"Accuracy (SVM) : {acc_svm}%\")\n",
        "\n",
        "# Cross Validation Accuracy SVM\n",
        "# performing cross validation with 5 different splits\n",
        "scores_svm = cross_val_score(svm, X, Y, cv=5)\n",
        "# mean of cross val score (accuracy)\n",
        "score = round(Decimal(scores_svm.mean() * 100), 2)\n",
        "cross_accuracy_list.append(score)\n",
        "print(f\"Cross Validation Accuracy (SVM): {score}%\")"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy (SVM) : 90.05%\n",
            "Cross Validation Accuracy (SVM): 88.62%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uUYxizhO-FtC",
        "colab_type": "text"
      },
      "source": [
        "# **Decision Tree Classifier**\n",
        "\n",
        "DT is one of the easiest and popular classification algorithms to understand and interpret. It can be utilized for both classification and regression. DT follows a tree like structure to reach to a decision whether the given sample under consideration belong to which class."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CwFDYYBQmKAc",
        "colab_type": "code",
        "outputId": "fca7c327-b54d-4ffb-9eb8-4711372773cb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "# DT Classifier\n",
        "dt = DecisionTreeClassifier()\n",
        "dt = dt.fit(X, Y)\n",
        "# prediction of labels for the test data\n",
        "dt_pred = dt.predict(x_test)\n",
        "acc_dt = round(Decimal(accuracy_score(y_test, dt_pred) * 100), 2)\n",
        "accuracy_list.append(acc_dt)\n",
        "model_list.append(\"DT\")\n",
        "print(f\"Accuracy (DT) : {acc_dt}%\")\n",
        "\n",
        "# Cross Validation Accuracy DT\n",
        "# performing cross validation with 5 different splits\n",
        "scores_dt = cross_val_score(dt, X, Y, cv=5)\n",
        "# mean of cross val score (accuracy)\n",
        "score = round(Decimal(scores_dt.mean() * 100), 2)\n",
        "cross_accuracy_list.append(score)\n",
        "print(f\"Cross Validation Accuracy (DT): {score}%\")"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy (DT) : 91.29%\n",
            "Cross Validation Accuracy (DT): 83.60%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2zI71-uw-JMq",
        "colab_type": "text"
      },
      "source": [
        "# **Multilayer Perceptron Classifier**\n",
        "\n",
        "MLP is a feed forward ANN (Artificial Neural Network) which is extensively used for classification purpose."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nwVwjevImMQU",
        "colab_type": "code",
        "outputId": "18989cdc-3840-47c7-92dd-f5775446042a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "# MLP Classifier\n",
        "mlp = MLPClassifier(hidden_layer_sizes=(32, 32, 32), activation='relu', solver='adam', max_iter=50)\n",
        "mlp = mlp.fit(X, Y)\n",
        "# prediction of labels for the test data\n",
        "mlp_pred = mlp.predict(x_test)\n",
        "acc_mlp = round(Decimal(accuracy_score(y_test, mlp_pred) * 100), 2)\n",
        "accuracy_list.append(acc_mlp)\n",
        "model_list.append(\"MLP\")\n",
        "print(f\"Accuracy (MLP) : {acc_mlp}%\")\n",
        "\n",
        "# Cross Validation Accuracy MLP\n",
        "# performing cross validation with 5 different splits\n",
        "scores_mlp = cross_val_score(mlp, X, Y, cv=5)\n",
        "# mean of cross val score (accuracy)\n",
        "score = round(Decimal(scores_mlp.mean() * 100), 2)\n",
        "cross_accuracy_list.append(score)\n",
        "print(f\"Cross Validation Accuracy (MLP): {score}%\")"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy (MLP) : 90.72%\n",
            "Cross Validation Accuracy (MLP): 86.77%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x0deyBf7-QSD",
        "colab_type": "text"
      },
      "source": [
        "# **Accuracy Comparison Plot for all the classifiers**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c_4WiPo4mR2M",
        "colab_type": "code",
        "outputId": "e233f609-b457-47cc-cdaa-9905da4a9355",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 647
        }
      },
      "source": [
        "# comparison plot for all classifiers with their accuracy\n",
        "plt.style.use('seaborn-poster')\n",
        "fig = plt.figure(figsize=(10, 10))\n",
        "ax = fig.add_subplot()\n",
        "plt.title(\"Model Vs Accuracy\")\n",
        "plt.xlabel('Classifier')\n",
        "plt.ylabel('Accuracy (%)')\n",
        "plt.bar(model_list, accuracy_list, color='green')\n",
        "for i, j in enumerate(accuracy_list):\n",
        "    ax.text(float(i)-0.15, float(j)+0.7, str(j), color='blue')\n",
        "plt.show()"
      ],
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ja6vRv2M-l_s",
        "colab_type": "text"
      },
      "source": [
        "# **Cross Validation Accuracy Comparison Plot for all the classifiers**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8WmaR3XBzT0e",
        "colab_type": "code",
        "outputId": "77a1a225-6af3-4088-8414-c29ae6a621da",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 647
        }
      },
      "source": [
        "# comparison plot for all classifiers with their accuracy\n",
        "plt.style.use('seaborn-poster')\n",
        "fig = plt.figure(figsize=(10, 10))\n",
        "ax = fig.add_subplot()\n",
        "plt.title(\"Model Vs Cross Validation Accuracy\")\n",
        "plt.xlabel('Classifier')\n",
        "plt.ylabel('Accuracy (%)')\n",
        "plt.bar(model_list, cross_accuracy_list, color='green')\n",
        "for i, j in enumerate(cross_accuracy_list):\n",
        "    ax.text(float(i)-0.15, float(j)+0.7, str(j), color='blue')\n",
        "plt.show()"
      ],
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}