SHL_featureAnalysis.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "SHL_featureAnalysis.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyODr8bW53A20wcU/QdCHUQZ",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/farhanfuadabir/SHL2020/blob/master/SHL_featureAnalysis.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xr9VAwk4wN2I",
        "outputId": "5805f272-fab7-45eb-b87a-fbfbeb5afbeb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 122
        }
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&response_type=code&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly\n",
            "\n",
            "Enter your authorization code:\n",
            "··········\n",
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ntj5FtxieTi1"
      },
      "source": [
        "def createBatch(data, batch_size = 1000, random_state=None):\n",
        "\n",
        "  \"\"\"\n",
        "  Randomly selects `batch_size` entries of each label from the dataset \n",
        "\n",
        "  Parameters:\n",
        "\n",
        "      data          : The dataset to create small batch from. \n",
        "                      This must be a DataFrame.\n",
        "      batch_size    : Batch size of each label\n",
        "      random_state  : Seed for the random number generator (if int), or numpy \n",
        "                      RandomState object.\n",
        "  \n",
        "  Returns:\n",
        "\n",
        "      Series or DataFrame\n",
        "  \"\"\"\n",
        "\n",
        "  y = data.label\n",
        "  num_label = y.nunique()\n",
        "  newDataBatch = pd.DataFrame(columns=data.columns)\n",
        "  \n",
        "  for i in range(1, num_label + 1):\n",
        "    data_i = data.loc[y == i, :].sample(n=batch_size, random_state=random_state)\n",
        "    newDataBatch = pd.concat([newDataBatch, data_i], axis=0)\n",
        "  return newDataBatch\n",
        "\n",
        "def random_split_half(data, random_state=123):\n",
        "\n",
        "  import pandas as pd\n",
        "\n",
        "  y = data.label\n",
        "  num_label = y.nunique()\n",
        "  newDataBatch1 = pd.DataFrame(columns=data.columns)\n",
        "  \n",
        "  for i in range(1, num_label + 1):\n",
        "    data_i = data.loc[y == i, :].sample(frac=0.5, random_state=random_state)\n",
        "    newDataBatch1 = pd.concat([newDataBatch1, data_i], axis=0)\n",
        "  newDataBatch2 = pd.concat([data, newDataBatch1], axis=0)\n",
        "  newDataBatch2 = newDataBatch2.drop_duplicates(keep=False)\n",
        "  return newDataBatch1, newDataBatch2\n",
        "\n",
        "def feature_scaling(X):\n",
        "\n",
        "  from sklearn.preprocessing import MinMaxScaler\n",
        "  \n",
        "  scaler = MinMaxScaler(feature_range=(-1,1))\n",
        "  X = scaler.fit_transform(X)\n",
        "  \n",
        "  return X"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F5eoxZAjvvwD",
        "outputId": "5f97c0e8-acae-45d7-a337-c8afa6fb1d4d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        }
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "\n",
        "path = '/content/drive/My Drive/SHL_2020_DATASET_PICKLED/'\n",
        "trainPrefix = 'train_2020'\n",
        "cvPrefix = 'validation_2020'\n",
        "position = '_hand'\n",
        "\n",
        "#Unpickle Train Set\n",
        "print('Unpickling from: ' + trainPrefix + position + '_DATA.pickle ...',end=' ')\n",
        "data_train = pd.read_pickle(path + trainPrefix + position + '_DATA.pickle')\n",
        "print('Done | Shape: ', data_train.shape)\n",
        "\n",
        "#Unpickle Validation Set\n",
        "print('Unpickling from: ' + cvPrefix + position + '_DATA.pickle ...',end=' ')\n",
        "data_cv = pd.read_pickle(path + cvPrefix + position + '_DATA.pickle')\n",
        "print('Done | Shape: ', data_cv.shape)\n",
        "\n",
        "# Check for nan\n",
        "if data_train.isna().any().any() == True:\n",
        "  print('\\nnan Detected in Train set')\n",
        "  # Drop nan rows\n",
        "  print('Dropping nan rows...',end=' ')\n",
        "  data_train.dropna(inplace=True)\n",
        "  print('Done | Shape: ', data_train.shape)\n",
        "\n",
        "if data_cv.isna().any().any() == True:\n",
        "  print('\\nnan Detected in Validation set')\n",
        "  # Drop nan rows\n",
        "  print('Dropping nan rows...',end=' ')\n",
        "  data_cv.dropna(inplace=True)\n",
        "  print('Done | Shape: ', data_cv.shape)\n",
        "\n",
        "# Extract X and y from train set\n",
        "X = data_train.drop('label', axis=1)\n",
        "y = data_train.label\n",
        "\n",
        "print('\\nX Shape: ', X.shape, ' |  y Shape: ', y.shape)\n",
        "\n",
        "# Extract X and y from validation set\n",
        "X_cv = data_cv.drop('label', axis=1)\n",
        "y_cv = data_cv.label\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Unpickling from: train_2020_hand_DATA.pickle ... Done | Shape:  (196072, 496)\n",
            "Unpickling from: validation_2020_hand_DATA.pickle ... Done | Shape:  (28789, 496)\n",
            "\n",
            "X Shape:  (196072, 495)  |  y Shape:  (196072,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xt1zalAexVuF",
        "outputId": "4e414921-dedd-470d-bca8-1ea495a4f445",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 493
        }
      },
      "source": [
        "# Check instances of each lable\n",
        "\n",
        "print('Instances of each Label of the Dataset: ')\n",
        "print(y.value_counts())\n",
        "\n",
        "print('\\nCreating mini batch...', end=' ')\n",
        "data_batch = createBatch(data_train, batch_size=8000, random_state=123)\n",
        "print('Done | Shape: ', data_batch.shape)\n",
        "\n",
        "# Merge Half of validation set\n",
        "train_2, cv_test = random_split_half(data_cv, random_state=123)\n",
        "data_batch = pd.concat([data_batch, train_2], axis = 0)\n",
        "print('Merged Train Set Shape: ', data_batch.shape)\n",
        "\n",
        "# Extract X_test and y_test\n",
        "X_test = cv_test.drop('label', axis=1)\n",
        "y_test = cv_test.label\n",
        "\n",
        "print('\\nX_test Shape: ', X_test.shape, ' |  y_test Shape: ', y_test.shape)\n",
        "\n",
        "# Extract X_new and y_new\n",
        "X_new = data_batch.drop('label', axis=1)\n",
        "y_new = data_batch.label\n",
        "\n",
        "print('\\nX Shape: ', X_new.shape, ' |  y Shape: ', y_new.shape)\n",
        "\n",
        "print('\\nInstances of each Label of the new Dataset: ')\n",
        "print(y_new.value_counts())\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Instances of each Label of the Dataset: \n",
            "5.0    31733\n",
            "7.0    31253\n",
            "6.0    28326\n",
            "2.0    24544\n",
            "1.0    24456\n",
            "8.0    23834\n",
            "4.0    23473\n",
            "3.0     8453\n",
            "Name: label, dtype: int64\n",
            "\n",
            "Creating mini batch... Done | Shape:  (64000, 496)\n",
            "Merged Train Set Shape:  (78396, 496)\n",
            "\n",
            "X_test Shape:  (14393, 495)  |  y_test Shape:  (14393,)\n",
            "\n",
            "X Shape:  (78396, 495)  |  y Shape:  (78396,)\n",
            "\n",
            "Instances of each Label of the new Dataset: \n",
            "1.0    10984\n",
            "2.0    10612\n",
            "7.0    10181\n",
            "8.0    10171\n",
            "5.0    10048\n",
            "4.0     9204\n",
            "6.0     8918\n",
            "3.0     8278\n",
            "Name: label, dtype: int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "saG8NMhIjIQL",
        "outputId": "48f9d80f-7535-4ef0-b9f9-34863ad9d3fa",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "X_new_B = X_new.loc[:, (X_new != X_new.iloc[0]).any()]\n",
        "#X_new_B = feature_scaling(X_new_B)\n",
        "print(X_new_B.shape)\n",
        "#print(X_new_B.max())\n",
        "#print(X_new_B.min())\n",
        "\n",
        "X_test_new = X_test.loc[:, (X_new != X_new.iloc[0]).any()]\n",
        "#X_cv_new = feature_scaling(X_cv_new)\n",
        "print(X_test_new.shape)\n",
        "#print(X_cv_new.max())\n",
        "#print(X_cv_new.min())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(78396, 452)\n",
            "(14393, 452)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fz7mK1xY6GjV",
        "outputId": "6fd366d2-a40c-4540-a814-ad0f263e2534",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        }
      },
      "source": [
        "from sklearn.ensemble import ExtraTreesClassifier\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "model = ExtraTreesClassifier()\n",
        "model.fit(X_new_B,y_new)\n",
        "\n",
        "#print(model.feature_importances_) #use inbuilt class feature_importances of tree based classifiers\n",
        "#plot graph of feature importances for better visualization\n",
        "feat_importances = pd.Series(model.feature_importances_, index=X_new_B.columns)\n",
        "feat_importances.nlargest(8).plot(kind='barh')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "orbhn99y4H9n",
        "outputId": "214c7265-6d7a-4441-b9c3-40ce3164cb9e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 967
        }
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.naive_bayes import GaussianNB\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.datasets import load_digits\n",
        "from sklearn.model_selection import learning_curve\n",
        "from sklearn.model_selection import ShuffleSplit\n",
        "\n",
        "\n",
        "def plot_learning_curve(estimator, title, X, y, axes=None, ylim=None, cv=None,\n",
        "                        n_jobs=None, train_sizes=np.linspace(.1, 1.0, 5)):\n",
        "    \"\"\"\n",
        "    Generate 3 plots: the test and training learning curve, the training\n",
        "    samples vs fit times curve, the fit times vs score curve.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    estimator : object type that implements the \"fit\" and \"predict\" methods\n",
        "        An object of that type which is cloned for each validation.\n",
        "\n",
        "    title : string\n",
        "        Title for the chart.\n",
        "\n",
        "    X : array-like, shape (n_samples, n_features)\n",
        "        Training vector, where n_samples is the number of samples and\n",
        "        n_features is the number of features.\n",
        "\n",
        "    y : array-like, shape (n_samples) or (n_samples, n_features), optional\n",
        "        Target relative to X for classification or regression;\n",
        "        None for unsupervised learning.\n",
        "\n",
        "    axes : array of 3 axes, optional (default=None)\n",
        "        Axes to use for plotting the curves.\n",
        "\n",
        "    ylim : tuple, shape (ymin, ymax), optional\n",
        "        Defines minimum and maximum yvalues plotted.\n",
        "\n",
        "    cv : int, cross-validation generator or an iterable, optional\n",
        "        Determines the cross-validation splitting strategy.\n",
        "        Possible inputs for cv are:\n",
        "\n",
        "          - None, to use the default 5-fold cross-validation,\n",
        "          - integer, to specify the number of folds.\n",
        "          - :term:`CV splitter`,\n",
        "          - An iterable yielding (train, test) splits as arrays of indices.\n",
        "\n",
        "        For integer/None inputs, if ``y`` is binary or multiclass,\n",
        "        :class:`StratifiedKFold` used. If the estimator is not a classifier\n",
        "        or if ``y`` is neither binary nor multiclass, :class:`KFold` is used.\n",
        "\n",
        "        Refer :ref:`User Guide <cross_validation>` for the various\n",
        "        cross-validators that can be used here.\n",
        "\n",
        "    n_jobs : int or None, optional (default=None)\n",
        "        Number of jobs to run in parallel.\n",
        "        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.\n",
        "        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`\n",
        "        for more details.\n",
        "\n",
        "    train_sizes : array-like, shape (n_ticks,), dtype float or int\n",
        "        Relative or absolute numbers of training examples that will be used to\n",
        "        generate the learning curve. If the dtype is float, it is regarded as a\n",
        "        fraction of the maximum size of the training set (that is determined\n",
        "        by the selected validation method), i.e. it has to be within (0, 1].\n",
        "        Otherwise it is interpreted as absolute sizes of the training sets.\n",
        "        Note that for classification the number of samples usually have to\n",
        "        be big enough to contain at least one sample from each class.\n",
        "        (default: np.linspace(0.1, 1.0, 5))\n",
        "    \"\"\"\n",
        "    if axes is None:\n",
        "        _, axes = plt.subplots(1, 3, figsize=(20, 5))\n",
        "\n",
        "    axes[0].set_title(title)\n",
        "    if ylim is not None:\n",
        "        axes[0].set_ylim(*ylim)\n",
        "    axes[0].set_xlabel(\"Training examples\")\n",
        "    axes[0].set_ylabel(\"Score\")\n",
        "\n",
        "    train_sizes, train_scores, test_scores, fit_times, _ = \\\n",
        "        learning_curve(estimator, X, y, cv=cv, n_jobs=n_jobs,\n",
        "                       train_sizes=train_sizes,\n",
        "                       return_times=True)\n",
        "    train_scores_mean = np.mean(train_scores, axis=1)\n",
        "    train_scores_std = np.std(train_scores, axis=1)\n",
        "    test_scores_mean = np.mean(test_scores, axis=1)\n",
        "    test_scores_std = np.std(test_scores, axis=1)\n",
        "    fit_times_mean = np.mean(fit_times, axis=1)\n",
        "    fit_times_std = np.std(fit_times, axis=1)\n",
        "\n",
        "    # Plot learning curve\n",
        "    axes[0].grid()\n",
        "    axes[0].fill_between(train_sizes, train_scores_mean - train_scores_std,\n",
        "                         train_scores_mean + train_scores_std, alpha=0.1,\n",
        "                         color=\"r\")\n",
        "    axes[0].fill_between(train_sizes, test_scores_mean - test_scores_std,\n",
        "                         test_scores_mean + test_scores_std, alpha=0.1,\n",
        "                         color=\"g\")\n",
        "    axes[0].plot(train_sizes, train_scores_mean, 'o-', color=\"r\",\n",
        "                 label=\"Training score\")\n",
        "    axes[0].plot(train_sizes, test_scores_mean, 'o-', color=\"g\",\n",
        "                 label=\"Cross-validation score\")\n",
        "    axes[0].legend(loc=\"best\")\n",
        "\n",
        "    '''\n",
        "    # Plot n_samples vs fit_times\n",
        "    axes[1].grid()\n",
        "    axes[1].plot(train_sizes, fit_times_mean, 'o-')\n",
        "    axes[1].fill_between(train_sizes, fit_times_mean - fit_times_std,\n",
        "                         fit_times_mean + fit_times_std, alpha=0.1)\n",
        "    axes[1].set_xlabel(\"Training examples\")\n",
        "    axes[1].set_ylabel(\"fit_times\")\n",
        "    axes[1].set_title(\"Scalability of the model\")\n",
        "\n",
        "    # Plot fit_time vs score\n",
        "    axes[2].grid()\n",
        "    axes[2].plot(fit_times_mean, test_scores_mean, 'o-')\n",
        "    axes[2].fill_between(fit_times_mean, test_scores_mean - test_scores_std,\n",
        "                         test_scores_mean + test_scores_std, alpha=0.1)\n",
        "    axes[2].set_xlabel(\"fit_times\")\n",
        "    axes[2].set_ylabel(\"Score\")\n",
        "    axes[2].set_title(\"Performance of the model\")\n",
        "    '''\n",
        "    return plt\n",
        "\n",
        "\n",
        "fig, axes = plt.subplots(3, 2, figsize=(10, 15))\n",
        "#fig, axes = plt.subplots(1, 2, figsize=(10, 15))\n",
        "\n",
        "###############################################################################\n",
        "title = \"Random Forest\"\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "estimator = RandomForestClassifier()\n",
        "\n",
        "cv = ShuffleSplit(n_splits=3, test_size=0.2, random_state=123)\n",
        "\n",
        "plot_learning_curve(estimator, title, X_new_B, y_new, axes=axes[:, 0], ylim=(0.1, 1.01),\n",
        "                    cv=cv, n_jobs=-1)\n",
        "\n",
        "###############################################################################\n",
        "title = \"Learning Curves (XGBoost)\"\n",
        "from xgboost import XGBClassifier\n",
        "estimator = XGBClassifier()\n",
        "\n",
        "cv = ShuffleSplit(n_splits=3, test_size=0.2, random_state=123)\n",
        "\n",
        "plot_learning_curve(estimator, title, X_new_B, y_new, axes=axes[:, 1], ylim=(0.1, 1.01),\n",
        "                    cv=cv, n_jobs=-1)\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/joblib/externals/loky/process_executor.py:691: UserWarning: A worker stopped while some jobs were given to the executor. This can be caused by a too short worker timeout or by a memory leak.\n",
            "  \"timeout or by a memory leak.\", UserWarning\n",
            "/usr/local/lib/python3.6/dist-packages/joblib/externals/loky/process_executor.py:691: UserWarning: A worker stopped while some jobs were given to the executor. This can be caused by a too short worker timeout or by a memory leak.\n",
            "  \"timeout or by a memory leak.\", UserWarning\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x1080 with 6 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "paUr52L87VCI",
        "outputId": "32eb226e-4c07-479d-db93-2800f434f38d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        }
      },
      "source": [
        "from xgboost import XGBClassifier\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.model_selection import cross_val_score\n",
        "\n",
        "clf = XGBClassifier()\n",
        "scores = cross_val_score(clf, X_new_B, y_new , cv=4,scoring='accuracy')\n",
        "print(\"XGBoost Accuracy: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))\n",
        "print(scores)\n",
        "\n",
        "clf2 = RandomForestClassifier()\n",
        "scores = cross_val_score(clf2, X_new_B, y_new, cv=4,scoring='accuracy')\n",
        "print(\"Random Forest Accuracy: %0.2f (+/- %0.2f)\" % (scores.mean(), scores.std() * 2))\n",
        "print(scores)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "XGBoost Accuracy: 0.82 (+/- 0.04)\n",
            "[0.78918279 0.79957889 0.84326885 0.82892486]\n",
            "Random Forest Accuracy: 0.82 (+/- 0.05)\n",
            "[0.79247269 0.80221082 0.85840242 0.84261087]\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}