Depuis décembre 2018 · Mis à jour en octobre 2026

Un environnement Python pratique pour l'intelligence artificielle

Guide d'installation et d'outillage pour l'IA, l'apprentissage automatique, la vision et le langage en Python, écrit pour les scientifiques, les étudiants et les équipes de laboratoire.

Par Warith Harchaoui, Mohamed Chelali, Matias Tassano, Pierre-Louis Antonsanti, Bachir Zerroug et Edmond Jacoupeau.

En service quotidien au laboratoire de mathématiques appliquées MAP5. Vos remarques et vos corrections sont les bienvenues : écrivez à Warith Harchaoui.

Introduction

Cette page répond à la question qui revient sans cesse : qu'est-ce que j'installe aujourd'hui pour faire de l'apprentissage automatique, de la vision ou du langage en Python ?

Elle prend parti, délibérément. La section 1 donne ce que nous installons sur toute machine neuve du laboratoire. La section 2 propose un tableau pour les cas où ce choix ne convient pas. Les sections 3 à 6 traitent des bibliothèques, de la carte graphique, des notebooks et des éditeurs, puis du chemin qui mène d'un essai à une démonstration présentable. La section 7 rassemble les recettes longues, une par système, prêtes à coller. La section 8 dit pourquoi nous gardons un équivalent libre à côté de chaque service commercial.

Elle évolue avec le domaine. Les commandes qu'elle donne sont celles que nous taperions aujourd'hui, pas celles d'il y a deux ans.

Sommaire

1. Qu'est-ce que j'installe aujourd'hui ?
2. Quelle configuration correspond à ma situation ?
3. Le socle Python pour l'apprentissage automatique
4. Carte graphique : NVIDIA CUDA ou Apple Silicon
5. Notebooks, éditeurs et agents de code
6. Du notebook à la petite application
7. Les recettes d'installation complètes
8. Notes historiques et philosophiques

1. Qu'est-ce que j'installe aujourd'hui ?

Toute la page tient en quatre commandes. Le reste n'est que le détail autour.

Il vous faut Miniconda d'abord. Les commandes ci-dessous reposent sur conda, livré avec Miniconda, une Anaconda allégée. La ligne d'installation dépend de votre système : prenez celle de votre machine en section 7, qui couvre Ubuntu, macOS sur Apple Silicon et Windows 11, puis revenez. Si conda --version répond déjà, passez votre chemin.

Une fois conda dans votre PATH, ouvrez un terminal neuf :

conda create -n env4ml python=3.13
conda activate env4ml
pip install scikit-learn pandas matplotlib seaborn jupyterlab
pip install torch torchvision torchaudio

Quatre lignes, et vous avez l'apprentissage automatique classique (scikit-learn), les outils de données (pandas, matplotlib, seaborn), les notebooks (JupyterLab) et l'apprentissage profond (PyTorch). PyTorch embarque ses moteurs mps (Apple Silicon) et CUDA dans la même wheel, et l'installation par défaut retient celui qui correspond à votre machine.

Trois cas demandent un détour : une wheel NVIDIA CUDA précise, un Windows natif, ou la configuration de classe sans PyTorch. Les recettes de la section 7 les traitent une à une. Si votre situation n'entre dans aucune de ces cases, le tableau de la section 2 propose autre chose. Et si vous ne voulez rien installer du tout, Google Colab vous ouvre un notebook distant, carte graphique comprise, avec NumPy, pandas, scikit-learn et PyTorch déjà en place.

Avant d'installer : quelques avertissements

• N'installez jamais ces paquets à l'échelle du système. Un environnement par projet vous épargne les conflits de pip qui coûtent une journée à démêler.
• Ne courez pas après le Python le plus récent. Python 3.13 est le choix sûr aujourd'hui : toutes les bibliothèques de la section 3 publient des wheels pour lui. Python 3.14 existe et PyTorch le prend déjà en charge, mais quelques paquets plus petits traînent, et il faut en général quelques mois pour que l'écosystème suive une version nouvelle. Python 3.12 fonctionne encore partout : un environnement qui tourne bien peut rester où il est. En production comme en cours, mieux vaut ce qui marche partout que ce qui vient de sortir.
• C'est la carte graphique qui fait le plus mal. Si une installation sur processeur suffit, livrez-la d'abord et ajoutez la carte ensuite.
• Pour enseigner, visez la reproductibilité avant la vitesse. Une configuration un peu lente que toute la classe sait installer vaut mieux qu'une configuration rapide qui casse chez un tiers des étudiants.
• Pour l'apprentissage profond à grande échelle, CUDA reste le pari le plus sûr. Apple Silicon excelle pour prototyper ; les entraînements sérieux finissent sur NVIDIA.

2. Quelle configuration correspond à ma situation ?

L'installation de la section 1 convient à la plupart des lecteurs. Si la vôtre est plus particulière, une carte graphique donnée, une contrainte d'enseignement, un travail entièrement dans le cloud, cherchez votre ligne et suivez-la.

3. Le socle Python pour l'apprentissage automatique

En quelques décennies, le domaine est passé de Java à MATLAB puis à Python. Les entreprises qui pèsent mille milliards s'y sont arrêtées, la recherche a suivi avec ses financements et ses outils. Nous conseillons Python pour cette raison et pas par goût : c'est là que tout se passe. Si votre équipe travaille en R ou en Java, ONNX-R et DL4J vous permettent de livrer quand même. Rust progresse régulièrement : le site arewelearningyet.com en tient la chronique.

Les boîtes à outils que nous conseillons

Classées par date de sortie de l'outil principal, ce qui donne au passage une petite histoire du domaine. Les notebooks, les éditeurs et les agents de code ont leur section à eux, la section 5.

• Vision par ordinateur : bibliothèques, modèles, annotation, plateforme (depuis 2000). Cinq outils, du pixel brut au service en ligne :
  • Vision classique : OpenCV (2000). Traitement d'image, transformations géométriques, calibration de caméra, suivi d'objets. Un cœur en C++ et des liaisons Python. Pour tout ce qui ne demande pas d'apprentissage, c'est encore la bonne réponse.
  • Détection et segmentation : Detectron2 (Meta FAIR, 2019), boîte à outils PyTorch modulaire pour la détection, la segmentation, les points clés et le panoptique. Recettes éprouvées, collection de modèles, boucle d'entraînement lisible : à prendre quand vous voulez la main sur l'architecture. Pour aller plus vite, la lignée YOLO d'Ultralytics (pip install ultralytics) domine le prêt-à-l'emploi. YOLO26, la version courante, couvre la détection, la segmentation d'instances et sémantique, l'estimation de profondeur, la classification, la pose et les boîtes orientées. YOLOv8, YOLO11 et YOLO12 restent livrés et restent bons. Licence AGPL-3.0, avec une licence commerciale pour un usage fermé.
  • Annotation : CVAT, sous licence MIT, est la référence libre pour étiqueter images et vidéos : classification, détection, étiquetage temporel, segmentation, points clés, reconnaissance de texte. L'édition communautaire est gratuite. Avec un agent de code à côté, vous montez des chaînes d'annotation sérieuses sans écrire la plomberie vous-même.
  • Plateforme hébergée et dépôt de modèles : Roboflow (2020) couvre aujourd'hui toute la chaîne, entraîner, déployer, servir, avec Roboflow Universe comme dépôt public de modèles et de jeux de données. L'annotation existe toujours, mais ce n'est plus là que se trouve l'intérêt principal.
  • Représentations auto-supervisées : DINOv3 (Meta FAIR, 2025) produit d'excellentes représentations d'images apprises sans étiquettes. À utiliser comme couche figée pour classer, chercher ou segmenter quand vous avez peu d'étiquettes.
• Apprentissage automatique classique (depuis 2007). scikit-learn, la bibliothèque de référence pour classer, régresser, partitionner et choisir un modèle. Interface stable, réglages par défaut sensés, documentation remarquable. Commencez là, sauf si votre problème réclame vraiment l'apprentissage profond.
• Apprentissage profond (depuis 2015). Aujourd'hui je commencerais par PyTorch (2016) : c'est là que se fait la recherche, là que l'écosystème est le plus riche, et là que les architectures nouvelles arrivent en premier. TensorFlow (2015) garde trois atouts : son écosystème, son outillage de production, et le déploiement sur mobile et embarqué par TF Lite et LiteRT.
• Les surcouches (depuis 2015). Keras 3 tourne désormais sur TensorFlow, JAX ou PyTorch, avec OpenVINO pour l'inférence : une seule écriture Python par-dessus plusieurs moteurs. PyTorch Lightning (2019) vous débarrasse du code répétitif de la boucle d'entraînement et vous offre le calcul distribué et les sauvegardes sans effort.
• Langage et grands modèles : traitement classique, transformeurs, inférence locale, recherche, évaluation (depuis 2015). Cinq outils, du découpage en mots jusqu'à l'évaluation :
  • Traitement classique et représentations de mots : spaCy (2015) découpe, reconnaît les entités, analyse les dépendances et étiquette la grammaire, à l'échelle industrielle. fastText (Meta, 2016) produit des représentations de mots très rapides et classe du texte multilingue : cœur C++, liaisons Python, et une référence de comparaison toujours difficile à battre pour son coût.
  • Transformeurs et embeddings : Hugging Face Transformers (2018) pour les modèles pré-entraînés, encodeurs, décodeurs et séquence à séquence ; sentence-transformers (2019) pour les embeddings sémantiques et la recherche. Voir aussi l'entrée Hugging Face plus bas.
  • Faire tourner un grand modèle chez soi : Ollama (2023) est le plus simple, un démon local qui enveloppe llama.cpp pour l'inférence quantifiée sur processeur, sur Apple Silicon ou sur CUDA. Pour servir à l'échelle d'une production, avec attention paginée, lots continus et interface compatible OpenAI, prenez vLLM (2023). Quant au modèle lui-même, c'est la taille qui tranche : en dessous, quand il doit tenir sur un portable, un téléphone ou un appareil embarqué, la famille Qwen est la plus solide ; au-dessus, avec une vraie carte graphique, Gemma tient mieux la route.
  • Recherche documentaire et orchestration : LangChain ou LlamaIndex (2022) assemblent recherches, invites et appels d'outils. Ajoutez un entrepôt de vecteurs : FAISS (Meta) donne l'index approché de référence, dans votre processus. Quand la mémoire compte, prenez turbovec (2026 ; cœur Rust, liaisons Python, bâti sur le TurboQuant de Google Research) : il comprime des embeddings de 32 bits vers 2 ou 4 bits et loge une dizaine de millions de vecteurs dans 4 Go sans perdre grand-chose en rappel, et sans entraînement séparé. C'est mon index approché préféré en local. Qdrant ou Chroma quand il vous faut un service à part.
  • Évaluer un grand modèle : DeepEval (2023) écrit des tests en forme d'assertions, avec un modèle comme juge, dans un lanceur qui ressemble à Pytest. Ragas (2023) mesure ce qui est propre à la recherche documentaire : pertinence du contexte, fidélité, justesse de la réponse.
• Équité, explicabilité, causalité (depuis 2016). Six outils, à passer avant que le modèle parte, pas le jour où un régulateur pose la question :
  • Mesurer et corriger les biais : Fairlearn (Microsoft, 2018) fournit la parité démographique, l'égalité des chances, et un catalogue d'algorithmes de correction.
  • Expliquer une prédiction : SHAP (2017) attribue à chaque variable sa part de responsabilité par les valeurs de Shapley, et c'est la réponse habituelle sur des tableaux et des arbres. Shapash (MAIF, 2020) se pose dessus avec une couche lisible par le métier : libellés clairs, application web intégrée, export des rapports individuels en un appel. Prenez-le quand l'explication s'adresse à quelqu'un qui n'est pas de l'équipe. LIME (2016), plus ancien, reste utile comme contrôle de bon sens.
  • Et si on changeait l'entrée ? FACET (BCG X, 2020) explique et simule par-dessus scikit-learn. DiCE (Microsoft, 2020) répond à « quel changement minimal ferait basculer cette prédiction ? » en proposant plusieurs réponses plutôt qu'une.
  • Auditer de bout en bout : Aequitas (CMU DSSG, 2018) emballe le zoo des mesures dans un audit complet, avec un rapport par groupe protégé. Utile quand il faut montrer votre travail à un relecteur non technique.
  • Attribution sur réseaux profonds : Captum (Meta et PyTorch, 2019) pour les gradients intégrés et les autres méthodes d'attribution. What-If Tool (Google PAIR, 2018) permet de tripoter les entrées à la main dans TensorBoard ou Colab.
  • Causalité : PyWhy (2022, issu de Microsoft Research) rassemble l'écosystème libre. Sa bibliothèque centrale, DoWhy, déroule quatre temps, modéliser, identifier, estimer, réfuter, pour répondre à « est-ce que X cause Y ? » et non à « peut-on prédire Y à partir de X ? ». EconML traite le cas où la réponse dépend du sous-groupe. La différence avec les contrefactuels ci-dessus tient en une phrase : ceux-là demandent quel changement d'entrée ferait basculer la prédiction, ceux-ci quelle intervention changerait le résultat.
• Préparer des données tabulaires (depuis 2017). skrub, autrefois dirty_cat, renommé en 2024, vient de la famille Probabl et Inria autour de scikit-learn. Il transforme des tableaux sales en variables exploitables : jointures floues sur des clés textuelles approximatives, encodeurs pour les catégories à forte cardinalité (GapEncoder, MinHashEncoder, TableVectorizer), et une référence en un appel, tabular_pipeline(), renommée depuis tabular_learner(), si bien que les exemples anciens demandent le nouveau nom. À sortir dès que votre fichier CSV doit être nettoyé avant d'atteindre une chaîne scikit-learn.
• Modèles de fondation pour les tableaux (depuis 2022). Résultat inattendu de la vague des modèles de fondation : des transformeurs pré-entraînés égalent ou battent des arbres de gradient bien réglés sur des tableaux de taille petite à moyenne, sans le moindre entraînement sur vos données. Deux comptent. TabPFN vient du laboratoire de Frank Hutter, NeurIPS 2022, avec sa v2 publiée dans Nature en 2025. TabICL vient de l'équipe SODA d'Inria, d'abord à ICML 2025 ; sa v2, présentée à ICML 2026, gagne en justesse et livre pour la première fois un régresseur à côté du classifieur. Tous deux lisent votre tableau d'entraînement comme des exemples et prédisent les lignes de test en une seule passe, sans descente de gradient ni recherche d'hyperparamètres. La vieille question « XGBoost règne-t-il encore sur le tabulaire ? » commence enfin à bouger : essayez-en un avant de sortir une pile qu'il faut entraîner.
• Modèles pré-entraînés pour la vision, le langage et la parole (depuis 2018). Hugging Face : le dépôt de modèles et les bibliothèques transformers, diffusers et datasets. C'est par là que passent les modèles à poids ouverts, et un from_pretrained() d'une ligne y joue le rôle qu'avait le pip install.
• Tester une IA (depuis 2022). Cinq outils. Un chiffre de justesse sur un jeu de validation teste une chose ; ceux-ci testent le reste :
  • Analyser un modèle ou un agent : Giskard (2022, libre sur GitHub avec un service hébergé à côté) est ce qui ressemble le plus à un « qu'est-ce qui cloche dans ce modèle ? » en un appel : robustesse, performance, hallucination, injection d'invite, biais. Sa version 3 s'est déplacée des modèles tabulaires vers l'évaluation et l'attaque des systèmes agentiques, là où se trouvent désormais les pannes difficiles.
  • Tests unitaires de grands modèles : DeepEval (2023, libre sur GitHub) met les mesures à base de modèle juge dans un lanceur en forme de Pytest, et vous écrivez des assertions sur l'hallucination, la pertinence, la qualité d'un résumé. À poser à côté de votre suite de tests habituelle.
  • Mesures propres à la recherche documentaire : Ragas (2023), à associer à DeepEval quand le système cherche et génère à la fois.
  • Attaquer son propre système : PyRIT (Microsoft, 2024) automatise l'attaque d'une IA générative. garak (NVIDIA, 2023) est le scanneur de vulnérabilités : injection d'invite, contournement des garde-fous, fuite de données, sondes d'hallucination.
  • Valider les données : Great Expectations (2017) et Pandera (2019) vérifient les données avant qu'elles atteignent le modèle. On ne teste pas un modèle dont on ne sait pas auditer les entrées.
• Suivre un projet (depuis 2024). Skore, de Probabl, l'entreprise scikit-learn, se pose sur scikit-learn et vous donne une évaluation qui prend parti, une comparaison de modèles et un tableau de bord. À sortir dès que vous avez plus d'un modèle à départager.

AI helpers

Dix-sept bibliothèques Python sous licence BSD-3-Clause, que Warith maintient avec Mohamed Chelali et Bachir Zerroug, en ligne depuis avril 2024. L'index complet se trouve sur deraison.ai/ai-helpers. Chacune couvre un coin précis de la chaîne IA et média, pour vous éviter de réécrire la même plomberie à chaque projet. Prenez le coin qu'il vous faut : chaque paquet tire os-helper tout seul.

Deux choses les distinguent, au-delà du confort. Toutes exposent les mêmes cinq surfaces : une interface Python, deux lignes de commande, un serveur HTTP FastAPI, un jeu d'outils MCP monté sur cette même application, et une compétence installable pour Claude Code ou OpenCode. La surface MCP n'est pas une seconde implémentation, ce sont les mêmes routes montées sur /mcp, donc les deux ne peuvent pas diverger. Et le local est le défaut : audio, vidéo, capture, voix, md2star et wallet tournent entièrement chez vous, sur ffmpeg, whisper.cpp, pyannote et un Ollama local. Les deux qui déplacent vos données, bucket-helper et sftp-helper, le disent franchement : c'est leur métier.

Le socle. os-helper : fichiers, empreintes, configuration, mesure du temps, sur tous les systèmes. La fondation des seize autres.

Son et voix. audio-helper charge, convertit, sépare les sources avec Demucs en option, découpe et recolle. vocal-helper transforme du son en paroles transcrites et attribuées à leur locuteur, sur Silero VAD, whisper.cpp et pyannote, en flux ou par lots, avec un résumé continu facultatif. speaker-helper fait le chemin inverse, du texte vers la parole, dans votre propre processus plutôt que derrière un serveur, et produit la piste minutée qui permet à une page de suivre mot à mot. discussion-helper referme la boucle en une vraie conversation parlée, qui s'arrête dès que vous coupez la parole.

Vidéo et capture. video-helper extrait les images par plusieurs moteurs, VidGear, PyAV ou un tuyau ffmpeg, convertit, et manipule les formats de sous-titres. capture-helper capture caméra et microphone en direct, avec un configurateur de scènes dans le navigateur.

Récupérer des médias. youtube-helper télécharge vidéo, son et vignettes depuis YouTube, Vimeo, DailyMotion, SoundCloud et Twitch, par yt-dlp. podcast-helper généralise la même promesse : une adresse entre, du son brut sort, qu'il s'agisse d'un fichier, d'une adresse directe ou d'un flux RSS, avec un rééchantillonnage conforme à Shannon.

Stockage et transfert. bucket-helper pour S3 et tout ce qui lui ressemble, MinIO, Backblaze B2, DigitalOcean Spaces, Cloudflare R2, Wasabi. sftp-helper pour SFTP, avec vérification stricte de la clé d'hôte.

Documents et cache. md2star fait le pont du Markdown vers DOCX, PPTX et PDF sur Pandoc, avec vos gabarits, le rendu Mermaid et les bibliographies. Sa commande twin refait le chemin à l'envers, d'un PDF vers un Markdown modifiable. wallet-helper vous évite de relancer deux fois le même appel coûteux : une mémoïsation persistante indexée sur le contenu du fichier et non sur son chemin, et un verrou qui fond en un seul appel ceux qui partent en même temps.

Décider plutôt que deviner. Trois d'entre elles répondent à une question que vous trancheriez sinon à l'habitude. best-engine-ai-helper mesure la machine sur laquelle il tourne, mémoire unifiée Apple, mémoire vidéo NVIDIA ou mémoire vive, puis choisit et télécharge le meilleur grand modèle local qui tienne dans une marge de sécurité. ann-router applique la même idée à la recherche vectorielle : décrivez votre problème en chiffres, taille du jeu, dimension, rappel visé, budget mémoire, et il choisit puis justifie un moteur parmi la recherche exacte, turbovec, HNSW, FAISS, Annoy, Qdrant et pgvector. elbow-helper s'attaque à la version difficile de la question du coude : non pas « où est le coude ? », à quoi un algorithme répond toujours quelque chose, même sur du bruit, mais « y en a-t-il un ? », avec le droit de s'abstenir.

Comparer plutôt qu'affirmer. standpoint transforme un tableau de comparaison en une carte de positionnement légendée, accompagnée d'un YAML de toutes les coordonnées : le placement devient vérifiable au lieu d'être dessiné à la main.

Cinq d'entre elles ont une réécriture en Rust, publiée sur crates.io et non sur PyPI, pour les machines sans Python : audio-helper-rs, capture-helper-rs, podcast-helper-rs, youtube-helper-rs et md2star-rs. Elles couvrent moins de terrain en échange d'un encombrement minuscule, et ne remplacent pas les versions Python trait pour trait.

4. Carte graphique : NVIDIA CUDA ou Apple Silicon

Deux chemins matériels se partagent le travail en 2026, et ils ne servent pas aux mêmes choses. Prenez celui qui correspond à la tâche devant vous.

NVIDIA CUDA

La configuration de référence pour entraîner sérieusement : écosystème mûr, la plus grande collection de modèles, le plus d'outillage tiers, et le seul chemin réaliste pour l'entraînement à grande échelle et l'inférence à fort débit.

• Pour : l'apprentissage profond à grande échelle, les gros lots, l'inférence en production.
• Installation par le sélecteur officiel de PyTorch, qui donne la bonne wheel CUDA.
• Cartes gratuites pour la recherche : le programme de dotation académique de NVIDIA.

Apple Silicon (série M)

Une option sérieuse pour travailler en local. La mémoire unifiée et le silence de la machine rendent l'expérimentation, le prototypage et l'enseignement agréables, et suffisent à quantité de travaux de taille moyenne. Ce n'est pas un remplacement de CUDA quand les modèles grossissent.

• Pour : le développement local, le prototypage, l'enseignement, les essais embarqués.
• PyTorch par le moteur Metal Performance Shaders, appareil mps.
• MLX, développé par Apple, pour une recherche à la manière de NumPy (voir aussi mlx-examples).

Règle pratique

Développez et prototypez sur la machine que vous avez sous la main ; Apple Silicon rend cela confortable. Quand l'expérience déborde du portable, passez sur une machine CUDA, une carte dans le cloud ou une grappe de calcul. L'installation d'une carte graphique coûte toujours du temps : déménagez une fois que le déménagement est rentable, et pas avant.

5. Notebooks, éditeurs et agents de code

L'endroit où vous écrivez compte presque autant que ce que vous écrivez. Trois couches se touchent tous les jours : les notebooks pour explorer, les éditeurs pour le vrai travail, et les agents de code, qui se posent désormais par-dessus.

Les notebooks

• JupyterLab : le notebook de référence dans le navigateur, pour explorer, montrer et enseigner. pip install jupyterlab, puis jupyter lab.
• Marimo (depuis 2023) : un notebook réactif enregistré en simple fichier .py, donc lisible dans un diff et compatible avec le suivi de versions. Les cellules forment un graphe de dépendances : changez une valeur en amont et tout ce qui en découle se recalcule, sans état caché et sans ces séances où l'on cherche dans quel ordre Jupyter a bien pu exécuter les choses. Ses composants d'interface (mo.ui.slider, mo.ui.dropdown, mo.ui.table) transforment le fichier en petite application avec marimo run notebook.py. Un Jupyter moderne, quand vous voulez la reproductibilité, la relecture de code et la démonstration dans le même objet.
• Google Colab : un notebook qui tourne sur les machines de Google plutôt que sur la vôtre. Pour quelques heures de calcul, ou pour une classe où tout le monde doit partir du même environnement.

Les éditeurs

VS Code reste le choix sûr au quotidien. Deux dérivés tournés vers l'IA sont apparus depuis 2023 :

• Cursor (Anysphere, 2023), le premier du genre. Complétion en ligne poussée et un mode agent qui lance des commandes. C'est l'éditeur auquel les équipes comparent tous les autres.
• Google Antigravity (2025), pensé pour les agents. Jusqu'à cinq travaillent en parallèle sous une vue d'orchestration, et l'éditeur embarque une fenêtre Chrome pour regarder l'interface qu'il vient de construire. Il est volontairement agnostique du modèle : Gemini par défaut, avec des modèles Anthropic ou à poids ouverts choisissables agent par agent. Nous ne citons pas de versions ici, parce que cette liste se renouvelle tous les deux ou trois mois.
• Dans la même famille, l'équivalent libre est Cline, extension sous Apache-2 : vous apportez votre clé, pour n'importe quel fournisseur, Ollama local compris, et il mène le classement libre de SWE-bench.

Les agents de code, une couche d'abstraction de plus

La programmation a toujours avancé par couches. Le code machine a cédé à l'assembleur, l'assembleur au C, le C à Python, JavaScript et Rust. Chaque couche a laissé le programmeur exprimer davantage son intention et confier davantage de mécanique à un outil, le compilateur. Les grands modèles de langage ajoutent la couche suivante : la langue naturelle devient la source, le code devient ce que la machine en tire.

C'est le point de vue de l'optimiste. Vue depuis l'autre bout de la pile, la même observation donne ceci, de la part du créateur de Linux :

Les deux ont raison en même temps. Karpathy décrit ce qui devient accessible : la plupart des gens obtiendront un programme utile en écrivant de l'anglais plutôt que du Python. Torvalds rappelle ce qui ne se délègue pas. Quelqu'un comprend ce que le compilateur, ou le modèle, a réellement produit, et c'est encore lui qui saura le déboguer, l'accélérer et le livrer. Le jugement, le débogage, les tests, l'architecture et le goût n'ont disparu nulle part. Un agent de code sert surtout quand on sait déjà ce qu'on veut construire : il amplifie une intention, il n'en fournit pas.

Pour un étudiant, la leçon tient en peu de mots. Traitez l'agent comme le compilateur suivant. Dites clairement ce que vous voulez, puis relisez d'un œil critique ce qui revient. Les deux que nous utilisons le plus :

Deux agents de code que nous recommandons

Claude Code

L'agent en ligne de commande d'Anthropic. Il lit votre dépôt, lance des commandes, modifie des fichiers et suit les compétences déclarées dans ~/.claude/skills/. Particulièrement bon en relecture, en remaniement, en débogage de bout en bout et sur les modifications qui touchent plusieurs fichiers à la fois.

OpenCode

Agent libre, dans le terminal, qui pilote Claude, GPT ou des modèles locaux derrière la même interface, et lit le même format de compétences depuis ~/.opencode/skills/. À choisir pour ne pas dépendre d'un seul fournisseur, ou pour faire tourner un modèle local sur du code sensible.

Les deux lisent le même format de compétences : un dossier contenant un SKILL.md, qui apprend un seul métier à l'agent et ne se charge que lorsque votre demande y correspond. La suite que nous employons pour tout ce qui finit sur un écran, de la page de démonstration à la figure d'un article, s'appelle Sprezzature, et fait l'objet de la section 6.

6. Du notebook à la petite application

Les projets suivent presque tous la même trajectoire :

Notebook → script → ligne de commande → petite interface web → démonstration déployée

Vous cherchez d'abord le modèle qui marche dans un notebook. Vous promouvez les cellules utiles en script, pour que l'expérience se rejoue. Vous habillez le script d'une ligne de commande, pour qu'un collègue le lance sans lire votre code. Vous posez une petite interface web par-dessus, pour qu'un interlocuteur l'essaie sans terminal. Et si tout cela survit, vous déployez.

À chaque barreau son outil. Voici comment je choisis.

Les générateurs de formulaires, côté Python

Pour aller vite du notebook à l'application, les options Python sont Streamlit, Gradio et Taipy. Chacune transforme du code en formulaire web en quelques minutes et couvre très bien le cas courant. Le prix à payer : le résultat ressemble à une application Streamlit, Gradio ou Taipy, parce que leur CSS se laisse mal reprendre. À la longue, elles se ressemblent toutes.

Quand vous avez déjà une ligne de commande : Sprezzature

Beaucoup de projets ont une ligne de commande qui marche avant d'avoir quoi que ce soit d'autre, en argparse, click ou Typer. La question devient alors : comment poser une interface utilisable par-dessus, sans tout réécrire en Streamlit ? Sprezzature est une réponse. C'est une suite de neuf compétences libres pour Claude Code et OpenCode, qui verrouille l'agent sur une seule pile côté navigateur, du JavaScript sans cadriciel avec Tailwind CSS et les trois familles Roboto, et lui remet un système de design déjà choisi.

Demandez à l'agent de « mettre une interface graphique sur cette ligne de commande ». Vous récupérez une page unique : index.html, app.js et une configuration Tailwind. Chaque option de votre analyseur d'arguments devient le bon contrôle de formulaire, et la sortie de la commande se déverse dans un panneau de journal. Pas de cadriciel qui vous retient, pas de moteur Python à servir, pas d'« air de Gradio » : du HTML ordinaire que vous pouvez modifier.

Les neuf compétences

Installez celles dont vous avez besoin. sprezzature-ui porte les règles de la pile et les jetons de design ; les autres en héritent.

Il y en avait une dixième, sprezzature-vision, fondue dans sprezzature-accessibility : l'outil qui repère un texte de remplacement manquant est aussi celui qui devrait savoir l'écrire.

Installation avec Claude Code

VERSION=$(curl -fsSL https://api.github.com/repos/warith-harchaoui/sprezzature/releases/latest \
  | sed -n 's/.*"tag_name": *"v\([^"]*\)".*/\1/p')
curl -L https://github.com/warith-harchaoui/sprezzature/releases/download/v${VERSION}/sprezzature-skills-${VERSION}.tar.gz | tar xz

mkdir -p ~/.claude/skills
cp -r sprezzature-ui sprezzature-cli-gui sprezzature-figures ~/.claude/skills/

Ou avec OpenCode

mkdir -p ~/.opencode/skills
cp -r sprezzature-* ~/.opencode/skills/

Documentation : sprezzature.ai. Dépôt : github.com/warith-harchaoui/sprezzature.

Pourquoi cela compte quand on fait de l'apprentissage automatique

• Votre ligne de commande garde l'exécution. Sprezzature ne produit que l'enveloppe d'interface et un mince adaptateur HTTP par-dessus l'existant. Vous ne réécrivez ni la boucle d'entraînement, ni le script d'inférence, ni le banc d'évaluation.
• Le résultat ressemble à votre projet, pas à l'outil. Ce qui sort est du Tailwind ordinaire, que vous pouvez lire, vérifier et retoucher.
• Chaque compétence fabrique, puis vérifie. La production va toujours avec un contrôle déterministe contre les règles annoncées : contrôle d'accessibilité, audit de contraste, auditeur des lois de l'expérience utilisateur. Ce contrôle est un script avec un code de sortie, pas un second avis du modèle.
• Quelqu'un regarde la figure. Une phrase, on la relit. Un graphique, non : sa justesse est dans les pixels, pas dans le code. La boucle de l'œil rend donc la figure en image, la fait regarder par l'agent ou par un modèle de vision hors ligne, corrige la source et recommence. Elle attrape l'étiquette coupée au bord et la légende sortie du cadre, que nul contrôle de code ne verra. Pour un laboratoire qui livre des figures dans ses articles et ses diapositives, c'est ce qui fait gagner le plus de temps.
• Les modèles peuvent rester chez vous. Textes de remplacement et sous-titres passent par un Ollama ou un whisper.cpp local si vous le demandez, et vos données non publiées ne quittent pas la machine.
• L'accessibilité et la traduction viennent avec le balisage. Anneaux de focus, variantes sombres et garde-fous de mouvement réduit sont posés d'office. Textes de remplacement, sous-titres, audit de contraste et extraction des chaînes vers un YAML de traduction ont chacun leur compétence : rien de tout cela n'est remis à plus tard.
• Vous pouvez vous passer de l'agent. Neuf des outils déterministes sont aussi des paquets pip (sprezzature-figures, sprezzature-colors, sprezzature-accessibility, sprezzature-cli-gui, sprezzature-ux-laws, sprezzature-audio, sprezzature-maps, sprezzature-publish, sprezzature-ui), utilisables comme bibliothèque Python, interface HTTP ou outils MCP.
• Tout cela se compose avec le reste. Posez le HTML produit dans Tauri pour une application de bureau, dans FastAPI pour une démonstration hébergée, ou derrière n'importe quel mandataire inverse.

Quand la démonstration doit partir

Dès qu'une page HTML pilote une ligne de commande, l'empaquetage devient simple. Tauri pour une application de bureau. FastAPI pour une démonstration hébergée avec une frontière HTTP nette. Un export ONNX quand le modèle doit quitter Python. Chaque étape s'ajoute sans rien réécrire, parce que la ligne de commande, le modèle et l'interface restent indépendants.

Servir le modèle en production

Servir un modèle, c'est l'héberger une fois entraîné, chez vous ou dans le cloud, et l'exposer derrière une interface pour que des applications s'y branchent. Pour le transporter d'un langage à l'autre, utilisez ONNX : à la fois un format de fichier et un moteur d'exécution, maintenu par une communauté libre avec Microsoft et la Linux Foundation AI. Prototypez en Python, puis déployez le fichier par ONNX Runtime en C, C++, C#, Java, JavaScript ou Objective-C.

Quand la performance décide, la route éprouvée reste le C ou le C++ appelé depuis un langage de plus haut niveau. Côté Python, pybind11 offre la meilleure expérience, et Meta s'en est servi pour fastText. Cython demeure solide, scikit-learn en étant la vitrine. Numba compile à la volée et convient bien aux boucles de calcul les plus sollicitées. Les coremltools d'Apple ouvrent l'accès au moteur neuronal depuis Python au moment de l'inférence.

7. Les recettes d'installation complètes

Voici la forme longue de la section 1. Elles servent dans trois cas : préparer une machine neuve, installer les pilotes NVIDIA et CUDA, ou obtenir un environnement de type Linux sur Windows. Partout, l'environnement s'appelle env4ml et Python est en 3.13, la version la plus récente pour laquelle toute la pile de la section 3 publie des wheels. Mettez 3.12 si un paquet dont vous dépendez n'a pas suivi.

Ubuntu (22.04 LTS ou supérieur)

1. Installer Miniconda :

   mkdir -p ~/miniconda3
   wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh
   bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
   rm -rf ~/miniconda3/miniconda.sh
   ~/miniconda3/bin/conda init bash
   

   Fermez et rouvrez le terminal, puis créez l'environnement :

   ENV=env4ml
   conda update -y -n base -c defaults conda
   conda create -y -n $ENV python=3.13
   conda activate $ENV
   conda install -y pip
   pip install scikit-learn pandas matplotlib seaborn jupyterlab
   

2. Pilote NVIDIA et CUDA : suivez les instructions de Google Cloud sur votre propre machine. Indispensable pour l'accélération NVIDIA.

   Installez ensuite PyTorch avec la wheel CUDA correspondante, par le sélecteur officiel. Prenez le suffixe cuXXX dans le sélecteur, pas sur cette page : chaque canal CUDA se fige dès que PyTorch cesse de construire pour lui, si bien qu'un suffixe périmé installe sans rien dire un vieux PyTorch au lieu d'échouer. En octobre 2026, le canal le plus récent est cu130 :

   pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu130

3. Activer l'environnement à chaque session :

   ENV=env4ml
   conda activate $ENV
   

macOS (Sonoma 14 ou supérieur, Apple Silicon)

Sur les Mac Apple Silicon, la situation s'est nettement améliorée. PyTorch sait viser le moteur Metal Performance Shaders par l'appareil mps, ce qui rend l'expérimentation locale confortable. Apple développe aussi MLX, une bibliothèque de tableaux proche de NumPy, avec différentiation automatique, pensée pour la recherche sur ses propres puces. Les deux sont excellentes en local ; pour les entraînements lourds, CUDA reste la référence (voir la section 4).

1. Outils en ligne de commande et Homebrew :

   xcode-select --install
   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
   brew install wget
   

2. Installer Miniconda (Apple Silicon, arm64) :

   mkdir -p ~/miniconda3
   curl https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh -o ~/miniconda3/miniconda.sh
   bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
   rm -rf ~/miniconda3/miniconda.sh
   ~/miniconda3/bin/conda init zsh
   

   Fermez et rouvrez le terminal, puis créez l'environnement :

   ENV=env4ml
   conda update -y -n base -c defaults conda
   conda create -y -n $ENV python=3.13
   conda activate $ENV
   conda install -y pip
   pip install scikit-learn pandas matplotlib seaborn jupyterlab
   pip install torch torchvision torchaudio
   

Windows 11

Pour 2026 nous recommandons Windows 11 à qui travaille en Windows natif. Mais pour tout travail sérieux d'apprentissage automatique, nous conseillons fortement WSL2, le sous-système Windows pour Linux. Vous y obtenez un vrai noyau Linux et un environnement proche de ce que font tourner les serveurs, si bien que les mêmes commandes marchent à trois endroits : votre portable, un exécuteur d'intégration continue et une machine distante à carte graphique.

Le chemin recommandé : WSL2

Depuis un PowerShell en administrateur :

wsl --install -d Ubuntu

Ouvrez ensuite l'invite Ubuntu et suivez la recette Ubuntu ci-dessus. CUDA fonctionne dans WSL2, par le guide officiel NVIDIA.

Le chemin Windows natif

S'il vous faut vraiment du Windows natif, par exemple parce qu'un kit de développement n'existe que là :

1. Installer Miniconda :

   curl https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -o miniconda.exe
   start /wait "" miniconda.exe /S
   del miniconda.exe
   

2. Créer l'environnement :

   set ENV=env4ml
   conda update -y -n base -c defaults conda
   conda create -y -n %ENV% python=3.13
   conda activate %ENV%
   conda install -y pip
   pip install scikit-learn pandas matplotlib seaborn jupyterlab
   

Sans rien installer

Si vous préférez ne rien toucher sur votre machine, Google Colab ne demande aucune installation : ouvrez un notebook dans le navigateur et la carte graphique est déjà branchée. Parfait pour une expérience ponctuelle, un devoir ou une courte démonstration.

8. Notes historiques et philosophiques

Le logiciel libre, groupe électrogène de secours

La formule a été répétée au point de paraître évidente, mais le chemin qu'elle décrit est réel. L'électricité est passée de technologie de pointe à service public, puis à quelque chose auquel plus personne ne pense, et l'IA suit la même route. La comparaison sert ici pour une raison précise : l'électricité est aussi le cas d'école de la bonne façon de dépendre de quelque chose.

Dans n'importe quel pays de l'OCDE, un hôpital est raccordé à un réseau conçu, régulé, surveillé et très largement fiable. Il garde quand même un groupe électrogène au sous-sol. Personne ne fait tourner la réanimation dessus un mardi ordinaire : il est là pour le jour où le réseau tombe, parce que « nous faisions confiance au fournisseur » n'est pas une réponse défendable.

L'IA s'installe dans la même catégorie que l'électricité, l'eau et les routes. Hôpitaux, ministères, laboratoires, écoles et petites entreprises en viennent à en dépendre d'une façon qu'il serait douloureux de défaire. La différence avec le réseau électrique, c'est que les fournisseurs d'IA ne sont pas l'État : ce sont quelques entreprises privées, dans quelques juridictions, chacune avec ses tarifs, ses règles et son historique de pannes.

La réponse pratique est celle de l'hôpital. Prenez une IA commerciale quand c'est le bon outil. Gardez un équivalent libre installé et testé. Un jour, une facture, un changement de conditions, une limite de débit ou une décision politique mettra l'option commerciale hors de portée. L'IA libre est, au minimum, le groupe électrogène de la centrale payante.

Même la meilleure interface payante tombe en panne. Incidents chez le fournisseur, coupures régionales, clés révoquées, quotas rabotés du jour au lendemain, versions de modèles retirées, fournisseur qui quitte un pays : rien de tout cela n'est hypothétique, et tout est arrivé en production cette année. Garder une solution libre sous la main relève du simple bon sens, idéalement une que vous pouvez faire tourner chez vous ou sur vos propres serveurs. Le même bon sens qui met un groupe électrogène au sous-sol d'un hôpital qui n'a jamais manqué de courant.

Une double pile, par pragmatisme

• Côté commercial : Claude, ChatGPT, Gemini, Mistral. Capacité de pointe, inférence hébergée, engagements de service.
• Côté libre : les familles à poids ouverts de Meta Llama, Google Gemma, Qwen, Mistral et DeepSeek, que vous faites tourner chez vous par Ollama, llama.cpp ou vLLM.
• Agent de code : le même schéma une couche plus haut. Claude Code au quotidien, OpenCode au sous-sol, qui pilote les mêmes compétences avec un modèle local, pour le jour où l'interface en amont devient injoignable ou interdite.

Un cercle vertueux, pas une rivalité

Au-delà de l'argument du secours, les deux côtés se nourrissent. Les laboratoires commerciaux poussent la frontière ; le libre rattrape, souvent en quelques mois, puis la pousse plus loin avec des idées que la version propriétaire suivante absorbe à son tour. La filiation se lit facilement : TensorFlow et PyTorch ouverts par Google et Meta, l'article fondateur sur le Transformer déposé sur arXiv, Hugging Face et son dépôt de modèles, llama.cpp faisant tourner des modèles sérieux sur un portable, les poids ouverts de Llama, les recettes de raisonnement de DeepSeek-R1. Chacun a effondré une courbe de coût ou débloqué une technique sur laquelle le monde propriétaire a bâti, et réciproquement.

L'IA moderne n'aurait pas pu se construire en vase clos. Ses articles, ses jeux d'épreuve, ses références reproductibles et la communauté mondiale qui les lit et les améliore avaient besoin de la porte ouverte. Le domaine est trop vaste, trop transversal et trop rapide pour qu'un seul laboratoire le porte. Sans logiciel libre, pas de PyTorch dont on apprend, pas de prépublication qu'on reproduit un vendredi soir, pas de carnet Kaggle qu'on bifurque. Pas de domaine du tout.

La double pile est donc deux choses à la fois. Une bonne pratique : le groupe tourne une fois par mois, l'équipe sait le démarrer, et le jour où le réseau tombe l'hôpital continue. Et une dette reconnue : tous les autres jours, le réseau lui-même tourne sur du code ouvert, des articles ouverts et des poids ouverts.

Les cadriciels qui ont compté

Des cadriciels et des couches graphiques plus anciens, Apache MXNet, PlaidML, DeepCL, ont façonné l'outillage d'aujourd'hui. Je ne commencerais plus un projet avec aucun d'eux ; MXNet en particulier a été retiré au grenier d'Apache. Ils valent pour comprendre d'où l'on vient, pas pour défricher.

Pourquoi conda et pip

Tout au long de cette page, le choix par défaut est conda et pip, pour une raison pratique :

• conda gère les environnements isolés et les versions de Python, et installe proprement les dépendances scientifiques compilées, sur tous les systèmes.
• pip atteint le reste de l'univers Python, y compris les bibliothèques qui sortent plus vite sur PyPI que sur les canaux conda.

Créez l'environnement avec conda, installez avec l'un ou l'autre selon le besoin. Pour l'exporter et le recréer :

conda list --export > requirements.txt
conda create --name NOMENV --file requirements.txt

Et si quelque chose tourne mal et qu'il faut repartir de zéro :

cd ~
rm -rf miniconda*
rm -rf .conda*

Qui débute et cherche à pratiquer trouvera dans les cours gratuits de Kaggle un bon point de départ, une fois l'environnement de la section 1 en place.