Sur Habr, un tutoriel montre comment entraîner un mini-LLM en C# avec ILGPU et un GPU AMD intégré

Habr a publié une analyse pratique détaillée qui montre un scénario rare dans la communauté de l'IA locale : un petit modèle de langage peut être construit et entraîné de zéro en C#, sans Python et sans carte NVIDIA obligatoire, puis enregistré en GGUF et lancé dans LM Studio. L'auteur a utilisé la bibliothèque ILGPU et OpenCL, en s'appuyant sur le GPU intégré d'AMD, et a obtenu un prototype de LLM fonctionnel, quoique très limité, d'environ 422 Ko. Le projet se veut une démonstration pédagogique du cycle complet, et non une tentative de rivaliser avec les grands modèles open source.

L'article passe en revue l'architecture de base du transformeur : tokenisation, couche d'embedding, self-attention, feed-forward, normalisation et projection de sortie. Pour l'entraînement, l'auteur a préparé deux petits jeux de données : un court corpus de pretrain avec des faits généraux sur le monde et un échantillon d'instruction tuning composé de questions et de réponses. L'objectif n'était pas d'obtenir un modèle performant, mais de parcourir à la main toutes les étapes, du vocabulaire à l'inférence.

La configuration finale est extrêmement compacte : vocabulaire de 512 tokens, longueur de contexte de 64, embedding de 64, couche cachée de 128, une couche de transformeur et deux têtes d'attention. Cela fait 103 744 paramètres au total. Avant l'export, le modèle peut être enregistré dans un fichier binaire d'environ 6,87 Mo, mais le fichier GGUF final occupe environ 422 Ko et est reconnu comme GGUF V3. Après l'entraînement, la pretrain-loss est descendue à environ 0,212 et, après l'affinage au format dialogue, la finetune-loss à 0,3926. À cette échelle, c'est plutôt le signe que le schéma fonctionne techniquement qu'une preuve de la qualité des réponses.

La logique d'entraînement compte aussi. Le modèle passe d'abord par une phase de préentraînement sur un court corpus de quelques dizaines de phrases, puis par une étape distincte d'instruction tuning sur des exemples de dialogue. L'interface du programme propose des menus pour réentraîner, tester le tokenizer, sauvegarder les poids et lancer un chat interactif.

Pour les réponses, l'auteur a ajouté un filtre de confiance primitif : si la confiance minimale par token passe sous un seuil, le système affiche la phrase « j'ai du mal à répondre » au lieu d'une réponse. C'est une méthode grossière mais lisible pour masquer le charabia évident qu'un modèle de cette taille produit presque inévitablement. C'est ce qui rend la démo utilisable, au moins pour une vérification de base du pipeline.

La partie la plus difficile n'a été ni le forward pass ni l'entraînement lui-même, mais la compatibilité avec l'écosystème llama.cpp. L'auteur a d'abord tenté de construire le modèle dans une configuration plus proche de LLaMA, mais s'est heurté à des erreurs de chargement et à un nombre de tenseurs non conforme.

Il a finalement dû simplifier l'architecture, reconstruire le tokenizer dans l'esprit de Microsoft.ML.Tokenizers et décrire soigneusement les métadonnées GGUF : architecture, longueur de contexte, paramètres d'attention, tokens spéciaux et chat template.

Autre subtilité technique : le modèle ne retient en pratique pas un long historique de dialogue, si bien que le chat utilise un modèle ne contenant que le dernier message de l'utilisateur ; sinon, le contexte minuscule fait vite dérailler l'inférence.

Le résultat pratique est modeste, mais instructif. Le modèle répond à des requêtes simples et s'ouvre dans LM Studio, où il peut fonctionner via une pile compatible, mais llama.cpp avertit d'une dégradation de la qualité de génération, et l'auteur écrit lui-même que l'entraînement n'est pas encore assez bon. De plus, l'inférence plante sur certaines requêtes comportant des points d'interrogation et d'exclamation : le projet reste donc une expérience et un banc d'essai pédagogique.

Mais ce travail compte pour une autre raison : il montre que le ticket d'entrée pour les expériences LLM de bas niveau peut être considérablement abaissé. Pour les développeurs du monde .NET, c'est un exemple concret de la façon de construire un modèle minimal, de tester un scénario OpenCL hors du monopole de CUDA et de comprendre de quelles briques se compose réellement l'exécution locale d'un modèle de langage.