Exécutez Frontier AI sur votre PC de jeu

L'IA surhumaine de jeu qui faisait auparavant partie des articles de recherche et des centres de données sans fenêtres. AlphaGo, OpenAI Five, les bots StarCraft II de DeepMind—des systèmes comme ceux-ci ont consommé des milliers de GPU et des budgets de recherche qui ressemblaient à de petites introductions en bourse. Maintenant, le même apprentissage par renforcement qui a battu des grands maîtres de Go peut fonctionner sur un seul PC de jeu alimenté par RTX sous votre bureau.

Pendant des années, former des agents pour conquérir des jeux ou conduire des voitures nécessitait des clusters coûtant des millions de dollars. Il fallait des racks d'accélérateurs, un réseau personnalisé et une équipe de doctorants veillant sur des pipelines fragiles. Aujourd'hui, un PC AI RTX avec un GPU NVIDIA grand public peut traiter la même catégorie d'algorithmes localement, échangeant l'échelle pour l'accessibilité et rendant l'expérimentation de style frontalier accessible aux développeurs individuels.

Ce changement est ce que ce guide pratique explore. Avec NVIDIA qui parraine la construction, nous utilisons un PC AI RTX comme terrain d'expérimentation pour l'apprentissage par renforcement local, suivant le tutoriel sur l'apprentissage par renforcement de Matthew Berman intitulé "Tutoriel sur l'apprentissage par renforcement - RLVR avec NVIDIA & Unsloth". L'objectif n'est pas une démonstration simpliste qui ne fait que reproduire des mouvements scriptés, mais un véritable système d'apprentissage qui s'améliore par l'essai et l'erreur.

La recette repose sur RLVR—Apprentissage par Renforcement avec Récompenses Vérifiables—fonctionnant sur l'infrastructure d'entraînement hautement optimisée d'Unsloth. Au lieu qu'un humain clique sur "bon" ou "mauvais" sur les sorties du modèle, une fonction de récompense évalue automatiquement chaque mouvement, éliminant ainsi l'intervention humaine. Ce même procédé sous-tend la manière dont les laboratoires de pointe renforcent les modèles sur des tâches vérifiables comme les mathématiques, la programmation et les jeux.

Pour rendre cela concret, nous allons entraîner une IA à maîtriser le jeu de puzzle 2048 en partant de zéro connaissance. L'agent commence comme un modèle de base GPT-OSS qui ne connaît ni les règles, ni l'objectif, ni aucune stratégie. À travers des milliers d'interactions en auto-jeu, une fonction de récompense l'incite à de meilleures fusions de tuiles, des scores plus élevés et, finalement, des victoires cohérentes.

Vous verrez comment tout mettre en place de A à Z sur une configuration de jeu : NVIDIA App, CUDA Toolkit, WSL, Unsloth et le Notebook 2048, le tout en local. À la fin, votre PC ne se contentera pas de jouer à des jeux ; il entraînera une IA pour les battre.

L'apprentissage par renforcement semble sophistiqué, mais l'idée de base est familière : un agent interagit avec un environnement, reçoit des récompenses ou des punitions, et découvre lentement ce qui fonctionne. Imaginez un chien apprenant des tours, sauf que le « chien » est un réseau neuronal et les « tours » sont des mouvements dans un jeu, des lignes de code ou des étapes dans une preuve mathématique. Chaque action met à jour la politique interne du modèle afin qu'il choisisse plus souvent des actions à récompense plus élevée la prochaine fois.

L'apprentissage par renforcement traditionnel nécessitait d'énormes clusters pour jouer des millions de parties d'échecs, de Go ou de StarCraft. Maintenant, les GPU de classe RTX réduisent ce processus à un PC de jeu, et une nouvelle approche appelée Apprentissage par Renforcement avec Récompenses Vérifiables (RLVR) rend l'ensemble du processus nettement plus évolutif. Au lieu que des humains évaluent le comportement, un « vérificateur » programmatique attribue des récompenses automatiquement.

RLVR remplace un humain dans la boucle par une règle stricte, vérifiable par machine. Vous définissez une fonction de récompense qui dit : « Étant donné l'état de l'environnement et l'action du modèle, calculez un score numérique. » Pas de ressentis, pas d'opinions, juste des mathématiques. Si le résultat correspond à ce que les règles considèrent comme correct, le modèle obtient des points ; sinon, il en perd.

La démo 2048 du tutoriel sur l'apprentissage par renforcement de Matthew Berman utilise cette idée dans sa forme la plus pure. L'environnement est une grille 4x4 ; les actions sont des gestes vers le haut, le bas, la gauche, la droite. Le vérificateur est littéralement le code du jeu, qui peut :

• 1Rejetez les mouvements illégaux.
• 2Ajoutez une récompense lorsque les tuiles fusionnent et que le score augmente.
• 3Pénalisez les mouvements qui ralentissent ou terminent le jeu prématurément.

Parce que le moteur de jeu connaît déjà le score et si vous avez perdu, il peut agir en tant que juge objectif pour chaque mouvement. Commencez avec GPT-OSS, un modèle qui n'a jamais "vu" la stratégie de 2048, et après suffisamment de mises à jour RLVR, il commence à enchaîner des mouvements qui produisent systématiquement des tuiles de plus haute valeur et évitent de remplir le plateau. Aucun humain ne labelise jamais un tour comme "bon" ou "mauvais".

Cela contraste fortement avec l'Apprentissage par Renforcement à partir des Retours Humains (RLHF), où les gens comparent les résultats des modèles et entraînent un modèle de récompense pour imiter leurs préférences. Le RLHF fonctionne pour des objectifs flous—politesse, utilité, ton—mais il est mal évolutif et intègre des biais. Le RLVR prospère chaque fois que les tâches ont des résultats vérifiables : des benchmarks mathématiques comme GSM8K, du code qui compile et passe des tests ou non, des jeux comme 2048, les échecs et le Go. Pour ceux-ci, des vérificateurs automatisés ainsi que des outils comme Unsloth et des GPU RTX transforment votre PC de jeu en un laboratoire d'entraînement de style frontière.

Frontier RL sur un PC de gaming commence par une courte liste de contrôle matériel et logiciel, et non un laboratoire de recherche. Vous avez besoin d'un GPU NVIDIA RTX, de la dernière application NVIDIA pour les pilotes, du Toolkit CUDA et du Windows Subsystem for Linux (WSL) fonctionnant sous Ubuntu. Cet ensemble de technologies reflète ce que Matthew Berman utilise dans son tutoriel sur l'apprentissage par renforcement pour entraîner GPT-OSS sur le jeu 2048.

Vous n'avez pas besoin d'une carte monstrueuse RTX 5090. Toute carte GPU RTX récente avec Tensor Cores fonctionne : RTX 3060, 3070, 4070, ou un ordinateur portable de la série RTX 40 fera fonctionner RLVR ; l'entraînement évolue simplement avec les cœurs, la VRAM et la puissance. Attendez-vous à des itérations plus lentes sur les cartes de milieu de gamme, mais le même chemin de code et les mêmes résultats.

Considérez le GPU RTX comme le cheval de bataille de l'apprentissage par renforcement. Il effectue des multiplications de matrices pour les mises à jour de politique et les déploiements d'environnement, transformant des millions de mouvements 2048 en gradients. Plus de VRAM vous permet d'augmenter les tailles de lot, les fenêtres de contexte ou la taille du modèle sans risques de panne de mémoire.

CUDA se situe une couche au-dessus du silicium. Le CUDA Toolkit fournit le runtime de calcul parallèle et les bibliothèques (cuBLAS, cuDNN) dont s'appuient des frameworks comme PyTorch et Unsloth. Sans CUDA, votre session de RL "accélérée par GPU" retombe silencieusement sur le CPU et rame.

WSL complète le tableau en offrant aux utilisateurs de Windows un véritable environnement Linux sans avoir besoin de dual-boot. Vous installez Ubuntu via WSL, puis vous exécutez Python, Jupyter, Unsloth et le carnet de notes GPT-OSS RLVR exactement comme le décrivent les documents Unsloth. Des outils en ligne de commande comme `nvidia-smi` confirment que WSL peut détecter votre GPU RTX.

Voici la liste de contrôle pour une configuration minimale avec des liens officiels, correspondant aux ressources de la vidéo : - Application NVIDIA : https://www.nvidia.com/en-eu/software/nvidia-app/ - Toolkit CUDA : https://developer.nvidia.com/cuda-downloads - Instructions WSL + Ubuntu (via la documentation Unsloth) : https://docs.unsloth.ai/get-started/install-and-update/windows-installation - Unsloth : https://unsloth.ai/ - Tutoriel sur RLVR dans la documentation Unsloth : https://docs.unsloth.ai/new/gpt-oss-reinforcement-learning/tutorial-how-to-train-gpt-oss-with-rl Pour une théorie plus approfondie sur les politiques, les récompenses et le GRPO, le Guide d'apprentissage par renforcement (RL) | Documentation Unsloth relie le matériel que vous venez de configurer aux algorithmes que vous allez exécuter.

WSL fait office de pont entre votre configuration de jeu Windows et l'écosystème AI axé sur Linux que des outils comme Unsloth attendent. Après avoir testé plusieurs approches—Python natif sur Windows, double démarrage complet, Docker sur Windows—WSL s'est avéré supérieur en termes de stabilité, de support GPU et sans détruire votre configuration existante. Vous conservez votre flux de travail quotidien sur Windows tout en bénéficiant d'un environnement Linux quasi natif pour vos expériences RLVR.

L'installation se résume à une seule commande dans PowerShell ou Windows Terminal, exécutée en tant qu'administrateur : `wsl.exe --install ubuntu-24.04` Windows télécharge le noyau Linux, configure Ubuntu 24.04 et vous invite à créer un nom d'utilisateur et un mot de passe Unix lors de son premier lancement.

Une fois qu'Ubuntu démarre dans WSL, vous devez confirmer deux choses : Linux fonctionne réellement et il peut détecter votre GPU RTX. Dans le shell Ubuntu, tapez : `nvidia-smi` Si tout fonctionne, vous verrez un tableau listant votre NVIDIA GPU (par exemple, “GeForce RTX 5090”), la version du pilote et la version de CUDA au lieu d'une erreur.

Vous pouvez également vérifier que vous êtes dans WSL en exécutant : `wsl.exe --status` depuis un terminal Windows, ou en vérifiant que votre invite Linux affiche un chemin typique comme `/home/nom_utilisateur` au lieu de `C:\Users\...`. Si `nvidia-smi` échoue, corrigez les pilotes et CUDA sur Windows avant de toucher à quoi que ce soit dans le code RL.

Pour quiconque n'a jamais touché à Linux, WSL n'est pas un "deuxième système d'exploitation" effrayant. Il se comporte davantage comme un conteneur de développement sécurisé et isolé qui vit aux côtés de vos applications Windows. Vous pouvez ouvrir VS Code, votre navigateur, et votre lanceur de jeux sous Windows pendant que vos tâches d'entraînement RL s'exécutent à l'intérieur d'Ubuntu.

Ce modèle conteneurisé réduit également les risques. Vous pouvez installer, supprimer et réinitialiser des environnements Python, des bibliothèques compatibles CUDA et des stacks RLVR expérimentaux sans polluer votre installation principale de Windows. Lorsque la documentation Unsloth, le tutoriel sur l'apprentissage par renforcement ou de futures chaînes d'outils supposent « Linux + CUDA », WSL satisfait discrètement cette exigence sur votre PC RTX existant.

Unsloth se trouve au cœur de toute cette pile locale RLVR. La bibliothèque open-source a accumulé près de 50 000 étoiles sur GitHub, non pas à cause du battage médiatique, mais parce qu'elle rend l'entraînement de grands modèles de langage sur des GPU grand public réellement pratique et non pas masochiste.

Le réglage fin traditionnel atteint rapidement les limites de votre VRAM. Unsloth contourne cela en réduisant l'utilisation de la mémoire de plus de 60 % et en maximisant le travail utile de chaque cœur CUDA, ce qui se traduit par des temps d'entraînement sensiblement plus rapides sur la même carte RTX.

L'astuce : Unsloth s'appuie fortement sur LoRA (Adaptation à Bas Rang) et des noyaux CUDA personnalisés. LoRA maintient la plupart des poids d'un modèle gelés et apprend uniquement un petit ensemble d'adaptateurs à bas rang, vous permettant d'affiner des modèles de 7B à 20B paramètres sur un seul GPU de jeu sans que votre système ne s'affole ou ne plante.

Les noyaux optimisés gèrent les lourdes opérations mathématiques sur les tenseurs de manière beaucoup plus efficace que les opérations PyTorch standard. Cela signifie une utilisation plus efficace du GPU, moins de copies de mémoire et moins de surcharge par étape — exactement ce que vous souhaitez lorsque vous effectuez des milliers de déploiements RLVR dans un carnet Jupyter sur votre bureau.

L'installation dans votre environnement WSL reste agréablement banale. Une fois votre virtualenv Python activée et PyTorch installé avec le support CUDA, vous exécutez une seule commande : `pip install unsloth` et WSL récupère la dernière version depuis PyPI, sans besoin de roues personnalisées ou de drapeaux obscurs.

Parce que vous êtes dans WSL, Unsloth communique directement avec les pilotes NVIDIA et le CUDA Toolkit que vous avez configurés précédemment. Vous avez un accès complet à votre GPU RTX depuis les outils Linux tout en étant sur un bureau Windows, ce qui correspond exactement au flux de travail hybride que la plupart des laboratoires domestiques recherchent.

Unsloth est également livré avec des algorithmes de RL à la pointe de la technologie, y compris GRPO (Optimisation de Politique Relative en Groupe). GRPO conserve l'esprit du PPO mais laisse de côté les contraintes : il évite les modèles de récompense et de valeur séparés, ce qui réduit l'utilisation de la mémoire et simplifie la boucle d'entraînement.

Ce design rend le GRPO nettement plus efficace que les configurations traditionnelles de type PPO, en particulier pour les recettes RLVR où une fonction de vérification évalue directement les sorties. Pour un agent 2048 ou un tuteur en mathématiques/code, cela signifie plus de déploiements par seconde, plus d'étapes de gradient par heure, et des courbes d'amélioration plus rapides sur le même matériel.

Une nouvelle installation de WSL est prête, votre prochaine étape est de créer un environnement Python propre afin que les expériences RL ne soient pas en conflit avec le reste de votre système. Mettez à jour les paquets d'Ubuntu, puis installez Python et le support venv : `sudo apt update` suivi de `sudo apt install python3 python3-full python3-pip python3-venv -y`. Cet ensemble d'outils vous permet d'isoler les dépendances et de garder les versions compatibles avec CUDA de PyTorch sous contrôle.

Créez un environnement virtuel dédié pour le travail avec RLVR. À partir de votre répertoire home, exécutez `python3 -m venv unslothrl` puis activez-le avec `source unslothrl/bin/activate`. Votre invite devrait maintenant afficher `(unslothrl)`, indiquant que toute installation avec `pip` se fait dans cet espace isolé.

Avec l'environnement virtuel activé, installez une version de PyTorch compatible GPU qui utilise CUDA. Suivez l'index des roues de NVIDIA ou les conseils d'Unsloth, par exemple : `pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121`. Une fois l'installation terminée, vérifiez le bon fonctionnement avec `python -c "import torch; print(torch.cuda.is_available())"` et attendez-vous à obtenir `True` sur une carte RTX correctement configurée.

Ensuite, intégrez les outils qui donnent l’impression d’un laboratoire de ML moderne. Installez Jupyter Notebook et Unsloth en une seule commande : `pip install jupyter unsloth`. Ce duo vous offre les primitives d'entraînement RL ainsi qu'un panneau de contrôle basé sur un navigateur pour examiner chaque étape du cerveau de l'agent 2048.

Vous devez maintenant obtenir la véritable recette 2048 RL. Rendez-vous sur le lien du notebook OpenAI GPT-OSS utilisé par Unsloth : le tutoriel sur l'apprentissage par renforcement renvoie à `reinforcement-fine-tuning.ipynb` hébergé sur Colab. Ouvrez-le dans votre navigateur, cliquez sur Fichier → Télécharger, et enregistrez le fichier `.ipynb` dans un dossier que votre instance WSL peut voir, comme votre répertoire personnel Linux ou un chemin de téléchargements Windows monté.

De retour dans le terminal WSL, naviguez jusqu'au répertoire contenant le notebook et démarrez Jupyter avec `jupyter notebook`. Le serveur imprime une URL `http://localhost:8888/?token=...` ; copiez-la dans votre navigateur Windows, et l'explorateur de fichiers de Jupyter apparaîtra. Cliquez sur le fichier `.ipynb` téléchargé pour ouvrir l'intégralité du pipeline RLVR 2048.

Les blocs-notes changent la façon dont l'expérimentation en apprentissage par renforcement est perçue. Vous exécutez la pile d'entraînement cellule par cellule, ajustez les hyperparamètres, corrigez une importation défectueuse ou redémarrez juste une seule étape sans détruire un travail de plusieurs heures. C'est le même cycle itératif qu'NVIDIA met en avant pour des travaux sur des LLM plus importants dans des guides tels que Entraînez un LLM sur NVIDIA Blackwell avec Unsloth—et mettez-le à l'échelle pour la production, simplement réduit à votre PC de jeu et à un jeu de tuiles trompeusement simple.

Cellule Jupyter vide, curseur clignotant, ventilateurs RTX au repos. Vous commencez par importer Unsloth, l'intégrant dans PyTorch, et le dirigeant vers le point de contrôle open-source GPT-OSS d'OpenAI. Une ligne fait entrer le modèle de 20 milliards de paramètres ; une autre relie le formateur RLVR alimenté par GRPO de Unsloth qui finira par transformer ce modèle de texte générique en un spécialiste de 2048.

Ensuite, le notebook déploie discrètement une astuce très 2025 : l'ensemble du moteur de jeu 2048 que vous vous apprêtez à utiliser a été écrit par une IA. L'implémentation Python de la grille, des fusions de tuiles et de la logique de score provient de GPT-4, tirée de l'exemple officiel GPT-OSS 2048. Les outils générés par l'IA deviennent le terrain de jeu où une autre IA apprend à jouer.

Avant toute formation, vous vous assurez que le bac à sable fonctionne correctement. Les premières cellules définissent une classe légère `Game2048`, puis instancient un tableau et l'impriment sous forme de matrice 4×4 d'entiers. Vous pouvez effectuer des déplacements directement dans le carnet, en appelant des fonctions auxiliaires pour glisser les tuiles vers le haut, le bas, la gauche ou la droite, et observer la mise à jour du tableau après chaque action.

Le jeu manuel n'est pas seulement une question de plaisir ; il permet de vérifier la cohérence de l'environnement. Vous vérifiez que : - Les mouvements invalides laissent le plateau inchangé - Les mouvements valides fusionnent correctement les tuiles égales - Le score et le drapeau "partie terminée" se mettent à jour comme prévu

Une fois que les règles semblent solides, le carnet passe de l'humain au modèle. Un modèle de prompt décrit l'état du jeu sous la forme d'un tableau 4×4 plus le score actuel, puis demande à GPT-OSS de générer une fonction Python qui encode sa politique de mouvement. Au lieu de répondre "HAUT" ou "GAUCHE", le modèle doit générer du code qui renvoie l'une des actions valides.

L'ingénierie des invites ici fait le gros du travail. Le modèle : - Précise le nom de la fonction et sa signature - Énumère les mouvements autorisés (`"haut"`, `"bas"`, `"gauche"`, `"droite"`) - Exige un code Python syntaxiquement valide sans importations externes

Cette contrainte transforme un LLM en agent de synthèse de programmes. Chaque réponse devient une stratégie exécutable, que la boucle RLVR peut exécuter dans l'environnement 2048, évaluer automatiquement et réinjecter dans le pipeline d'entraînement d'Unsloth.

Les fonctions de récompense agissent comme le contrat secret entre votre agent propulsé par RTX et le plateau de 2048. Dans RLVR, vous ne distribuez pas des étoiles dorées manuellement ; vous les encodez en Python. Ces petites fonctions enfouies dans le carnet de notes déterminent à quoi ressemble le "bien", à chaque tour.

Au cœur de cette configuration se trouvent trois vérificateurs : `function_works`, `no_cheating` et `strategy_succeeds`. Chacun d'eux analyse la séquence de mouvements suggérée par le modèle et renvoie un score clair, lisible par machine. Ensemble, ils forment un tribunal miniature qui juge chaque tentative de votre agent GPT-OSS.

`function_works` joue le rôle de videur à la porte. Il vérifie si la réponse du modèle est interprétable comme un code valide ou une description de mouvement valide, si les arguments sont cohérents et si le moteur du jeu peut réellement l’exécuter sans déclencher d’exception. Si le code plante ou produit des incohérences, la récompense diminue, et la politique s'éloigne discrètement de ce comportement lors de la mise à jour suivante.

`no_cheating` gère les arts obscurs : le piratage des récompenses et l'interprétation stricte des règles. Les grands modèles de langage excellent à exploiter des instructions mal spécifiées, donc ce vérificateur scrute les actions qui enfreignent les mécaniques de 2048, altèrent l'état du plateau ou contournent l'API autorisée. Si le modèle essaie de "gagner" en modifiant directement la grille ou en sautant des tours, `no_cheating` lui inflige une forte punition négative.

`strategy_succeeds` se concentre sur le progrès réel du gameplay. Il exécute les mouvements proposés dans l'environnement de 2048 et vérifie des signaux concrets : augmentation du score, fusions de tuiles et si le plateau survit plutôt que de se bloquer complètement. Les stratégies réussies obtiennent des points positifs ; les lignes stagnantes ou perdantes sont pénalisées, incitant le modèle à adopter des jeux plus rentables et de plus longue durée.

Ensemble, ces vérificateurs créent une boucle de rétroaction automatisée. Chaque étape d'entraînement suit le même rythme : le modèle propose une stratégie, les vérificateurs l'exécutent et lui attribuent une note, et RLVR utilise cette récompense scalaire pour ajuster les paramètres du modèle. Au fil de centaines ou de milliers d'itérations, la politique passe de coups aléatoires à quelque chose qui commence à ressembler à un guide 2048 conçu par des humains.

Le hacking de récompenses rôde toujours en arrière-plan de l'apprentissage par renforcement (RL). Des vérificateurs robustes comme ceux-ci—vérifications de code explicites, protections anti-triche et scoring basé sur les résultats—obligent l'agent à apprendre la tâche réelle plutôt qu'à manipuler vos métriques. C'est ainsi que RLVR maintient votre modèle de pointe fait maison honnête tout en travaillant vers la maîtrise.

Le lancement de l'entraînement se résume à une seule ligne dans votre carnet : `trainer.train()`. Cet appel confie le contrôle au moteur RL d'Unsloth, qui commence à traiter vos instructions, à générer des réponses et à les faire passer par le pipeline de récompenses vérifiables que vous avez configuré précédemment.

Une fois que la boucle commence, le modèle GPT-OSS propose en continu des stratégies pour le plateau de 2048. L'environnement exécute ces mouvements, les vérificateurs les évaluent, et RLVR convertit ces scores en gradients qui ajustent les poids du modèle. Chaque étape réorganise légèrement le réseau, l'orientant vers des séquences d'actions qui ont généré des récompenses plus élevées.

Sous le capot, cela ressemble beaucoup à un jeu de millions de petits paris. Pour chaque prompt, le modèle sélectionne une séquence de mouvements, l'environnement renvoie une récompense numérique, et l'optimiseur met à jour les paramètres afin que les trajectoires offrant des récompenses plus élevées deviennent plus susceptibles d'être choisies la prochaine fois. Au fil de centaines ou de milliers d'étapes, ce processus d'essais et d'erreurs transforme des mouvements aléatoires en une stratégie reconnaissable.

L'un des moments les plus instructifs du tutoriel sur l'apprentissage par renforcement de Matthew Berman survient lorsque le modèle génère un code incomplet pour la logique du jeu. Le vérificateur échoue immédiatement : pas de compilation, pas de récompense. Ce dur "0" n'est pas une impasse ; c'est précisément le signal négatif dont l'optimiseur a besoin pour orienter le modèle loin des chemins de code à moitié finis.

L'échec devient des données d'entraînement. Lorsque des extraits incomplets ou logiquement incohérents obtiennent régulièrement de mauvais résultats, les mises à jour de gradien suppriment ces schémas et amplifient les solutions complètes et vérifiables. Vous assistez littéralement à la transformation de RLVR qui transforme « à peine fonctionnel » en « passe tous les contrôles » en exploitant les erreurs.

Pendant tout cela, votre écran peut sembler trompeusement calme. La cellule du notebook exécutant `trainer.train()` peut rester sur "In [*]" pendant de longues périodes, en particulier sur une carte RTX de milieu de gamme. Cela signifie généralement que votre GPU est saturé, et non que quelque chose a planté.

Pour confirmer les progrès, gardez un œil sur : - Les journaux du terminal affichant les étapes d'entraînement, les récompenses et les valeurs de perte - `nvidia-smi` montrant une utilisation du GPU proche de 90–100% - L'utilisation de la VRAM augmentant pour correspondre à votre modèle et à votre taille de lot

Pour des informations plus approfondies, le dépôt unslothai/unsloth - GitHub et les documents Unsloth détaillent comment l'entraîneur regroupe les invites, applique des mises à jour de style GRPO et expose des hooks si vous souhaitez personnaliser davantage la boucle.

Vous venez de réaliser un exploit qui, il y a quelques années, aurait figuré dans un article de DeepMind : vous avez entraîné un agent RL de style frontier sur un GPU grand public, sous Windows, en utilisant WSL, la pile CUDA de NVIDIA et Unsloth. Pas de cluster Kubernetes géré, pas de factures mystérieuses sur le cloud—juste un PC de jeu enseignant à un modèle GPT-OSS comment battre un jeu de réflexion par pure tâtonnement.

2048 est la démo, pas la destination. La même recette RLVR—modèle de politique, environnement vérifiable, récompense automatisée—pousse déjà des modèles ouverts sur des benchmarks mathématiques comme le GSM8K, où la réponse est objectivement vraie ou fausse, et sur la génération de code, où un ensemble de tests unitaires devient votre fonction de récompense. Si un programme compile, passe les tests et s'exécute dans les limites de temps, il obtient des points ; s'il échoue, le gradient s'inverse.

Ce changement est important car les domaines vérifiables sont partout. Vous pouvez transformer un concours de mathématiques, une archive LeetCode ou les tests d'intégration privés d'une entreprise en un terrain d'entraînement. Au lieu de donner des étiquettes de préférences, vous définissez des règles : - Pour les mathématiques : égalité numérique ou symbolique exacte - Pour le code : tests réussis, temps d'exécution, utilisation de la mémoire - Pour les jeux/simulations : score, temps de survie, taux de victoire

Les barrières matérielles continuent de diminuer également. Unsloth a récemment ajouté le support FP8 pour son entraînement de style GRPO, compressant les modèles dans moins de VRAM et poussant plus de tokens par seconde sur des cartes RTX de milieu de gamme. Vous échangez une petite part de précision numérique pour beaucoup plus de débit, ce qui permet des entraînements plus approfondis sur des GPU qui étaient auparavant réservés à l’inférence.

À partir de là, l'expérimentation devient la principale contrainte. Vous pouvez cloner le carnet 2048, remplacer par GSM8K, connecter un juge local et observer un modèle gravir son propre tableau de classement privé. Le RL local et vérifiable cesse d'être un mot à la mode en recherche et commence à ressembler à une nouvelle plateforme—celle où développeurs, chercheurs et amateurs peuvent tous réaliser des expériences de pointe sans demander la permission à quiconque.

Qu'est-ce que l'apprentissage par renforcement avec des récompenses vérifiables (RLVR) ?

RLVR est un type de formation en IA où un modèle apprend par essais et erreurs dans un environnement avec des récompenses automatisées basées sur des règles. Contrairement à RLHF qui utilise des retours humains, RLVR est idéal pour des tâches avec des critères de succès clairs, comme résoudre des problèmes mathématiques ou gagner à un jeu comme 2048.

Quel matériel ai-je besoin pour suivre ce tutoriel ?

Vous avez besoin d'un PC Windows avec n'importe quel GPU NVIDIA RTX moderne. Bien que la vidéo mette en avant une carte haut de gamme, le processus fonctionne sur n'importe quelle carte graphique RTX grand public, même si les temps d'entraînement peuvent être plus longs sur les modèles d'entrée de gamme.

Pourquoi Unsloth est-il recommandé pour l'entraînement RL local ?

Unsloth est une bibliothèque open-source optimisée pour la vitesse et l'efficacité mémoire. Elle permet des techniques comme le GRPO et utilise des fonctionnalités telles que le LoRA pour affiner de grands modèles sur du matériel ordinaire, réduisant ainsi de manière spectaculaire l'utilisation de la mémoire de plus de 60 % par rapport aux méthodes traditionnelles.

Puis-je appliquer cette méthode RLVR à des tâches autres que les jeux ?

Oui. RLVR est très efficace pour toute tâche dont la performance peut être vérifiée de manière automatique et objective. Cela inclut la génération de code, le raisonnement mathématique et d'autres problèmes logiques.