Introduction à l'apprentissage automatique avec scikit-learn

Publié dans: 

L’apprentissage automatique est la capacité d’une machine à résoudre, à partir des données empiriques, des problèmes sans avoir été explicitement programmé avec un algorithme classique. En général un problème d’apprentissage considère n échantillons de données et essaie de prédire des propriétés ou des caractéristiques (features) pour les données inconnues.
Les algorithmes d'apprentissage peuvent se catégoriser selon le mode d'apprentissage qu'ils emploient :

  • Apprentissage supervisé
  • Apprentissage non supervisé

La Librairie scikit-learn

 

Scikit-learn est un module python intégrant les algorithmes classiques de l’apprentissage automatique. Il vise à fournir des solutions simples et efficaces pour les problèmes d'apprentissage, accessible à tous et réutilisables dans divers contextes.
Il existe quelques ensembles de données classiques intégrés avec Scikit-learn, par exemple “le dataset de fleurs des iris de Fisher” et “digits” qui est un dataset d'images de chiffres manuscrits.

 

Exemple pratique : reconnaissance des chiffres manuscrits

Pour le cas de l’ensemble de données “digits” la tâche est de prédire la valeur de chiffres manuscrits. On nous donne des échantillons de chacune des 10 classes possibles de 0 à 9 sur lesquelles nous nous situons un estimateur pour être en mesure de prédire les étiquettes correspondantes aux nouvelles données.
Concrètement un classificateur est une classe python qui implémente les méthodes fit et predict.
Un exemple de l'estimateur est la classe sklearn.svm.SVC qui implémente l'algorithme Support Vector classification. Le constructeur d'un estimateur prend comme arguments les paramètres du modèle, mais pour le moment, nous allons considérer l'estimateur comme une boîte noire.

 

from sklearn import svm
classifier= svm.SVC(gamma=0.001, C=100.)

Le paramètre gamma est choisi manuellement mais il est recommandé de le configurer avec la validation croisée.

Le classificateur SVC est un classificateur binaire à la base (i.e. Il ne peut classifier que entre 2 classes à la fois), son principe de résolution du problème passe par la construction d'un hyperplan qui permet de séparer les deux classe.

Dans la figure ci-dessus la droite en rouge qui est calculé par le classificateur SVC qui permet de classifier les deux classes (+)  et (-).
Afin de construire un classificateur SVC multi-classes cette approche est utilisée :
Le problème de classification de 3 types par exemple A, B et C devient un ensemble de sous problèmes de classification binaire.

Chaque classificateur va choisir une classe parmi 2 puis on va choisir la classe qui a plus de "vote".


Nous appelons notre exemple estimateur classifier comme il est un classificateur. Il doit maintenant être monté sur le modèle, c'est à dire qu'il doit apprendre à partir du modèle. Cela se fait en adoptant notre ensemble d’entrainement à la méthode fit. Nous utiliserons la moitié de notre base de données pour cet entrainement.

 

classifier.fit(data[:n_samples / 2], digits.target[:n_samples / 2])

 

Pour afficher par exemple les 8 premières images de l’ensemble d’entrainement :

for index, (image, label) in enumerate(zip(digits.images, digits.target)[:8]):
   pl.subplot(2, 8, index + 1)
   pl.axis('off')
   pl.imshow(image, cmap=pl.cm.gray_r, interpolation='nearest')
   pl.title('Training: %i' % label)

 

Maintenant, nous pouvons prédire les autres valeurs, que nous n'avons pas utilisées pour entrainer le classificateur. La prédiction se fait avec la méthode predict

predicted = classifier.predict(data[n_samples / 2:])

Comme nous avons déjà fait pour l’ensemble d’entrainement nous allons afficher quelques images et leurs prédiction.

for index, (image, prediction) in enumerate(
   zip(digits.images[n_samples / 2:], predicted)[:8]):
   pl.subplot(2, 8, index + 9)
   pl.axis('off')
   pl.imshow(image, cmap=pl.cm.gray_r, interpolation='nearest')
   pl.title('Prediction: %i' % prediction , fontsize=16)

 

Validation du modèle et des paramètres

En pratique, il faut avoir une méthode ou métrique pour évaluer qui est le meilleur modèle (ou algorithme) et les paramètres adéquats.

Validation croisée

La validation croisée (K-Fold cross validation) est une technique qui permet de mesurer l’efficacité de l’algorithme de l’apprentissage.
On divise l'échantillon original en k échantillons, puis on sélectionne un des k échantillons comme ensemble de validation et les (k-1) autres échantillons constituent l'ensemble d'apprentissage. On calcule comme dans la première méthode l'erreur quadratique moyenne. Puis on répète l'opération en sélectionnant un autre échantillon de validation parmi les (k-1) échantillons qui n'ont pas encore été utilisés pour la validation du modèle. L'opération se répète ainsi k fois pour qu'en fin de compte chaque sous-échantillon soit utilisé exactement une fois comme ensemble de validation. Enfin, la moyenne des k erreurs quadratiques moyennes est calculée pour estimer l'erreur de prédiction.

from sklearn.cross_validation import cross_val_score, KFold import numpy as np
def evaluate_cross_validation(clf, X, y, K):
   cv = KFold(len(y), K, shuffle=True, random_state=0)
   scores = cross_val_score(clf, X, y, cv)
   print scores
   print ("Mean score: {0:.3f}").format( np.mean(scores))

from sklearn.cross_validation import train_test_split

X_train, X_test, y_train, y_test = train_test_split( digits.data, digits.target, test_size=0.25, random_state=0)

evaluate_cross_validation(classifier, X_train, y_train, 5)

 

 

Le résultat du cross validation est

[ 0.9962963   0.98148148  0.99628253  0.98884758  0.99256506]
Mean score: 0.991

La matrice de confusion

La matrice de confusion est utilisée essentiellement pour les problèmes de classification. Chaque colonne de la matrice représente le nombre d'occurrences d'une classe estimée, tandis que chaque ligne représente le nombre d'occurrences d'une classe réelle (ou de référence). Les données utilisées pour chacun de ces groupes doivent être différentes

Comme montre l'image ci dessus cette matrice met en évidence les classe que le modèle parvient à les classifier et les classes qu'il n'y parvient pas.
Pour l'exemple de la classification de chiffres manuscrits, la matrice de confusion se dégage avec le code suivant:

cm = metrics.confusion_matrix(expected, predicted)

print(cm)

La matrice de confusion est :

[[87  0  0  0  1  0  0  0  0  0]
[ 0 88  1  0  0  0  0  0  1  1]
[ 0  0 85  1  0  0  0  0  0  0]
[ 0  0  0 79  0  3  0  4  5  0]
[ 0  0  0  0 88  0  0  0  0  4]
[ 0  0  0  0  0 88  1  0  0  2]
[ 0  1  0  0  0  0 90  0  0  0]
[ 0  0  0  0  0  1  0 88  0  0]
[ 0  0  0  0  0  0  0  0 88  0]
[ 0  0  0  1  0  1  0  0  0 90]]

 


La bibliothèque Scikit-learn offre également plusieurs algorithmes d’apprentissage automatique, on peut citer Machine à vecteurs de support, modèle linéaire, classification naïve bayésienne,  modèle de mélanges gaussiens, apprentissage de variétés, factorisation matricielle.