scikit-learn

Par mkurman · zorai

Apprentissage automatique en Python avec scikit-learn. À utiliser pour le supervised learning (classification, régression), l'unsupervised learning (clustering, réduction de dimensionnalité), l'évaluation de modèles, le réglage d'hyperparamètres, le preprocessing ou la construction de pipelines ML. Fournit une documentation de référence complète sur les algorithmes, les techniques de preprocessing, les pipelines et les bonnes pratiques.

npx skills add https://github.com/mkurman/zorai --skill scikit-learn

Scikit-learn

Aperçu

Cette compétence fournit des conseils complets pour les tâches d'apprentissage automatique utilisant scikit-learn, la bibliothèque Python standard de l'industrie pour le machine learning classique. Utilisez cette compétence pour la classification, la régression, le clustering, la réduction de dimensionnalité, le prétraitement, l'évaluation de modèles et la création de pipelines ML prêts pour la production.

Installation

# Installer scikit-learn avec uv
uv pip install scikit-learn

# Optionnel : installer les dépendances de visualisation
uv pip install matplotlib seaborn

# Généralement utilisé avec
uv pip install pandas numpy

Quand utiliser cette compétence

Utilisez la compétence scikit-learn pour :

  • Construire des modèles de classification ou de régression
  • Effectuer du clustering ou de la réduction de dimensionnalité
  • Prétraiter et transformer les données pour l'apprentissage automatique
  • Évaluer les performances du modèle avec la validation croisée
  • Optimiser les hyperparamètres avec une recherche en grille ou aléatoire
  • Créer des pipelines ML pour les workflows de production
  • Comparer différents algorithmes pour une tâche
  • Travailler avec des données structurées (tabulaires) et textuelles
  • Avoir besoin d'approches d'apprentissage automatique classique interprétables

Démarrage rapide

Exemple de classification

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

# Diviser les données
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

# Prétraiter
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Entraîner le modèle
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train_scaled, y_train)

# Évaluer
y_pred = model.predict(X_test_scaled)
print(classification_report(y_test, y_pred))

Pipeline complet avec données mixtes

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.ensemble import GradientBoostingClassifier

# Définir les types de features
numeric_features = ['age', 'income']
categorical_features = ['gender', 'occupation']

# Créer les pipelines de prétraitement
numeric_transformer = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])

# Combiner les transformateurs
preprocessor = ColumnTransformer([
    ('num', numeric_transformer, numeric_features),
    ('cat', categorical_transformer, categorical_features)
])

# Pipeline complet
model = Pipeline([
    ('preprocessor', preprocessor),
    ('classifier', GradientBoostingClassifier(random_state=42))
])

# Entraîner et prédire
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

Capacités essentielles

1. Apprentissage supervisé

Algorithmes complets pour les tâches de classification et de régression.

Algorithmes clés :

  • Modèles linéaires : Logistic Regression, Linear Regression, Ridge, Lasso, ElasticNet
  • Basés sur les arbres : Decision Trees, Random Forest, Gradient Boosting
  • Machines à vecteurs de support : SVC, SVR avec divers noyaux
  • Méthodes d'ensemble : AdaBoost, Voting, Stacking
  • Réseaux de neurones : MLPClassifier, MLPRegressor
  • Autres : Naive Bayes, K-Nearest Neighbors

Quand les utiliser :

  • Classification : Prédire des catégories discrètes (détection de spam, classification d'images, détection de fraude)
  • Régression : Prédire des valeurs continues (prédiction de prix, prévision de demande)

Voir : references/supervised_learning.md pour la documentation détaillée des algorithmes, les paramètres et les exemples d'utilisation.

2. Apprentissage non supervisé

Découvrir des motifs dans les données non étiquetées via le clustering et la réduction de dimensionnalité.

Algorithmes de clustering :

  • Basés sur partition : K-Means, MiniBatchKMeans
  • Basés sur la densité : DBSCAN, HDBSCAN, OPTICS
  • Hiérarchique : AgglomerativeClustering
  • Probabiliste : Gaussian Mixture Models
  • Autres : MeanShift, SpectralClustering, BIRCH

Réduction de dimensionnalité :

  • Linéaire : PCA, TruncatedSVD, NMF
  • Apprentissage de variété : t-SNE, UMAP, Isomap, LLE
  • Extraction de features : FastICA, LatentDirichletAllocation

Quand les utiliser :

  • Segmentation de clients, détection d'anomalies, visualisation de données
  • Réduire les dimensions des features, analyse exploratoire de données
  • Modélisation de sujets, compression d'images

Voir : references/unsupervised_learning.md pour la documentation détaillée.

3. Évaluation et sélection de modèles

Outils pour une évaluation robuste des modèles, la validation croisée et l'ajustement des hyperparamètres.

Stratégies de validation croisée :

  • KFold, StratifiedKFold (classification)
  • TimeSeriesSplit (données temporelles)
  • GroupKFold (échantillons regroupés)

Optimisation des hyperparamètres :

  • GridSearchCV (recherche exhaustive)
  • RandomizedSearchCV (échantillonnage aléatoire)
  • HalvingGridSearchCV (division successive)

Métriques :

  • Classification : accuracy, precision, recall, F1-score, ROC AUC, matrice de confusion
  • Régression : MSE, RMSE, MAE, R², MAPE
  • Clustering : silhouette score, Calinski-Harabasz, Davies-Bouldin

Quand les utiliser :

  • Comparer objectivement les performances du modèle
  • Trouver les hyperparamètres optimaux
  • Prévenir le surapprentissage via la validation croisée
  • Comprendre le comportement du modèle avec les courbes d'apprentissage

Voir : references/model_evaluation.md pour les métriques complètes et les stratégies d'ajustement.

4. Prétraitement des données

Transformer les données brutes en formats appropriés pour l'apprentissage automatique.

Normalisation et mise à l'échelle :

  • StandardScaler (moyenne zéro, variance unitaire)
  • MinMaxScaler (plage bornée)
  • RobustScaler (robuste aux valeurs aberrantes)
  • Normalizer (normalisation au niveau de l'échantillon)

Encodage des variables catégorielles :

  • OneHotEncoder (catégories nominales)
  • OrdinalEncoder (catégories ordonnées)
  • LabelEncoder (encodage de cible)

Gestion des valeurs manquantes :

  • SimpleImputer (moyenne, médiane, plus fréquent)
  • KNNImputer (k-plus proches voisins)
  • IterativeImputer (imputation multivariée)

Ingénierie de features :

  • PolynomialFeatures (termes d'interaction)
  • KBinsDiscretizer (binning)
  • Sélection de features (RFE, SelectKBest, SelectFromModel)

Quand les utiliser :

  • Avant d'entraîner tout algorithme qui nécessite des features mises à l'échelle (SVM, KNN, Réseaux de neurones)
  • Convertir les variables catégorielles en format numérique
  • Gérer systématiquement les données manquantes
  • Créer des features non-linéaires pour les modèles linéaires

Voir : references/preprocessing.md pour les techniques de prétraitement détaillées.

5. Pipelines et composition

Construire des workflows ML reproductibles et prêts pour la production.

Composants clés :

  • Pipeline : Chaîner des transformateurs et estimateurs séquentiellement
  • ColumnTransformer : Appliquer un prétraitement différent à différentes colonnes
  • FeatureUnion : Combiner plusieurs transformateurs en parallèle
  • TransformedTargetRegressor : Transformer la variable cible

Avantages :

  • Prévient la fuite de données en validation croisée
  • Simplifie le code et améliore la maintenabilité
  • Active l'ajustement conjoint des hyperparamètres
  • Assure la cohérence entre l'entraînement et la prédiction

Quand les utiliser :

  • Toujours utiliser des Pipelines pour les workflows de production
  • Lors de la combinaison de features numériques et catégorielles (utiliser ColumnTransformer)
  • Lors de la validation croisée avec des étapes de prétraitement
  • Lors de l'ajustement des hyperparamètres qui incluent des paramètres de prétraitement

Voir : references/pipelines_and_composition.md pour les modèles de pipeline complets.

Scripts d'exemple

Pipeline de classification

Exécuter un workflow de classification complet avec prétraitement, comparaison de modèles, ajustement des hyperparamètres et évaluation :

python scripts/classification_pipeline.py

Ce script démontre :

  • La gestion des types de données mixtes (numériques et catégoriels)
  • La comparaison de modèles avec validation croisée
  • L'ajustement des hyperparamètres avec GridSearchCV
  • Une évaluation complète avec plusieurs métriques
  • L'analyse de l'importance des features

Analyse de clustering

Effectuer une analyse de clustering avec comparaison d'algorithmes et visualisation :

python scripts/clustering_analysis.py

Ce script démontre :

  • Trouver le nombre optimal de clusters (méthode du coude, analyse de silhouette)
  • Comparer plusieurs algorithmes de clustering (K-Means, DBSCAN, Agglomératif, Gaussian Mixture)
  • Évaluer la qualité du clustering sans vérité terrain
  • Visualiser les résultats avec projection PCA

Documentation de référence

Cette compétence inclut des fichiers de référence complets pour des approfondissements sur des sujets spécifiques :

Référence rapide

Fichier : references/quick_reference.md

  • Modèles d'importation courants et instructions d'installation
  • Modèles de workflow rapides pour les tâches courantes
  • Feuilles de sélection d'algorithmes
  • Modèles courants et pièges
  • Conseils d'optimisation des performances

Apprentissage supervisé

Fichier : references/supervised_learning.md

  • Modèles linéaires (régression et classification)
  • Machines à vecteurs de support
  • Arbres de décision et méthodes d'ensemble
  • K-Nearest Neighbors, Naive Bayes, Réseaux de neurones
  • Guide de sélection d'algorithmes

Apprentissage non supervisé

Fichier : references/unsupervised_learning.md

  • Tous les algorithmes de clustering avec paramètres et cas d'utilisation
  • Techniques de réduction de dimensionnalité
  • Détection d'anomalies et de nouveauté
  • Gaussian Mixture Models
  • Guide de sélection de méthodes

Évaluation de modèles

Fichier : references/model_evaluation.md

  • Stratégies de validation croisée
  • Méthodes d'ajustement des hyperparamètres
  • Métriques de classification, régression et clustering
  • Courbes d'apprentissage et de validation
  • Bonnes pratiques pour la sélection de modèles

Prétraitement

Fichier : references/preprocessing.md

  • Normalisation et mise à l'échelle des features
  • Encodage des variables catégorielles
  • Imputation des valeurs manquantes
  • Techniques d'ingénierie de features
  • Transformateurs personnalisés

Pipelines et composition

Fichier : references/pipelines_and_composition.md

  • Construction et utilisation de Pipelines
  • ColumnTransformer pour types de données mixtes
  • FeatureUnion pour transformations parallèles
  • Exemples de bout en bout complets
  • Bonnes pratiques

Workflows courants

Construire un modèle de classification

  1. Charger et explorer les données

    import pandas as pd
df = pd.read_csv('data.csv')
X = df.drop('target', axis=1)
y = df['target']

  2. Diviser les données avec stratification

    from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

  3. Créer un pipeline de prétraitement

    from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.compose import ColumnTransformer

# Gérer séparément les features numériques et catégorielles
preprocessor = ColumnTransformer([
    ('num', StandardScaler(), numeric_features),
    ('cat', OneHotEncoder(), categorical_features)
])

  4. Construire le pipeline complet

    model = Pipeline([
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier(random_state=42))
])

  5. Optimiser les hyperparamètres

    from sklearn.model_selection import GridSearchCV

param_grid = {
    'classifier__n_estimators': [100, 200],
    'classifier__max_depth': [10, 20, None]
}

grid_search = GridSearchCV(model, param_grid, cv=5)
grid_search.fit(X_train, y_train)

  6. Évaluer sur l'ensemble de test

    from sklearn.metrics import classification_report

best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test)
print(classification_report(y_test, y_pred))

Effectuer une analyse de clustering

  1. Prétraiter les données

    from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

  2. Trouver le nombre optimal de clusters

    from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

scores = []
for k in range(2, 11):
    kmeans = KMeans(n_clusters=k, random_state=42)
    labels = kmeans.fit_predict(X_scaled)
    scores.append(silhouette_score(X_scaled, labels))

optimal_k = range(2, 11)[np.argmax(scores)]

  3. Appliquer le clustering

    model = KMeans(n_clusters=optimal_k, random_state=42)
labels = model.fit_predict(X_scaled)

  4. Visualiser avec réduction de dimensionnalité

    from sklearn.decomposition import PCA

pca = PCA(n_components=2)
X_2d = pca.fit_transform(X_scaled)

plt.scatter(X_2d[:, 0], X_2d[:, 1], c=labels, cmap='viridis')

Bonnes pratiques

Toujours utiliser des Pipelines

Les Pipelines préviennent la fuite de données et assurent la cohérence :

# Bon : Prétraitement dans le pipeline
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', LogisticRegression())
])

# Mauvais : Prétraitement en dehors (peut fuir de l'information)
X_scaled = StandardScaler().fit_transform(X)

Entraîner uniquement sur les données d'entraînement

Ne jamais entraîner sur les données de test :

# Bon
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)  # Seulement transformer

# Mauvais
scaler = StandardScaler()
X_all_scaled = scaler.fit_transform(np.vstack([X_train, X_test]))

Utiliser la division stratifiée pour la classification

Préserver la distribution des classes :

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

Définir l'état aléatoire pour la reproductibilité

model = RandomForestClassifier(n_estimators=100, random_state=42)

Choisir les métriques appropriées

  • Données équilibrées : Accuracy, F1-score
  • Données déséquilibrées : Precision, Recall, ROC AUC, Balanced Accuracy
  • Sensible au coût : Définir un scorer personnalisé

Normaliser les features quand nécessaire

Algorithmes nécessitant une normalisation des features :

  • SVM, KNN, Réseaux de neurones
  • PCA, Régression linéaire/logistique avec régularisation
  • Clustering K-Means

Algorithmes ne nécessitant pas de normalisation :

  • Modèles basés sur les arbres (Decision Trees, Random Forest, Gradient Boosting)
  • Naive Bayes

Résolution des problèmes courants

ConvergenceWarning

Problème : Le modèle n'a pas convergé Solution : Augmenter max_iter ou normaliser les features

model = LogisticRegression(max_iter=1000)

Mauvaises performances sur l'ensemble de test

Problème : Surapprentissage Solution : Utiliser la régularisation, la validation croisée ou un modèle plus simple

# Ajouter la régularisation
model = Ridge(alpha=1.0)

# Utiliser la validation croisée
scores = cross_val_score(model, X, y, cv=5)

Erreur de mémoire avec de grands ensembles de données

Solution : Utiliser des algorithmes conçus pour de grandes données

# Utiliser SGD pour les grands ensembles de données
from sklearn.linear_model import SGDClassifier
model = SGDClassifier()

# Ou MiniBatchKMeans pour le clustering
from sklearn.cluster import MiniBatchKMeans
model = MiniBatchKMeans(n_clusters=8, batch_size=100)

Ressources supplémentaires

Skills similaires

ad-model-onboard
nvidia / skills

Automatiser l'intégration de modèles HuggingFace dans AutoDeploy avec tests et rapport.

1 033
claude-api
anthropics / skills

Construire des applications LLM avec Claude via le SDK officiel adapté au langage.

146 952
umap-learn
mkurman / zorai

Réduire la dimensionnalité de données avec UMAP pour visualisation et clustering.

309
eval-bootstrap
datadog-labs / agent-skills

Générer du code d'évaluation Python à partir de traces de production LLM Datadog.

126
trtllm-moe-develop
nvidia / skills

Auditer et aligner le code MoE TensorRT-LLM avec l'architecture de référence.

1 033