Projets

Projets open source pour apprendre

Des projets gratuits qui valent chacun une soirée, des petits classiques qui rendent une idée concrète aux bases de code récentes qui montrent toute la chaîne moderne. Pour chacun : pourquoi le lire, et le premier fichier à ouvrir.

Classiques

• DébutantMIT★ 17,7 k

  micrograd

  Python

  Un moteur complet de différentiation automatique en 94 lignes, surmonté d’une petite bibliothèque de réseaux de neurones.

  Pourquoi : La rétropropagation est d’ordinaire enseignée comme une formule et utilisée comme une boîte noire. Ici, c’est une classe Value dont chaque opération enregistre comment renvoyer un gradient vers l’arrière, et une méthode backward() qui parcourt le graphe dans l’ordre topologique inverse. Une fois ce code lu, l’autograd de PyTorch n’est que la même idée appliquée à des tenseurs plutôt qu’à des scalaires.

  Par où commencer : micrograd/engine.py, puis micrograd/nn.py (60 lignes) : regardez comment __mul__ stocke la dérivée locale de chaque entrée, et pourquoi backward() doit trier le graphe avant d’appliquer la règle de dérivation en chaîne.

  Sur ce site : La rétropropagation et la descente de gradient, Qu’est-ce qu’un réseau de neurones ?

  GitHubOuvrir dans Colab
  L'exécuter ici, dans votre navigateur

  micrograd: the autograd engine, checked against finite differences

  Exécuter ▶

  Modifier le codefrom math import isclose # micrograd's engine (MIT licence, (c) 2020 Andrej Karpathy, github.com/karpathy/micrograd), # with its comments trimmed and one-line helpers joined. Every gradient below comes from these lines. class Value: def __init__(self, data, _children=(), _op=''): self.data = data self.grad = 0 self._backward = lambda: None self._prev = set(_children) self._op = _op def __add__(self, other): other = other if isinstance(other, Value) else Value(other) out = Value(self.data + other.data, (self, other), '+') def _backward(): self.grad += out.grad other.grad += out.grad out._backward = _backward return out def __mul__(self, other): other = other if isinstance(other, Value) else Value(other) out = Value(self.data * other.data, (self, other), '*') def _backward(): self.grad += other.data * out.grad other.grad += self.data * out.grad out._backward = _backward return out def __pow__(self, other): out = Value(self.data**other, (self,), f'**{other}') def _backward(): self.grad += (other * self.data**(other-1)) * out.grad out._backward = _backward return out def relu(self): out = Value(0 if self.data < 0 else self.data, (self,), 'ReLU') def _backward(): self.grad += (out.data > 0) * out.grad out._backward = _backward return out def backward(self): topo, visited = [], set() def build_topo(v): if v not in visited: visited.add(v) for child in v._prev: build_topo(child) topo.append(v) build_topo(self) self.grad = 1 for v in reversed(topo): v._backward() def __neg__(self): return self * -1 def __radd__(self, other): return self + other def __sub__(self, other): return self + (-other) def __rsub__(self, other): return other + (-self) def __rmul__(self, other): return self * other def __truediv__(self, other): return self * other**-1 def __rtruediv__(self, other): return other * self**-1 # 1. The chain rule, checked. Change f and the numbers: the two columns must agree. def f(a, b): return (a * b + b**3).relu() / (a + 2) a, b = Value(1.5), Value(0.8) out = f(a, b) out.backward() h = 1e-6 num_a = (f(Value(1.5 + h), Value(0.8)).data - out.data) / h num_b = (f(Value(1.5), Value(0.8 + h)).data - out.data) / h print(f"f = {out.data:.6f}") print(f"df/da autograd {a.grad: .6f} finite difference {num_a: .6f}") print(f"df/db autograd {b.grad: .6f} finite difference {num_b: .6f}") print("agree:", isclose(a.grad, num_a, rel_tol=1e-4) and isclose(b.grad, num_b, rel_tol=1e-4)) # 2. Gradient descent on one neuron: learn y = 2x - 1 from four points. xs, ys = [-1.0, 0.0, 1.0, 2.0], [-3.0, -1.0, 1.0, 3.0] w, c = Value(0.0), Value(0.0) for step in range(60): loss = sum((w * x + c - y)**2 for x, y in zip(xs, ys)) / len(xs) w.grad, c.grad = 0, 0 loss.backward() w.data -= 0.1 * w.grad c.data -= 0.1 * c.grad if step % 20 == 0 or step == 59: print(f"step {step:2d} loss {loss.data:8.5f} w {w.data: .4f} c {c.data: .4f}")

  S'exécute dans votre navigateur. La première exécution télécharge l'environnement Python (~10 Mo), puis il est mis en cache.

• DébutantMIT★ 24,6 k

  Neural Networks: Zero to Hero

  Python (PyTorch)

  Les notebooks d’un cours vidéo qui construit des modèles de langage en partant d’un moteur d’autograd scalaire, une étape par cours.

  Pourquoi : Chaque notebook construit le modèle suivant à partir du précédent : micrograd, puis un modèle bigramme au niveau des caractères, un MLP, la normalisation par lots, une passe arrière écrite à la main, et un réseau de type WaveNet ; les vidéos se poursuivent ensuite jusqu’à un GPT et son tokeniseur. Tout l’intérêt est dans la progression : rien n’apparaît dont le modèle précédent n’avait pas besoin.

  Par où commencer : lectures/micrograd, puis lectures/makemore/makemore_part1_bigrams.ipynb : un modèle de langage qui n’est qu’une table de comptages, et la log-vraisemblance négative qui indique la qualité de cette table.

  Sur ce site : Qu’est-ce qu’un réseau de neurones ?, La tokenisation et les plongements, L’architecture du transformeur

  GitHubOuvrir dans Colab
• DébutantMIT★ 32,9 k

  ML From Scratch

  Python (NumPy)

  Des implémentations en NumPy pur des algorithmes classiques : régressions, arbres, boosting, SVM, clustering, et un petit framework d’apprentissage profond.

  Pourquoi : Les bibliothèques cachent la boucle qui ajuste un modèle. Ici, chaque algorithme tient dans un seul fichier lisible : on voit ainsi que ridge et lasso ne diffèrent que d’une ligne dans le terme de régularisation, ou que le gradient boosting est une boucle qui ajuste des arbres aux résidus. Le projet n’est plus activement développé, ce qui le rend stable à lire, mais n’en fait pas un outil à déployer.

  Par où commencer : mlfromscratch/supervised_learning/regression.py : une seule classe de base, et chaque régression (linéaire, polynomiale, ridge, lasso, elastic net) ne diffère que par sa régularisation.

  Sur ce site : La régression linéaire à partir des premiers principes, La régularisation : ridge et lasso, Les arbres de décision et les ensembles

  GitHub
• DébutantApache-2.0★ 14,2 k

  Hands-On Machine Learning (3rd edition) notebooks

  Python (scikit-learn, Keras)

  Les notebooks du livre d’Aurélien Géron, d’un premier projet de bout en bout jusqu’à l’apprentissage profond, chacun exécutable dans Colab.

  Pourquoi : La plupart des tutoriels commencent avec un jeu de données propre. Le chapitre 2 part d’une table immobilière désordonnée et montre ce que fait un vrai projet avant tout modèle : une séparation stratifiée du jeu de test, l’examen des données, un pipeline de prétraitement, puis la validation croisée et l’analyse des erreurs. C’est sur cet ordre que les débutants se trompent le plus souvent.

  Par où commencer : 02_end_to_end_machine_learning_project.ipynb : observez où le jeu de test est mis de côté, et qu’il n’est plus touché avant la toute fin.

  Sur ce site : Qu’est-ce que l’apprentissage statistique ?, La validation croisée et le rééchantillonnage

  GitHubOuvrir dans Colab
• DébutantMIT (code) ; texte CC BY-NC-ND 3.0★ 50 k

  Python Data Science Handbook

  Python (NumPy, pandas, Matplotlib, scikit-learn)

  Le livre de Jake VanderPlas, texte intégral sous forme de notebooks, lisible gratuitement en ligne : la boîte à outils de travail, avant les modèles.

  Pourquoi : La moitié du travail en apprentissage automatique, c’est du broadcasting NumPy et du remodelage pandas, et on l’enseigne rarement délibérément. Ce livre l’enseigne délibérément, puis se termine par une partie consacrée à l’apprentissage automatique qui explique clairement l’interface des estimateurs de scikit-learn et la validation des modèles.

  Par où commencer : notebooks/05.00-Machine-Learning.ipynb et les chapitres qui le suivent : l’API des estimateurs, puis les hyperparamètres et la validation des modèles.

  Sur ce site : Qu’est-ce que l’apprentissage statistique ?, Le compromis biais-variance

  GitHubOuvrir dans ColabGuide
• IntermédiaireMIT★ 28,2 k

  Bayesian Methods for Hackers

  Python (PyMC)

  L’inférence bayésienne enseignée par le calcul d’abord et par les mathématiques ensuite, avec PyMC.

  Pourquoi : Là où un manuel dérive une loi a posteriori, ce livre l’échantillonne et la trace, si bien que l’a priori, la vraisemblance et l’a posteriori sont des images avant d’être des formules. Le premier chapitre infère le moment où les habitudes d’envoi de SMS d’une personne ont changé : un modèle de point de rupture que la plupart des lecteurs ne se croiraient pas capables d’ajuster.

  Par où commencer : Chapter1_Introduction/Ch1_Introduction_PyMC_current.ipynb : l’exemple des SMS, et la façon dont la loi a posteriori du jour de bascule se lit sur les échantillons.

  Sur ce site : Le théorème de Bayes et la mise à jour des croyances, Apprendre les nombres d’un modèle probabiliste

  GitHubOuvrir dans Colab
• IntermédiaireBSD-3-Clause★ 67,4 k

  scikit-learn

  Python (Cython)

  La bibliothèque de référence de l’apprentissage automatique classique, et l’une des bases de code les mieux documentées pour apprendre.

  Pourquoi : Lire comment une bibliothèque de production résout le problème que vous avez dérivé sur papier montre ce qu’une dérivation laisse de côté : quel solveur pour quelle forme de données, comment l’ordonnée à l’origine est traitée, ce qui se passe quand la matrice est mal conditionnée. Les docstrings citent les articles dont provient chaque choix.

  Par où commencer : sklearn/linear_model/_ridge.py (le solveur choisi selon la forme des données), puis _coordinate_descent.py pour le lasso.

  Sur ce site : La régularisation : ridge et lasso, La régression linéaire à partir des premiers principes

  GitHubGuide
• IntermédiaireMIT★ 12 k

  Spinning Up in Deep RL

  Python (PyTorch, TensorFlow 1)

  La ressource pédagogique d’OpenAI sur l’apprentissage par renforcement profond : une introduction, une liste de lectures et de courtes implémentations des algorithmes clés.

  Pourquoi : Son introduction au RL est l’un des textes courts les plus clairs sur les politiques, les retours et les fonctions de valeur, et chaque algorithme (VPG, PPO, SAC et d’autres) tient dans un seul fichier écrit pour être lu en regard de sa dérivation. Le projet est en mode maintenance : traitez le code comme un manuel, pas comme une bibliothèque.

  Par où commencer : Les pages « Introduction to RL » du site, puis spinup/algos/pytorch/vpg/vpg.py : l’estimateur du gradient de politique, son estimation de l’avantage et sa boucle d’entraînement, dans un seul fichier.

  Sur ce site : L’apprentissage par renforcement et le Q-learning, Les processus de décision markoviens

  GitHubGuide
• DébutantMIT★ 12,6 k

  Gymnasium

  Python

  L’interface standard des environnements d’apprentissage par renforcement, successeur maintenu d’OpenAI Gym.

  Pourquoi : Tout algorithme de RL communique avec son monde par les deux mêmes appels, reset et step. Apprendre cette interface sur un petit environnement, et lire comment un environnement est écrit, est le moyen le plus rapide de faire tourner le Q-learning des leçons sur une vraie tâche.

  Par où commencer : gymnasium/envs/toy_text/frozen_lake.py : un processus de décision markovien complet, avec les probabilités de transition écrites sous forme de table.

  Sur ce site : Les processus de décision markoviens, L’apprentissage par renforcement et le Q-learning

  GitHubGuide
• IntermédiaireMIT★ 67,5 k

  Implémentations annotées d’articles d’apprentissage profond

  Python (PyTorch)

  De courtes implémentations PyTorch de plus de 60 articles, présentées sur un site web avec l’explication à côté de chaque ligne.

  Pourquoi : Les articles énoncent une architecture en un paragraphe et une équation ; ce projet montre la même chose sous forme de code, avec le paragraphe à côté. C’est le moyen le plus rapide de confronter votre lecture d’un article à une implémentation qui fonctionne.

  Par où commencer : L’attention multi-tête (labml_nn/transformers/mha.py, annotée sur nn.labml.ai/transformers/mha.html) : les formes de Q, K et V à chaque ligne.

  Sur ce site : L’attention et l’auto-attention, L’architecture du transformeur

  GitHubGuide
• DébutantRèglement de la compétition Kaggle

  Titanic: Machine Learning from Disaster

  Python ou R, dans des notebooks Kaggle gratuits

  La compétition permanente de Kaggle pour débutants : prédire qui a survécu à partir d’une petite table de passagers, et être évalué sur des données mises de côté.

  Pourquoi : Elle est assez petite pour qu’on comprenne chaque colonne, et assez réelle pour qu’on rencontre les pièges classiques : des âges manquants, des catégories à encoder, et un score de validation qui flatte un modèle réglé sur lui. Le cours gratuit Intro to Machine Learning de Kaggle est la porte d’entrée la plus douce.

  Par où commencer : Construisez une référence qui prédit « n’a pas survécu » pour tout le monde (juste pour 549 des 891 passagers d’entraînement, soit 61,6 %) : chaque modèle suivant doit la battre.

  Sur ce site : La régression logistique et la classification, Comparer les classifieurs, et ce que l’exactitude dissimule, Un score qui perd contre ne rien faire

  KaggleGuide

Récents et incontournables

• IntermédiaireApache-2.0★ 105,7 k

  Build a Large Language Model (From Scratch)

  Python (PyTorch)

  Le code du livre de Sebastian Raschka : un GPT construit, pré-entraîné et affiné pas à pas, chapitre par chapitre.

  Pourquoi : Il couvre tout le chemin dans l’ordre (du texte aux tokens, l’attention, le bloc GPT, le pré-entraînement, le chargement de vrais poids GPT-2, puis l’affinage pour la classification et pour le suivi d’instructions), chaque chapitre étant un notebook qui tourne sur un ordinateur portable.

  Par où commencer : ch02/01_main-chapter-code/ch02.ipynb (tokenisation et plongements), puis ch03 pour l’attention construite à partir d’une seule requête.

  Sur ce site : La tokenisation et les plongements, L’attention et l’auto-attention, L’architecture du transformeur, Le préentraînement et l’affinage

  GitHubOuvrir dans Colab
• AvancéMIT★ 58,3 k

  nanochat

  Python (PyTorch)

  Un pipeline minimal et complet pour entraîner un modèle conversationnel : tokeniseur, pré-entraînement, affinage supervisé, apprentissage par renforcement, évaluation et chat.

  Pourquoi : Son README annonce un modèle au niveau de GPT-2 (environ 43 000 $ à entraîner en 2019) pour environ 48 $, soit quelque deux heures sur un seul nœud 8xH100. Nul besoin des GPU pour en tirer des leçons : c’est tout le pipeline moderne dans une base de code petite et lisible. Il succède à nanoGPT, du même auteur, que le README de nanoGPT marque désormais comme obsolète.

  Par où commencer : runs/speedrun.sh : tout le pipeline en un seul script, étape par étape, chaque ligne renvoyant au fichier qui l’implémente.

  Sur ce site : Le préentraînement et l’affinage, L’architecture du transformeur

  GitHub
• AvancéMIT★ 31,1 k

  llm.c

  C / CUDA

  L’entraînement de GPT-2 en C et CUDA purs, sans PyTorch ni Python.

  Pourquoi : Sans framework, chaque passe avant et arrière est écrite à la main : layer norm, attention, gradient du softmax, AdamW. C’est la réponse la plus concrète à la question « que calcule réellement le framework ? ».

  Par où commencer : train_gpt2.c, la référence CPU (environ 1 200 lignes) : trouvez layernorm_forward et layernorm_backward et vérifiez-les par rapport à la dérivation.

  Sur ce site : La rétropropagation et la descente de gradient, L’architecture du transformeur

  GitHub
• IntermédiaireMIT★ 129,8 k

  llama.cpp

  C / C++

  Exécute localement des modèles de langage à poids ouverts, sur le CPU ou le GPU d’un ordinateur portable, avec des poids quantifiés.

  Pourquoi : C’est ainsi que la plupart des gens font tourner un modèle ouvert sur leur propre machine, et il rend la quantification tangible : le même modèle à 16, 8 et 4 bits par poids, et ce que cela change pour la mémoire, la vitesse et les réponses.

  Par où commencer : docs/build.md pour le compiler, puis lancez un petit modèle quantifié et comparez deux niveaux de quantification sur le même prompt.

  Sur ce site : Le préentraînement et l’affinage

  GitHub
• IntermédiaireApache-2.0★ 76,9 k

  Unsloth

  Python (PyTorch)

  L’affinage de modèles ouverts avec beaucoup moins de mémoire GPU, et des notebooks prêts à l’emploi qui tournent sur un GPU Colab gratuit.

  Pourquoi : L’affinage est généralement hors de portée sans un gros GPU. Ses notebooks affinent un petit modèle ouvert avec LoRA sur un T4 Colab gratuit, ce qui transforme la leçon sur l’affinage en quelque chose que vous pouvez exécuter en un après-midi.

  Par où commencer : La liste des notebooks dans unslothai/notebooks : choisissez un petit modèle, et lisez les réglages LoRA (rang, quelles couches) avant d’entraîner.

  Sur ce site : Le préentraînement et l’affinage

  GitHubGuide
• AvancéApache-2.0★ 27,8 k

  LeRobot

  Python (PyTorch)

  La bibliothèque de Hugging Face pour apprendre des politiques robotiques à partir de démonstrations, avec des jeux de données, des politiques pré-entraînées et de la simulation.

  Pourquoi : C’est là que les idées d’apprentissage du site rencontrent un système physique : apprentissage par imitation à partir de démonstrations enregistrées et apprentissage par renforcement, sur des bras robotiques à bas coût et en simulation, avec des jeux de données partagés sur le Hub.

  Par où commencer : Les pages de prise en main de la documentation, puis chargez un jeu de données depuis le Hub et regardez ce que contient une démonstration.

  Sur ce site : L’apprentissage par renforcement et le Q-learning

  GitHubGuide