Scikit-learn : apprentissage automatique (machine learning)

Qu'est-ce que Scikit-learn ? Un couteau suisse pour le machine learning

Scikit-learn (également appelée sklearn) est une bibliothèque Python open source dédiée à l'apprentissage automatique (machine learning). Elle fournit une large gamme d'algorithmes d'apprentissage supervisé et non supervisé, ainsi que des outils pour la préparation des données, l'évaluation des modèles, et l'optimisation des hyperparamètres.

Scikit-learn est construite sur NumPy, SciPy et Matplotlib.

Scikit-learn est appréciée pour :

• Sa simplicité et sa facilité d'utilisation : L'API de Scikit-learn est cohérente et intuitive, ce qui rend la bibliothèque accessible aux débutants.
• Sa richesse fonctionnelle : Scikit-learn offre une grande variété d'algorithmes et d'outils pour couvrir la plupart des tâches courantes de machine learning.
• Sa performance : De nombreux algorithmes de Scikit-learn sont implémentés en C ou en Cython, ce qui leur confère de bonnes performances.
• Sa documentation complète et de qualité : La documentation de Scikit-learn est claire, bien organisée, et contient de nombreux exemples.
• Sa communauté active : Scikit-learn est une bibliothèque très populaire, avec une communauté active d'utilisateurs et de contributeurs.

Scikit-learn est un outil indispensable pour toute personne souhaitant faire de l'apprentissage automatique en Python.

Installation et importation

Scikit-learn peut être installée avec `pip` :

pip install scikit-learn

Scikit-learn est généralement importée avec l'alias `sklearn` :

import sklearn

Les différents modules et fonctions de Scikit-learn sont accessibles à partir de cet alias (par exemple, `sklearn.linear_model`, `sklearn.model_selection`, etc.).

Principaux modules et fonctionnalités

Scikit-learn est organisée en plusieurs modules, chacun dédié à un type de tâche spécifique. Voici quelques-uns des modules les plus importants :

• `sklearn.linear_model` : Modèles linéaires (régression linéaire, régression logistique, etc.).
• `sklearn.tree` : Arbres de décision.
• `sklearn.ensemble` : Méthodes d'ensemble (forêts aléatoires, boosting, etc.).
• `sklearn.svm` : Machines à vecteurs de support (SVM).
• `sklearn.neighbors` : Plus proches voisins.
• `sklearn.cluster` : Clustering (K-means, clustering hiérarchique, etc.).
• `sklearn.decomposition` : Réduction de dimensionnalité (ACP, etc.).
• `sklearn.model_selection` : Sélection de modèles, validation croisée, recherche d'hyperparamètres.
• `sklearn.preprocessing` : Prétraitement des données (normalisation, standardisation, encodage, etc.).
• `sklearn.metrics` : Métriques d'évaluation des modèles (accuracy, precision, recall, F1-score, AUC, etc.).
• `sklearn.pipeline` : Création de pipelines de machine learning.

Chaque module contient plusieurs classes et fonctions pour implémenter différents algorithmes et techniques.

Exemple simple : classification avec un arbre de décision

Voici un exemple simple de classification avec un arbre de décision, en utilisant Scikit-learn :

# Importer les modules nécessaires
from sklearn.tree import DecisionTreeClassifier  # Importe la classe DecisionTreeClassifier
from sklearn.model_selection import train_test_split  # Pour diviser les données en ensembles d'apprentissage et de test
from sklearn.metrics import accuracy_score  # Pour évaluer la performance du modèle

# Créer des données d'exemple (X : features, y : labels)
X = [[0, 0], [1, 1], [0, 1], [1, 0]]
y = [0, 1, 1, 0]  # 0 et 1 sont les deux classes possibles

# Diviser les données en ensembles d'apprentissage et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

# Créer un classifieur arbre de décision
clf = DecisionTreeClassifier(random_state=42)  # random_state pour la reproductibilité

# Entraîner le modèle sur les données d'apprentissage
clf.fit(X_train, y_train)

# Prédire les étiquettes pour les données de test
y_pred = clf.predict(X_test)

# Evaluer la performance du modèle
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy : {accuracy:.2f}")

Dans cet exemple :

1. On importe les classes et fonctions nécessaires de Scikit-learn : `DecisionTreeClassifier` (l'algorithme d'arbre de décision), `train_test_split` (pour diviser les données), et `accuracy_score` (pour évaluer la performance).
2. On crée des données d'exemple (X : les *features*, y : les *labels* ou *classes*).
3. On divise les données en un ensemble d'apprentissage (75%) et un ensemble de test (25%) avec `train_test_split`.
4. On crée un classifieur arbre de décision (`DecisionTreeClassifier`).
5. On entraîne le modèle sur les données d'apprentissage avec la méthode `fit`.
6. On prédit les étiquettes pour les données de test avec la méthode `predict`.
7. On évalue la performance du modèle en calculant l'accuracy (le pourcentage de prédictions correctes) avec `accuracy_score`.

Cet exemple illustre le flux de travail typique en apprentissage supervisé avec Scikit-learn : préparer les données, choisir un modèle, entraîner le modèle, faire des prédictions, et évaluer la performance.

Flux de travail typique en apprentissage supervisé

Un flux de travail typique en apprentissage supervisé avec Scikit-learn comprend les étapes suivantes :

1. Préparation des données :
   • Importer les données.
   • Nettoyer les données (gérer les valeurs manquantes, supprimer les doublons, etc.).
   • Transformer les données (mettre à l'échelle, encoder les variables catégorielles, etc.).
   • Diviser les données en un ensemble d'apprentissage et un ensemble de test.
2. Choix du modèle : Choisir un algorithme d'apprentissage adapté au problème (classification, régression, etc.) et au type de données.
3. Entraînement du modèle : Utiliser la méthode `fit` du modèle pour l'entraîner sur les données d'apprentissage.
4. Prédiction : Utiliser la méthode `predict` du modèle (pour la classification ou la régression) ou `predict_proba` (pour obtenir les probabilités des classes en classification) pour faire des prédictions sur de nouvelles données (généralement les données de test).
5. Evaluation du modèle : Utiliser des métriques appropriées (accuracy, precision, recall, F1-score, RMSE, etc.) pour évaluer la performance du modèle sur les données de test.
6. Optimisation des hyperparamètres (optionnel) : Utiliser des techniques comme la validation croisée et la recherche sur grille pour optimiser les hyperparamètres du modèle.
7. Déploiement du modèle (si nécessaire) : Intégrer le modèle entraîné dans une application ou un système.

Scikit-learn fournit des outils pour faciliter chacune de ces étapes.

Aller plus loin avec Scikit-learn

Scikit-learn est une bibliothèque très riche, et il y a beaucoup à apprendre. Voici quelques pistes pour aller plus loin :

• Explorez la documentation : La documentation de Scikit-learn est une ressource précieuse. Elle contient des descriptions détaillées de tous les modules, classes et fonctions, ainsi que de nombreux exemples.
• Suivez des tutoriels : Il existe de nombreux tutoriels en ligne sur Scikit-learn, pour tous les niveaux.
• Entraînez-vous sur des jeux de données réels : Essayez d'appliquer Scikit-learn à des jeux de données réels (par exemple, ceux disponibles sur Kaggle, UCI Machine Learning Repository, ou d'autres sources).
• Participez à des compétitions de machine learning : C'est un excellent moyen d'apprendre et de progresser.
• Lisez des articles de recherche : Pour vous tenir au courant des dernières avancées en matière d'apprentissage automatique.
• Contribuez à Scikit-learn : Si vous vous sentez à l'aise, vous pouvez contribuer à Scikit-learn en corrigeant des bugs, en ajoutant de nouvelles fonctionnalités, ou en améliorant la documentation.