Un guide complet et pas-à-pas pour coder votre premier petit LLM (mini-GPT) en Python

GPT-4, Claude, Llama... Ces noms sont sur toutes les lèvres. Ces intelligences artificielles semblent dotées d'une compréhension quasi-magique du langage humain, capables de rédiger des poèmes, de coder des applications ou d'expliquer la physique quantique. On les imagine comme des boîtes noires inaccessibles, forgées dans les forteresses secrètes de la Silicon Valley. Et si je vous disais que vous pouviez, en moins d'une heure, construire votre propre version de cette technologie sur votre ordinateur ?

Aujourd'hui, on ne va pas se contenter de parler d'IA. On va la construire. Nous allons utiliser Python et la bibliothèque qui a démocratisé l'accès à l'IA, Hugging Face Transformers, pour créer un petit modèle de langage capable de comprendre un début de phrase et de générer une suite cohérente. Ce guide va vous prendre par la main, démystifier le jargon, et vous montrer que le pouvoir des LLMs n'est plus réservé à une élite. Vous êtes sur le point de donner le don de la parole à votre propre programme.

Avant le code : Qu'est-ce qu'on "Construit" vraiment ?

Soyons clairs dès le départ. Nous n'allons pas "entraîner" un LLM de zéro. Cet exploit, appelé "pre-training", est l'apanage de géants comme Google ou OpenAI. Il nécessite :

• Des données astronomiques : Des pétaoctets de texte, soit la quasi-totalité de l'internet.
• Une puissance de calcul colossale : Des milliers de GPUs tournant pendant des semaines, coûtant des millions de dollars.

Tenter de faire ça sur un ordinateur personnel, c'est comme essayer de construire une fusée dans son garage avec des outils de jardinage.

La Révolution Open Source : Utiliser des modèles Pré-Entraînés

Notre approche est bien plus intelligente et accessible. Nous allons nous appuyer sur la communauté open source. Des entreprises et des laboratoires de recherche publient des modèles pré-entraînés, plus petits mais déjà très compétents. Notre travail consiste à :

1. Choisir un modèle : On va sélectionner un modèle léger, déjà entraîné, qui peut tourner sur un ordinateur normal.
2. Le charger dans notre code : Grâce à la magie de Hugging Face, cela se fera en quelques lignes.
3. L'utiliser pour générer du texte : On va lui donner un "prompt" (un début de texte) et le laisser prédire la suite, mot par mot.

Notre "construction" est donc plutôt un assemblage. On prend un cerveau pré-entraîné (le modèle) et on lui construit un corps (notre script Python) pour interagir avec lui.

Les Outils de notre laboratoire d'IA

• Python : Le langage de prédilection pour l'IA, simple et puissant.
• Hugging Face Transformers : C'est LE "GitHub" des modèles d'IA. Une plateforme qui héberge des milliers de modèles pré-entraînés et une bibliothèque Python (transformers) qui permet de les télécharger et de les utiliser avec une simplicité déconcertante.
• PyTorch (ou TensorFlow) : C'est le moteur sous-jacent. transformers utilise l'un de ces deux frameworks de deep learning pour effectuer les calculs. Nous utiliserons PyTorch dans cet exemple.

Étape 1 : Préparer l'environnement

Ouvrez votre terminal et créez un nouvel environnement virtuel (c'est une bonne pratique !). Ensuite, installez les bibliothèques nécessaires.

# Créez un dossier pour votre projet
mkdir mon-petit-llm
cd mon-petit-llm

# Créez un environnement virtuel
python -m venv venv
source venv/bin/activate # Sur Windows: venv\Scripts\activate

# Installez les bibliothèques
pip install transformers torch

Avec ces deux installations, vous avez tout ce qu'il faut pour commencer.

Étape 2 : Notre première génération de texte (La Voie Facile)

Hugging Face propose une abstraction merveilleuse appelée pipeline. C'est la façon la plus simple de commencer. Elle s'occupe de tout le travail de bas niveau pour vous.

Créez un fichier simple_test.py :

from transformers import pipeline

# 1. On charge le pipeline pour la tâche "text-generation"
# Le modèle "distilgpt2" est une version plus petite et plus rapide de GPT-2, parfaite pour commencer.
print("Chargement du modèle...")
generator = pipeline('text-generation', model='distilgpt2')
print("Modèle chargé.")

# 2. On lui donne un prompt et on lui demande de générer du texte
prompt = "In a world full of dragons,"

print(f"Prompt: {prompt}")
result = generator(prompt, max_length=50, num_return_sequences=1)

# 3. On affiche le résultat
print("Résultat généré:")
print(result[0]['generated_text'])

Exécutez ce script avec python simple_test.py. La première fois, cela prendra un peu de temps car il va télécharger le modèle distilgpt2 (environ 350 Mo). Ensuite, admirez le résultat ! Le modèle aura complété votre phrase de manière créative.

Étape 3 : Plongée en Profondeur - Contrôle Manuel du Modèle

Le pipeline est génial, mais pour vraiment comprendre, nous devons manipuler les deux composants clés nous-mêmes : le Tokenizer et le Modèle.

• Le Tokenizer : Le traducteur. Un LLM ne comprend pas les mots. Il ne comprend que les nombres. Le tokenizer transforme notre phrase en une séquence de nombres (tokens) que le modèle peut lire.
• Le Modèle : Le cerveau. C'est le réseau de neurones qui prend les tokens en entrée et prédit les tokens suivants.

Créons un nouveau fichier interactive_bot.py.

Partie 1 : Chargement du Tokenizer et du Modèle

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

# Le nom du modèle que nous allons utiliser depuis le Hub Hugging Face
model_name = "distilgpt2"

print("Chargement du tokenizer...")
# Le tokenizer convertit le texte en "tokens" (nombres)
tokenizer = AutoTokenizer.from_pretrained(model_name)

print("Chargement du modèle...")
# Le modèle est le réseau de neurones qui va générer le texte
model = AutoModelForCausalLM.from_pretrained(model_name)
print("Modèle et tokenizer chargés avec succès !")

Partie 2 : La Logique de Génération

Maintenant, nous allons recréer manuellement ce que le ` pipeline faisait pour nous.

# ... (suite du fichier interactive_bot.py)

def generate_response(prompt_text):
    print("\nEncodage du prompt...")
    # 1. Tokenization : Transformer le texte en nombres
    # return_tensors='pt' signifie que nous voulons un tenseur PyTorch en sortie
    inputs = tokenizer.encode(prompt_text, return_tensors='pt')
    
    print("Génération en cours...")
    # 2. Génération : Le modèle prédit la suite
    # model.generate est la fonction magique qui fait tout le travail
    outputs = model.generate(
        inputs, 
        max_length=100, # Longueur maximale de la sortie
        num_return_sequences=1, # On veut une seule réponse
        pad_token_id=tokenizer.eos_token_id, # Empêche un avertissement
        no_repeat_ngram_size=2, # Empêche la répétition de groupes de 2 mots
        early_stopping=True # Arrête la génération quand une phrase semble finie
    )

    print("Décodage de la sortie...")
    # 3. Décodage : Re-transformer les nombres en texte
    generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
    
    return generated_text

Partie 3 : Créer la Boucle Interactive

Pour finir, nous allons mettre tout cela dans une boucle pour pouvoir "discuter" avec notre bot.

# ... (suite du fichier interactive_bot.py)

# Boucle principale pour interagir avec le bot
if __name__ == "__main__":
    while True:
        user_prompt = input("\nEntrez votre prompt (ou 'quit' pour arrêter) > ")
        if user_prompt.lower() == 'quit':
            break
        
        response = generate_response(user_prompt)
        print("\n--- Réponse du LLM ---")
        print(response)
        print("--------------------")

Le Code Complet

Voici le fichier interactive_bot.py complet que vous pouvez exécuter.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

# Le nom du modèle que nous allons utiliser
model_name = "distilgpt2"

print("Chargement du tokenizer...")
tokenizer = AutoTokenizer.from_pretrained(model_name)

print("Chargement du modèle...")
model = AutoModelForCausalLM.from_pretrained(model_name)
print("Modèle et tokenizer chargés !")

def generate_response(prompt_text):
    inputs = tokenizer.encode(prompt_text, return_tensors='pt')
    
    outputs = model.generate(
        inputs, 
        max_length=100,
        num_return_sequences=1,
        pad_token_id=tokenizer.eos_token_id,
        no_repeat_ngram_size=2,
        early_stopping=True
    )
    
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

# Boucle principale
if __name__ == "__main__":
    while True:
        user_prompt = input("\nEntrez votre prompt (ou 'quit' pour arrêter) > ")
        if user_prompt.lower() == 'quit':
            break
        
        response = generate_response(user_prompt)
        print("\n--- Réponse du LLM ---")
        print(response)
        print("--------------------")

Lancez-le avec python interactive_bot.py et commencez à discuter avec votre création !

Demo finale

Distilgpt2 n'est pas un modèle très intelligent — c'est comparable à text-davinci selon nos essais. D'après nos tests dans un environnement contrôlé, il a consommé 4.4 Go de RAM sur 12 Go disponibles pour fonctionner, et le processus lui-même a occupé 39 Go de mémoire (comme montré sur l'image ci-dessous).

Capture d'écran : utilisation mémoire observée lors du test.

Conclusion : Ce n'est que le Commencement

Félicitations ! Vous avez construit votre premier LLM. Vous avez démystifié la "magie" en comprenant le rôle du modèle et du tokenizer, et vous avez créé une interface pour interagir avec lui.

Bien sûr, notre "p'tit LLM" a ses limites. Il n'a pas la connaissance encyclopédique de GPT-4 et il oublie le contexte de la conversation à chaque tour. Mais la fondation est là. À partir d'ici, un monde de possibilités s'ouvre à vous :

• Explorez le Hugging Face Hub : Essayez d'autres modèles ! Remplacez `"distilgpt2"` par `"gpt2"` ou des modèles plus récents.
• Découvrez le fine-tuning : Le prochain niveau consiste à prendre un modèle pré-entraîné et à l'entraîner un peu plus sur vos propres données pour le spécialiser.
• Apprenez LangChain ou LlamaIndex : Ces frameworks vous permettent de connecter votre LLM à des sources de données externes et de lui donner une mémoire à long terme.

Vous avez fait le premier pas le plus important. Le reste du voyage dans le monde de l'IA générative ne dépend plus que de votre curiosité. 🔥