cavcalc.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn import preprocessing\n",
    "from sklearn import model_selection\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.metrics import accuracy_score, f1_score, classification_report, precision_score, recall_score, confusion_matrix\n",
    "from sklearn import tree\n",
    "from sklearn.model_selection import train_test_split\n",
    "from imblearn.over_sampling import RandomOverSampler,SMOTE, ADASYN\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "import matplotlib\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import r2_score\n",
    "import statsmodels.api as sm\n",
    "from sklearn.linear_model import RidgeCV, LassoCV, Ridge, Lasso"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PMF</th>\n",
       "      <th>cav1</th>\n",
       "      <th>cav2</th>\n",
       "      <th>cav3</th>\n",
       "      <th>cav4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3.088686</td>\n",
       "      <td>78.00</td>\n",
       "      <td>46.0</td>\n",
       "      <td>126.22</td>\n",
       "      <td>58.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3.088686</td>\n",
       "      <td>72.24</td>\n",
       "      <td>41.0</td>\n",
       "      <td>62.00</td>\n",
       "      <td>22.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3.088686</td>\n",
       "      <td>70.00</td>\n",
       "      <td>44.0</td>\n",
       "      <td>126.22</td>\n",
       "      <td>59.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3.088686</td>\n",
       "      <td>57.00</td>\n",
       "      <td>33.0</td>\n",
       "      <td>52.00</td>\n",
       "      <td>46.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3.088686</td>\n",
       "      <td>38.00</td>\n",
       "      <td>47.0</td>\n",
       "      <td>126.22</td>\n",
       "      <td>34.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        PMF   cav1  cav2    cav3  cav4\n",
       "0  3.088686  78.00  46.0  126.22  58.0\n",
       "1  3.088686  72.24  41.0   62.00  22.0\n",
       "2  3.088686  70.00  44.0  126.22  59.0\n",
       "3  3.088686  57.00  33.0   52.00  46.0\n",
       "4  3.088686  38.00  47.0  126.22  34.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df=pd.read_csv('0100cavscsv.csv')\n",
    "df.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['PMF'].nunique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PMF     0\n",
       "cav1    0\n",
       "cav2    0\n",
       "cav3    0\n",
       "cav4    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = df[['PMF']]\n",
    "x = df[['cav1','cav2','cav3','cav4']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=77)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.013286762878021996"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lm = LinearRegression()\n",
    "lm.fit(X_train, y_train)\n",
    "lm.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.012909278347589814"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lm.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The linear model is: Y = 1.1742 + 0.00080424*cav1 + 0.0042655*cav2 + -0.00046762*cav3+ 0.0023078*cav4\n"
     ]
    }
   ],
   "source": [
    "        print(\"The linear model is: Y = {:.5} + {:.5}*cav1 + {:.5}*cav2 + {:.5}*cav3+ {:.5}*cav4\".format(lm.intercept_[0], lm.coef_[0][0], lm.coef_[0][1], lm.coef_[0][2], lm.coef_[0][3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            OLS Regression Results                            \n",
      "==============================================================================\n",
      "Dep. Variable:                    PMF   R-squared:                       0.014\n",
      "Model:                            OLS   Adj. R-squared:                  0.013\n",
      "Method:                 Least Squares   F-statistic:                     43.71\n",
      "Date:                Fri, 17 Apr 2020   Prob (F-statistic):           1.72e-36\n",
      "Time:                        16:50:33   Log-Likelihood:                -16408.\n",
      "No. Observations:               12750   AIC:                         3.283e+04\n",
      "Df Residuals:                   12745   BIC:                         3.286e+04\n",
      "Df Model:                           4                                         \n",
      "Covariance Type:            nonrobust                                         \n",
      "==============================================================================\n",
      "                 coef    std err          t      P>|t|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "const          1.1618      0.046     25.116      0.000       1.071       1.252\n",
      "x1             0.0012      0.000      3.494      0.000       0.001       0.002\n",
      "x2             0.0043      0.000     10.038      0.000       0.003       0.005\n",
      "x3            -0.0005      0.000     -2.212      0.027      -0.001   -5.29e-05\n",
      "x4             0.0021      0.000      6.983      0.000       0.002       0.003\n",
      "==============================================================================\n",
      "Omnibus:                      176.734   Durbin-Watson:                   0.020\n",
      "Prob(Omnibus):                  0.000   Jarque-Bera (JB):              182.059\n",
      "Skew:                           0.285   Prob(JB):                     2.93e-40\n",
      "Kurtosis:                       2.871   Cond. No.                     1.01e+03\n",
      "==============================================================================\n",
      "\n",
      "Warnings:\n",
      "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n",
      "[2] The condition number is large, 1.01e+03. This might indicate that there are\n",
      "strong multicollinearity or other numerical problems.\n"
     ]
    }
   ],
   "source": [
    "X = np.column_stack((df['cav1'], df['cav2'], df['cav3'],df['cav4']))\n",
    "y = df['PMF']\n",
    "X2 = sm.add_constant(X)\n",
    "est = sm.OLS(y, X2)\n",
    "est2 = est.fit()\n",
    "print(est2.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best alpha using built-in LassoCV: 1.483604\n",
      "Best score using built-in LassoCV: 0.000000\n",
      "Lasso picked 0 variables and eliminated the other 4 variables\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Feature importance using Lasso Model')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "reg = LassoCV()\n",
    "reg.fit(x, y)\n",
    "print(\"Best alpha using built-in LassoCV: %f\" % reg.alpha_)\n",
    "print(\"Best score using built-in LassoCV: %f\" %reg.score(x,y))\n",
    "coef = pd.Series(reg.coef_, index = x.columns)\n",
    "\n",
    "print(\"Lasso picked \" + str(sum(coef != 0)) + \" variables and eliminated the other \" +  str(sum(coef == 0)) + \" variables\")\n",
    "\n",
    "imp_coef = coef.sort_values()\n",
    "import matplotlib\n",
    "matplotlib.rcParams['figure.figsize'] = (8.0, 10.0)\n",
    "imp_coef.plot(kind = \"barh\")\n",
    "plt.title(\"Feature importance using Lasso Model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PMF</th>\n",
       "      <th>cav1</th>\n",
       "      <th>cav2</th>\n",
       "      <th>cav3</th>\n",
       "      <th>cav4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1250</th>\n",
       "      <td>1.194153</td>\n",
       "      <td>51.00</td>\n",
       "      <td>53.0</td>\n",
       "      <td>58.00</td>\n",
       "      <td>53.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1251</th>\n",
       "      <td>1.194153</td>\n",
       "      <td>72.24</td>\n",
       "      <td>50.0</td>\n",
       "      <td>64.00</td>\n",
       "      <td>85.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1252</th>\n",
       "      <td>1.194153</td>\n",
       "      <td>55.00</td>\n",
       "      <td>52.0</td>\n",
       "      <td>55.00</td>\n",
       "      <td>45.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1253</th>\n",
       "      <td>1.194153</td>\n",
       "      <td>72.24</td>\n",
       "      <td>48.0</td>\n",
       "      <td>126.22</td>\n",
       "      <td>66.42</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1254</th>\n",
       "      <td>1.194153</td>\n",
       "      <td>67.00</td>\n",
       "      <td>48.0</td>\n",
       "      <td>49.00</td>\n",
       "      <td>62.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           PMF   cav1  cav2    cav3   cav4\n",
       "1250  1.194153  51.00  53.0   58.00  53.00\n",
       "1251  1.194153  72.24  50.0   64.00  85.00\n",
       "1252  1.194153  55.00  52.0   55.00  45.00\n",
       "1253  1.194153  72.24  48.0  126.22  66.42\n",
       "1254  1.194153  67.00  48.0   49.00  62.00"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df=pd.read_csv('0100cavscsv.csv')\n",
    "df.drop(df.index[:1250], inplace=True)\n",
    "df.drop(df.index[10000:], inplace=True)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PMF</th>\n",
       "      <th>cav1</th>\n",
       "      <th>cav2</th>\n",
       "      <th>cav3</th>\n",
       "      <th>cav4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>10000.000000</td>\n",
       "      <td>10000.000000</td>\n",
       "      <td>10000.000000</td>\n",
       "      <td>10000.000000</td>\n",
       "      <td>10000.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>1.370507</td>\n",
       "      <td>72.915840</td>\n",
       "      <td>49.213244</td>\n",
       "      <td>126.113108</td>\n",
       "      <td>66.542718</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.793028</td>\n",
       "      <td>23.316653</td>\n",
       "      <td>19.308285</td>\n",
       "      <td>37.733904</td>\n",
       "      <td>26.245723</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>18.000000</td>\n",
       "      <td>18.000000</td>\n",
       "      <td>19.000000</td>\n",
       "      <td>18.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.764571</td>\n",
       "      <td>69.000000</td>\n",
       "      <td>48.960000</td>\n",
       "      <td>126.220000</td>\n",
       "      <td>49.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>1.346367</td>\n",
       "      <td>72.240000</td>\n",
       "      <td>48.960000</td>\n",
       "      <td>126.220000</td>\n",
       "      <td>66.420000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>2.175508</td>\n",
       "      <td>72.240000</td>\n",
       "      <td>48.960000</td>\n",
       "      <td>126.220000</td>\n",
       "      <td>81.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>2.513287</td>\n",
       "      <td>249.000000</td>\n",
       "      <td>249.000000</td>\n",
       "      <td>250.000000</td>\n",
       "      <td>237.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                PMF          cav1          cav2          cav3          cav4\n",
       "count  10000.000000  10000.000000  10000.000000  10000.000000  10000.000000\n",
       "mean       1.370507     72.915840     49.213244    126.113108     66.542718\n",
       "std        0.793028     23.316653     19.308285     37.733904     26.245723\n",
       "min        0.000000     18.000000     18.000000     19.000000     18.000000\n",
       "25%        0.764571     69.000000     48.960000    126.220000     49.000000\n",
       "50%        1.346367     72.240000     48.960000    126.220000     66.420000\n",
       "75%        2.175508     72.240000     48.960000    126.220000     81.000000\n",
       "max        2.513287    249.000000    249.000000    250.000000    237.000000"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['PMF']=df['PMF'].apply(lambda x:\"0.2\" if 0<=x<0.2 else (\"0.4\" if 0.2<=x<0.4 else (\"0.6\" if 0.4<=x<0.6 else (\"0.8\" if 0.6<=x<0.8 else (\"1.0\" if 0.8<=x<1.0 else (\"1.2\" if 1.0<=x<1.2 else (\"1.4\" if 1.2<=x<1.4 else (\"1.6\" if 1.4<=x<1.6 else (\"1.8\" if 1.6<=x<1.8 else \"2.0\")))))))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PMF</th>\n",
       "      <th>cav1</th>\n",
       "      <th>cav2</th>\n",
       "      <th>cav3</th>\n",
       "      <th>cav4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1250</th>\n",
       "      <td>1.2</td>\n",
       "      <td>51.00</td>\n",
       "      <td>53.0</td>\n",
       "      <td>58.00</td>\n",
       "      <td>53.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1251</th>\n",
       "      <td>1.2</td>\n",
       "      <td>72.24</td>\n",
       "      <td>50.0</td>\n",
       "      <td>64.00</td>\n",
       "      <td>85.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1252</th>\n",
       "      <td>1.2</td>\n",
       "      <td>55.00</td>\n",
       "      <td>52.0</td>\n",
       "      <td>55.00</td>\n",
       "      <td>45.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1253</th>\n",
       "      <td>1.2</td>\n",
       "      <td>72.24</td>\n",
       "      <td>48.0</td>\n",
       "      <td>126.22</td>\n",
       "      <td>66.42</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1254</th>\n",
       "      <td>1.2</td>\n",
       "      <td>67.00</td>\n",
       "      <td>48.0</td>\n",
       "      <td>49.00</td>\n",
       "      <td>62.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      PMF   cav1  cav2    cav3   cav4\n",
       "1250  1.2  51.00  53.0   58.00  53.00\n",
       "1251  1.2  72.24  50.0   64.00  85.00\n",
       "1252  1.2  55.00  52.0   55.00  45.00\n",
       "1253  1.2  72.24  48.0  126.22  66.42\n",
       "1254  1.2  67.00  48.0   49.00  62.00"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "enc=preprocessing.LabelEncoder()\n",
    "df['PMF'] = enc.fit_transform(df['PMF'])\n",
    "y = df[['PMF']]\n",
    "x = df[['cav1','cav2','cav3','cav4']]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=77)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.382125"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Train and fit Logistic Regression model.\n",
    "LoRmod=LogisticRegression(max_iter=10000)\n",
    "LoRmod.fit(X_train,y_train)\n",
    "#Score LR training\n",
    "LoRmod.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy score: 37.2\n",
      "F1 score: 7.760091883200718\n",
      "Recall score: 11.321477208181925\n",
      "Precision score: 15.034639498432604\n",
      "Confusion matrix: [[  0   0   0   0   0   0   7   0   0 189]\n",
      " [  0   0   0   0   0   0   5   0   0  36]\n",
      " [  1   0   0   0   0   0  10   0   0 153]\n",
      " [  0   0   0   0   0   0  12   0   0 196]\n",
      " [  1   0   0   0   0   0   2   0   0 105]\n",
      " [  0   0   0   0   0   0   3   0   0 157]\n",
      " [  0   0   0   0   0   0  19   1   0 181]\n",
      " [  0   0   0   0   0   0   7   7   0 126]\n",
      " [  0   0   0   0   0   0   2   0   0  53]\n",
      " [  0   0   0   0   0   1   8   0   0 718]]\n",
      "Classification report:               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.00      0.00      0.00       196\n",
      "           1       0.00      0.00      0.00        41\n",
      "           2       0.00      0.00      0.00       164\n",
      "           3       0.00      0.00      0.00       208\n",
      "           4       0.00      0.00      0.00       108\n",
      "           5       0.00      0.00      0.00       160\n",
      "           6       0.25      0.09      0.14       201\n",
      "           7       0.88      0.05      0.09       140\n",
      "           8       0.00      0.00      0.00        55\n",
      "           9       0.38      0.99      0.54       727\n",
      "\n",
      "    accuracy                           0.37      2000\n",
      "   macro avg       0.15      0.11      0.08      2000\n",
      "weighted avg       0.22      0.37      0.22      2000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1321: UserWarning: Note that pos_label (set to 'positive') is ignored when average != 'binary' (got 'macro'). You may use labels=[pos_label] to specify a single positive class.\n",
      "  % (pos_label, average), UserWarning)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1272: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1272: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "#Predict from manufactured test and score\n",
    "LoRpred= LoRmod.predict(X_test)\n",
    "print('Accuracy score:', accuracy_score(y_test,LoRpred)*100)\n",
    "print('F1 score:', f1_score(y_test, LoRpred,pos_label='positive',average='macro')*100)\n",
    "print('Recall score:', recall_score(y_test, LoRpred,pos_label='positive',average='macro')*100)\n",
    "print('Precision score:', precision_score(y_test, LoRpred,pos_label='positive',average='macro')*100)\n",
    "print('Confusion matrix:', confusion_matrix(y_test, LoRpred))\n",
    "print('Classification report:', classification_report(y_test, LoRpred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n"
     ]
    }
   ],
   "source": [
    "k_list=[]\n",
    "for i in range(1,20):\n",
    "  classifier=KNeighborsClassifier(n_neighbors=i)\n",
    "  classifier.fit(X_train,y_train)\n",
    "  k_list.append(classifier.score(X_test,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(1,20),k_list)\n",
    "plt.ylabel('Validation acc')\n",
    "plt.title('nice')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:2: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.4765"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "KNNmod=KNeighborsClassifier(n_neighbors=8)\n",
    "KNNmod.fit(X_train,y_train)\n",
    "#Score RF fit.\n",
    "KNNmod.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy score: 36.85\n",
      "F1 score: 24.053952438269206\n",
      "Recall score: 23.03257387602445\n",
      "Precision score: 27.376293302082633\n",
      "Confusion matrix: [[ 35   5   4  15   1   1  11   4   1 119]\n",
      " [  9   8   1   3   0   0   4   1   0  15]\n",
      " [ 19   5  22  13  11  11   5   6   1  71]\n",
      " [ 29  13  15  39  10  14   8   3   1  76]\n",
      " [  6   0  14   8  23  12   1   4   1  39]\n",
      " [  7   1  14  21  17  34   7  10   0  49]\n",
      " [ 13   7   5  16   4   9  53  11   2  81]\n",
      " [ 10   1   4   8   4   9  27  20   0  57]\n",
      " [ 11   0   3   4   0   3   6   1   5  22]\n",
      " [ 76   4  17  23  14  24  45  20   6 498]]\n",
      "Classification report:               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.16      0.18      0.17       196\n",
      "           1       0.18      0.20      0.19        41\n",
      "           2       0.22      0.13      0.17       164\n",
      "           3       0.26      0.19      0.22       208\n",
      "           4       0.27      0.21      0.24       108\n",
      "           5       0.29      0.21      0.25       160\n",
      "           6       0.32      0.26      0.29       201\n",
      "           7       0.25      0.14      0.18       140\n",
      "           8       0.29      0.09      0.14        55\n",
      "           9       0.48      0.69      0.57       727\n",
      "\n",
      "    accuracy                           0.37      2000\n",
      "   macro avg       0.27      0.23      0.24      2000\n",
      "weighted avg       0.34      0.37      0.34      2000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1321: UserWarning: Note that pos_label (set to 'positive') is ignored when average != 'binary' (got 'macro'). You may use labels=[pos_label] to specify a single positive class.\n",
      "  % (pos_label, average), UserWarning)\n"
     ]
    }
   ],
   "source": [
    "#Predict from manufactured test and score\n",
    "KNNpred = KNNmod.predict(X_test)\n",
    "print('Accuracy score:', accuracy_score(y_test,KNNpred)*100)\n",
    "print('F1 score:', f1_score(y_test, KNNpred,pos_label='positive',average='macro')*100)\n",
    "print('Recall score:', recall_score(y_test, KNNpred,pos_label='positive',average='macro')*100)\n",
    "print('Precision score:', precision_score(y_test, KNNpred,pos_label='positive',average='macro')*100)\n",
    "print('Confusion matrix:', confusion_matrix(y_test, KNNpred))\n",
    "print('Classification report:', classification_report(y_test, KNNpred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.70525"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SVCmod=SVC(kernel='rbf',gamma=0.1)\n",
    "SVCmod.fit(X_train,y_train)\n",
    "#Score DT fit.\n",
    "SVCmod.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy score: 36.5\n",
      "F1 score: 10.598191429523537\n",
      "Recall score: 12.456861392381043\n",
      "Precision score: 17.8766023068155\n",
      "Confusion matrix: [[  9   0   1   8   0   1   4   1   1 171]\n",
      " [  3   0   0   3   0   0   1   0   0  34]\n",
      " [  4   0   3   5   2   6   1   1   0 142]\n",
      " [  6   1   3   9   3  13   3   2   0 168]\n",
      " [  3   0   4   2   3  12   0   2   0  82]\n",
      " [  1   0   2   2   5  11   2   0   0 137]\n",
      " [  4   0   1   3   0   1  19   8   0 165]\n",
      " [  2   0   2   2   1   3  12   3   0 115]\n",
      " [  0   0   0   3   1   0   0   0   0  51]\n",
      " [ 13   0   3   8   4   9  12   5   0 673]]\n",
      "Classification report:               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.20      0.05      0.07       196\n",
      "           1       0.00      0.00      0.00        41\n",
      "           2       0.16      0.02      0.03       164\n",
      "           3       0.20      0.04      0.07       208\n",
      "           4       0.16      0.03      0.05       108\n",
      "           5       0.20      0.07      0.10       160\n",
      "           6       0.35      0.09      0.15       201\n",
      "           7       0.14      0.02      0.04       140\n",
      "           8       0.00      0.00      0.00        55\n",
      "           9       0.39      0.93      0.55       727\n",
      "\n",
      "    accuracy                           0.36      2000\n",
      "   macro avg       0.18      0.12      0.11      2000\n",
      "weighted avg       0.26      0.36      0.24      2000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1321: UserWarning: Note that pos_label (set to 'positive') is ignored when average != 'binary' (got 'macro'). You may use labels=[pos_label] to specify a single positive class.\n",
      "  % (pos_label, average), UserWarning)\n"
     ]
    }
   ],
   "source": [
    "#Predict from manufactured test and score\n",
    "SVCpred = SVCmod.predict(X_test)\n",
    "print('Accuracy score:', accuracy_score(y_test,SVCpred)*100)\n",
    "print('F1 score:', f1_score(y_test, SVCpred,pos_label='positive',average='macro')*100)\n",
    "print('Recall score:', recall_score(y_test, SVCpred,pos_label='positive',average='macro')*100)\n",
    "print('Precision score:', precision_score(y_test, SVCpred,pos_label='positive',average='macro')*100)\n",
    "print('Confusion matrix:', confusion_matrix(y_test, SVCpred))\n",
    "print('Classification report:', classification_report(y_test, SVCpred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:3: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.858125"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Train and fit Random Forest model.\n",
    "RFmod=RandomForestClassifier(n_estimators=100,random_state=77)\n",
    "RFmod.fit(X_train,y_train)\n",
    "#Score RF fit.\n",
    "RFmod.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy score: 39.300000000000004\n",
      "F1 score: 25.928798735117454\n",
      "Recall score: 25.098813119979518\n",
      "Precision score: 28.518723345462554\n",
      "Confusion matrix: [[ 27   2   6  19   0   2   6   8   4 122]\n",
      " [  8   8   0   6   0   0   1   0   1  17]\n",
      " [  8   1  27  11  10  27   8   5   0  67]\n",
      " [ 10   9  10  54  15  24   8   7   2  69]\n",
      " [  3   0  15  10  23  29   3   4   1  20]\n",
      " [  4   0  18  22  14  61   4  12   1  24]\n",
      " [ 10   6   2   9   3   4  44  22   0 101]\n",
      " [  3   0   2  10   7  19  28  22   0  49]\n",
      " [  8   0   0   4   1   1   2   2   4  33]\n",
      " [ 40   3  13  33  18  20  46  29   9 516]]\n",
      "Classification report:               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.22      0.14      0.17       196\n",
      "           1       0.28      0.20      0.23        41\n",
      "           2       0.29      0.16      0.21       164\n",
      "           3       0.30      0.26      0.28       208\n",
      "           4       0.25      0.21      0.23       108\n",
      "           5       0.33      0.38      0.35       160\n",
      "           6       0.29      0.22      0.25       201\n",
      "           7       0.20      0.16      0.18       140\n",
      "           8       0.18      0.07      0.10        55\n",
      "           9       0.51      0.71      0.59       727\n",
      "\n",
      "    accuracy                           0.39      2000\n",
      "   macro avg       0.29      0.25      0.26      2000\n",
      "weighted avg       0.36      0.39      0.36      2000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1321: UserWarning: Note that pos_label (set to 'positive') is ignored when average != 'binary' (got 'macro'). You may use labels=[pos_label] to specify a single positive class.\n",
      "  % (pos_label, average), UserWarning)\n"
     ]
    }
   ],
   "source": [
    "#Predict from manufactured test and score\n",
    "RFpred = RFmod.predict(X_test)\n",
    "print('Accuracy score:', accuracy_score(y_test,RFpred)*100)\n",
    "print('F1 score:', f1_score(y_test, RFpred,pos_label='positive',average='macro')*100)\n",
    "print('Recall score:', recall_score(y_test, RFpred,pos_label='positive',average='macro')*100)\n",
    "print('Precision score:', precision_score(y_test, RFpred,pos_label='positive',average='macro')*100)\n",
    "print('Confusion matrix:', confusion_matrix(y_test, RFpred))\n",
    "print('Classification report:', classification_report(y_test, RFpred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PMF</th>\n",
       "      <th>Cav1</th>\n",
       "      <th>Cav2</th>\n",
       "      <th>Cav3</th>\n",
       "      <th>Cav4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3.088686</td>\n",
       "      <td>71.29152</td>\n",
       "      <td>59.75648</td>\n",
       "      <td>122.60480</td>\n",
       "      <td>54.79288</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.257551</td>\n",
       "      <td>64.53520</td>\n",
       "      <td>50.57584</td>\n",
       "      <td>143.73504</td>\n",
       "      <td>53.62224</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1.864369</td>\n",
       "      <td>65.13696</td>\n",
       "      <td>48.13488</td>\n",
       "      <td>142.13392</td>\n",
       "      <td>55.74880</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.561414</td>\n",
       "      <td>66.24832</td>\n",
       "      <td>57.27488</td>\n",
       "      <td>129.32152</td>\n",
       "      <td>71.24248</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1.264104</td>\n",
       "      <td>61.00608</td>\n",
       "      <td>45.01888</td>\n",
       "      <td>129.16120</td>\n",
       "      <td>61.77176</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        PMF      Cav1      Cav2       Cav3      Cav4\n",
       "0  3.088686  71.29152  59.75648  122.60480  54.79288\n",
       "1  2.257551  64.53520  50.57584  143.73504  53.62224\n",
       "2  1.864369  65.13696  48.13488  142.13392  55.74880\n",
       "3  1.561414  66.24832  57.27488  129.32152  71.24248\n",
       "4  1.264104  61.00608  45.01888  129.16120  61.77176"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df=pd.read_csv('0100aggcav.csv')\n",
    "df.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = df[['PMF']]\n",
    "x = df[['Cav1','Cav2','Cav3','Cav4']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=77)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.15369491165065752"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lm = LinearRegression()\n",
    "lm.fit(X_train, y_train)\n",
    "lm.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.4719435263665943"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lm.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The linear model is: Y = -2.1273 + 0.0097707*cav1 + 0.050384*cav2 + -0.0072462*cav3+ 0.019959*cav4\n"
     ]
    }
   ],
   "source": [
    "print(\"The linear model is: Y = {:.5} + {:.5}*cav1 + {:.5}*cav2 + {:.5}*cav3+ {:.5}*cav4\".format(lm.intercept_[0], lm.coef_[0][0], lm.coef_[0][1], lm.coef_[0][2], lm.coef_[0][3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            OLS Regression Results                            \n",
      "==============================================================================\n",
      "Dep. Variable:                    PMF   R-squared:                       0.140\n",
      "Model:                            OLS   Adj. R-squared:                  0.066\n",
      "Method:                 Least Squares   F-statistic:                     1.878\n",
      "Date:                Fri, 17 Apr 2020   Prob (F-statistic):              0.130\n",
      "Time:                        16:51:19   Log-Likelihood:                -62.128\n",
      "No. Observations:                  51   AIC:                             134.3\n",
      "Df Residuals:                      46   BIC:                             143.9\n",
      "Df Model:                           4                                         \n",
      "Covariance Type:            nonrobust                                         \n",
      "==============================================================================\n",
      "                 coef    std err          t      P>|t|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "const         -2.0467      2.262     -0.905      0.370      -6.600       2.507\n",
      "x1             0.0092      0.013      0.696      0.490      -0.017       0.036\n",
      "x2             0.0477      0.022      2.206      0.032       0.004       0.091\n",
      "x3            -0.0059      0.012     -0.489      0.627      -0.030       0.018\n",
      "x4             0.0198      0.014      1.381      0.174      -0.009       0.049\n",
      "==============================================================================\n",
      "Omnibus:                        0.997   Durbin-Watson:                   0.365\n",
      "Prob(Omnibus):                  0.607   Jarque-Bera (JB):                0.588\n",
      "Skew:                           0.260   Prob(JB):                        0.745\n",
      "Kurtosis:                       3.081   Cond. No.                     3.15e+03\n",
      "==============================================================================\n",
      "\n",
      "Warnings:\n",
      "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n",
      "[2] The condition number is large, 3.15e+03. This might indicate that there are\n",
      "strong multicollinearity or other numerical problems.\n"
     ]
    }
   ],
   "source": [
    "X = np.column_stack((df['Cav1'], df['Cav2'], df['Cav3'],df['Cav4']))\n",
    "y = df['PMF']\n",
    "X2 = sm.add_constant(X)\n",
    "est = sm.OLS(y, X2)\n",
    "est2 = est.fit()\n",
    "print(est2.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            OLS Regression Results                            \n",
      "==============================================================================\n",
      "Dep. Variable:                    PMF   R-squared:                       0.140\n",
      "Model:                            OLS   Adj. R-squared:                  0.066\n",
      "Method:                 Least Squares   F-statistic:                     1.878\n",
      "Date:                Fri, 17 Apr 2020   Prob (F-statistic):              0.130\n",
      "Time:                        16:51:19   Log-Likelihood:                -62.128\n",
      "No. Observations:                  51   AIC:                             134.3\n",
      "Df Residuals:                      46   BIC:                             143.9\n",
      "Df Model:                           4                                         \n",
      "Covariance Type:            nonrobust                                         \n",
      "==============================================================================\n",
      "                 coef    std err          t      P>|t|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "const         -2.0467      2.262     -0.905      0.370      -6.600       2.507\n",
      "x1             0.0092      0.013      0.696      0.490      -0.017       0.036\n",
      "x2             0.0477      0.022      2.206      0.032       0.004       0.091\n",
      "x3            -0.0059      0.012     -0.489      0.627      -0.030       0.018\n",
      "x4             0.0198      0.014      1.381      0.174      -0.009       0.049\n",
      "==============================================================================\n",
      "Omnibus:                        0.997   Durbin-Watson:                   0.365\n",
      "Prob(Omnibus):                  0.607   Jarque-Bera (JB):                0.588\n",
      "Skew:                           0.260   Prob(JB):                        0.745\n",
      "Kurtosis:                       3.081   Cond. No.                     3.15e+03\n",
      "==============================================================================\n",
      "\n",
      "Warnings:\n",
      "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n",
      "[2] The condition number is large, 3.15e+03. This might indicate that there are\n",
      "strong multicollinearity or other numerical problems.\n"
     ]
    }
   ],
   "source": [
    "X = np.column_stack((df['Cav1'], df['Cav2'], df['Cav3'],df['Cav4']))\n",
    "y = df['PMF']\n",
    "X2 = sm.add_constant(X)\n",
    "est = sm.OLS(y, X2)\n",
    "est2 = est.fit()\n",
    "print(est2.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "#https://towardsdatascience.com/the-complete-guide-to-linear-regression-in-python-3d3f8f06bf8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PMF</th>\n",
       "      <th>Cav1</th>\n",
       "      <th>Cav2</th>\n",
       "      <th>Cav3</th>\n",
       "      <th>Cav4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>REACT</td>\n",
       "      <td>61.00608</td>\n",
       "      <td>45.01888</td>\n",
       "      <td>129.16120</td>\n",
       "      <td>61.77176</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>REACT</td>\n",
       "      <td>59.83424</td>\n",
       "      <td>60.53152</td>\n",
       "      <td>128.26824</td>\n",
       "      <td>75.82352</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>REACT</td>\n",
       "      <td>65.90576</td>\n",
       "      <td>51.13152</td>\n",
       "      <td>109.93688</td>\n",
       "      <td>73.00168</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>REACT</td>\n",
       "      <td>65.29072</td>\n",
       "      <td>45.05536</td>\n",
       "      <td>123.54120</td>\n",
       "      <td>48.93480</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>REACT</td>\n",
       "      <td>66.85248</td>\n",
       "      <td>46.60992</td>\n",
       "      <td>125.97256</td>\n",
       "      <td>63.42520</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     PMF      Cav1      Cav2       Cav3      Cav4\n",
       "0  REACT  61.00608  45.01888  129.16120  61.77176\n",
       "1  REACT  59.83424  60.53152  128.26824  75.82352\n",
       "2  REACT  65.90576  51.13152  109.93688  73.00168\n",
       "3  REACT  65.29072  45.05536  123.54120  48.93480\n",
       "4  REACT  66.85248  46.60992  125.97256  63.42520"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df=pd.read_csv('0100cataggcav.csv')\n",
    "df.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "enc=preprocessing.LabelEncoder()\n",
    "df['PMF'] = enc.fit_transform(df['PMF'])\n",
    "y = df[['PMF']]\n",
    "x = df[['Cav1','Cav2','Cav3','Cav4']]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=77)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.625"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Train and fit Logistic Regression model.\n",
    "LoRmod=LogisticRegression(max_iter=10000)\n",
    "LoRmod.fit(X_train,y_train)\n",
    "#Score LR training\n",
    "LoRmod.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy score: 55.55555555555556\n",
      "F1 score: 44.44444444444444\n",
      "Recall score: 55.55555555555555\n",
      "Precision score: 38.888888888888886\n",
      "Confusion matrix: [[2 0 1]\n",
      " [1 0 2]\n",
      " [0 0 3]]\n",
      "Classification report:               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.67      0.67      0.67         3\n",
      "           1       0.00      0.00      0.00         3\n",
      "           2       0.50      1.00      0.67         3\n",
      "\n",
      "    accuracy                           0.56         9\n",
      "   macro avg       0.39      0.56      0.44         9\n",
      "weighted avg       0.39      0.56      0.44         9\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1321: UserWarning: Note that pos_label (set to 'positive') is ignored when average != 'binary' (got 'macro'). You may use labels=[pos_label] to specify a single positive class.\n",
      "  % (pos_label, average), UserWarning)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1272: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1272: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "#Predict from manufactured test and score\n",
    "LoRpred= LoRmod.predict(X_test)\n",
    "print('Accuracy score:', accuracy_score(y_test,LoRpred)*100)\n",
    "print('F1 score:', f1_score(y_test, LoRpred,pos_label='positive',average='macro')*100)\n",
    "print('Recall score:', recall_score(y_test, LoRpred,pos_label='positive',average='macro')*100)\n",
    "print('Precision score:', precision_score(y_test, LoRpred,pos_label='positive',average='macro')*100)\n",
    "print('Confusion matrix:', confusion_matrix(y_test, LoRpred))\n",
    "print('Classification report:', classification_report(y_test, LoRpred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PMF</th>\n",
       "      <th>cav1</th>\n",
       "      <th>cav2</th>\n",
       "      <th>cav3</th>\n",
       "      <th>cav4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>LOW</td>\n",
       "      <td>78.00</td>\n",
       "      <td>46.0</td>\n",
       "      <td>126.22</td>\n",
       "      <td>58.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>LOW</td>\n",
       "      <td>72.24</td>\n",
       "      <td>41.0</td>\n",
       "      <td>62.00</td>\n",
       "      <td>22.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>LOW</td>\n",
       "      <td>70.00</td>\n",
       "      <td>44.0</td>\n",
       "      <td>126.22</td>\n",
       "      <td>59.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>LOW</td>\n",
       "      <td>57.00</td>\n",
       "      <td>33.0</td>\n",
       "      <td>52.00</td>\n",
       "      <td>46.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>LOW</td>\n",
       "      <td>38.00</td>\n",
       "      <td>47.0</td>\n",
       "      <td>126.22</td>\n",
       "      <td>34.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   PMF   cav1  cav2    cav3  cav4\n",
       "0  LOW  78.00  46.0  126.22  58.0\n",
       "1  LOW  72.24  41.0   62.00  22.0\n",
       "2  LOW  70.00  44.0  126.22  59.0\n",
       "3  LOW  57.00  33.0   52.00  46.0\n",
       "4  LOW  38.00  47.0  126.22  34.0"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df=pd.read_csv('0100cataggcavbig.csv')\n",
    "df.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "enc=preprocessing.LabelEncoder()\n",
    "df['PMF'] = enc.fit_transform(df['PMF'])\n",
    "y = df[['PMF']]\n",
    "x = df[['cav1','cav2','cav3','cav4']]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=77)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.4118627450980392"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Train and fit Logistic Regression model.\n",
    "LoRmod=LogisticRegression(max_iter=10000)\n",
    "LoRmod.fit(X_train,y_train)\n",
    "#Score LR training\n",
    "LoRmod.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy score: 42.627450980392155\n",
      "F1 score: 35.46962100255669\n",
      "Recall score: 38.40113237446652\n",
      "Precision score: 41.101343942807894\n",
      "Confusion matrix: [[112 186 414]\n",
      " [ 65 173 574]\n",
      " [ 75 149 802]]\n",
      "Classification report:               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.44      0.16      0.23       712\n",
      "           1       0.34      0.21      0.26       812\n",
      "           2       0.45      0.78      0.57      1026\n",
      "\n",
      "    accuracy                           0.43      2550\n",
      "   macro avg       0.41      0.38      0.35      2550\n",
      "weighted avg       0.41      0.43      0.38      2550\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1321: UserWarning: Note that pos_label (set to 'positive') is ignored when average != 'binary' (got 'macro'). You may use labels=[pos_label] to specify a single positive class.\n",
      "  % (pos_label, average), UserWarning)\n"
     ]
    }
   ],
   "source": [
    "#Predict from manufactured test and score\n",
    "LoRpred= LoRmod.predict(X_test)\n",
    "print('Accuracy score:', accuracy_score(y_test,LoRpred)*100)\n",
    "print('F1 score:', f1_score(y_test, LoRpred,pos_label='positive',average='macro')*100)\n",
    "print('Recall score:', recall_score(y_test, LoRpred,pos_label='positive',average='macro')*100)\n",
    "print('Precision score:', precision_score(y_test, LoRpred,pos_label='positive',average='macro')*100)\n",
    "print('Confusion matrix:', confusion_matrix(y_test, LoRpred))\n",
    "print('Classification report:', classification_report(y_test, LoRpred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n",
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  after removing the cwd from sys.path.\n"
     ]
    }
   ],
   "source": [
    "k_list=[]\n",
    "for i in range(1,20):\n",
    "  classifier=KNeighborsClassifier(n_neighbors=i)\n",
    "  classifier.fit(X_train,y_train)\n",
    "  k_list.append(classifier.score(X_test,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(1,20),k_list)\n",
    "plt.ylabel('Validation acc')\n",
    "plt.title('nice')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:2: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.6599019607843137"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "KNNmod=KNeighborsClassifier(n_neighbors=7)\n",
    "KNNmod.fit(X_train,y_train)\n",
    "#Score RF fit.\n",
    "KNNmod.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy score: 59.80392156862745\n",
      "F1 score: 60.18261346841577\n",
      "Recall score: 60.59622649258789\n",
      "Precision score: 60.61599305941534\n",
      "Confusion matrix: [[448 131 133]\n",
      " [ 88 541 183]\n",
      " [146 344 536]]\n",
      "Classification report:               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.66      0.63      0.64       712\n",
      "           1       0.53      0.67      0.59       812\n",
      "           2       0.63      0.52      0.57      1026\n",
      "\n",
      "    accuracy                           0.60      2550\n",
      "   macro avg       0.61      0.61      0.60      2550\n",
      "weighted avg       0.61      0.60      0.60      2550\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1321: UserWarning: Note that pos_label (set to 'positive') is ignored when average != 'binary' (got 'macro'). You may use labels=[pos_label] to specify a single positive class.\n",
      "  % (pos_label, average), UserWarning)\n"
     ]
    }
   ],
   "source": [
    "#Predict from manufactured test and score\n",
    "KNNpred = KNNmod.predict(X_test)\n",
    "print('Accuracy score:', accuracy_score(y_test,KNNpred)*100)\n",
    "print('F1 score:', f1_score(y_test, KNNpred,pos_label='positive',average='macro')*100)\n",
    "print('Recall score:', recall_score(y_test, KNNpred,pos_label='positive',average='macro')*100)\n",
    "print('Precision score:', precision_score(y_test, KNNpred,pos_label='positive',average='macro')*100)\n",
    "print('Confusion matrix:', confusion_matrix(y_test, KNNpred))\n",
    "print('Classification report:', classification_report(y_test, KNNpred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.5603921568627451, 0.5364705882352941, 0.5192156862745098, 0.5066666666666667, 0.5015686274509804, 0.4984313725490196, 0.49254901960784314, 0.4945098039215686, 0.49098039215686273]\n"
     ]
    }
   ],
   "source": [
    "#SVCmod=SVC(kernel='rbf',gamma=0.1)\n",
    "gamma_list=[]\n",
    "for i in range(1,10):\n",
    "  classifier=SVC(kernel='rbf',gamma=(float(i)/10))\n",
    "  classifier.fit(X_train,y_train)\n",
    "  gamma_list.append(classifier.score(X_test,y_test))\n",
    "print(gamma_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(1,10),gamma_list)\n",
    "plt.ylabel('Validation acc')\n",
    "plt.title('nice')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.7835294117647059"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SVCmod=SVC(kernel='rbf',gamma=0.1)\n",
    "SVCmod.fit(X_train,y_train)\n",
    "#Score DT fit.\n",
    "SVCmod.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy score: 56.03921568627451\n",
      "F1 score: 55.903351889540595\n",
      "Recall score: 58.40600387058309\n",
      "Precision score: 56.610697005728305\n",
      "Confusion matrix: [[517  83 112]\n",
      " [147 534 131]\n",
      " [296 352 378]]\n",
      "Classification report:               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.54      0.73      0.62       712\n",
      "           1       0.55      0.66      0.60       812\n",
      "           2       0.61      0.37      0.46      1026\n",
      "\n",
      "    accuracy                           0.56      2550\n",
      "   macro avg       0.57      0.58      0.56      2550\n",
      "weighted avg       0.57      0.56      0.55      2550\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1321: UserWarning: Note that pos_label (set to 'positive') is ignored when average != 'binary' (got 'macro'). You may use labels=[pos_label] to specify a single positive class.\n",
      "  % (pos_label, average), UserWarning)\n"
     ]
    }
   ],
   "source": [
    "#Predict from manufactured test and score\n",
    "SVCpred = SVCmod.predict(X_test)\n",
    "print('Accuracy score:', accuracy_score(y_test,SVCpred)*100)\n",
    "print('F1 score:', f1_score(y_test, SVCpred,pos_label='positive',average='macro')*100)\n",
    "print('Recall score:', recall_score(y_test, SVCpred,pos_label='positive',average='macro')*100)\n",
    "print('Precision score:', precision_score(y_test, SVCpred,pos_label='positive',average='macro')*100)\n",
    "print('Confusion matrix:', confusion_matrix(y_test, SVCpred))\n",
    "print('Classification report:', classification_report(y_test, SVCpred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7384313725490196"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DTmod=DecisionTreeClassifier(criterion='gini', random_state = 77,max_depth=10)\n",
    "DTmod.fit(X_train,y_train)\n",
    "#Score DT fit.\n",
    "DTmod.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy score: 66.62745098039215\n",
      "F1 score: 67.13175633161187\n",
      "Recall score: 68.41507531366624\n",
      "Precision score: 68.1783843803041\n",
      "Confusion matrix: [[540  83  89]\n",
      " [ 60 640 112]\n",
      " [124 383 519]]\n",
      "Classification report:               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.75      0.76      0.75       712\n",
      "           1       0.58      0.79      0.67       812\n",
      "           2       0.72      0.51      0.59      1026\n",
      "\n",
      "    accuracy                           0.67      2550\n",
      "   macro avg       0.68      0.68      0.67      2550\n",
      "weighted avg       0.68      0.67      0.66      2550\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1321: UserWarning: Note that pos_label (set to 'positive') is ignored when average != 'binary' (got 'macro'). You may use labels=[pos_label] to specify a single positive class.\n",
      "  % (pos_label, average), UserWarning)\n"
     ]
    }
   ],
   "source": [
    "#Predict from manufactured test and score\n",
    "DTpred = DTmod.predict(X_test)\n",
    "print('Accuracy score:', accuracy_score(y_test,DTpred)*100)\n",
    "print('F1 score:', f1_score(y_test, DTpred,pos_label='positive',average='macro')*100)\n",
    "print('Recall score:', recall_score(y_test, DTpred,pos_label='positive',average='macro')*100)\n",
    "print('Precision score:', precision_score(y_test, DTpred,pos_label='positive',average='macro')*100)\n",
    "print('Confusion matrix:', confusion_matrix(y_test, DTpred))\n",
    "print('Classification report:', classification_report(y_test, DTpred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cav1', 'cav2', 'cav3', 'cav4']\n"
     ]
    }
   ],
   "source": [
    "featurelist=list(df.columns[1:])\n",
    "plt.bar(range(len(DTmod.feature_importances_)), DTmod.feature_importances_)\n",
    "plt.xlabel(\"feature\")\n",
    "plt.ylabel(\"importance\")\n",
    "plt.title(\"feature importance\")\n",
    "plt.xticks(range(len(DTmod.feature_importances_)), featurelist,rotation='vertical')\n",
    "plt.show()\n",
    "print(featurelist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/alia/.local/lib/python3.5/site-packages/ipykernel_launcher.py:3: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.8663725490196078"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Train and fit Random Forest model.\n",
    "RFmod=RandomForestClassifier(n_estimators=100,random_state=77)\n",
    "RFmod.fit(X_train,y_train)\n",
    "#Score RF fit.\n",
    "RFmod.score(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy score: 64.70588235294117\n",
      "F1 score: 65.40981473220765\n",
      "Recall score: 66.1033849242044\n",
      "Precision score: 65.72019174585625\n",
      "Confusion matrix: [[531  79 102]\n",
      " [ 71 571 170]\n",
      " [117 361 548]]\n",
      "Classification report:               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.74      0.75      0.74       712\n",
      "           1       0.56      0.70      0.63       812\n",
      "           2       0.67      0.53      0.59      1026\n",
      "\n",
      "    accuracy                           0.65      2550\n",
      "   macro avg       0.66      0.66      0.65      2550\n",
      "weighted avg       0.65      0.65      0.65      2550\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/metrics/_classification.py:1321: UserWarning: Note that pos_label (set to 'positive') is ignored when average != 'binary' (got 'macro'). You may use labels=[pos_label] to specify a single positive class.\n",
      "  % (pos_label, average), UserWarning)\n"
     ]
    }
   ],
   "source": [
    "#Predict from manufactured test and score\n",
    "RFpred = RFmod.predict(X_test)\n",
    "print('Accuracy score:', accuracy_score(y_test,RFpred)*100)\n",
    "print('F1 score:', f1_score(y_test, RFpred,pos_label='positive',average='macro')*100)\n",
    "print('Recall score:', recall_score(y_test, RFpred,pos_label='positive',average='macro')*100)\n",
    "print('Precision score:', precision_score(y_test, RFpred,pos_label='positive',average='macro')*100)\n",
    "print('Confusion matrix:', confusion_matrix(y_test, RFpred))\n",
    "print('Classification report:', classification_report(y_test, RFpred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cav1', 'cav2', 'cav3', 'cav4']\n"
     ]
    }
   ],
   "source": [
    "featurelist=list(df.columns[1:])\n",
    "plt.bar(range(len(RFmod.feature_importances_)), RFmod.feature_importances_)\n",
    "plt.xlabel(\"feature\")\n",
    "plt.ylabel(\"importance\")\n",
    "plt.title(\"feature importance\")\n",
    "plt.xticks(range(len(RFmod.feature_importances_)), featurelist,rotation='vertical')\n",
    "plt.show()\n",
    "print(featurelist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_split.py:296: FutureWarning: Setting a random_state has no effect since shuffle is False. This will raise an error in 0.24. You should leave random_state to its default (None), or set shuffle=True.\n",
      "  FutureWarning\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/model_selection/_validation.py:515: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  estimator.fit(X_train, y_train, **fit_params)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "kfold = model_selection.KFold(n_splits=10, random_state=77)\n",
    "cv_LoR = model_selection.cross_val_score(LogisticRegression(max_iter=10000), X_train, y_train, cv=kfold, scoring='accuracy')\n",
    "cv_DT = model_selection.cross_val_score(DecisionTreeClassifier(criterion='gini', random_state = 77,max_depth=10), X_train, y_train, cv=kfold, scoring='accuracy')\n",
    "cv_RF = model_selection.cross_val_score(RandomForestClassifier(n_estimators=100), X_train, y_train, cv=kfold, scoring='accuracy')\n",
    "cv_SVC = model_selection.cross_val_score(SVC(kernel='rbf',gamma=0.1), X_train, y_train, cv=kfold, scoring='accuracy')\n",
    "cv_KNN = model_selection.cross_val_score(KNeighborsClassifier(n_neighbors=7), X_train, y_train, cv=kfold, scoring='accuracy')\n",
    "results=[cv_LoR,cv_DT, cv_RF,cv_SVC,cv_KNN]\n",
    "names=[\"LoR\",\"DT\",\"RF\",\"SVC\",\"KNN\"]\n",
    "fig = plt.figure()\n",
    "fig.suptitle('Algorithm Comparison')\n",
    "ax = fig.add_subplot(111)\n",
    "plt.boxplot(results)\n",
    "ax.set_xticklabels(names)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}