TFIDF_2000.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.5"
    },
    "colab": {
      "name": "tfidf_4grams_2000words.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "dlfJ31TAux6A",
        "colab_type": "code",
        "colab": {},
        "outputId": "ff2f641e-0b8c-49c4-ad67-a80dacbb94de"
      },
      "source": [
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import re\n",
        "import time\n",
        "import warnings\n",
        "import numpy as np\n",
        "from nltk.corpus import stopwords\n",
        "from sklearn.decomposition import TruncatedSVD\n",
        "from sklearn.preprocessing import normalize\n",
        "from sklearn.feature_extraction.text import CountVectorizer\n",
        "from sklearn.manifold import TSNE\n",
        "import seaborn as sns\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.metrics import confusion_matrix\n",
        "from sklearn.metrics.classification import accuracy_score, log_loss\n",
        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
        "from sklearn.linear_model import SGDClassifier\n",
        "from imblearn.over_sampling import SMOTE\n",
        "from collections import Counter\n",
        "from scipy.sparse import hstack\n",
        "from sklearn.multiclass import OneVsRestClassifier\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.cross_validation import StratifiedKFold \n",
        "from collections import Counter, defaultdict\n",
        "from sklearn.calibration import CalibratedClassifierCV\n",
        "from sklearn.naive_bayes import MultinomialNB\n",
        "from sklearn.naive_bayes import GaussianNB\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "import math\n",
        "from sklearn.metrics import normalized_mutual_info_score\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "from mlxtend.classifier import StackingClassifier\n",
        "from tqdm import tqdm\n",
        "\n",
        "from sklearn import model_selection\n",
        "from sklearn.linear_model import LogisticRegression\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "C:\\Users\\TULASI RAM\\Anaconda3\\lib\\site-packages\\sklearn\\cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.\n",
            "  \"This module will be removed in 0.20.\", DeprecationWarning)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cF6gGXDuux6I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#after merging and preprocessed data\n",
        "result = pd.read_csv('final_data',index_col=0)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PCJZ4IOWux6M",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "y_true = result['Class'].values\n",
        "result.Gene      = result.Gene.str.replace('\\s+', '_')\n",
        "result.Variation = result.Variation.str.replace('\\s+', '_')\n",
        "\n",
        "# split the data into test and train by maintaining same distribution of output varaible 'y_true' [stratify=y_true]\n",
        "X_train, test_df, y_train, y_test = train_test_split(result, y_true, stratify=y_true, test_size=0.2)\n",
        "# split the train data into train and cross validation by maintaining same distribution of output varaible 'y_train' [stratify=y_train]\n",
        "train_df, cv_df, y_train, y_cv = train_test_split(X_train, y_train, stratify=y_train, test_size=0.2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f7vyJGaEux6T",
        "colab_type": "code",
        "colab": {},
        "outputId": "fbc893b8-1334-4649-c9f9-b99806eb80a5"
      },
      "source": [
        "text_vectorizer = TfidfVectorizer(ngram_range=(1,4),max_features=2000)\n",
        "train_text_feature_onehotCoding = text_vectorizer.fit_transform(train_df['TEXT'])\n",
        "# getting all the feature names (words)\n",
        "train_text_features= text_vectorizer.get_feature_names()\n",
        "\n",
        "# train_text_feature_onehotCoding.sum(axis=0).A1 will sum every row and returns (1*number of features) vector\n",
        "train_text_fea_counts = train_text_feature_onehotCoding.sum(axis=0).A1\n",
        "\n",
        "# zip(list(text_features),text_fea_counts) will zip a word with its number of times it occured\n",
        "text_fea_dict = dict(zip(list(train_text_features),train_text_fea_counts))\n",
        "\n",
        "\n",
        "print(\"Total number of unique words in train data :\", len(train_text_features))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Total number of unique words in train data : 2000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ntdPEsx5ux6Y",
        "colab_type": "code",
        "colab": {},
        "outputId": "d00219ec-3180-42fa-f132-0865c2a846db"
      },
      "source": [
        "# normalizing every feature\n",
        "train_text_feature_onehotCoding = normalize(train_text_feature_onehotCoding, axis=0)\n",
        "\n",
        "\n",
        "\n",
        "# we use the same vectorizer that was trained on train data\n",
        "test_text_feature_onehotCoding = text_vectorizer.transform(test_df['TEXT'])\n",
        "\n",
        "test_text_features= text_vectorizer.get_feature_names()\n",
        "\n",
        "# train_text_feature_onehotCoding.sum(axis=0).A1 will sum every row and returns (1*number of features) vector\n",
        "test_text_fea_counts = test_text_feature_onehotCoding.sum(axis=0).A1\n",
        "\n",
        "# zip(list(text_features),text_fea_counts) will zip a word with its number of times it occured\n",
        "text_fea_dict = dict(zip(list(test_text_features),test_text_fea_counts))\n",
        "\n",
        "\n",
        "print(\"Total number of unique words in test data :\", len(test_text_features))\n",
        "# don't forget to normalize every feature\n",
        "test_text_feature_onehotCoding = normalize(test_text_feature_onehotCoding, axis=0)\n",
        "\n",
        "# we use the same vectorizer that was trained on train data\n",
        "cv_text_feature_onehotCoding = text_vectorizer.transform(cv_df['TEXT'])\n",
        "#normalizing every feature\n",
        "cv_text_feature_onehotCoding = normalize(cv_text_feature_onehotCoding, axis=0)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Total number of unique words in train data : 2000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HTvBL0Qpux6c",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "### one-hot encoding of Gene feature.\n",
        "gene_vectorizer = TfidfVectorizer(ngram_range=(1,2))\n",
        "train_gene_feature_onehotCoding = gene_vectorizer.fit_transform(train_df['Gene'])\n",
        "test_gene_feature_onehotCoding = gene_vectorizer.transform(test_df['Gene'])\n",
        "cv_gene_feature_onehotCoding = gene_vectorizer.transform(cv_df['Gene'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xHowaDhlux6i",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# one-hot encoding of variation feature.\n",
        "variation_vectorizer = TfidfVectorizer(ngram_range=(1,2))\n",
        "train_variation_feature_onehotCoding = variation_vectorizer.fit_transform(train_df['Variation'])\n",
        "test_variation_feature_onehotCoding = variation_vectorizer.transform(test_df['Variation'])\n",
        "cv_variation_feature_onehotCoding = variation_vectorizer.transform(cv_df['Variation'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p9l-h_zkux6p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# normalizing every feature\n",
        "train_text_feature_onehotCoding = normalize(train_text_feature_onehotCoding, axis=0)\n",
        "\n",
        "# we use the same vectorizer that was trained on train data\n",
        "test_text_feature_onehotCoding = text_vectorizer.transform(test_df['TEXT'])\n",
        "# don't forget to normalize every feature\n",
        "test_text_feature_onehotCoding = normalize(test_text_feature_onehotCoding, axis=0)\n",
        "\n",
        "# we use the same vectorizer that was trained on train data\n",
        "cv_text_feature_onehotCoding = text_vectorizer.transform(cv_df['TEXT'])\n",
        "#normalizing every feature\n",
        "cv_text_feature_onehotCoding = normalize(cv_text_feature_onehotCoding, axis=0)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_NQBV8R7ux6t",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# merging gene, variance and text features\n",
        "train_gene_var_onehotCoding = hstack((train_gene_feature_onehotCoding,train_variation_feature_onehotCoding))\n",
        "test_gene_var_onehotCoding = hstack((test_gene_feature_onehotCoding,test_variation_feature_onehotCoding))\n",
        "cv_gene_var_onehotCoding = hstack((cv_gene_feature_onehotCoding,cv_variation_feature_onehotCoding))\n",
        "\n",
        "train_x_onehotCoding = hstack((train_gene_var_onehotCoding, train_text_feature_onehotCoding)).tocsr()\n",
        "train_y = np.array(list(train_df['Class']))\n",
        "\n",
        "test_x_onehotCoding = hstack((test_gene_var_onehotCoding, test_text_feature_onehotCoding)).tocsr()\n",
        "test_y = np.array(list(test_df['Class']))\n",
        "\n",
        "cv_x_onehotCoding = hstack((cv_gene_var_onehotCoding, cv_text_feature_onehotCoding)).tocsr()\n",
        "cv_y = np.array(list(cv_df['Class']))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X-NPQH1Pux6y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def predict_and_plot_confusion_matrix(train_x, train_y,test_x, test_y, clf):\n",
        "    clf.fit(train_x, train_y)\n",
        "    sig_clf = CalibratedClassifierCV(clf, method=\"sigmoid\")\n",
        "    sig_clf.fit(train_x, train_y)\n",
        "    pred_y = sig_clf.predict(test_x)\n",
        "\n",
        "    # for calculating log_loss we willl provide the array of probabilities belongs to each class\n",
        "    print(\"Log loss :\",log_loss(test_y, sig_clf.predict_proba(test_x)))\n",
        "    # calculating the number of data points that are misclassified\n",
        "    print(\"Number of mis-classified points :\", np.count_nonzero((pred_y- test_y))/test_y.shape[0])\n",
        "    plot_confusion_matrix(test_y, pred_y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZJjS_7Hqux62",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def report_log_loss(train_x, train_y, test_x, test_y,  clf):\n",
        "    clf.fit(train_x, train_y)\n",
        "    sig_clf = CalibratedClassifierCV(clf, method=\"sigmoid\")\n",
        "    sig_clf.fit(train_x, train_y)\n",
        "    sig_clf_probs = sig_clf.predict_proba(test_x)\n",
        "    return log_loss(test_y, sig_clf_probs, eps=1e-15)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NuDUdu39ux66",
        "colab_type": "code",
        "colab": {},
        "outputId": "03efa762-eb4c-4a99-93da-6805ceb6a2ae"
      },
      "source": [
        "#hyperparameter tuning\n",
        "alpha = [10 ** x for x in range(-6, 3)]\n",
        "cv_log_error_array = []\n",
        "for i in alpha:\n",
        "    print(\"for alpha =\", i)\n",
        "    clf = SGDClassifier(class_weight='balanced', alpha=i, penalty='l2', loss='log', random_state=42)\n",
        "    clf.fit(train_x_onehotCoding, train_y)\n",
        "    sig_clf = CalibratedClassifierCV(clf, method=\"sigmoid\")\n",
        "    sig_clf.fit(train_x_onehotCoding, train_y)\n",
        "    sig_clf_probs = sig_clf.predict_proba(cv_x_onehotCoding)\n",
        "    cv_log_error_array.append(log_loss(cv_y, sig_clf_probs, labels=clf.classes_, eps=1e-15))\n",
        "    # to avoid rounding error while multiplying probabilites we use log-probability estimates\n",
        "    print(\"Log Loss :\",log_loss(cv_y, sig_clf_probs)) \n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "ax.plot(alpha, cv_log_error_array,c='g')\n",
        "for i, txt in enumerate(np.round(cv_log_error_array,3)):\n",
        "    ax.annotate((alpha[i],str(txt)), (alpha[i],cv_log_error_array[i]))\n",
        "plt.grid()\n",
        "plt.title(\"Cross Validation Error for each alpha\")\n",
        "plt.xlabel(\"Alpha i's\")\n",
        "plt.ylabel(\"Error measure\")\n",
        "plt.show()\n",
        "\n",
        "\n",
        "best_alpha = np.argmin(cv_log_error_array)\n",
        "clf = SGDClassifier(class_weight='balanced', alpha=alpha[best_alpha], penalty='l2', loss='log', random_state=42)\n",
        "clf.fit(train_x_onehotCoding, train_y)\n",
        "sig_clf = CalibratedClassifierCV(clf, method=\"sigmoid\")\n",
        "sig_clf.fit(train_x_onehotCoding, train_y)\n",
        "\n",
        "predict_y = sig_clf.predict_proba(train_x_onehotCoding)\n",
        "print('For values of best alpha = ', alpha[best_alpha], \"The train log loss is:\",log_loss(y_train, predict_y, labels=clf.classes_, eps=1e-15))\n",
        "predict_y = sig_clf.predict_proba(cv_x_onehotCoding)\n",
        "print('For values of best alpha = ', alpha[best_alpha], \"The cross validation log loss is:\",log_loss(y_cv, predict_y, labels=clf.classes_, eps=1e-15))\n",
        "predict_y = sig_clf.predict_proba(test_x_onehotCoding)\n",
        "print('For values of best alpha = ', alpha[best_alpha], \"The test log loss is:\",log_loss(y_test, predict_y, labels=clf.classes_, eps=1e-15))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "for alpha = 1e-06\n",
            "Log Loss : 1.0335229172905518\n",
            "for alpha = 1e-05\n",
            "Log Loss : 1.0018634256599313\n",
            "for alpha = 0.0001\n",
            "Log Loss : 0.9573729736179031\n",
            "for alpha = 0.001\n",
            "Log Loss : 0.9873080998395\n",
            "for alpha = 0.01\n",
            "Log Loss : 1.1471183925794122\n",
            "for alpha = 0.1\n",
            "Log Loss : 1.6472011717647108\n",
            "for alpha = 1\n",
            "Log Loss : 1.7788455276901565\n",
            "for alpha = 10\n",
            "Log Loss : 1.7926202272744378\n",
            "for alpha = 100\n",
            "Log Loss : 1.7941943532596092\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "For values of best alpha =  0.0001 The train log loss is: 0.4391548785173384\n",
            "For values of best alpha =  0.0001 The cross validation log loss is: 0.9573729736179031\n",
            "For values of best alpha =  0.0001 The test log loss is: 0.9829755627590934\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}