Machine Learning
as a Service
appunti di un workshop a Europython 2017
Alessandro Cucci Energee3 srl
Cosa faremo¶
Una banca si accorge di perdere molto denaro nei prestiti di piccola entità!!!¶
Il vostro lavoro, in quanto consulenti, sarà quello di:¶
- sviluppare una pagina web per la richiesta di nuovi prestiti
- sviluppare un'analisi per capire quali prestiti sono rischiosi e quali no
- applicare questa analisi in modo che le richieste vengano filtrate a priori
Tipico Workflow di ML¶
- Acquisizione Dati
- Pulizia Dati
- Esplorazione Visiva
- Trasformazione (eventuale) e Scelta del Modello
- Misurazione delle performance del Modello
Con l'aggiunta di:¶
- Deploying del Modello as a service
- Collegamento dell'API alla Web Application
Acquisizione Dati¶
In [1]:
import pandas as pd
df = pd.read_csv("storico_prestiti.csv")
df.head()
Out[1]:
Pulizia dei Dati¶
Di che tipo sono i dati presenti nel DataFrame?¶
In [2]:
df.dtypes
Out[2]:
Quanti dati ho?¶
In [3]:
print("Righe: {0}, Colonne: {1}".format(*df.shape))
In [4]:
df.describe()
Out[4]:
Come verifico se ho dei valori nulli?¶
In [5]:
df.isnull().sum()
Out[5]:
Cosa posso fare con queste righe?¶
- Eliminarle (sono 279 su 7727)
- Sostituirle con un valore soglia (es. 9999 -> Errore nell'importazione)
- Sostituirle applicando una funzione (random tra le altre righe, media, valore stimato da un altro modello)
In [6]:
import numpy as np
df.years = df.years.fillna(np.mean(df.years))
Prestiti andati a buon fine o meno¶
In [8]:
df.default.plot.hist()
Out[8]:
Grafico dei livelli di solvibilità del cliente¶
In [9]:
df.grade.value_counts().plot.barh()
Out[9]:
Età dei richiedenti¶
In [10]:
df.age.plot.hist(bins=30)
Out[10]:
Grafico età-disponibilità economica¶
In [11]:
df.plot.scatter(x='age', y='income', alpha=0.7)
Out[11]:
Relazione tra età, disponibilità economica e default del prestito¶
In [12]:
df.plot.scatter(x='age', y='income', c='default', logx=True, logy=True, cmap='viridis')
Out[12]:
Trasformazione dei valori non numerici¶
In [13]:
df.describe(include='all')
Out[13]:
In [14]:
from sklearn.preprocessing import LabelEncoder
df_encoded = df.copy()
le_grade = LabelEncoder().fit(df_encoded["grade"])
df_encoded.grade = le_grade.transform(df_encoded.grade)
le_ownership = LabelEncoder().fit(df["ownership"])
df_encoded.ownership = le_ownership.transform(df_encoded.ownership)
In [15]:
df_encoded.head()
Out[15]:
Alberi Decisionali¶
In [16]:
from IPython.display import Image
Image("img/decisionanimals.png")
Out[16]:
Criterio di partizione: Algoritmo CART¶
- si genera l’insieme S di tutte le possibili partizioni binarie ottenute dal set di predittori X;
- per ogni split s dell’insieme S si calcola il decremento di impurità;
- si determina la miglior partizione a cui é associato il massimo decremento di impurità.
L’algoritmo é applicato ad ogni nodo fino a che la costruzione dell’albero non si arresta.
Indice H di eterogeneità di Gini (misura di impurità)¶
Esso si definisce in generale come:
$H = 1 - \sum\limits_{j = 1}^J {f_j^2 }$
Dove $f_j$ rappresenta la frequenza relativa di osservazioni la cui modalità della variabile è pari a j.
Indice H di eterogeneità di Gini (misura di impurità)¶
In un classificatore binario, l’impurità in un nodo sarà quindi pari a:
$i_Y (t) = 1 - \sum\limits_{j = 1}^J {p^2 \left( {t\left| {Y = j} \right.} \right)}$
Dove $i_Y (t)$ è la misura di impurità in un generico nodo t e $p \left( {t\left| {Y = j} \right.} \right)$ è la proporzione di unità nel nodo t che appartengono alla j-esima classe della variabile di risposta Y.
Per maggiori info: https://it.wikipedia.org/wiki/Indice_di_eterogeneità_di_Gini
Proviamo a creare un albero usando solo due variabili e con profondità = 2¶
In [17]:
X_2 = df_encoded.loc[:,('age', 'amount')]
y = df_encoded.loc[:,'default']
from sklearn import tree
clf_dt = tree.DecisionTreeClassifier(max_depth=2)
clf_dt = clf_dt.fit(X_2, y)
In [19]:
Image(graph.create_png())
Out[19]:
In [21]:
plot_boundaries(X_2, clf_dt)
Proviamo a costruirne uno con profondità 5¶
In [22]:
clf_dt_5 = tree.DecisionTreeClassifier(max_depth=5).fit(X_2,y)
plot_boundaries(X_2, clf_dt_5)
Sta funzionando? Non direi...¶
In [23]:
pred_class = clf_dt_5.predict(X_2)
plt.hist(pred_class);
Validazione del modello¶
Vari tipi di metriche¶
- Sum of Square Error
- Area under Curve (ROC) -> Classificatori Binari
AREA UNDER CURVE (ROC)¶
- Si costruisce un grafico che rappresenti la relazione tra sensitività (veri positivi, asse y) e la specificità (falsi positivi, asse x)
- usati per la prima volta nella seconda guerra mondiale per individuare i nemici usando i radar.
- Una curva ROC è il grafico dell'insieme delle coppie (FP, TP) al variare del parametro del classificatore.
In [24]:
Image("img/roc.png")
Out[24]:
due curve limite:¶
- una che taglia il grafico a 45°. Questa retta rappresenta il caso del classificatore casuale. Il suo valore è 0.5
- curva rappresentata dal segmento che dall'origine sale al punto (0,1) e da quello che congiunge il punto (0,1) a (1,1). Rappresenta il classificatore perfetto e il suo valore è 1.
In [25]:
Image("img/cv.jpg")
Out[25]:
In [26]:
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import roc_auc_score
Algoritmo per ottenere la media della valutazione ROC usando la Cross-Validation¶
- Generazione dei k-fold
- Per ogni fold
- Training del modello
- Previsione
- Calcolo dell'accuratezza.
- Calcolo della media delle accuratezze
Prepariamo l'occorrente¶
In [27]:
X = df_encoded.iloc[:,1:]
y = df_encoded.iloc[:,0]
In [28]:
def cross_val(clf, k):
kf = StratifiedKFold(n_splits=k)
kfold_auc_score = []
for train_index, test_index in kf.split(X,y):
clf = clf.fit(X.iloc[train_index], y.iloc[train_index])
dt_prediction = clf.predict_proba(X.iloc[test_index])[:,1]
auc_score = roc_auc_score(y.iloc[test_index],dt_prediction)
print(auc_score)
kfold_auc_score.append(auc_score)
print("Media roc della cross validation:", np.mean(kfold_auc_score))
In [29]:
clf_dt_2 = tree.DecisionTreeClassifier(max_depth=2)
print("Cross validation: profondità = 2, k = 3")
cross_val(clf_dt_2, 3)
print("")
print("Cross validation: profondità = 2, k = 5")
cross_val(clf_dt_2, 5)
In [30]:
clf_dt_5 = tree.DecisionTreeClassifier(max_depth=5)
cross_val(clf_dt_5, 5)
In [31]:
Image("img/tradeoff.png")
Out[31]: