settings_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import shap\n",
    "from imblearn.over_sampling import KMeansSMOTE, SMOTE\n",
    "from sklearn.metrics import f1_score, recall_score, precision_score, classification_report, make_scorer, accuracy_score, \\\n",
    "    balanced_accuracy_score\n",
    "from sklearn.model_selection import GridSearchCV, StratifiedKFold, train_test_split\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "from matplotlib import pyplot as plt\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drop unnecessary columns in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def clean_dataframe(df):\n",
    "\n",
    "    df.drop(columns=['name', 'followers', 'commit_count_a', 'source', 'job', 'name_without_spaces',\n",
    "                     'project', 'index'], inplace=True)\n",
    "    \n",
    "    df.drop(columns=['AddSM','DelSM','ChurnSM',\"SumAddDelSM\"], inplace=True)\n",
    "    \n",
    "    for column in  df.columns:\n",
    "         if \"SumAddDel\" in column:\n",
    "            df.drop(columns=[column], inplace=True)\n",
    "\n",
    "\n",
    "    df['DiP'] = df['DiP'].round()\n",
    "    df['DiP'].replace(0, 1, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Log columns in the dataset to reduce the skewness in data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def log_dataframe(df):\n",
    "\n",
    "    #columns_4_log = ['SumAddDelLOC', 'DiP', 'NoC', 'SumAddDelF',\n",
    "    #                 'SumAddDelSAM', 'SumAddDelSM', 'AddLOC', 'DelLOC', 'AddSAM', 'DelSAM',\n",
    "    #                 'AddSM','DelSM']\n",
    "\n",
    "    columns_4_log = ['SumAddDelLOC', 'DiP', 'NoC', 'SumAddDelF',\n",
    "                     'SumAddDelSAM', 'AddLOC', 'DelLOC', 'AddSAM', 'DelSAM']\n",
    "\n",
    "\n",
    "    for column in columns_4_log:\n",
    "        df[column] = np.log(df[column] + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returns labels (y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def get_labels(df):\n",
    "    df.loc[df['job'] == \"SA\", 'job'] = \"SSE\"\n",
    "    df.loc[df['job'] != \"SSE\", 'job'] = \"NSSE\"\n",
    "\n",
    "    return df[\"job\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scales data according to the scaler given as input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def scaling(scaler, X):\n",
    "    return scaler.fit_transform(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creates synthetic data with original data using smote method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def create_synthetic_data(smote, X_scaled, y):\n",
    "    return smote.fit_resample(X_scaled, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train the classifier with synthetic data an create a classification report on original data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def train_and_classification_report(classifier, X_synthetic, y_synthetic, X_scaled, y):\n",
    "    classifier.fit(X_synthetic, y_synthetic)\n",
    "    print(classification_report(y, classifier.predict(X_scaled)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scores the classifier using a k-fold (here a Stratified 4-fold with shuffle)\n",
    "Synthetic data are created to train the classifier for each fold.\n",
    "Real data are used to compute measures for the classifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def stratifiedKFold_scoring(classifier, X, y, smote = None):\n",
    "    kf = StratifiedKFold(n_splits=4, shuffle=False)#, random_state=0)\n",
    "    print(\"===> Start kfold <===\")\n",
    "    scores = {\"F1\": {\"values\" : []}, \"Recall\": {\"values\" : []},\n",
    "              \"Precision\": {\"values\" : []}, \"Balanced\\nAccuracy\" : {\"values\" : []}}\n",
    "\n",
    "    for fold, (train_index, test_index) in enumerate(kf.split(X, y), 1):\n",
    "        print(\"=> Fold : \",fold)\n",
    "        #print(\"TRAIN:\", train_index, \"TEST:\", test_index)\n",
    "        \n",
    "        if isinstance(X, np.ndarray):\n",
    "            X_train = X[train_index]\n",
    "            y_train = y[train_index]\n",
    "            X_test = X[test_index]\n",
    "            y_test = y[test_index]\n",
    "        elif isinstance(X, pd.core.frame.DataFrame):\n",
    "            X_train = X.iloc[train_index]\n",
    "            y_train = y.iloc[train_index]\n",
    "            X_test = X.iloc[test_index]\n",
    "            y_test = y.iloc[test_index]\n",
    "        else : \n",
    "            raise Exception(\"X should be a Pandas Dataframe of Numpy N dim Array\")\n",
    "\n",
    "        if smote is not None:\n",
    "            print(\"smote\")\n",
    "            X_train_synthetic, y_train_synthetic = smote.fit_resample(X_train, y_train)\n",
    "            classifier.fit(X_train_synthetic, y_train_synthetic)\n",
    "        else:\n",
    "            classifier.fit(X_train, y_train)\n",
    "        y_pred = classifier.predict(X_test)\n",
    "\n",
    "        f1 = f1_score(y_test, y_pred, pos_label=\"SSE\")\n",
    "        recall = recall_score(y_test, y_pred, pos_label=\"SSE\")\n",
    "        precision = precision_score(y_test, y_pred, pos_label=\"SSE\")\n",
    "        accuracy = balanced_accuracy_score(y_test, y_pred)\n",
    "\n",
    "        scores[\"F1\"][\"values\"].append(f1)\n",
    "        scores[\"Recall\"][\"values\"].append(recall)\n",
    "        scores[\"Precision\"][\"values\"].append(precision)\n",
    "        scores[\"Balanced\\nAccuracy\"][\"values\"].append(accuracy)\n",
    "\n",
    "    for key in scores:\n",
    "        scores[key][\"values\"] = np.array(scores[key][\"values\"])\n",
    "        scores[key][\"mean\"] = np.mean(scores[key][\"values\"])\n",
    "        scores[key][\"std\"] = np.std(scores[key][\"values\"])\n",
    "        scores[key][\"ci95\"] = np.std(scores[key][\"values\"]) * 2\n",
    "\n",
    "        print(key, \"mean :%0.4f\" % scores[key][\"mean\"])\n",
    "        print(key, \"std : %0.4f\" % scores[key][\"std\"])\n",
    "        print(key, \"95%% Confidence Interval +/- %0.4f\" % (scores[key][\"ci95\"]))\n",
    "        print(\"\")\n",
    "    return scores\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "scaler = MinMaxScaler(feature_range=(-1,1))\n",
    "smote = KMeansSMOTE(sampling_strategy='minority', random_state=9090)\n",
    "classifier = KNeighborsClassifier(algorithm='ball_tree', n_neighbors=4, p=1, weights='distance')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Setting 1:\n",
    "* kNN classifier by default\n",
    "* No log transformation\n",
    "* No scaling\n",
    "* No data over-sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===> Start kfold <===\n",
      "=> Fold :  1\n",
      "=> Fold :  2\n",
      "=> Fold :  3\n",
      "=> Fold :  4\n",
      "F1 mean :0.7601\n",
      "F1 std : 0.0285\n",
      "F1 95% Confidence Interval +/- 0.0571\n",
      "\n",
      "Recall mean :0.6829\n",
      "Recall std : 0.0489\n",
      "Recall 95% Confidence Interval +/- 0.0978\n",
      "\n",
      "Precision mean :0.8608\n",
      "Precision std : 0.0312\n",
      "Precision 95% Confidence Interval +/- 0.0625\n",
      "\n",
      "Balanced\n",
      "Accuracy mean :0.8324\n",
      "Balanced\n",
      "Accuracy std : 0.0229\n",
      "Balanced\n",
      "Accuracy 95% Confidence Interval +/- 0.0459\n",
      "\n"
     ]
    },
    {
     "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>feature</th>\n",
       "      <th>importance</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>churnLOC</td>\n",
       "      <td>0.138166</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>AddLOC</td>\n",
       "      <td>0.108535</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NoNAB</td>\n",
       "      <td>0.094855</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>NonCE</td>\n",
       "      <td>0.087144</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>AddF</td>\n",
       "      <td>0.073445</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>DelLOC</td>\n",
       "      <td>0.070294</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>NoCnII</td>\n",
       "      <td>0.047870</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>DelF</td>\n",
       "      <td>0.043676</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>NoCE</td>\n",
       "      <td>0.042460</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>NoCII</td>\n",
       "      <td>0.040505</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>AddLGM</td>\n",
       "      <td>0.033299</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>DiP</td>\n",
       "      <td>0.032147</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>NoMGM</td>\n",
       "      <td>0.031677</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NoC</td>\n",
       "      <td>0.026600</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>ChurnGM</td>\n",
       "      <td>0.024444</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>ICT</td>\n",
       "      <td>0.023939</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>NoInEI</td>\n",
       "      <td>0.018201</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NoAB</td>\n",
       "      <td>0.013802</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>NoIEI</td>\n",
       "      <td>0.013727</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>DelLGM</td>\n",
       "      <td>0.012676</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>AddSAM</td>\n",
       "      <td>0.009484</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>ChurnSAM</td>\n",
       "      <td>0.008186</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>DelSAM</td>\n",
       "      <td>0.004868</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     feature  importance\n",
       "15  churnLOC    0.138166\n",
       "13    AddLOC    0.108535\n",
       "2      NoNAB    0.094855\n",
       "6      NonCE    0.087144\n",
       "16      AddF    0.073445\n",
       "14    DelLOC    0.070294\n",
       "4     NoCnII    0.047870\n",
       "17      DelF    0.043676\n",
       "5       NoCE    0.042460\n",
       "3      NoCII    0.040505\n",
       "9     AddLGM    0.033299\n",
       "21       DiP    0.032147\n",
       "12     NoMGM    0.031677\n",
       "0        NoC    0.026600\n",
       "11   ChurnGM    0.024444\n",
       "22       ICT    0.023939\n",
       "7     NoInEI    0.018201\n",
       "1       NoAB    0.013802\n",
       "8      NoIEI    0.013727\n",
       "10    DelLGM    0.012676\n",
       "18    AddSAM    0.009484\n",
       "20  ChurnSAM    0.008186\n",
       "19    DelSAM    0.004868"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier = KNeighborsClassifier()\n",
    "classifier = RandomForestClassifier(random_state=0)\n",
    "\n",
    "df = pd.read_csv(\"merged_2_annotated.csv\")\n",
    "y = get_labels(df)\n",
    "\n",
    "clean_dataframe(df)\n",
    "\n",
    "X = df\n",
    "\n",
    "scores_setting_1 = stratifiedKFold_scoring(classifier,X,y)\n",
    "\n",
    "classifier.fit(X,y)\n",
    "# check Important features\n",
    "feature_importances_df = pd.DataFrame(\n",
    "    {\"feature\": list(X.columns), \"importance\": classifier.feature_importances_}\n",
    ").sort_values(\"importance\", ascending=False)\n",
    "\n",
    "# Display\n",
    "feature_importances_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Setting 2:\n",
    "* kNN classifier by default\n",
    "* No log transformation\n",
    "* No data over-sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['NoC', 'NoAB', 'NoNAB', 'NoCII', 'NoCnII', 'NoCE', 'NonCE', 'NoInEI',\n",
      "       'NoIEI', 'AddLGM', 'DelLGM', 'ChurnGM', 'NoMGM', 'AddLOC', 'DelLOC',\n",
      "       'churnLOC', 'AddF', 'DelF', 'AddSAM', 'DelSAM', 'ChurnSAM', 'DiP',\n",
      "       'ICT'],\n",
      "      dtype='object')\n",
      "===> Start kfold <===\n",
      "=> Fold :  1\n",
      "=> Fold :  2\n",
      "=> Fold :  3\n",
      "=> Fold :  4\n",
      "F1 mean :0.7591\n",
      "F1 std : 0.0229\n",
      "F1 95% Confidence Interval +/- 0.0458\n",
      "\n",
      "Recall mean :0.6933\n",
      "Recall std : 0.0389\n",
      "Recall 95% Confidence Interval +/- 0.0777\n",
      "\n",
      "Precision mean :0.8412\n",
      "Precision std : 0.0327\n",
      "Precision 95% Confidence Interval +/- 0.0654\n",
      "\n",
      "Balanced\n",
      "Accuracy mean :0.8359\n",
      "Balanced\n",
      "Accuracy std : 0.0182\n",
      "Balanced\n",
      "Accuracy 95% Confidence Interval +/- 0.0363\n",
      "\n"
     ]
    }
   ],
   "source": [
    "scaler = MinMaxScaler(feature_range=(-1,1))\n",
    "classifier = KNeighborsClassifier()\n",
    "classifier = RandomForestClassifier(criterion='gini', max_depth=None, max_features='log2', random_state=0, n_estimators=75)\n",
    "\n",
    "\n",
    "df = pd.read_csv(\"merged_2_annotated.csv\")\n",
    "y = get_labels(df)\n",
    "\n",
    "#log_dataframe(df)\n",
    "clean_dataframe(df)\n",
    "\n",
    "X = df\n",
    "#X_scaled = scaling(scaler, X)\n",
    "print(df.columns)\n",
    "\n",
    "scores_setting_2 = stratifiedKFold_scoring(classifier,X,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Setting 3:\n",
    "* kNN classifier by default\n",
    "* Log transformation\n",
    "* No data over-sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===> Start kfold <===\n",
      "=> Fold :  1\n",
      "=> Fold :  2\n",
      "=> Fold :  3\n",
      "=> Fold :  4\n",
      "F1 mean :0.7654\n",
      "F1 std : 0.0555\n",
      "F1 95% Confidence Interval +/- 0.1111\n",
      "\n",
      "Recall mean :0.7033\n",
      "Recall std : 0.0633\n",
      "Recall 95% Confidence Interval +/- 0.1267\n",
      "\n",
      "Precision mean :0.8411\n",
      "Precision std : 0.0549\n",
      "Precision 95% Confidence Interval +/- 0.1098\n",
      "\n",
      "Balanced\n",
      "Accuracy mean :0.8409\n",
      "Balanced\n",
      "Accuracy std : 0.0339\n",
      "Balanced\n",
      "Accuracy 95% Confidence Interval +/- 0.0678\n",
      "\n"
     ]
    }
   ],
   "source": [
    "scaler = MinMaxScaler(feature_range=(-1,1))\n",
    "classifier = KNeighborsClassifier()\n",
    "classifier = RandomForestClassifier(criterion='gini', max_depth=None, max_features='log2', random_state=0, n_estimators=75)\n",
    "\n",
    "\n",
    "df = pd.read_csv(\"merged_2_annotated.csv\")\n",
    "y = get_labels(df)\n",
    "\n",
    "log_dataframe(df)\n",
    "clean_dataframe(df)\n",
    "\n",
    "X = df\n",
    "X_scaled = scaling(scaler, X)\n",
    "\n",
    "scores_setting_3 = stratifiedKFold_scoring(classifier,X_scaled,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Setting 4:\n",
    "* kNN classifier optimized by Grid-Search\n",
    "* Log transformation\n",
    "* No data over-sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===> Start kfold <===\n",
      "=> Fold :  1\n",
      "=> Fold :  2\n",
      "=> Fold :  3\n",
      "=> Fold :  4\n",
      "F1 mean :0.7654\n",
      "F1 std : 0.0555\n",
      "F1 95% Confidence Interval +/- 0.1111\n",
      "\n",
      "Recall mean :0.7033\n",
      "Recall std : 0.0633\n",
      "Recall 95% Confidence Interval +/- 0.1267\n",
      "\n",
      "Precision mean :0.8411\n",
      "Precision std : 0.0549\n",
      "Precision 95% Confidence Interval +/- 0.1098\n",
      "\n",
      "Balanced\n",
      "Accuracy mean :0.8409\n",
      "Balanced\n",
      "Accuracy std : 0.0339\n",
      "Balanced\n",
      "Accuracy 95% Confidence Interval +/- 0.0678\n",
      "\n"
     ]
    }
   ],
   "source": [
    "scaler = MinMaxScaler(feature_range=(-1,1))\n",
    "classifier = KNeighborsClassifier(algorithm='ball_tree', n_neighbors=4, p=1, weights='distance')\n",
    "classifier = RandomForestClassifier(criterion='gini', max_depth=None, max_features='log2', random_state=0, n_estimators=75)\n",
    "\n",
    "df = pd.read_csv(\"merged_2_annotated.csv\")\n",
    "y = get_labels(df)\n",
    "\n",
    "log_dataframe(df)\n",
    "clean_dataframe(df)\n",
    "\n",
    "X = df\n",
    "X_scaled = scaling(scaler, X)\n",
    "\n",
    "scores_setting_4 = stratifiedKFold_scoring(classifier,X_scaled,y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Setting 5:\n",
    "* kNN classifier optimized by Grid-Search\n",
    "* Log transformation\n",
    "* Data over-sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===> Start kfold <===\n",
      "=> Fold :  1\n",
      "smote\n",
      "=> Fold :  2\n",
      "smote\n",
      "=> Fold :  3\n",
      "smote\n",
      "=> Fold :  4\n",
      "smote\n",
      "F1 mean :0.7887\n",
      "F1 std : 0.0265\n",
      "F1 95% Confidence Interval +/- 0.0529\n",
      "\n",
      "Recall mean :0.7446\n",
      "Recall std : 0.0354\n",
      "Recall 95% Confidence Interval +/- 0.0708\n",
      "\n",
      "Precision mean :0.8390\n",
      "Precision std : 0.0219\n",
      "Precision 95% Confidence Interval +/- 0.0438\n",
      "\n",
      "Balanced\n",
      "Accuracy mean :0.8607\n",
      "Balanced\n",
      "Accuracy std : 0.0182\n",
      "Balanced\n",
      "Accuracy 95% Confidence Interval +/- 0.0364\n",
      "\n"
     ]
    }
   ],
   "source": [
    "scaler = MinMaxScaler(feature_range=(-1,1))\n",
    "smote = KMeansSMOTE(sampling_strategy='minority', random_state=9090)\n",
    "#classifier = KNeighborsClassifier(algorithm='ball_tree', n_neighbors=4, p=1, weights='distance')\n",
    "#classifier = RandomForestClassifier(criterion='gini', max_depth=None, max_features='log2', n_estimators=150, random_state=9090)\n",
    "#classifier = RandomForestClassifier(random_state=0)\n",
    "classifier = RandomForestClassifier(criterion='gini', max_depth=None, max_features='log2', random_state=0, n_estimators=75)\n",
    "\n",
    "\n",
    "df = pd.read_csv(\"merged_2_annotated.csv\")\n",
    "y = get_labels(df)\n",
    "\n",
    "\n",
    "log_dataframe(df)\n",
    "clean_dataframe(df)\n",
    "\n",
    "X = df\n",
    "X_scaled = scaling(scaler, X)\n",
    "#X_scaled = X\n",
    "scores_setting_5 = stratifiedKFold_scoring(classifier,X_scaled,y,smote)\n",
    "pickle.dump(classifier, open(\"classifier_rf_model.pkl\", 'wb'))\n",
    "\n",
    "#print(scores_setting_5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x864 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(2, 2, figsize=(20, 12))\n",
    "\n",
    "scores_settings = [scores_setting_1, scores_setting_2, scores_setting_4,scores_setting_5]\n",
    "#scores_settings = [scores_setting_1, scores_setting_2, scores_setting_3,scores_setting_4, scores_setting_5]\n",
    "\n",
    "\n",
    "labels = ['Setting 1', 'Setting 2', 'Setting 3', 'Setting 4']\n",
    "#labels = ['Config 1', 'Config 2', 'Config 3', 'Config 4', 'Config 5']\n",
    "\n",
    "xtick_size = 18\n",
    "label_size = 18\n",
    "\n",
    "bars= []\n",
    "metrics = {\"F1\":\"F1-mesure\", \"Recall\":\"Rappel\", \n",
    "           \"Precision\":\"Précision\", \"Balanced\\nAccuracy\":\"Accuracy\"}\n",
    "metrics = {\"F1\":\"F1 measure\", \"Recall\":\"Recall\", \n",
    "           \"Precision\":\"Precision\", \"Balanced\\nAccuracy\":\"Accuracy\"}\n",
    "#colors=['#4b51d1','#694BD2', '#AE13A6', '#E60080', '#F70069']\n",
    "colors=['#694BD2', '#AE13A6', '#E60080', '#F70069']\n",
    "\n",
    "# \"nice\" if is_nice else \"not nice\"\n",
    "bar_index = 0\n",
    "for scores_setting in scores_settings :\n",
    "    j = 0\n",
    "    for metric in list(metrics.keys()):\n",
    "        results = scores_setting[metric]\n",
    "\n",
    "        n = len(labels)-4\n",
    "        index = np.arange(0, n * 2.0, 2.0)\n",
    "        bar_width = 0.45\n",
    "        opacity = 0.7\n",
    "        x = 1 if j > 1 else 0\n",
    "        y = j % 2\n",
    "\n",
    "        axs[x, y].grid(b=True, which='major', linestyle='-', zorder=0)\n",
    "        bars.append(axs[x, y].bar(bar_index, results[\"mean\"],\n",
    "                              bar_width,\n",
    "                              yerr=results[\"ci95\"], capsize=7, edgecolor='black',\n",
    "                              alpha=opacity, zorder=3, color=colors[bar_index])) #, , label=project[3:4], zorder=3))\n",
    "\n",
    "        # ax.set_xlabel('Settings')\n",
    "        axs[x, y].set_ylabel(metrics[metric], fontsize=label_size)\n",
    "        # axs[x, y].set_ylabel(metric, fontsize=label_size)\n",
    "        axs[x, y].set_ylim(0.50,1.05)\n",
    "\n",
    "        # ax.set_title('Milan v/s Inter v/s Juventus')\n",
    "        axs[x, y].set_xticks(index + bar_width + 0.25)\n",
    "        axs[x, y].set_yticks(np.arange(0.50, 1.02, 0.05))\n",
    "        axs[x, y].set_xticks(range(0, len(labels)))\n",
    "        axs[x, y].set_xticklabels(labels)\n",
    "        axs[x, y].tick_params(axis='both', which='major', labelsize=xtick_size)\n",
    "        #axs[x, y].tick_params(axis='both', which='minor', labelsize=16)\n",
    "        #axs[x, y].legend(ncol=1)\n",
    "        #plt.setp(axs[x, y].get_legend().get_texts(), fontsize='18')\n",
    "\n",
    "        j += 1\n",
    "    bar_index += 1\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}