Logistic_Regression_Stratified (1).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ihnOrOMu8Uv2"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy import linalg\n",
    "from sklearn import metrics\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "from sklearn import preprocessing \n",
    "from sklearn.feature_selection import chi2, SelectKBest\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix\n",
    "from matplotlib.pyplot import figure\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "czk2qIaHMKMW"
   },
   "outputs": [],
   "source": [
    "\n",
    "def data_cleaner(df):\n",
    "    data = df.copy()\n",
    "    #remove the id, partlybad columns\n",
    "    data.drop([\"id\",\"partlybad\"],1,inplace=True)\n",
    "    #set new index using the date column\n",
    "    data.set_index([\"date\"],inplace=True)\n",
    "    #add binary 'class2' col for event/non-event\n",
    "    data[\"class2\"] = np.where(data[\"class4\"] == \"nonevent\", \"nonevent\",\"event\")\n",
    "    #arrange to put class2 col at the front\n",
    "    cols = ['class2'] + [col for col in data if col != 'class2']\n",
    "    data = data[cols]\n",
    "    return data\n",
    "\n",
    "##### New way to generate the data\n",
    "def normalize_0to1(df):\n",
    "    # create a scaler object\n",
    "    scaler = preprocessing.MinMaxScaler()\n",
    "    # fit and transform the data\n",
    "    df_norm = pd.DataFrame(scaler.fit_transform(df), columns=df.columns)\n",
    "    # Return result\n",
    "    return df_norm\n",
    "\n",
    "def data_generator(df):\n",
    "    '''\n",
    "    input:\n",
    "        df: dataframe to split stratified by variable class\n",
    "        class: string with variable to use as response and as variable to stratify by\n",
    "    output:\n",
    "        X_train, y_train: variables and response 60% data \n",
    "        X_val, y_val: variables and response 20% data \n",
    "        X_trainval, y_trainval: variables and response 80% data (for cross validation)\n",
    "        X_test, y_test: variables and response 20% data \n",
    "    '''\n",
    "    \n",
    "    X = df.drop([\"class2\",\"class4\"], axis=1)\n",
    "    X = normalize_0to1(X) \n",
    "    y = df['class4']\n",
    "    \n",
    "    # 60%, 20%, 20%\n",
    "    # Generate TrainVal 80% and test 20% \n",
    "    X_trainval, X_test, y_trainval, y_test = train_test_split( X, y, test_size=0.20, random_state=42, stratify=y)\n",
    "    \n",
    "    # Furthermore split train into Train and Val\n",
    "    X_train, X_val, y_train, y_val= train_test_split( X_trainval, y_trainval, test_size=0.25, random_state=42, stratify=y_trainval)\n",
    "    \n",
    "    return X_train, X_val, X_trainval, X_test, y_train, y_val, y_trainval, y_test\n",
    "\n",
    "def convert_binary(y):\n",
    "    '''\n",
    "    Parameters\n",
    "    ----------\n",
    "    y : repsonse variable with 4 classes\n",
    "    Returns\n",
    "    -------\n",
    "    y : reponse variable 2 classes\n",
    "    '''\n",
    "    y_bin = np.where(y == \"nonevent\", \"nonevent\",\"event\")\n",
    "    return y_bin\n",
    "\n",
    "url = \"https://raw.githubusercontent.com/williwilliams3/TermProjectIML/master/data/train.csv\"\n",
    "df = pd.read_csv(url)\n",
    "df = data_cleaner(df)\n",
    "\n",
    "X_train, X_val, X_trainval, X_test, y_train, y_val, y_trainval, y_test = data_generator(df)\n",
    "\n",
    "# If needed conversion from 4 classes to binary classes\n",
    "y_train_bin = convert_binary(y_train)\n",
    "y_val_bin = convert_binary(y_val)\n",
    "y_trainval_bin = convert_binary(y_trainval)\n",
    "y_test_bin = convert_binary(y_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lbwZBf9e7sqW"
   },
   "outputs": [],
   "source": [
    "def select_n_best_feature(X, y, n):\n",
    "    # Normalize X values to be between 0 and 1\n",
    "    x = X.values\n",
    "    min_max_scaler = preprocessing.MinMaxScaler()\n",
    "    x_scaled = min_max_scaler.fit_transform(x)\n",
    "    X = pd.DataFrame(x_scaled)\n",
    "\n",
    "    # Use SelectKBest class to extract top n best features\n",
    "    bestfeatures = SelectKBest(score_func=chi2, k=n)\n",
    "    fit = bestfeatures.fit(X,y)\n",
    "    dfscores = pd.DataFrame(fit.scores_)\n",
    "    dfcolumns = pd.DataFrame(X.columns)\n",
    "\n",
    "    # Concat two dataframes for better visualization and print best features\n",
    "    featureScores = pd.concat([dfcolumns,dfscores],axis=1)\n",
    "    featureScores.columns = ['Feature_index','Score']\n",
    "    #print(featureScores.nlargest(n,'Score'))\n",
    "\n",
    "    # Filter X. Leave only top n features\n",
    "    #X = bestfeatures.fit_transform(X, y)\n",
    "    \n",
    "    # Return X\n",
    "    #return X\n",
    "    return bestfeatures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 336
    },
    "id": "CL3_NQH6OxuY",
    "outputId": "e3251dff-8632-4730-ab25-6641fd1d4fcb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on train set:  0.8636363636363636\n",
      "Accuracy on validation set:  0.8461538461538461\n",
      "Accuracy on test set:  0.8461538461538461\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#binary classifier with logistic regression\n",
    "logistic_regression= LogisticRegression()\n",
    "logistic_regression.fit(X_train,y_train_bin)\n",
    "y_pred_test = logistic_regression.predict(X_test)\n",
    "y_pred_train = logistic_regression.predict(X_train)\n",
    "y_pred_val = logistic_regression.predict(X_val)\n",
    "\n",
    "confusion_matrix = pd.crosstab(y_test_bin, y_pred_test, rownames=['Actual'], colnames=['Predicted'])\n",
    "sns.heatmap(confusion_matrix, annot=True)\n",
    "\n",
    "print('Accuracy on train set: ',metrics.accuracy_score(y_train_bin, y_pred_train))\n",
    "print('Accuracy on validation set: ',metrics.accuracy_score(y_val_bin, y_pred_val))\n",
    "print('Accuracy on test set: ',metrics.accuracy_score(y_test_bin, y_pred_test))\n",
    "\n",
    "bin_train_val = np.c_[X_trainval.index,logistic_regression.predict_proba(X_trainval)]\n",
    "bin_test = np.c_[X_test.index,logistic_regression.predict_proba(X_test)]\n",
    "\n",
    "\n",
    "from numpy import savetxt\n",
    "#savetxt('bin_trainval_logReg.csv', bin_train_val, delimiter=',')\n",
    "#savetxt('bin_test_logReg.csv', bin_test, delimiter=',')\n",
    "\n",
    "from google.colab import files\n",
    "#files.download(\"bin_trainval_logReg.csv\")\n",
    "#files.download(\"bin_test_logReg.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DVJVvm67GmbI"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 313
    },
    "id": "Q8cNPDQxPPsE",
    "outputId": "5ca15809-3c91-4f93-d1ed-4a8985042487"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Linear Response')"
      ]
     },
     "execution_count": 40,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Linear Reponse of test set\n",
    "\n",
    "#extract coefs\n",
    "betas = logistic_regression.coef_\n",
    "beta_interr = logistic_regression.intercept_\n",
    "#find linear responses for training set\n",
    "beta_t_x =  X_test @ betas.T + beta_interr\n",
    "\n",
    "#figures for linear response\n",
    "fig = plt.figure()\n",
    "plt.scatter(beta_t_x,y_test_bin)\n",
    "plt.title(\"Linear Response on Test Set\")\n",
    "plt.ylabel(\"nonEvent =1, Event =0\")\n",
    "plt.xlabel(\"Linear Response\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Y8mRAi1CvaEW"
   },
   "source": [
    "##Reducing Features\n",
    "\n",
    "-selecting the best features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KrTuTS4khJth"
   },
   "outputs": [],
   "source": [
    "def find_n_best_feature(X, y, n):\n",
    "    '''\n",
    "    input:\n",
    "        X:\n",
    "        y:\n",
    "        n:\n",
    "    output:\n",
    "     cols:\n",
    "    '''\n",
    "    bestfeatures = SelectKBest(score_func=chi2, k=n)\n",
    "    fit = bestfeatures.fit(X_train, y_train)\n",
    "    dfscores = pd.DataFrame(fit.scores_)\n",
    "    dfcolumns = pd.DataFrame(X_train.columns)\n",
    "    featureScores = pd.concat([dfcolumns,dfscores],axis=1)\n",
    "    featureScores.columns = ['col_name','Score']\n",
    "    featureScores= featureScores.nlargest(n,'Score')\n",
    "    cols = list(featureScores[\"col_name\"])\n",
    "    return cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 282
    },
    "id": "Z_n178CE_Jxl",
    "outputId": "8e8c8219-0220-49ff-fd49-5386abe91fdb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 100.0)"
      ]
     },
     "execution_count": 42,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#select optimum number of features on validation set\n",
    "train_acc_rate = np.zeros(100)\n",
    "val_acc_rate = np.zeros(100)\n",
    "test_acc_rate = np.zeros(100)\n",
    "\n",
    "for i in range(1,100): \n",
    "    bestFeatureCols = find_n_best_feature(X_train, y_train, i)\n",
    "    #bestFeaturesFilter = select_n_best_feature(X_train, y_train, i)\n",
    "    X_train_filter = X_train[bestFeatureCols]\n",
    "    X_val_filter = X_val[bestFeatureCols]\n",
    "    X_test_filter = X_test[bestFeatureCols]\n",
    "        \n",
    "    \n",
    "    #binary classifier with logistic regression\n",
    "    logistic_regression= LogisticRegression()\n",
    "    logistic_regression.fit(X_train_filter,y_train_bin)\n",
    "    y_pred_train = logistic_regression.predict(X_train_filter)\n",
    "    y_pred_val = logistic_regression.predict(X_val_filter)\n",
    "    y_pred_test = logistic_regression.predict(X_test_filter)\n",
    "\n",
    "    test_acc_rate[i] = metrics.accuracy_score(y_test_bin, y_pred_test)\n",
    "    val_acc_rate[i] = metrics.accuracy_score(y_val_bin, y_pred_val)\n",
    "    train_acc_rate[i] = metrics.accuracy_score(y_train_bin, y_pred_train)\n",
    "\n",
    "\n",
    "f, ax = plt.subplots(1)\n",
    "plt.plot(train_acc_rate,color=\"red\")\n",
    "plt.plot(val_acc_rate,color=\"blue\")\n",
    "plt.plot(test_acc_rate,color=\"yellow\")\n",
    "\n",
    "ax.set_xlim(1, 100)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 336
    },
    "id": "3vo8R1Ve8Y6M",
    "outputId": "65c7435e-b0c6-44ab-ce1a-62d71c84e492"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on train set:  0.8636363636363636\n",
      "Accuracy on validation set:  0.8653846153846154\n",
      "Accuracy on test set:  0.8461538461538461\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWgAAAEKCAYAAAA/2c+EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAbxklEQVR4nO3deZhV1Znv8e9P0KgICu3QiFxxCramjRpn4oAYLygJGL0m5urFqJSmfVBMnjigt70mdCdxyKDkRkskoFE0RjFGo8EQG8QIBpA4QUI75QoIGtEYpQWq3vvH2QXHsqrOwN7n7Kr6fXz2U+ess/daq6jyZfHutddSRGBmZvmzRb07YGZmbXOANjPLKQdoM7OccoA2M8spB2gzs5xygDYzyykHaDOzFEkaKOlxSS9KekHSxUn5dZKWSnpW0gxJO5Ssy/OgzczSI6k/0D8iFknqDSwERgO7Ab+LiA2SvgcQEZd1VJdH0GZmKYqIlRGxKHn9HrAEGBARMyNiQ3LaPAoBu0M9s+vm5ln/1sse2tvHbLPr0fXuguXQhnXLtbl1VBJzttppr/OBhqKixohobH2epEHAQcD8Vh+dA9xTqp3cBmgzs7xKgvHHAnIxSdsB9wHjI+JvReVXAhuAO0u14wBtZgbQ3JRaVZK2pBCc74yI+4vKzwZGAsOijBuADtBmZgBNG0qfUwZJAm4DlkTE94vKhwOXAsdGxAfl1OUAbWYGRDSnVdUQ4CzgOUmLk7IJwI3AJ4DHCjGceRFxQUcVOUCbmQE0pxOgI2Iu0NZNy19XWpcDtJkZQHoj6NQ4QJuZQao3CdPiAG1mBh5Bm5nlVaQ0iyNNDtBmZpDaTcI0OUCbmYFTHGZmueWbhGZmOeURtJlZTvkmoZlZTvkmoZlZPkU4B21mlk/OQZuZ5ZRTHGZmOeURtJlZTjWtr3cPPsa7epuZQSHFUe7RAUkDJT0u6UVJL0i6OCnvJ+kxScuSr31LdckB2swMCimOco+ObQC+ERH7AUcAF0raD7gcmBUR+wCzkvcdcoA2M4PURtARsTIiFiWv3wOWAAOAUcC05LRpwOhSXXIO2swMMpnFIWkQcBAwH9glIlYmH70B7FLqegdoMzMgKrhJKKkBaCgqaoyIxlbnbAfcB4yPiL8lG8UW2ooISVGqHQdoMzOoaJpdEowb2/tc0pYUgvOdEXF/UrxKUv+IWCmpP7C6VDvOQZuZQZqzOATcBiyJiO8XffQgMCZ5PQb4ZakueQRtZgZpPqgyBDgLeE7S4qRsAvBd4OeSzgVeA04vVZEDtJkZpHaTMCLmAmrn42GV1OUAbWYGftTbzCy3NnjBfjOzfPII2swsp7zcqJlZTnkEbWaWUx5Bm5nllEfQZmY55VkcZmY5FSXXLqo5B2gzM3AO2swstxygzcxyyjcJzcxyqqmp3j34GAdoMzNwisPMLLccoM3MciqHOWhveWVmBkRzlH2UImmKpNWSni8qO1DSPEmLJS2QdFipehygzcwgtT0JE1OB4a3KrgWuiYgDgX9N3nfIKQ4zM0h1FkdEzJE0qHUx0Cd5vT2wolQ9DtBmZlDRTUJJDUBDUVFjRDSWuGw88BtJ11PIXhxVqh0HaDMzqChAJ8G4VEBu7WvAJRFxn6TTgduAEzq6wAE6Z1auepMJ376ev65ZgxCnjRrBWaeP5vpJk5n95Hx6btmTgQP6M3HC1+nTe7t6d9fqZIsttmD+vEdYsfwNRp0ypt7d6RqyXyxpDHBx8vpeYHKpC3yTMGd69ujBN8eN5cE7G7mr8Qfcff9DvPTKaxx56EHMuONmZtz+EwYNHMDkO+6pd1etji4adx5Lly6rdze6lnRvErZlBXBs8vp4oOQPMNMALWmPcspsk5127Md+g/cGoFevbdlz94GsevOvDDn8M/Ts2QOAA/bfl1Wr36pnN62OBgzoz0kjhjFlyvR6d6VraY7yjxIkTQeeAgZLel3SucBY4AZJfwT+nY/msNuUdYrjPuDgVmW/AD6TcbtdwvKVq1iy7CUO2H/wR8pnPDyT4cOObecq6+q+f8M1XH7FRHo7xZWudGdxnNHORxXFvkxG0JL2lXQqsL2kLxYdZwNbd3BdQzKBe8Hk27v36OCDD9ZyyZUTueyi89muV6+N5bdMm06PHj0YeeLQOvbO6uXkk05g9eq3WPTMc/XuSpcTzc1lH7WS1Qh6MDAS2AH4fFH5exSG+W0qvjO6/q2X87e9QY2s37CB8VdO5OQTh/K544ZsLH/g4ceY8+TTTL7xO0iqYw+tXo466hA+P/JERgw/nq23/gR9+vRm2tQbGXP2RfXuWudXRuqi1hQZ3rmUdGREPFXNtd01QEcEEybewPa9t+Py8RdsLJ87bwHX3tTI1EnX0q/vDnXsYX1ts+vR9e5Cbhx7zJF8/ZILPIsD2LBu+WaPWN6feGbZMafXVT+ryQgp6xz0f0qaAAwqbisizsm43U7rmWdf4FePzmKfvQZx6pgLAbj4/DF854c3s279esaOvxIo3Ci8+tJx9eyqWdfSDUfQvweeABYCGzPwEXFfqWu76wjaOuYRtLUllRH0v365/BH0t+7uEiPobSPisozbMDPbfN1wudGHJJ2UcRtmZpsvxXnQacl6BH0xMEHSOmAdICAiok/Hl5mZ1VYtp8+VK9MAHRG9s6zfzCw1ObxJmPWj3pJ0pqT/nbwfWM4uAmZmNZfDFEfWOej/CxwJfCV5/3fgxxm3aWZWuaam8o8ayToHfXhEHCzpGYCIWCNpq4zbNDOrWDl7DdZa1gF6vaQeFLZ6QdJOQP4y8WZm3TBA3wjMAHaW9G/AacBVGbdpZla5bjiL405JC4FhFKbYjY6IJVm2aWZWlRyOoLOexXEj0C8ifhwRkxyczSy30l2wf4qk1ZKeb1U+TtJSSS9IurZUPVmnOBYCV0kaTCHVcXdELMi4TTOzikVTqimOqcAk4PaWAklDgVHApyPiQ0k7l6ok0xF0REyLiJOAQ4E/Ad+T5I3UzCx/UhxBR8Qc4O1WxV8DvhsRHybnrC5VT602jd0b2BfYHVhaozbNzMoWzVH2Ubz7U3KU3F8Q+CRwtKT5kmZLOrTUBZmmOJIcy2jgZeBu4NsR8U6WbZqZVaWCm4TFuz9VoCfQDziCQlbh55L2jA7WfM56BP0qMBH4fURMBfr4UW8zy6XmCo7qvA7cHwVPJzXt2NEFWQfofwYOB1p2uH0PP+ptZjkUG5rLPqr0ADAUQNInga2Atzq6wI96m5lBqs84S5oOHAfsKOl14GpgCjAlmXq3DhjTUXoD/Ki3mRmQ7locEXFGOx+dWUk9Wac4Wj/qPRf494zbNDOrXPY56Ir5UW8zM7rnanZExFI899nM8i6HydfMA7SZWWcQG+rdg49zgDYzA8IjaDOznHKANjPLJ4+gzcxyygHazCynokn17sLHOECbmeERtJlZbkWzR9BmZrnkEbSZWU5FeARtZpZLHkGbmeVUcw5ncdRq01gzs1yLZpV9lCJpiqTVyeL8rT/7hqSQ1OF2V+AAbWYGpBugganA8NaFkgYCJwJ/KacSB2gzMyCi/KN0XTEHeLuNj34AXEqyy1Qp7eagJd3UUSURcVE5DZiZdQaVzIOW1AA0FBU1RkRjiWtGAcsj4o9SeW11dJNwQVk1mJl1AZVMs0uCcYcBuZikbYEJFNIbZWs3QEfEtEoqMjPrzJqyncWxF7AH0DJ63g1YJOmwiHijvYtKTrNLduK+DNgP2LqlPCKO39wem5nlRZYPqkTEc8DOLe8lvQocEhFvdXRdOTcJ7wSWUIj+1wCvAn+otqNmZnmU8jS76cBTwGBJr0s6t5o+lfOgyj9ExG2SLo6I2cBsSQ7QZtallDM7o/y64owSnw8qp55yAvT65OtKSScDK4B+5VRuZtZZdNbV7CZK2h74BnAT0Ae4JNNemZnVWFNz/h4LKRmgI+Kh5OW7wNBsu2NmVh9ppjjSUs4sjp/SxgMrEXFOJj0yM6uD5k663OhDRa+3Bk6hkIc2M+syOuV60BFxX/H7ZPrI3Mx6ZGZWB50yxdGGfSiacJ2VbXY9OusmrBNau+KJenfBuqhOmeKQ9B4fzUG/QeHJQjOzLqOzzuLoXYuOmJnVUw4zHKUf9ZY0q5wyM7POrDlU9lErHa0HvTWwLbCjpL5AS6/6AANq0Dczs5rpbLM4zgfGA7sCC9kUoP8GTMq4X2ZmNZXDTb07XA/6R8CPJI2LiJtq2Cczs5oL8jeCLue2ZbOkHVreSOor6V8y7JOZWc1tCJV91Eo5AXpsRLzT8iYi1gBjs+uSmVntBSr7qJVyAnQPFe1wKKkHsFV2XTIzq73mCo5SJE2RtFrS80Vl10laKulZSTOKMxPtKSdAPwrcI2mYpGHAdOCRMq4zM+s0Uh5BTwWGtyp7DPhURBwA/Bm4olQl5TzqfRmF7cUvSN4/C/xjOT00M+ss0pzFERFzJA1qVTaz6O084LRS9ZQcQUdEMzCfwl6EhwHHU9ij0Mysy2hCZR+SGiQtKDoaKmzuHMrIRHT0oMongTOS4y3gHoCI8KL9ZtblVLLjVUQ0Ao3VtCPpSmADhQ25O9RRimMp8AQwMiL+M6nYW12ZWZfUXIPZGZLOBkYCwyJKL3DaUYrji8BK4HFJtyY3CPM3k9vMLAVRwVENScOBS4EvRMQH5VzTboCOiAci4svAvsDjFB773lnSTySdWGUfzcxyKeVpdtOBp4DBkl6XdC6FJTJ6A49JWizp5lL1lLPc6PvAXcBdyaJJ/4PCzI6ZHV5oZtaJNCu9BEFEnNFG8W2V1lPRjirJU4RVJ8fNzPKqqd4daEM1W16ZmXU5lcziqBUHaDMzajOLo1IO0GZm5HPLKwdoMzOc4jAzy61OtaOKmVl30uQRtJlZPnkEbWaWUw7QZmY5VcOtBsvmAG1mhkfQZma55Ue9zcxyyvOgzcxyyikOM7OcymOALrlprJlZd5DmjiqSpkhaLen5orJ+kh6TtCz52rdUPQ7QZmYUctDlHmWYCgxvVXY5MCsi9gFmJe875ABtZkZhFke5RykRMQd4u1XxKGBa8noaMLpUPQ7QZmZAM1H2IalB0oKio6GMJnaJiJXJ6zeAXUpd4JuEZmZUdpMwIjZr67+ICEkl09keQZuZke5NwnasktQfIPm6utQFDtBmZhRG0OUeVXoQGJO8HgP8stQFTnGYmQEbSmccyiZpOnAcsKOk14Grge8CP5d0LvAacHqpehygzcxId0/CiDijnY+GVVKPA7SZGfl8ktAB2syMwjS7vHGANjMj3RRHWhygzcxwisPMLLeacjiGdoA2M8MjaDOz3AqPoM3M8skjaKvYFltswfx5j7Bi+RuMOmVM6Qusy1m56k0mfPt6/rpmDUKcNmoEZ50+musnTWb2k/PpuWVPBg7oz8QJX6dP7+3q3d1OK4/T7LwWR85dNO48li5dVu9uWB317NGDb44by4N3NnJX4w+4+/6HeOmV1zjy0IOYccfNzLj9JwwaOIDJd9xT7652ajVYLKliDtA5NmBAf04aMYwpU6bXuytWRzvt2I/9Bu8NQK9e27Ln7gNZ9eZfGXL4Z+jZswcAB+y/L6tWv1XPbnZ6G4iyj1rJNEBLmlVOmbXt+zdcw+VXTKS5OY/ZMauH5StXsWTZSxyw/+CPlM94eCafPfLQOvWqa4gK/quVTAK0pK0l9aOwklPfZLPEfpIGAQM6uG7jLgXNze9n0bVO4+STTmD16rdY9Mxz9e6K5cQHH6zlkisnctlF57Ndr14by2+ZNp0ePXow8sShdexd51eD5UYrltVNwvOB8cCuwEKgZZvFvwGT2ruoeJeCnlsNyF/GvoaOOuoQPj/yREYMP56tt/4Effr0ZtrUGxlz9kX17prVwfoNGxh/5UROPnEonztuyMbyBx5+jDlPPs3kG7+DVN5upta2PE6zU0R2nZI0LiJuquba7h6gix17zJF8/ZILPIsDWLviiXp3oeYiggkTb2D73ttx+fgLNpbPnbeAa29qZOqka+nXd4c69rD+ttxxz83+22nMoFPLjjnTXr2vJn8bZjrNLiJuknQUMKi4rYi4Pct2zbqSZ559gV89Oot99hrEqWMuBODi88fwnR/ezLr16xk7/kqgcKPw6kvH1bOrnVpTioNVSZcA51GY9PEc8NWI+K+K68l4BH0HsBewmE27lUdElPx3ukfQ1pbuOIK20tIYQX9l91PKjjl3vTaj3fYkDQDmAvtFxFpJPwd+HRFTK+1T1g+qHEKhkw62ZpZrKeegewLbSFoPbAusqKaSrOdBPw/8Y8ZtmJlttkpmcRTPOEuOhpZ6ImI5cD3wF2Al8G5EzKymT1mPoHcEXpT0NPBhS2FEfCHjds3MKlLJo97FM85ak9QXGAXsAbwD3CvpzIj4WaV9yjpA/5+M6zczS0WKKY4TgFci4k0ASfcDRwH5CtARMVvS7sA+EfFbSdsCPbJs08ysGinO4vgLcEQS79ZS2Ml7QTUVZf2o91jgF8AtSdEA4IEs2zQzq0YzUfbRkYiYTyHuLaIwxW4L2kmHlJJ1iuNC4DBgPkBELJO0c8ZtmplVLM1HuCPiauDqza0n6wD9YUSsa3kEVVJP8rl5rpl1c3l81DvrAD1b0gQK8wE/B/wL8KuM2zQzq1h3XLD/cuBNCnmY84FfA1dl3KaZWcUiouyjVrIeQY8Gbo+IWzNux8xsszR1wxH054E/S7pD0sgkB21mljtpzeJIU6YBOiK+CuwN3AucAbwkaXKWbZqZVaM7pjiIiPWSHqEwe2MbCmmP87Ju18ysEt3uJqGkEZKmAsuAU4HJePEkM8uhPO5JmPUI+n8B9wDnR8SHpU42M6uXNBfsT0vWOegzgGeAowEkbSOpd5ZtmplVo9vdJGxjLY7d8FocZpZD3S5AU1iLYwiF3byJiGWA1+Iws9zpjrM4vBaHmXUK3W4WBx9fi+NevBaHmeVQd5zFcTlwLh9di8MPqphZ7jRFmguOpiPrHVWagVuTw8wst9LMLUvagcJg9FMU0rrnRMRTldaTaYCWNITCvoS7J20JiIjYM8t2zcwqlXIO+kfAoxFxmqStgG2rqSTrFMdtwCXAQqAp47bMzKqWVm5Z0vbAMcDZABGxDlhXTV1ZB+h3I+KRjNswM9tszemlOPagsA7+TyV9msIA9eKIeL/SirKexfG4pOskHSnp4JYj4zbNzCpWySwOSQ2SFhQdDUVV9QQOBn4SEQcB71OYMFGxrEfQhydfDykqC+D4jNs1M6tIJbM4IqKR9nfqfh14PdndGwpPU+cvQEfE0CzrNzNLS1opjoh4Q9L/kzQ4Iv4EDANerKaurGdxbE9h6/FjkqLZwLci4t0s2zUzq1TKD6CMA+5MZnC8DHy1mkqyTnFMAZ4HTk/enwX8FPhixu2amVUkxZuERMRiPprarUrWAXqviDi16P01khZn3KaZWcVq+Qh3ubIO0GslfTYi5sLGB1fWZtymmVnFmiJ/j2pkHaC/BkxLctEAa4AxGbdpZlaxWi4jWq6sA/QS4FpgL2AH4F0Km8Y+m3G7ZmYVyeNyo1kH6F8C7wCLgOUZt2VmVrXuOILeLSKGZ9yGmdlmS3MWR1qyftT795L+OeM2zMw2W3dcsP+zwNmSXgE+ZNNyowdk3K6ZWUW63YL9wIiM6zczS0W3y0FHxGtZ1m9mlpY85qCzHkGbmXUK3W4EbWbWWXTHedBmZp2CR9BmZjnVHWdxmJl1Cr5JaGaWU3lMcWT9JKGZWaeQ9pOEknpIekbSQ9X2ySNoMzMyGUFfTGFFzz7VVuARtJkZhRx0uUcpknYDTgYmb06fcjuC3rBuuerdh7yQ1JBs8262kX8v0lVJzJHUADQUFTW2+ln8ELgU6L05ffIIunNoKH2KdUP+vaiTiGiMiEOKjo3BWdJIYHVELNzcdhygzczSNQT4gqRXgbuB4yX9rJqKHKDNzFIUEVdExG4RMQj4MvC7iDizmrocoDsH5xmtLf696OKUx8nZZmbmEbSZWW45QJuZ5ZQDdBciabSk/erdD+ucJI2XtG29+2GbOEB3LaMBB2ir1njAATpHHKBrTNKZkp6WtFjSLZIulHRd0ednS5rUzrk9kvK/S/o3SX+UNE/SLpKOAr4AXJecv1d9vkMrJmmQpCWSbpX0gqSZkraRdGDys3tW0gxJfZPz/0PS95Kf+58lHZ2U95B0naQ/JNecn5TfLenkovamSjqtg/OPS9r4haSlku5UwUXArsDjkh6v/Z+UtcUBuoYk/RPwJWBIRBwINAF/B04pOu1LwN3tnPs/k3N6AfMi4tPAHGBsRPweeBD4ZkQcGBEv1eSbsnLsA/w4IvYH3gFOBW4HLouIA4DngKuLzu8ZEYdRGNG2lJ8LvBsRhwKHAmMl7QHcA5wOIGkrYBjwcAfnAxyU1L0fsCeF37EbgRXA0IgYmsGfgVUht2txdFHDgM8Af5AEsA2wGnhZ0hHAMmBf4EngwnbOBVgHtCxhuBD4XI36b9V5JSIWJ68XAnsBO0TE7KRsGnBv0fn3F507KHl9InCApNOS99tTCPyPAD+S9AlgODAnItZKau/8dcDTEfE6gKTFSRtzU/peLUUO0LUlYFpEXPGRQukcCqOgpcCMiAgVovLHzk2sj00T2JvwzzHvPix63QTsUOb5xT9bAeMi4jetT5b0H8B/J/nXV0fnSzqujf749yennOKorVnAaZJ2BpDUT9LuwAxgFHAGm/4Ha+/cjrzHZq6eZTXxLrCmJb8MnAXM7uB8gN8AX5O0JYCkT0rqlXx2D/BV4Gjg0TLOb49/f3LGAbqGIuJF4CpgpqRngceA/hGxhsLC3rtHxNMdnVuiibuBbya7OPgmYb6NoXBD91ngQOBbJc6fDLwILJL0PHALm0a+M4Fjgd9GxLoyzm9PI/CobxLmhx/1NjPLKY+gzcxyygHazCynHKDNzHLKAdrMLKccoM3McsoB2jIhqSlZE+R5SfduzippLetLJK8nd7RiX7LWxFFVtPGqpB2r7aNZFhygLStrkzVBPkXh8eILij+UVNXTaxFxXjJHvD3HARUHaLM8coC2WngC2DsZ3T4h6UHgxQ5WXJOkSZL+JOm3wM4tFSUrsR2SvB4uaVGyqt8sSYMo/EVwSTJ6P1rSTpLuS9r4g6QhybX/kKws94KkyRQejTbLFT+Db5lKRsoj2PQI8sHApyLiFUkNJCuuJYv9PClpJoXV1gZTWG1tFwpPxE1pVe9OwK3AMUld/SLibUk3A3+PiOuT8+4CfhARcyX9NwqPQP8ThVXi5kbEt5LlOs/N9A/CrAoO0JaVbZKV0qAwgr6NQurh6Yh4JSlvb8W1Y4DpEdEErJD0uzbqP4LCym2vAETE2+304wRgv2RFQIA+krZL2vhicu3DktZU+X2aZcYB2rKyNlnHeqMkSL5fXETbK66dlGI/tgCOiIj/aqMvZrnmHLTVU3srrs0BvpTkqPsDbS0gPw84pmURekn9kvLWK7LNBMa1vJHU8pfGHOArSdkIoG9q35VZShygrZ7aW3FtBoXNC16ksPPIU60vjIg3gQbgfkl/pLDkJsCvgFNabhICFwGHJDchX2TTbJJrKAT4FyikOv6S0fdoVjWvZmdmllMeQZuZ5ZQDtJlZTjlAm5nllAO0mVlOOUCbmeWUA7SZWU45QJuZ5dT/B02WnbU15cBfAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#rerun logistic regression with top features only\n",
    "bestFeatureCols = find_n_best_feature(X_train, y_train, 70)\n",
    "\n",
    "#filter normalised data for each\n",
    "X_train_filter = X_train[bestFeatureCols]\n",
    "X_val_filter = X_val[bestFeatureCols]\n",
    "X_test_filter = X_test[bestFeatureCols] \n",
    "\n",
    "#binary classifier with logistic regression\n",
    "logistic_regression= LogisticRegression()\n",
    "logistic_regression.fit(X_train_filter,y_train_bin)\n",
    "y_pred_train = logistic_regression.predict(X_train_filter)\n",
    "y_pred_val = logistic_regression.predict(X_val_filter)\n",
    "y_pred_test = logistic_regression.predict(X_test_filter)\n",
    "\n",
    "confusion_matrix = pd.crosstab(y_test_bin, y_pred_test, rownames=['Actual'], colnames=['Predicted'])\n",
    "sns.heatmap(confusion_matrix, annot=True)\n",
    "\n",
    "\n",
    "print('Accuracy on train set: ',metrics.accuracy_score(y_train_bin, y_pred_train))\n",
    "print('Accuracy on validation set: ',metrics.accuracy_score(y_val_bin, y_pred_val))\n",
    "print('Accuracy on test set: ',metrics.accuracy_score(y_test_bin, y_pred_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 473
    },
    "id": "sKzy-o2a9lYt",
    "outputId": "2a53e77f-43a1-43cf-d1f8-bdfeabc89be4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on train set:  0.7207792207792207\n",
      "Accuracy on validation set:  0.5384615384615384\n",
      "Accuracy on test set:  0.6538461538461539\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "    async function download(id, filename, size) {\n",
       "      if (!google.colab.kernel.accessAllowed) {\n",
       "        return;\n",
       "      }\n",
       "      const div = document.createElement('div');\n",
       "      const label = document.createElement('label');\n",
       "      label.textContent = `Downloading \"${filename}\": `;\n",
       "      div.appendChild(label);\n",
       "      const progress = document.createElement('progress');\n",
       "      progress.max = size;\n",
       "      div.appendChild(progress);\n",
       "      document.body.appendChild(div);\n",
       "\n",
       "      const buffers = [];\n",
       "      let downloaded = 0;\n",
       "\n",
       "      const channel = await google.colab.kernel.comms.open(id);\n",
       "      // Send a message to notify the kernel that we're ready.\n",
       "      channel.send({})\n",
       "\n",
       "      for await (const message of channel.messages) {\n",
       "        // Send a message to notify the kernel that we're ready.\n",
       "        channel.send({})\n",
       "        if (message.buffers) {\n",
       "          for (const buffer of message.buffers) {\n",
       "            buffers.push(buffer);\n",
       "            downloaded += buffer.byteLength;\n",
       "            progress.value = downloaded;\n",
       "          }\n",
       "        }\n",
       "      }\n",
       "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
       "      const a = document.createElement('a');\n",
       "      a.href = window.URL.createObjectURL(blob);\n",
       "      a.download = filename;\n",
       "      div.appendChild(a);\n",
       "      a.click();\n",
       "      div.remove();\n",
       "    }\n",
       "  "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "download(\"download_2ae039bd-88fa-42f1-b229-1012199baa12\", \"multi_trainval_logReg.csv\", 25750)"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "    async function download(id, filename, size) {\n",
       "      if (!google.colab.kernel.accessAllowed) {\n",
       "        return;\n",
       "      }\n",
       "      const div = document.createElement('div');\n",
       "      const label = document.createElement('label');\n",
       "      label.textContent = `Downloading \"${filename}\": `;\n",
       "      div.appendChild(label);\n",
       "      const progress = document.createElement('progress');\n",
       "      progress.max = size;\n",
       "      div.appendChild(progress);\n",
       "      document.body.appendChild(div);\n",
       "\n",
       "      const buffers = [];\n",
       "      let downloaded = 0;\n",
       "\n",
       "      const channel = await google.colab.kernel.comms.open(id);\n",
       "      // Send a message to notify the kernel that we're ready.\n",
       "      channel.send({})\n",
       "\n",
       "      for await (const message of channel.messages) {\n",
       "        // Send a message to notify the kernel that we're ready.\n",
       "        channel.send({})\n",
       "        if (message.buffers) {\n",
       "          for (const buffer of message.buffers) {\n",
       "            buffers.push(buffer);\n",
       "            downloaded += buffer.byteLength;\n",
       "            progress.value = downloaded;\n",
       "          }\n",
       "        }\n",
       "      }\n",
       "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
       "      const a = document.createElement('a');\n",
       "      a.href = window.URL.createObjectURL(blob);\n",
       "      a.download = filename;\n",
       "      div.appendChild(a);\n",
       "      a.click();\n",
       "      div.remove();\n",
       "    }\n",
       "  "
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "download(\"download_8069c0f3-af5c-45c4-ac38-e90b71498ec6\", \"multi_test_logReg.csv\", 6500)"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#multi classifier with logistic regression\n",
    "logistic_regression= LogisticRegression()\n",
    "logistic_regression.fit(X_train,y_train)\n",
    "y_pred_train = logistic_regression.predict(X_train)\n",
    "y_pred_val = logistic_regression.predict(X_val)\n",
    "y_pred_test = logistic_regression.predict(X_test)\n",
    "\n",
    "confusion_matrix = pd.crosstab(y_test, y_pred_test, rownames=['Actual'], colnames=['Predicted'])\n",
    "sns.heatmap(confusion_matrix, annot=True)\n",
    "\n",
    "print('Accuracy on train set: ',metrics.accuracy_score(y_train, y_pred_train))\n",
    "print('Accuracy on validation set: ',metrics.accuracy_score(y_val, y_pred_val))\n",
    "print('Accuracy on test set: ',metrics.accuracy_score(y_test, y_pred_test))\n",
    "\n",
    "multi_train_val = np.c_[X_trainval.index,logistic_regression.predict_proba(X_trainval)]\n",
    "multi_test = np.c_[X_test.index,logistic_regression.predict_proba(X_test)]\n",
    "\n",
    "\n",
    "from numpy import savetxt\n",
    "savetxt('multi_trainval_logReg.csv', multi_train_val, delimiter=',')\n",
    "savetxt('multi_test_logReg.csv', multi_test, delimiter=',')\n",
    "\n",
    "from google.colab import files\n",
    "files.download(\"multi_trainval_logReg.csv\")\n",
    "files.download(\"multi_test_logReg.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mX-3gme-NgFX"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "zNFXOSBS4ap1"
   ],
   "name": "Logistic Regression Stratified.ipynb",
   "provenance": []
  },
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}