Classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data management\n",
    "import pandas as pd\n",
    "\n",
    "# Data preprocessing and trasformation (ETL)\n",
    "from sklearn.experimental import enable_iterative_imputer\n",
    "from sklearn.impute import SimpleImputer, IterativeImputer\n",
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler, MaxAbsScaler, FunctionTransformer, Binarizer, OneHotEncoder, OrdinalEncoder\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.datasets import fetch_openml, load_iris, make_moons, make_classification\n",
    "\n",
    "\n",
    "# Math and Stat modules\n",
    "import numpy as np\n",
    "from scipy.stats import sem\n",
    "from random import choice\n",
    "\n",
    "# Supervised Learning\n",
    "from sklearn.model_selection import train_test_split, cross_val_score, cross_val_predict, KFold, StratifiedKFold, RepeatedKFold, ShuffleSplit, StratifiedShuffleSplit, learning_curve, validation_curve\n",
    "from sklearn.linear_model import Perceptron, LogisticRegression\n",
    "from sklearn.base import BaseEstimator\n",
    "from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score, precision_recall_curve, roc_curve\n",
    "from sklearn.dummy import DummyClassifier\n",
    "from sklearn.multiclass import OneVsOneClassifier, OneVsRestClassifier\n",
    "\n",
    "# Unsupervised Learning\n",
    "\n",
    "# Visualization\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prepariamo velocemente i dati"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "credit_card_data = pd.read_csv('BankChurnersMissingData.csv')\n",
    "credit_card_data.dropna(subset=['Total_Revolving_Bal','Months_Inactive_12_mon'],\n",
    "                   inplace=True\n",
    "                  )\n",
    "\n",
    "# Estraggo la  colonna delle label e la rimuovo dal dataset\n",
    "credit_card_label = credit_card_data['Attrition_Flag'].map(\n",
    "    {'Existing Customer':0,\n",
    "     'Attrited Customer':1\n",
    "    }\n",
    ").values\n",
    "credit_card_data.drop(columns=['Attrition_Flag',\n",
    "                               'CLIENTNUM',\n",
    "                               'Naive_Bayes_Classifier_Attrition_Flag_Card_Category_Contacts_Count_12_mon_Dependent_count_Education_Level_Months_Inactive_12_mon_2',\n",
    "                               'Naive_Bayes_Classifier_Attrition_Flag_Card_Category_Contacts_Count_12_mon_Dependent_count_Education_Level_Months_Inactive_12_mon_1'],\n",
    "                      inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unknown_imputer(X, missing_value = 'Unknown'):\n",
    "    X = X.values\n",
    "    unique_values, count = np.unique(X,return_counts=True)\n",
    "    num_nan = count[unique_values == missing_value]\n",
    "    counting = count[unique_values != missing_value]\n",
    "    values = unique_values[unique_values != missing_value]\n",
    "    X_new = X.copy()\n",
    "    freq = counting / np.sum(counting)\n",
    "    X_new[X_new == missing_value] = np.random.choice(values,size=num_nan,p=freq)\n",
    "    return X_new\n",
    "\n",
    "ui = FunctionTransformer(unknown_imputer)\n",
    "\n",
    "customer_age_pipeline = Pipeline([\n",
    "    ('imputer', SimpleImputer(strategy='median')),\n",
    "    ('scaler', StandardScaler())\n",
    "])\n",
    "\n",
    "category_pipeline = Pipeline([\n",
    "    ('imputer', FunctionTransformer(unknown_imputer)),\n",
    "    ('ordinal', OneHotEncoder())\n",
    "])\n",
    "\n",
    "features_robust = ['Credit_Limit','Total_Revolving_Bal','Avg_Open_To_Buy']\n",
    "features_standard = list(set(credit_card_data.select_dtypes(include=['int64','float64']).columns).difference(set(features_robust + ['Avg_Utilization_Ratio', 'Customer_Age'])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_preprocessing = ColumnTransformer([\n",
    "    ('age', customer_age_pipeline, ['Customer_Age']),\n",
    "    ('gender', OrdinalEncoder(categories=[['M','F']]), ['Gender']),\n",
    "    ('edu', category_pipeline, ['Education_Level']),\n",
    "    ('status', category_pipeline, ['Marital_Status']),\n",
    "    ('income', category_pipeline, ['Income_Category']),\n",
    "    ('card', category_pipeline, ['Card_Category']),\n",
    "    ('numeric_robust', RobustScaler(), features_robust),\n",
    "    ('feature_standard', StandardScaler(), features_standard)\n",
    "],\n",
    "    remainder = 'passthrough'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_matrix = data_preprocessing.fit_transform(credit_card_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "columns_name = ['Customer_Age','Gender']\n",
    "for c in ['Education_Level','Marital_Status','Income_Category']:\n",
    "    cat_inc_name = [c+'_cat{}'.format(i) for i in range(1,len(credit_card_data[c].unique()))]\n",
    "    columns_name.extend(cat_inc_name)\n",
    "columns_name.extend(['Card_Category_cat{}'.format(i) for i in range(1,len(credit_card_data['Card_Category'].unique())+1)])\n",
    "columns_name.extend(features_robust)\n",
    "columns_name.extend(features_standard)\n",
    "columns_name.append('Avg_Utilization_Ratio')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classificazione\n",
    "\n",
    "Ora siamo pronti per addestrare un modello ML e lo potremmo fare piuttosto facilmente grazie al fatto che abbiamo gia' preparato i dati e alla struttura di SKL.\n",
    "\n",
    "Iniziamo ad addestrare un Perceptron."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Perceptron()"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perceptron = Perceptron()\n",
    "perceptron.fit(feature_matrix, credit_card_label)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vediamo come si comporta con alcuni elementi del training set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 True label: 0 vs Predicted Label: 0\n",
      "1 True label: 0 vs Predicted Label: 0\n",
      "2 True label: 0 vs Predicted Label: 0\n",
      "3 True label: 0 vs Predicted Label: 0\n",
      "4 True label: 0 vs Predicted Label: 0\n",
      "5 True label: 0 vs Predicted Label: 0\n",
      "6 True label: 0 vs Predicted Label: 0\n",
      "7 True label: 0 vs Predicted Label: 0\n",
      "8 True label: 0 vs Predicted Label: 0\n",
      "9 True label: 0 vs Predicted Label: 0\n"
     ]
    }
   ],
   "source": [
    "sample_training = feature_matrix[:10,:]\n",
    "sample_labels = credit_card_label[:10]\n",
    "prediction_sample = perceptron.predict(sample_training)\n",
    "for i in range(len(sample_labels)):\n",
    "    print(i,'True label: {} vs Predicted Label: {}'.format(sample_labels[i],prediction_sample[i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un risultato che potrebbe sembrare incoraggiante...\n",
    "\n",
    "Proviamo a contare quante volte sbaglio su un set di dati gia' visto...\n",
    "\n",
    "E' fondamentale, infatti, determinare/stimare le performance del modello su un insieme di dati mai visto prima. In precedenza non abbiamo "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_predicted = perceptron.predict(feature_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8961975308641975"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(all_predicted == credit_card_label)/len(all_predicted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Non sembra male, ma ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8393086419753086"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_predicted_dummy = np.zeros(len(credit_card_label))\n",
    "np.sum(all_predicted_dummy == credit_card_label)/len(all_predicted_dummy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il perceptron performance un po' meglio di un modello \"in tilt\",i.e un modello che predice sempre la classe piu' frequente.\n",
    "\n",
    "Questa piccola differenza di performance ci permette di introdurre alcune trappole in cui siamo caduti. \n",
    "1) La valutazione delle performance deve essere effettuata su dati non ancora 'visti' dall'algoritmo di apprendimento (errore metodologico)\n",
    "2) La valutazione deve tenere conto del bilanciamento o meno delle classi\n",
    "\n",
    "In questa fase, esploriamo il **primo** problema."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cross-validation\n",
    "Le metodologie di cross-validation possono essere utili per ottenere delle valutazioni piu' attendibili circa le proprieta' di generalizzazione del modello appreso, cioe' quanto il modello sara' in grado di predirre correttamente la classe di appartenenza su dati non ancora osservati.\n",
    "\n",
    "Per prevenire il primo errore, e  di conseguenza l'overfitting dei dati, una pratica comune e' **holdout cross-validation**. Si divide il dataset in due insiemi distinti: training e test dataset. Il primo e' usato per l'addestramento del modello, il secondo per la valutazione delle performance e la valutazione delle capacita' di generalizzazione.\n",
    "\n",
    "Un raffinamento del precedente schema e' l'utilizzo di un terzo insieme: **validation set**, grazie al quale viene fatto una model selection, i.e. vengono identificati l'insieme degli iperparametri ottimali. <br>\n",
    "In questo modo ho il vantaggio di non utilizzare il test set nella fase di learning riducendo il bias sulla stima della capacita' di generalizzare su nuovi dati.\n",
    "\n",
    "Il modo in cui gli insiemi vengono partizionati influenza la stima delle performance.<br>\n",
    "Per aumentare la robustezza della stima possiamo utilizzare **k-fold cross validation**.\n",
    "\n",
    "Prima, pero', vediamo come fare holdout cross-validation in SKL. SKL mette a disposizione il metodo **train_test_split** che mi restituisce una partizione in training e test sia della matrice delle feature sia del vettore delle label. E' possibile specificare la frazione di elementi che costituiscono i due insiemi.\n",
    "\n",
    "Nel nostro caso, il training set e' costituito dal 70% del campione."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(feature_matrix, credit_card_label, test_size=0.3, random_state=45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((7087, 33), (7087,), (3038, 33), (3038,))"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape, y_train.shape, X_test.shape, y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8624094799210007"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perceptron.fit(X_train, y_train)\n",
    "predicted_test = perceptron.predict(X_test)\n",
    "np.sum(predicted_test == y_test)/len(y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nella k-fold cross-validatin - k-fold CV - il training set viene suddiviso in $k$ sottoinsiemi disgiunti - *fold* , dove ogni fold:\n",
    "1) i rimanenti $k-1$ fold sono utilizzati come training set\n",
    "2) il modello addestrato sui $k-1$ fold viene valutato sulla parte rimanente del dataset.\n",
    "\n",
    "In questo modo si ottengono $k$ modelli e $k$ misure di performance diverse. Si calcola, quindi una media delle performance. Una volta selezionato l'insieme degli iperparametri migliori, si riaddestra il modello sul training set completo e si effettua la valutazione del test set.\n",
    "\n",
    "![](kfold-cross_validation.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attraverso il metodo **cross_val_score** possiamo usare direttamente k-CV e ottenere le misure di performance per ogni fold.\n",
    "\n",
    "Solitamente come valore da assegnare a $k$ si usa 5 o 10, a seconda della dimensione del dataset. In SKL, se $K$ e' un intero vengono utilizzate le classi **KFold** o **StratifiedKFold**, come strategie di partizionamento di default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.77715092, 0.74471086, 0.85754584, 0.85472496, 0.84062059,\n",
       "       0.85895628, 0.77291961, 0.82485876, 0.85028249, 0.88276836])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perceptron_score = cross_val_score(perceptron, X_train, y_train, cv = 10)\n",
    "perceptron_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Accuracy media: 0.826'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Accuracy media: {:0.3f}'.format(np.mean(perceptron_score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Approfondiremo le misure di performance in seguito.\n",
    "\n",
    "Come vedremo il parametro **cv** ammette tipo di dato diverso, in modo da specificare quale strategia di divisione del set utilizzare in forma di classi SKL o iterable su un insieme di indici."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una funzione simile a *cross_val_score* e' **cross_val_predict**. Restituisce per ogni elemento nel training set, la label predetta quando quell'elemento era nel fold di test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicted_in_fold = cross_val_predict(perceptron, X_train, y_train, cv = 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cross Validation Iterators\n",
    "La generazione delle fold dipende fortemente dal meto di partizionamento/campionamento adottato e dalle assunzioni sul tipo di dato presente nel dataset.\n",
    "\n",
    "Se assumiamo che i dati siano i.i.d.  - indipendenti e identicamente distribuiti - il processo generativo dei dati e' uno e non ha memoria dei dati generati in passato. In questo caso possiamo utilizzare:\n",
    "- k-fold\n",
    "- Repeated k-fold\n",
    "- LOO\n",
    "- LPO\n",
    "- Shuffle and Split\n",
    "\n",
    "La classe **KFold** implementa il k-fold splitting della k-fold CV. Vedi https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.KFold.html#sklearn.model_selection.KFold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.79407616, 0.88575458, 0.87023977, 0.86036671, 0.87588152,\n",
       "       0.8561354 , 0.87588152, 0.8559322 , 0.88135593, 0.87288136])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kf = KFold(n_splits = 10)\n",
    "perceptron_score = cross_val_score(perceptron, X_train, y_train, cv = kf)\n",
    "perceptron_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mediante il metodo **split** posso ottenere l'insieme dei fold di training e il fold di test, espressi come indici della feature matrix. In sostanza indica quali righe inserire nel fold di training e quali inseire nel fold di test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6378, 33) (709,)\n",
      "(6378, 33) (709,)\n",
      "(6378, 33) (709,)\n",
      "(6378, 33) (709,)\n",
      "(6378, 33) (709,)\n",
      "(6378, 33) (709,)\n",
      "(6378, 33) (709,)\n",
      "(6379, 33) (708,)\n",
      "(6379, 33) (708,)\n",
      "(6379, 33) (708,)\n"
     ]
    }
   ],
   "source": [
    "for train, test in kf.split(X_train, y_train):\n",
    "    print(X_train[train,:].shape, y_train[test].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Possiamo notare come nell'esempio precedente sul perceptron, i valori di performance possono oscillare ed influenzare la performance media. \n",
    "\n",
    "Una soluzione per ridurre l'effetto delle oscillazioni nel calcolo della performance media e' ripetere la k-fold CV per diverse volte e riportare la performance media calcolata su tutti i fold di tutte le ripetizioni. Ovviamente, il partizionamento tra due ripetizioni non e' lo stesso.<br>\n",
    "Questo approccio e' utile con dataset di piccola/media dimensione e che non richiedono un elevato costo di computazione nella fase di training, anche se e' facile parallelizzare il processo (SKL lo fa di default)\n",
    "\n",
    "SKL fornisce un'implementazione di tale metodo mediante la classe **RepeatedKFold** (https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.RepeatedKFold.html#sklearn.model_selection.RepeatedKFold). Si devono specificare i valori di $K$ e il numero di ripetizioni *n_repeats*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.84062059, 0.85472496, 0.82369535, 0.87729196, 0.84344147,\n",
       "       0.82651622, 0.87588152, 0.88276836, 0.86440678, 0.80932203,\n",
       "       0.88011283, 0.86882934, 0.89844852, 0.87023977, 0.85049365,\n",
       "       0.89562764, 0.88575458, 0.85028249, 0.89548023, 0.80367232,\n",
       "       0.88857546, 0.79689704, 0.82228491, 0.86459803, 0.86600846,\n",
       "       0.87023977, 0.89139633, 0.75988701, 0.89265537, 0.84039548])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rkf = RepeatedKFold(n_splits = 10, n_repeats=3)\n",
    "perceptron_score = cross_val_score(perceptron, X_train, y_train, cv = rkf, n_jobs=-1)\n",
    "perceptron_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da notare il parametro *n_jobs* tramite cui specifico quanti core utilizzare in parallelo per eseguire CV.\n",
    "\n",
    "E' possibile anche valutare l'effetto del numero di ripetizioni sulle performance medie del classificatore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">1 mean=0.8715 se=0.006\n",
      ">2 mean=0.8705 se=0.004\n",
      ">3 mean=0.8655 se=0.004\n",
      ">4 mean=0.8576 se=0.005\n",
      ">5 mean=0.8593 se=0.004\n",
      ">6 mean=0.8613 se=0.004\n",
      ">7 mean=0.8632 se=0.003\n",
      ">8 mean=0.8624 se=0.003\n",
      ">9 mean=0.8628 se=0.003\n",
      ">10 mean=0.8623 se=0.003\n",
      ">11 mean=0.8625 se=0.003\n",
      ">12 mean=0.8632 se=0.003\n",
      ">13 mean=0.8638 se=0.002\n",
      ">14 mean=0.8645 se=0.002\n",
      ">15 mean=0.8647 se=0.002\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def valuta_modello_ripetizione(X, y, repeats):\n",
    "    cv = RepeatedKFold(n_splits=10, n_repeats=repeats, random_state=1)\n",
    "    model = Perceptron()\n",
    "    scores = cross_val_score(model, X, y, cv=cv, n_jobs=-1)\n",
    "    return scores\n",
    "\n",
    "repeats = range(1,16)\n",
    "results = list()\n",
    "for r in repeats:\n",
    "    scores = valuta_modello_ripetizione(feature_matrix, credit_card_label, r)\n",
    "    print('>{} mean={:.4f} se={:.3f}'.format(r, np.mean(scores), sem(scores)))\n",
    "    results.append(scores)\n",
    "# plot the results\n",
    "plt.boxplot(results, labels=[str(r) for r in repeats], showmeans=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sempre nel setting iid, possiamo generare un insieme di split training/test in cui viene violata la condizione di insieme disgiunto tra le fold. In questo caso appliciamo una random permutation CV.\n",
    "\n",
    "In SKL tale strategia e' fornita dalla classe **ShuffleSplit**. Per ogni iterazione - splitting, la feature matrix viene permutata e una sua frazione di righe viene assegnata al test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8525984185040867"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spf = ShuffleSplit(n_splits = 10, test_size = 0.25)\n",
    "perceptron_score = cross_val_score(perceptron, X_train, y_train, cv = rkf, n_jobs=-1)\n",
    "perceptron_score.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In questo modo si ha un controllo maggiore sulla porzione di elementi nel test e si perde la dipendenza tra $k$ e *test_size*\n",
    "\n",
    "#### Stratification\n",
    "In alcuna situazione assistiamo - come nel nostro caso - ad un forrte sbilanciamento nella distribuzione delle classi nel vettore delle label. In questi casi si raccomanda di utilizzare un campionamento stratitificato implementato dalle classi SKL **StratifiedKFold** e **StratifiedShuffleSplit**. Tali classi assicurano che la distribuzione delle etichette in ogni fold approssimi quella dell'intero vettore delle etichette\n",
    "\n",
    "Nel caso di StratifiedKFold avremo la suddivisione in figura:\n",
    "![](stratified_kfold_cv.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----K-fold CV----------\n",
      "Train: 0.17 vs Test: 0.10\n",
      "Train: 0.17 vs Test: 0.07\n",
      "Train: 0.17 vs Test: 0.05\n",
      "Train: 0.16 vs Test: 0.14\n",
      "Train: 0.16 vs Test: 0.21\n",
      "Train: 0.15 vs Test: 0.21\n",
      "Train: 0.16 vs Test: 0.21\n",
      "Train: 0.16 vs Test: 0.20\n",
      "Train: 0.16 vs Test: 0.15\n",
      "Train: 0.15 vs Test: 0.25\n",
      "----Stratified K-fold CV-------\n",
      "Train: 0.16 vs Test: 0.16\n",
      "Train: 0.16 vs Test: 0.16\n",
      "Train: 0.16 vs Test: 0.16\n",
      "Train: 0.16 vs Test: 0.16\n",
      "Train: 0.16 vs Test: 0.16\n",
      "Train: 0.16 vs Test: 0.16\n",
      "Train: 0.16 vs Test: 0.16\n",
      "Train: 0.16 vs Test: 0.16\n",
      "Train: 0.16 vs Test: 0.16\n",
      "Train: 0.16 vs Test: 0.16\n"
     ]
    }
   ],
   "source": [
    "kf = KFold(n_splits=10)\n",
    "skf = StratifiedKFold(n_splits=10)\n",
    "print('----K-fold CV----------')\n",
    "for train, test in kf.split(feature_matrix, credit_card_label):\n",
    "    y_train, y_test = credit_card_label[train], credit_card_label[test]\n",
    "    print('Train: {:.2f} vs Test: {:.2f}'.format(sum(y_train == 1)/len(y_train), sum(y_test == 1)/len(y_test)))\n",
    "print('----Stratified K-fold CV-------')\n",
    "for train, test in skf.split(feature_matrix, credit_card_label):\n",
    "    y_train, y_test = credit_card_label[train], credit_card_label[test]\n",
    "    print('Train: {:.2f} vs Test: {:.2f}'.format(sum(y_train == 1)/len(y_train), sum(y_test == 1)/len(y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo stesso principio si applica alla metodologia di shuffle and split:\n",
    "![](stratified_shufflesplit_cv.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance Measure for Classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Viste le diverse strategie di cross-validation, affrontiamo un secondo argomento essenziale: le misure di performance.\n",
    "\n",
    "Abbiamo gia' visto che il perceptron utilizzato in precedenza non era meglio di un classificatore che prediceva sempre l'etichetta piu' frequente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "mf_dumb_cls = DummyClassifier(strategy='most_frequent')\n",
    "uni_dumb_cls = DummyClassifier(strategy='uniform')\n",
    "st_dumb_cls = DummyClassifier(strategy='stratified')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(feature_matrix, credit_card_label, test_size=0.3, random_state=45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8388599364107957"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pappagallo_score = cross_val_score(mf_dumb_cls, X_train, y_train, cv=10, scoring='accuracy')\n",
    "pappagallo_score.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cio' mostra come l'accuracy non e' una buona misura di performance, specialmente quando il vettore delle etichette e' sbilanciato.\n",
    "\n",
    "Un modo migliore per valutare le performance di un classificatore e' la **confusion matrix** $C$. L'elemento $C_{ij}$ della matrice corrisponde al numero di osservazioni che hanno etichetta $i$ e che sono state classificate con etichetta $j$. Nel caso di classificazione binario:\n",
    "1) $C_{00}$ = veri negativi\n",
    "2) $C_{01}$ = falsi positivi\n",
    "3) $C_{10}$ = falsi negativi\n",
    "4) $C_{11}$ = veri positivi\n",
    "\n",
    "Per calcolare la confusion matrix, necessitiamo di:\n",
    "1) il vettore delle etichette\n",
    "2) il vettore delle etichette predette\n",
    "\n",
    "Per ottenere il secondo elemento possiamo utilizzare il metodo  *cross_val_predict*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train_predicted = cross_val_predict(perceptron, X_train, y_train, cv = 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Infine per calcolare la confusion matrix utilizziamo il metodo **confusion matrix**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5252,  693],\n",
       "       [ 537,  605]], dtype=int64)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix(y_train, y_train_predicted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ogni riga corrisponde ad una classe _attuale_, mentre ogni colonna una _classe predetta_.\n",
    "\n",
    "Dalla matrice di confusione posso calcolare l'accuratezza delle predizioni positive, i.e. la **precision**:\n",
    "$$precision = \\frac{C_{11}}{C_{11} + C_{01}} = \\frac{TP}{TP + FP}$$\n",
    "\n",
    "a cui si accompagna un'altra metrica: la **recall** o **sensitivity** o **true positive rate**:\n",
    "$$recall = \\frac{C_{11}}{C_{11} + C_{10}} = \\frac{TP}{TP + FN}$$\n",
    "\n",
    "In SKL precision e recall sono restituite dai metodi **precision_score** e **recall_score**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4661016949152542"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_score(y_train, y_train_predicted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5297723292469352"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train, y_train_predicted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vediamo le differenze confrontandoci con i due dummy classifier definiti in precedenza"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train_mfdumb = cross_val_predict(mf_dumb_cls, X_train, y_train, cv = 10)\n",
    "y_train_unidumb = cross_val_predict(uni_dumb_cls, X_train, y_train, cv = 10)\n",
    "y_train_stdumb = cross_val_predict(st_dumb_cls, X_train, y_train, cv = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\matte\\miniconda3\\envs\\CSML21\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1245: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.0, 0.1635898892360125, 0.14904679376083188)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_score(y_train,y_train_mfdumb), precision_score(y_train, y_train_unidumb), precision_score(y_train, y_train_stdumb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nel caso di dummy che predice la singola classe piu' frequente, la colonna nella confusion matrix relativa alla classe 1 e' composta da 0 => 0/0. Nei rimanenti casi, si puo' intuire il risultato se pensiamo al processo di classificazione implementato come una selezione. Nel caso predica 1, seleziono l'elemento del campione e mi chiedo quale sia la sua etichetta. In entrambi i casi vengono rispettate le proporzioni della classe nel campione originario. In un caso seleziono meno elementi (stratified), perche' le etichette sono sbilanciate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 0.5043782837127846, 0.15061295971978983)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train,y_train_mfdumb), recall_score(y_train, y_train_unidumb), recall_score(y_train, y_train_stdumb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nel primo caso la recall e' 0 perche' $C_{11}=0$. Per spiegare i rimanenti risultati, si selezionano i campioni con etichetta vera = 1, nel caso uniforme ottengo il 50% di elementi con etichetta 1, nel caso stratified ottengo solo il 16% con etichetta 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[3000, 2945],\n",
       "        [ 566,  576]], dtype=int64),\n",
       " array([[4963,  982],\n",
       "        [ 970,  172]], dtype=int64))"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix(y_train, y_train_unidumb), confusion_matrix(y_train, y_train_stdumb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sia in recall che precision, il perceptron si comporta leggermente meglio di un random guesser.\n",
    "\n",
    "In generale *una soluzione basata su perceptron non e' affidabile nel caso mi segnali un cliente 'in uscita', e neanche in grado di identificare un cliente 'in uscita'*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Per avere un modo semplice per confrontare due classificatori, viene spesso impiegato l'indicatore $F_{1}$, definito come la media armonica tra precision e recall. Penalizza un classificatore con precision e recall sbilanciate.\n",
    "$F_1 = \\frac{2}{\\frac{1}{precision}+\\frac{1}{recall}}$. Questo indicatore viene implementato dal metodo **f1_score**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Precision/Recall Tradeoff\n",
    "Utilizziamo ora un logit classifier per il problema dell'identificazione dei churner dal momento che restituisce anche un prediction score. Nel caso del classificatore in questione, corrisponde al valore prima della funzione di threshold, i.e. $\\phi(\\mathbf{w}^T\\mathbf{x})$. Esso indica la confidenza sulla classe predetta. In SKL un logit classifier e' implementato dalla classe **LogisticRegression**, il quale rende disponibile il metodo **decision_function** per ottenere gli score di confidenza associati ad ogni istanza predetta.\n",
    "\n",
    "In questo modo possiamo agire sulla funzione di soglia e modificare la predizione finale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "logit_cls = LogisticRegression(max_iter=1000)\n",
    "y_scores = cross_val_predict(logit_cls, X_train, y_train, cv = 10, method='decision_function')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dato gli score, possiamo utilizzare il metodo **precision_recall_curve** per calcolare precision e recall al variare del valori di soglia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "prec, rec, soglia = precision_recall_curve(y_train, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x24605f66580>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(12,8))\n",
    "ax = fig.add_subplot()\n",
    "ax.plot(soglia, prec[:-1], 'r',label='precision')\n",
    "ax.plot(soglia, rec[:-1], 'b',label='recall')\n",
    "ax.legend(fontsize=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oppure posso visualizzare la precision in funzione della recall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'precision')"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(12,8))\n",
    "ax = fig.add_subplot()\n",
    "ax.plot(rec[:-1], prec[:-1], 'r',label='precision', lw=5)\n",
    "ax.set_xlabel('recall')\n",
    "ax.set_ylabel('precision')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Questo tipo di analisi ci permette di scegliere il valore in base alle nostre esigenze. Per esempio se volessimo aumentare la fino a 0.9 ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.9002695417789758, 0.44150693985459355, 0.29246935201401053)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "soglia_prec_90 = soglia[np.argmax(prec >= 0.9)]\n",
    "y_train_prec_90 = y_scores >= soglia_prec_90\n",
    "precision_score(y_train, y_train_prec_90), f1_score(y_train, y_train_prec_90), recall_score(y_train, y_train_prec_90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ROC Curve\n",
    "La curva **Receiver operating characteristic - ROC** e' molto simile alla curva precision/recall ma visualizza la recall in funzione del **false positive rate**:\n",
    "$$FPR = \\frac{C_{01}}{C_{01}+C_{00}} = \\frac{FP}{FP+TN} = 1 - specificity$$\n",
    "Per visualizzare la curva ROC applichiamo lo stesso procedimento precedente utilizzo il metodo **roc_curve**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "fpr, rec, soglia = roc_curve(y_train, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x24605b00340>]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(12,7))\n",
    "ax = fig.add_subplot()\n",
    "ax.plot(fpr, rec, 'r',label='precision', lw=5)\n",
    "ax.plot()\n",
    "ax.set_xlabel('false positive rate')\n",
    "ax.set_ylabel('recall')\n",
    "ax.plot([0,1],[0,1],'k--')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All'aumentare della recall, aumenta la produzione di falsi positivi."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning and validation curve\n",
    "Learning e validation curve  sono altri semplici strumenti per la valutazione delle performance e l'identificazoine di problemi di overfitting o underfitting\n",
    "\n",
    "se un modello e' troppo complesso, il modello tende a overfittare sui dati e non generalizza bene. In questo caso puo' aiutare aumentare la dimensione del training set - molto spesso non e' una soluzione attuabile. In questo caso si possono visualizzare le accuracy del training e del validation set in funzione della dimensione del training set = *learning curve* \n",
    "\n",
    "![](bias-variance.png)\n",
    "\n",
    "Nel primo caso abbiamo un modello con un bias elevato in quanto TS e V accuracy sono rispetto al target -> passare ad un modello con meno assunzioni, oppure aumentare grado di liberta' del modello (cfr. regolarizzazione). In questo caso abbiamo underfitting.\n",
    "\n",
    "Nel secondo caso abbiamo un alta varianza, in quanto raggiungiamo l'accuracy \"possibile\" ma esiste un gap tra TS e V accuracy. In questo caso abbiamo overfitting -> collezionare piu' training data, ridurre la complessita' del modello o introdurre regolarizzazione, oppure feature selection.\n",
    "\n",
    "In SKL posso valutare la learning curve mediante il metodo **learning_curve**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "logit_cls = LogisticRegression(max_iter=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_sizes, train_scores, test_scores = learning_curve(logit_cls,\n",
    "                                                       X=feature_matrix,\n",
    "                                                       y=credit_card_label,\n",
    "                                                       train_sizes=np.linspace(0.1,1.0,10),\n",
    "                                                       cv=10,\n",
    "                                                       n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.6, 1.03)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_mean = np.mean(train_scores, axis=1)\n",
    "train_std = np.std(train_scores, axis=1)\n",
    "test_mean = np.mean(test_scores, axis=1)\n",
    "test_std = np.std(test_scores, axis=1)\n",
    "\n",
    "fig=plt.figure(figsize=(12,7))\n",
    "ax = fig.add_subplot()\n",
    "ax.plot(train_sizes, train_mean,\n",
    "         color='blue', marker='o',\n",
    "         markersize=5, label='Training accuracy')\n",
    "\n",
    "ax.fill_between(train_sizes,\n",
    "                 train_mean + train_std,\n",
    "                 train_mean - train_std,\n",
    "                 alpha=0.15, color='blue')\n",
    "\n",
    "ax.plot(train_sizes, test_mean,\n",
    "         color='green', linestyle='--',\n",
    "         marker='s', markersize=5,\n",
    "         label='Validation accuracy')\n",
    "\n",
    "ax.fill_between(train_sizes,\n",
    "                 test_mean + test_std,\n",
    "                 test_mean - test_std,\n",
    "                 alpha=0.15, color='green')\n",
    "\n",
    "ax.grid()\n",
    "ax.set_xlabel('Dimensione del training set')\n",
    "ax.set_ylabel('Accuracy')\n",
    "ax.legend(loc='lower right')\n",
    "ax.set_ylim([0.6, 1.03])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un ulteriore strumento di valutazione di problemi di over/under-fitting e' la **validation curve**. In questo caso, si varia il valore dei parametri del modello.\n",
    "\n",
    "Nel caso di LogisticRegression, il parametro $C$ e' l'inverso del parametro di regolarizzazione $\\lambda$. All'aumentare del valore di C, diminuisce l'effetto di regolarizzazione, diminuisco la varianza\n",
    "\n",
    "In SKL posso valutare la validation curve mediante il metodo **validation_curve**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "range_c = [0.001, 0.01, 0.1, 1, 10, 100]\n",
    "train_scores, test_scores = validation_curve(logit_cls,\n",
    "                                                       X=feature_matrix,\n",
    "                                                       y=credit_card_label,\n",
    "                                                        param_name='C',\n",
    "                                                        param_range = range_c,\n",
    "                                                       cv=10,\n",
    "                                                       n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 1.03)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_mean = np.mean(train_scores, axis=1)\n",
    "train_std = np.std(train_scores, axis=1)\n",
    "test_mean = np.mean(test_scores, axis=1)\n",
    "test_std = np.std(test_scores, axis=1)\n",
    "\n",
    "fig=plt.figure(figsize=(12,7))\n",
    "ax = fig.add_subplot()\n",
    "ax.plot(range_c, train_mean,\n",
    "         color='blue', marker='o',\n",
    "         markersize=5, label='Training accuracy')\n",
    "\n",
    "ax.fill_between(range_c,\n",
    "                 train_mean + train_std,\n",
    "                 train_mean - train_std,\n",
    "                 alpha=0.15, color='blue')\n",
    "\n",
    "ax.plot(range_c, test_mean,\n",
    "         color='green', linestyle='--',\n",
    "         marker='s', markersize=5,\n",
    "         label='Validation accuracy')\n",
    "\n",
    "ax.fill_between(range_c,\n",
    "                 test_mean + test_std,\n",
    "                 test_mean - test_std,\n",
    "                 alpha=0.15, color='green')\n",
    "\n",
    "ax.grid()\n",
    "ax.set_xlabel('Parametro C')\n",
    "ax.set_ylabel('Accuracy')\n",
    "ax.legend(loc='lower right')\n",
    "ax.set_ylim([0.6, 1.03])\n",
    "ax.set_xlim([0., 1.03])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In questo caso per valori di C superiori a 0.01, inizia un fenomeno di overfitting indicato da una differenza crescente tra accuracy nel training e accuracy nella validation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multiclass classification\n",
    "\n",
    "La classificazione multiclasse e' applicabile in un contesto in cui il label vector assume piu' di due valori discreti. Alcuni algoritmi di ML sono in grado di gestire un vettore multiclasse (Random Forest e Naive Bayes), mentre alcuni sono strettamente binari (SVM, Linear Classifier). In questo caso esistono una serie di strategie da applicare ad un problema di classificazione multiclasse utilizzando classificatori binari:\n",
    "1. OvA (one-versus-all): si addesstrano N classificatore, uno per ognuna delle N classi. Per ognuno degli N classificatori, si considera lo score di classificazione ottenuto, e si restituisce la classe associata allo score con valore massimo.\n",
    "2. OvO (one-versus-one): si addestrano $N(N-1)/2$ classficiatori, uno per ogni coppia di classi. Per classificare un nuovo campione, si applicano tutti i classificatori e si restituisce la classe che vince piu' round di classificazione.\n",
    "\n",
    "Dal punto di vista computazionale, il primo approccio e' piu' efficiente  - N contro $N^2$ - rispetto a OvO, tranne nel caso in cui l'algoritmo di apprendimento non e' efficiente in funzione del numero di campioni $M$. Nel caso di OvA, la complessita' e' $NM$, mentre nel caso di OvO la complessita' e' $(N-1)M$ nel caso di label vector bilanciato, tuttavia, in caso di architettura multi-core si possono apprendere i classificatori nel confronto OvO in modo parallelo.\n",
    "\n",
    "\n",
    "In SKL tutti i classificatori implementano nativamente la classificazione multiclass. Nel caso si volesse sperimentare con una soluzione diversa da quella di default il modulo **multiclass** rende disponibili due classi **OneVsRestClassifier** e **OneVsOneClassifier**, che rispettivamente implementano OvA e OvO. Il costruttore della classe accetta un qualsiasi oggetti di tipo classifier.\n",
    "\n",
    "Per questo tipo di classificazione utilizziamo il data MNIST, il quale contiene come campione delle immagini"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import fetch_openml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_instance(X):\n",
    "    size = X.shape[0]\n",
    "    return X[np.random.choice(np.arange(size))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_mnist, y_mnist = fetch_openml('mnist_784', version=1, return_X_y=True, as_frame=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "Xmnist_train, Xmnist_test, ymnist_train, ymnist_test = train_test_split(X_mnist, y_mnist, test_size = 0.15, random_state = 42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Perceptron()"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perceptron.fit(Xmnist_train, ymnist_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2']\n"
     ]
    }
   ],
   "source": [
    "random_digit = random_instance(Xmnist_train).reshape(28,28)\n",
    "plt.imshow(random_digit, cmap = mpl.cm.binary)\n",
    "plt.show()\n",
    "print(perceptron.predict(random_digit.reshape(1,-1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Posso ottenere tutti gli score delle varie classi utilizzando il metodo **decision_function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3.2003000e+04 -2.9099204e+07  7.8541000e+06 -5.5926160e+06\n",
      "  -3.2795274e+07 -2.0330052e+07 -2.3536049e+07 -2.7592749e+07\n",
      "  -1.3778729e+07 -1.6417443e+07]]\n"
     ]
    }
   ],
   "source": [
    "random_digit_scores = perceptron.decision_function(random_digit.reshape(1,-1))\n",
    "print(random_digit_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E controllare la classe con lo score maggiore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perceptron.classes_[np.argmax(random_digit_scores)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'], dtype='<U1'), 2)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "perceptron.classes_, np.argmax(random_digit_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizziamo ora la classe **OneVsOneClassifier** per creare una strategia di decisione dell'etichetta diversa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['2'], dtype=object)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ovo_clf = OneVsOneClassifier(Perceptron(max_iter=5, tol=-np.infty, random_state=42))\n",
    "ovo_clf.fit(Xmnist_train, ymnist_train)\n",
    "ovo_clf.predict(random_digit.reshape(1,-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Posso accedere a tutti i classificatori binari sulle coppie mediante l'attributo **estimators_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ovo_clf.estimators_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Perceptron(max_iter=5, random_state=42, tol=-inf)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ovo_clf.estimators_[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anche in questo caso posso utilizzare la cross-validation utilizzando accuracy come misura di performance. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.88168067, 0.85084034, 0.83386555, 0.87831933, 0.8697479 ])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cross_val_score(perceptron, Xmnist_train, ymnist_train, cv = 5, scoring='accuracy', n_jobs=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E utilizzando una standardizzazione sulla feature matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.88226891, 0.87546218, 0.87739496, 0.87806723, 0.87403361])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scaler = StandardScaler()\n",
    "Xmnist_train_scaled = scaler.fit_transform(Xmnist_train.astype(np.float64))\n",
    "cross_val_score(perceptron, Xmnist_train_scaled, ymnist_train, cv=5, scoring=\"accuracy\", n_jobs=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Error analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5637,    4,   33,   30,   12,   39,   53,   14,   36,   10],\n",
       "       [   1, 6250,   61,   50,   11,   49,   22,   37,  179,   12],\n",
       "       [  65,  104, 5029,  142,   66,   37,  145,   77,  270,   36],\n",
       "       [  36,   23,  201, 5254,   18,  145,   25,   66,  200,   92],\n",
       "       [  24,   39,   55,   24, 5203,   35,   61,   52,  109,  254],\n",
       "       [  64,   31,   53,  363,   84, 4228,  151,   48,  267,   54],\n",
       "       [  43,   29,   55,   12,   34,   95, 5521,   11,   50,   17],\n",
       "       [  37,   29,  131,   90,   83,   34,    7, 5493,   48,  231],\n",
       "       [  74,  173,   87,  182,   53,  243,   58,   29, 4812,   98],\n",
       "       [  69,   39,   30,  151,  276,  165,    4,  351,  228, 4558]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_pred = cross_val_predict(perceptron, Xmnist_train_scaled, ymnist_train, cv=3, n_jobs=-1)\n",
    "conf_mx = confusion_matrix(ymnist_train, y_train_pred)\n",
    "conf_mx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(matrix):\n",
    "    \"\"\"If you prefer color and a colorbar\"\"\"\n",
    "    fig = plt.figure(figsize=(8,8))\n",
    "    ax = fig.add_subplot(111)\n",
    "    cax = ax.matshow(matrix)\n",
    "    fig.colorbar(cax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x246060482b0>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.matshow(conf_mx, cmap=plt.cm.gray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "row_sums = conf_mx.sum(axis=1, keepdims=True)\n",
    "norm_conf_mx = conf_mx / row_sums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x24605fd0910>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.fill_diagonal(norm_conf_mx, 0)\n",
    "plt.matshow(norm_conf_mx, cmap=plt.cm.gray)"
   ]
  },
  {
   "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}