On commence par importer quelques modules python importants :
import numpy as np
import pandas as pa
import warnings
warnings.filterwarnings("ignore")
from matplotlib import pyplot as plt
import seaborn as sns
sns.set()
La commencent les modules utiles pour le machine learning. En premier sklearn, une des bibliothèques les plus riches pour faire du ML.
En particulier, on importe :
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split
Nous allons illustrer notre premier algorithme d'apprentissage en travaillant avec le dataset breast cancer. Pour l'instant, nous allons utiliser quelques datasets de la bibliothèque sklearn. Nous verrons plus tard comment charger, grâce à pandas, des fichiers csv.
A noter que plusieurs datasets font partie de ce sous-module de sklearn.
from sklearn.datasets import load_breast_cancer
Les datasets de sklearn sont, en général, bien formatés. Ils viennent avec une structure permettant de les visualiser et de les "fouiller" facilement.
breast_cancer = load_breast_cancer()
print(breast_cancer.DESCR)
print(breast_cancer.feature_names)
Nous n'allons pas travailler avec le dataset dans sa globalité. Nous allons illustrer la méthode en travaillant juste sur deux attributs et sur la classe. N'oublions pas que nous cherchons à trouver un modèle, qui est en fait une fonction F telle que y = F(X).
A noter que la fonction Categorical transforme juste les deux classes en 0 et 1.
X = pa.DataFrame(breast_cancer.data, columns=breast_cancer.feature_names)
X = X[['mean area', 'mean compactness']]
y = pa.Categorical.from_codes(breast_cancer.target, breast_cancer.target_names)
y = pa.get_dummies(y, drop_first=True)
On découpe les données en deux parties : une pour l'entraînement et une pour le test. A noter que par défaut le dataset du test représente 25% de l'ensemble mais on peut changer ce découpage par défaut grâce au paramètre test_size.
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)
La commence l'utilisation du knn :
from sklearn.neighbors import KNeighborsClassifier
k = 5
knn = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
knn.fit(X_train, y_train)
Une fois le modèle entraîné, on l'utilise pour prédir les classes de X_test :
y_pred = knn.predict(X_test)
sns.scatterplot(
x='mean area',
y='mean compactness',
hue='benign',
data=X_test.join(y_test, how='outer')
)
plt.scatter(
X_test['mean area'],
X_test['mean compactness'],
c=y_pred,
cmap='coolwarm',
alpha=0.7
)
On mesure la performance de notre modèle. Pour cela, on calcule la matrice de confusion (voir le cours).
cm = confusion_matrix(y_test, y_pred)
print(cm)
Et on calcule les métriques qui nous intéressent. Nous allons calculer l'accuracy de notre modèle :
acc = np.sum(np.diag(cm))/np.sum(cm)
print('{:.2%}'.format(acc))
k-nn est un algorithme simple car le nombre d'hyper paramètres est de 1 (k). On peut donc écrire un programme simple pour chercher le meilleur modèle :
def best_model_search(X_train, X_test, y_train, y_test, n=10, patience=3):
k = 1
best_acc = 0
best_model = None
while k <n and patience >0 :
knn = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
acc = np.sum(np.diag(cm))/np.sum(cm)
print('{:.2%}'.format(acc))
if acc > best_acc:
best_acc = acc
best_model = knn
patience = patience -1
k = k+1
return best_model,k, best_acc
knn, k, acc = best_model_search(X_train, X_test, y_train, y_test, patience=10)
print(k, '{:.2%}'.format(acc))