Scikit-learn 1.9 Lancé le 12 juin 2026 : Un Grand Pas pour l'Ingénierie du ML Classique

L'équipe principale de scikit-learn a livré la version 1.9.0 le 12 juin 2026, marquant l'une des versions les plus riches en fonctionnalités de la bibliothèque en mémoire récente. La mise à jour arrive à un moment critique pour l'écosystème de l'apprentissage automatique : alors que les grands modèles de langage continuent de dominer les gros titres, les responsables de la maintenance de scikit-learn ont redoublé d'efforts sur ce que fait bien la bibliothèque — l'apprentissage automatique classique rapide, interprétable et de qualité production — tout en modernisant simultanément son interface pour la prochaine génération d'outils ML. La version est disponible sur PyPI et compatible avec Python 3.11 à 3.14.

Pour les ingénieurs qui construisent des pipelines ML sur des données structurées et tabulaires — le pain quotidien du ML en entreprise — scikit-learn 1.9 fournit une cascade d'améliorations : un tout nouveau système de callbacks expérimental pour le suivi de l'entraînement, une accélération GPU étendue via l'API Array, une couche de compatibilité dataframe plus légère via narwhals, et une visualisation HTML d'estimateur considérablement plus riche. Ces changements répondent collectivement aux points de friction de longue date pour les praticiens qui déploient les modèles sklearn à grande échelle.

La version arrive également sur fond d'un partenariat actif avec Hugging Face, la plateforme IA devenue le centre névralgique de la communauté ML open source. Bien que la version 1.9 ne soit pas livrée avec un nouveau code d'intégration spécifique à Hugging Face, les deux organisations ont passé les quatre dernières années à construire une infrastructure partagée — notamment via la bibliothèque skops — qui héberge désormais près de 800 modèles scikit-learn sur le Hub Hugging Face. Ensemble, la version 1.9 et le pipeline sklearn–Hugging Face en maturation représentent un moment charnière pour le ML classique à l'ère des modèles de base.

L'API Callback : Le Suivi de l'Entraînement en Temps Réel Arrive dans Scikit-learn

L'ajout le plus impactant de la version 1.9 est le mécanisme de callback expérimental, une fonctionnalité longtemps demandée qui introduit le suivi en temps réel et la visibilité de la progression dans la boucle d'entraînement des estimateurs scikit-learn. Jusqu'à présent, les ingénieurs ML utilisant sklearn n'avaient aucun moyen natif d'observer un modèle en train de s'adapter — pas de barres de progression, pas de courbes de perte en direct, pas de hooks d'arrêt précoce. Cet écart forçait les équipes à recourir à des contournements tels que les marqueurs de journalisation détaillée ou les bibliothèques externes. La version 1.9 la ferme définitivement.

Le système de callbacks introduit deux implémentations concrètes prêtes à l'emploi :

• sklearn.callback.ProgressBar — affiche une barre de progression en direct pendant fit(), donnant aux ingénieurs une vue en temps réel de l'avancement de l'entraînement sans quitter le notebook ou le terminal
• sklearn.callback.ScoringMonitor — enregistre les métriques de notation à chaque itération de la boucle d'optimisation, permettant le suivi de la convergence sans outils externes ou boilerplate personnalisé

Dans la version 1.9, le système de callbacks est pris en charge par un ensemble d'estimateurs ciblé mais significatif : LogisticRegression (utilisant le solveur lbfgs), toute la famille SearchCV (GridSearchCV, RandomizedSearchCV, HalvingGridSearchCV, et HalvingRandomSearchCV), Pipeline, et StandardScaler. Les responsables de la maintenance ont explicitement signalé que c'est une fondation, pas un plafond — le billet de blog de la version décrit le mécanisme de callback comme celui qui « ouvre la porte aux barres de progression ou au suivi avancé de la convergence », avec une couverture d'estimateur plus large prévue pour les versions ultérieures.

L'importance de cette fonctionnalité s'étend au-delà de l'expérience utilisateur. Pour les équipes intégrant scikit-learn dans des pipelines MLOps plus larges — où la surveillance, les alertes et l'auditabilité sont des exigences non négociables — l'API de callback fournit un hook programmatique qui peut s'introduire dans l'infrastructure de journalisation, les tableaux de bord ou les traqueurs d'expériences tels que MLflow et Weights & Biases. Elle signale que l'équipe scikit-learn réfléchit sérieusement au contexte opérationnel dans lequel leur bibliothèque est utilisée, pas seulement à la correction statistique de ses algorithmes.

« Le mécanisme de callback ouvre la porte aux barres de progression ou au suivi avancé de la convergence » — annonce de la version 1.9 de scikit-learn, juin 2026

Regardant vers l'avant, le statut expérimental de l'API de callback signifie que l'interface peut évoluer avant la stabilisation. Les ingénieurs construisant des systèmes de production dessus doivent traiter la surface API comme sujet à changement via les versions 1.10 et 1.11. Cela dit, la conception est déjà suffisamment expressive pour couvrir les cas d'utilisation de surveillance les plus courants, et la réponse communautaire depuis la version du 12 juin a été largement positive, avec plusieurs responsables des outils MLOps expérimentant déjà des adaptateurs de callback pour leurs plates-formes.

Accélération GPU et API Array : Scikit-learn Vers la Neutralité Matérielle

L'une des grandes narratives de la période 2024–2026 en ingénierie ML a été l'accélération de la diversité matérielle : les ingénieurs ne sont plus confinés aux CPU pour le ML classique. La réponse de Scikit-learn à cette tendance — le déploiement graduel du support de l'API Array — a fait un pas significatif en avant dans la version 1.9. La version élargit l'exécution compatible GPU à un ensemble d'estimateurs et de métriques plus large, découplant davantage scikit-learn de l'hypothèse que tous les calculs se font sur un CPU avec des tableaux NumPy.

Dans la version 1.9, les principaux estimateurs à bénéficier du support GPU via l'API Array sont :

• linear_model.LogisticRegression avec solver="lbfgs" — l'un des estimateurs les plus largement utilisés dans la bibliothèque s'exécute désormais nativement sur GPU
• linear_model.PoissonRegressor avec solver="lbfgs" — critique pour les données de dénombrement et les applications d'assurance ou actuarielles
• kernel_approximation.Nystroem — l'approximation du noyau accélérée par GPU déverrouille les flux de travail SVM à kernel à grande échelle
• pipeline.FeatureUnion — permettant des pipelines de combinaison de fonctionnalités multi-branches entièrement accélérées par GPU

Les fonctions de métrique ont également acquis une couverture dans 1.9 : d2_absolute_error_score, d2_pinball_score, et average_precision_score acceptent désormais des entrées conformes à l'API Array, ce qui signifie qu'elles peuvent fonctionner directement sur des tenseurs GPU sans copier les données vers le CPU. La version est également livrée avec un nouvel utilitaire, sklearn.utils._array_api.move_estimator_to, qui permet aux ingénieurs de déplacer les attributs de tableau d'un estimateur ajusté vers un appareil ou un espace de noms différent — un activateur critique pour les pipelines ML multi-appareil où le prétraitement peut se faire sur CPU tandis que l'inférence s'exécute sur GPU.

Les implications pratiques sont substantielles. Les benchmarks indépendants publiés par :probabl. en mars 2026 ont démontré des accélérations jusqu'à 15x dans les pipelines scikit-learn complexes lors de l'exécution sur GPU via l'API Array. Bien que ces gains dépendent fortement du type de modèle et de la taille des données — les ensembles de données plus petits ne voient souvent aucun bénéfice en raison des frais de transfert de données — ils valident la direction stratégique : pour les grands ensembles de données tabulaires et les pipelines intensifs en calcul, le sklearn accéléré par GPU est maintenant une option de production viable.

Modernisation de l'Interface Éparse

La version 1.9 introduit également la clé de configuration "sparse_interface", qui permet aux utilisateurs de contrôler si scikit-learn retourne des matrices éparses SciPy ou la nouvelle interface de tableau éparse :

import sklearn
sklearn.set_config(sparse_interface="sparray")  # opt into sparse arrays

Cela fait partie d'un alignement plus large avec la direction de l'écosystème SciPy, qui s'est déplacée du format legacy csr_matrix vers csr_array depuis SciPy 1.8. Le défaut actuel reste "spmatrix" pour la compatibilité rétroactive, mais l'équipe a signalé un changement de défaut futur vers "sparray" dans les versions à venir. Les ingénieurs construisant de nouveaux pipelines devraient envisager d'opter pour la nouvelle interface dès aujourd'hui pour éviter une migration disruptive plus tard.

Intégration Narwhals : Un Chemin Plus Léger vers l'Interopérabilité des DataFrames

L'un des changements plus discrets mais stratégiquement importants dans scikit-learn 1.9 est l'ajout de narwhals comme nouvelle dépendance de bibliothèque. Narwhals est une couche de compatibilité légère qui permet au code Python de fonctionner de manière transparente sur plusieurs bibliothèques dataframe — principalement pandas et Polars — sans nécessiter de branchement conditionnel spécifique à la bibliothèque. En adoptant narwhals, scikit-learn reconnaît une réalité que les praticiens ont ressentie au cours des deux dernières années : l'écosystème des données Python n'est plus synonyme de pandas seul.

L'impulsion immédiate pour ce changement est la dépréciation du protocole d'échange de dataframe (__dataframe__) par l'équipe Polars. Scikit-learn s'était appuyé sur ce protocole pour gérer les non-pandas dataframes via son API set_output, introduite dans la version 1.2. Avec Polars dépouillant le protocole, l'équipe sklearn avait besoin d'une solution plus robuste qui ne se briserait pas à mesure que l'API Polars continuerait à évoluer. Comme l'explique le changelog de la version 1.9, narwhals fournit exactement cela : une interface unifiée et légère qui se situe au-dessus de la couche dataframe et traduit les opérations vers la bibliothèque sous-jacente.

Pour les ingénieurs ML, c'est une amélioration significative de la qualité de vie avec des implications de production réelles. Polars, qui priorise la performance via l'évaluation paresseuse, le traitement multi-threadé et un backend Rust, a gagné une traction substantielle comme alternative à pandas pour le prétraitement des données à grande échelle. Les équipes qui ont migré leurs pipelines de prétraitement en amont vers Polars peuvent maintenant utiliser set_output(transform="polars") dans scikit-learn sans rencontrer les problèmes de compatibilité qui ont tourmenté l'approche du protocole d'échange. Le pont narwhals garantit que les sorties de transformateur de sklearn — qu'elles proviennent de StandardScaler, ColumnTransformer, ou des estimateurs personnalisés — peuvent être retournées en tant que DataFrames Polars nativement, préservant le contexte d'exécution paresseuse en aval.

Le choix de narwhals — un projet communautaire plutôt qu'une solution première partie de l'une ou l'autre équipe pandas ou Polars — reflète la préférence de l'équipe scikit-learn pour la neutralité de l'écosystème. Plutôt que de miser sur l'API interne d'une bibliothèque dataframe, ils ont adopté une couche d'abstraction qui évoluera aux côtés de l'écosystème plus large. C'est la même approche philosophique qui a motivé l'adoption de l'API Array : où possible, scikit-learn devrait être un consommateur des normes communautaires plutôt qu'un définisseur d'interfaces propriétaires.

Pour les data scientists travaillant à l'intersection de sklearn et de l'outillage moderne de la pile de données — des pipelines qui ingèrent depuis Parquet via DuckDB, prétraitent avec Polars, et modélisent avec sklearn — narwhals ferme une lacune qui nécessitait auparavant des étapes de conversion manuelles ou du code de wrapper personnalisé. Le pipeline de bout en bout peut désormais rester en territoire Polars-natif tout au long de l'étape de transformation sklearn.

Scikit-learn et Hugging Face Hub : 800 Modèles et un Partenariat Approfondi

La version 1.9 de scikit-learn n'inclut pas de nouveau code d'intégration Hugging Face première partie, mais elle arrive dans un écosystème qui s'est tranquillement amélioré depuis le juin 2022, quand Hugging Face est devenu un sponsor officiel du consortium scikit-learn à la Fondation Inria à Paris. Ce partenariat, maintenant dans sa quatrième année, a produit des changements d'infrastructure concrets qui transforment la façon dont les modèles ML classiques sont partagés, déployés et découverts.

La pièce maîtresse de l'intégration sklearn–Hugging Face est skops, une bibliothèque Python conçue à cet effet pour combler les deux écosystèmes. Skops fournit deux capacités principales qui répondent à de véritables points de douleur dans la distribution des modèles ML classique :

1. Sérialisation sécurisée via skops.io — les modèles scikit-learn sont empaquetés en tant qu'archives zip avec les fichiers de schéma JSON d'accompagnement, remplaçant le format pickle non sécurisé qui a longtemps été une préoccupation de sécurité dans le partage de modèles ML. Contrairement à pickle, le format skops permet aux consommateurs de modèles d'inspecter la structure d'objet complète avant de le charger, fournissant une sauvegarde significative contre les attaques de chaîne d'approvisionnement via les fichiers de modèles malveillants — un vecteur de menace qui est devenu de plus en plus pertinent à mesure que le Hub Hugging Face se scale.
2. Intégration du Hub Hugging Face via skops.card — avec skops, les ingénieurs peuvent pousser les modèles sklearn entraînés directement vers le Hub, générer automatiquement des cartes de modèle à partir des métadonnées d'estimateur, et rendre les modèles disponibles pour l'inférence en navigateur via les Hugging Face Spaces. La génération de carte de modèle seule supprime un fardeau de documentation qui a auparavant découragé les praticiens de partager les modèles ML classiques publiquement.

L'échelle de cette intégration est reflétée dans les statistiques actuelles du Hub : en juin 2026, il y a 799 modèles scikit-learn hébergés sur le Hub Hugging Face, couvrant la classification tabulaire, la régression tabulaire, et un ensemble croissant de tâches de prédiction structurée y compris la notation du crédit, la détection de fraude, la prédiction du churn client, et la stratification du risque médical. Ce nombre représente une bibliothèque qui, il y a quatre ans, avait pratiquement aucune présence sur le Hub — la plateforme Hugging Face a été construite principalement autour des modèles de deep learning pour NLP, la vision, et l'audio. La croissance des modèles sklearn sur le Hub signale un élargissement important de la portée de la plateforme : elle devient un foyer pour toute la pile ML, pas seulement les réseaux de neurones.

Le Capital Humain Derrière le Partenariat

L'investissement institutionnel soutenant la collaboration est également remarquable. Deux développeurs expérimentés sont intégrés à Hugging Face spécifiquement pour faire avancer l'écosystème sklearn : Adrin Jalali, un contributeur principal de scikit-learn qui a été central dans la gouvernance et la conception des API de la bibliothèque, et Benjamin Bossan, auteur de la bibliothèque skorch largement utilisée qui comble scikit-learn et PyTorch. Leur présence à Hugging Face garantit que l'intégration est menée par des ingénieurs qui comprennent les internals de scikit-learn au niveau requis pour construire un outillage fiable et compatible vers l'avant.

Le partenariat a également une profondeur institutionnelle via la bibliothèque Evaluate, le cadre Hugging Face pour une évaluation ML efficace et standardisée. La bibliothèque evaluate est en train d'être étendue pour supporter nativement les métriques scikit-learn dans son API, ce qui permettrait aux ingénieurs de calculer et de comparer les métriques sklearn — précision, rappel, F1, AUC, calibration — aux côtés des métriques de deep learning au sein d'un seul pipeline d'évaluation. C'est une étape importante vers un outillage d'évaluation ML unifié sur les approches classiques et neurales, réduisant la complexité opérationelle qui vient actuellement de la maintenance de code d'évaluation séparé pour différentes familles de modèles.

Ce que la Version 1.9 de Scikit-learn Signifie pour les Modèles Hébergés sur le Hub

Pour les 799 modèles déjà hébergés sur le Hub, les améliorations de scikit-learn 1.9 se traduisent directement dans une meilleure qualité de modèle. La manipulation améliorée des poids d'échantillon dans les modèles basés sur les arbres et la stabilité numérique améliorée dans les modèles de régression ridge signifient que les modèles rentraînés sur 1.9 devraient produire des sorties statistiquement plus correctes, particulièrement pour les modèles entraînés sur des données d'enquête ou administratives où les poids d'échantillon sont courants. Les ingénieurs qui maintiennent les modèles sklearn sur le Hub devraient envisager de réexécuter l'entraînement avec la version 1.9 et de mettre à jour leurs cartes de modèle — la nouvelle vue HTML d'estimateur rend la génération de descriptions d'architecture de modèle précises considérablement plus facile.

Améliorations Supplémentaires : Algorithmes Plus Rapides, Visualisations Plus Intelligentes, et Dépréciations Clés

Au-delà des fonctionnalités principales, scikit-learn 1.9 est livrée avec un ensemble dense d'améliorations algorithmiques, de mises à niveau de visualisation, et de corrections de bogues qui bénéficient au travail quotidien d'ingénierie ML. Plusieurs d'entre elles méritent l'attention des praticiens qui pourraient autrement les négliger dans les notes de version.

Gains de Performances Algorithmiques

FastICA avec l'algorithme de déflation est environ 10x plus rapide dans la version 1.9, une amélioration dramatique pour les équipes utilisant l'analyse des composantes indépendantes pour la séparation des signaux en traitement audio, neurosciences (EEG/IRMf), ou la décomposition de séries chronologiques financières. RidgeCV et RidgeClassifierCV — parmi les modèles les plus couramment déployés en ML classique de production — sont maintenant à la fois plus rapides et numériquement plus stables, traitant les cas limites qui pourraient produire une sélection d'alpha peu fiable sur les matrices de conception mal conditionnées. Le résolveur ARPACK eigenvalue utilisé dans SpectralEmbedding a été optimisé, bénéficiant aux flux de travail d'apprentissage de variétés basés sur le graphe qui s'appuient sur la décomposition en valeurs propres de grandes matrices éparses.

Nouvelle Fonction metric_at_thresholds()

La nouvelle fonction metrics.metric_at_thresholds() calcule les valeurs des métriques sur tous les seuils de classification possibles d'une seule passe sur les prédictions du modèle. Avant cet ajout, calculer les courbes de sensibilité au seuil pour les classificateurs binaires — une tâche courante en diagnostique médical, détection de fraude, et toute application où le point de fonctionnement est réglable — nécessitait soit du code de boucle personnalisé, soit du post-traitement des sorties precision_recall_curve() et roc_curve(). La nouvelle fonction standardise ce flux de travail et s'intègre proprement avec le reste de l'API de métriques sklearn.

Visualisations HTML d'Estimateur Plus Riches

La représentation HTML des estimateurs ajustés dans les notebooks Jupyter a été considérablement améliorée. Les attributs ajustés (ceux finissant par _, tels que coef_, feature_importances_, et n_iter_) sont maintenant affichés dans un tableau structuré dans la vue HTML, permettant aux ingénieurs d'inspecter les paramètres appris en un coup d'œil sans appeler print(model.coef_). ColumnTransformer affiche maintenant les noms des entités de sortie avec les boutons de copier-coller dans la visualisation, rendant dramatiquement plus facile de tracer comment les entités d'entrée sont mappées via les pipelines de prétraitement complexes. Pour les équipes qui utilisent Jupyter pour le développement de modèle exploratoire et la communication avec les parties prenantes, ces améliorations de visualisation réduisent significativement les frictions d'inspection de modèle.

Améliorations des Modèles d'Arbre et Linéaires

RandomForestRegressor supporte maintenant la gestion native des valeurs manquantes lors de l'utilisation du critère absolute_error — fermant une lacune qui forçait les praticiens à imputer les données avant d'adapter les modèles d'ensemble dans les contextes (tels que les dossiers médicaux ou les données de capteur) où l'absence d'information a du sens et ne doit pas être imputée. La version améliore également la correction statistique de la gestion des poids d'échantillon dans HistGradientBoosting, RandomForest, et ExtraTree, abordant les biais subtils qui pourraient affecter les modèles entraînés sur des ensembles de données déséquilibrés ou des données d'enquête avec des poids de probabilité. De plus, les modèles linéaires multi-tâches supportent maintenant les matrices d'entrée éparses X et les poids d'échantillon — une capacité importante pour les praticiens NLP qui utilisent la régression multi-sorties sur les matrices document-entité éparses.

Dépréciations à Surveiller

La version 1.9 introduit plusieurs dépréciations que les équipes doivent planifier les migrations avant les changements de rupture programmés dans les versions 1.11 et 1.12 :

• criterion="friedman_mse" dans les modèles basés sur les arbres est dépréciée ; le critère standard "squared_error" est le remplacement recommandé
• Le paramètre SVC.probability est déprécié ; le remplacement recommandé est CalibratedClassifierCV enveloppant un SVC(probability=False) de base
• Le paramètre n_alphas est déprécié dans lasso_path() et enet_path()
• La notation par défaut dans LogisticRegressionCV changera de la précision à "neg_log_loss" dans la version 1.11 — un changement statistiquement motivé qui peut surprendre les équipes s'appuyant sur le comportement par défaut actuel pour la sélection de modèle basée sur le seuil

Ces dépréciations suivent la convention de scikit-learn d'avertir deux versions majeures avant les changements de rupture, donnant aux équipes une piste de roulement adéquate pour mettre à jour leur code sans refactor d'urgence.

Fuentes

• Scikit-learn release 1.9 : better numerics, new core functionality (Blog scikit-learn)
• Version 1.9 — scikit-learn 1.9.0 release notes (scikit-learn.org)
• scikit-learn and Hugging Face join forces (Blog scikit-learn)
• Models compatible with the scikit-learn library (Hub Hugging Face)
• skops — Python library for secure scikit-learn model sharing (GitHub)
• Accelerating scikit-learn with GPUs: 15x speed-ups via Array API (blog :probabl.)
• scikit-learn 1.9.0 on PyPI
• Update on array API adoption in scikit-learn (Quansight Labs)