Personnalisation des LLM : prompts, réglage fin des modèles, exemples de code.

La personnalisation des LLM peut se faire de différentes manières : depuis des prompts soigneusement conçus et la gestion du contexte jusqu’au fine-tuning sur vos propres jeux de données. Le fine-tuning permet de consolider le style, la terminologie et le format des réponses, tout en améliorant la précision sur des tâches spécifiques à un domaine. Cependant, cette approche a ses limites et nécessite des données de haute qualité — sinon les résultats peuvent être moins bons que ceux du modèle de base.

In Questo Articolo

1. Comment les LLM « se souviennent » et « s’adaptent » : L’illusion du contexte

1. Comment les LLM « se souviennent » et « s’adaptent » : L’illusion du contexte

Avant de parler du réglage fin, il est important de comprendre comment les LLM parviennent généralement à créer un sentiment de personnalisation.
Ceci est important pour ne pas se lancer dans un réglage fin coûteux si la tâche peut être résolue par des méthodes plus simples :

Via la Fenêtre de Contexte (Mémoire à Court Terme) : Dans le cadre d’un seul dialogue, vous envoyez au modèle non seulement une nouvelle question, mais aussi tout ou partie de la correspondance précédente. Le modèle traite tout ce texte comme un « contexte » unique. C’est grâce à cela qu’il « se souvient » des remarques précédentes et poursuit la pensée. La limitation ici est la longueur de la fenêtre de contexte (nombre de jetons).
Composition des Instructions Système (System Prompt) : Vous pouvez définir le rôle, le ton et les règles de comportement du modèle au début de chaque dialogue. Par exemple : « Tu es un expert Python, réponds brièvement. »
Inclusion de plusieurs exemples du comportement souhaité dans la requête Apprentissage en Quelques Exemples (Few-Shot Learning) : (paires entrée/sortie) permet au modèle d' »apprendre » ce modèle directement dans la requête actuelle.
Gestion de l’état côté application : Le moyen le plus puissant. L’application (qui accède à l’API) peut stocker des informations sur l’utilisateur (préférences, historique, données de profil) et les ajouter dynamiquement au prompt avant de l’envoyer au modèle.

2. Pourquoi et quand le réglage fin (Fine-tuning) d’un modèle est nécessaire.

Le réglage fin est le processus de formation supplémentaire d’un LLM de base déjà préparé sur votre propre ensemble de données spécifique. Cela permet au modèle de :

Adapter le style et le ton : Le modèle parlera « votre langue » – qu’il s’agisse d’un langage scientifique strict, d’un marketing amical ou de l’argot d’une communauté spécifique.
Suivre des instructions et des formats spécifiques : Si vous avez besoin de réponses dans une structure JSON strictement définie, ou toujours avec un ensemble de champs spécifique.
Comprendre le langage spécifique au domaine : La formation sur votre documentation interne ou vos textes industriels aidera le modèle à mieux gérer la terminologie de votre niche.
Améliorer les performances sur des tâches spécifiques : Pour certains types de requêtes (par exemple, la classification des sentiments, la génération de code dans un framework spécifique), le réglage fin peut fournir des réponses plus précises et pertinentes que le modèle de base.
Réduire la longueur des prompts : Si le modèle « connaît » déjà le comportement souhaité grâce au réglage, vous n’avez pas besoin de le lui rappeler à chaque fois dans le prompt, ce qui économise des jetons et réduit la latence.

3. Quand le réglage fin n’est pas la meilleure solution.

Le réglage fin est un outil puissant mais non universel. Vous ne devriez pas l’utiliser si :

Le modèle doit accéder à de nouvelles connaissances : Le réglage fin modifie les poids du modèle, mais il ne « charge » pas de nouveaux faits en temps réel. Si votre tâche est de répondre à des questions basées sur une base de connaissances en constante évolution (documents d’entreprise, dernières nouvelles), il est préférable d’utiliser la Génération Augmentée par Récupération (RAG). Ici, le modèle de base obtient le contexte de votre base de données pendant l’exécution de la requête.
Une tâche simple peut être résolue par l’ingénierie de prompts : Commencez toujours par l’ingénierie de prompts la plus efficace. Si la tâche peut être résolue avec des instructions simples et des exemples en quelques coups, le réglage fin est redondant et plus coûteux.
Vous ne disposez pas de suffisamment de données de haute qualité : De mauvaises données = un modèle mal réglé.

4. Préparation des données.

La qualité et la quantité de vos données sont d’une importance capitale. Le modèle apprend de vos exemples, ils doivent donc être précis, diversifiés et cohérents.

Format : Le plus souvent JSON Lines (.jsonl) ou CSV (.csv).
Structure des données : Dépend de la tâche.
- Réglage d’instructions (Instruction Tuning – Instruction-Réponse) : Convient aux tâches généralisées telles que les questions-réponses, la reformulation, la synthèse.
  json
  {
  "input_text": "Reformulez la phrase : 'La technologie de l'IA se développe rapidement.'",
  "output_text": "L'intelligence artificielle progresse rapidement."
  }
  {
  "input_text": "Nommez la capitale de la France.",
  "output_text": "La capitale de la France est Paris."
  }
- Réglage de chat (Chat Tuning – Chat) : Idéal pour entraîner le modèle à mener un dialogue dans un rôle ou un style spécifique.
  json {
  "messages": [
  {"author": "user", "content": "Salut ! Que me recommandez-vous pour le dîner ?"},
  {"author": "model", "content": "Bonsoir ! Aujourd'hui est un excellent jour pour des pâtes Carbonara, ou, si vous préférez quelque chose de léger, une salade César."}
  ]},
  {
  "messages": [
  {"author": "user", "content": "Parlez-moi des nouvelles fonctionnalités de Python 3.12."},
  {"author": "model", "content": "Python 3.12 a introduit les f-strings avec indentation, une nouvelle syntaxe pour les génériques universels et une meilleure gestion des erreurs Unicode."}
  ]}
Quantité : Minimum 100-200 exemples de haute qualité, mais plus il y en a, mieux c’est (des milliers pour des tâches sérieuses).
Qualité : Précision, cohérence du style, du ton et du format dans l’ensemble des données.

5. Modèles et plateformes

5.1. OpenAI

OpenAI fournit une API assez simple et intuitive pour le réglage fin.

Processus :

Préparez les données au format JSONL, où chaque ligne est un objet avec un tableau de messages (comme dans l’API Chat Completions).
Téléchargez le fichier de données via l’API.
Créez une tâche de réglage fin, en spécifiant le fichier téléchargé et le modèle de base.
Surveillez la progression.
Utilisez le nouveau modèle réglé par son ID.

Exemple de données (fichier training_data.jsonl) :

{"messages": [
     {"role": "system", "content": "Vous êtes un assistant amical pour le support client d'une entreprise informatique."}, 
      {"role": "user", "content": "Mon internet ne fonctionne pas."}, 
      {"role": "assistant", "content": "Oh, je m'excuse pour le désagrément ! Essayons de comprendre. Comment êtes-vous connecté à internet – via Wi-Fi ou par câble ?"}
]}
{"messages": [
     {"role": "system", "content": "Vous êtes un assistant amical pour le support client d'une entreprise informatique."}, 
     {"role": "user", "content": "Comment puis-je réinitialiser mon mot de passe ?"},
     {"role": "assistant", "content": "Bien sûr ! Pour réinitialiser votre mot de passe, veuillez vous rendre sur la page de connexion et cliquer sur 'Mot de passe oublié ?' sous le champ de saisie. Suivez ensuite les instructions à l'écran."}
]}

Exemple de code Python :

Installez au préalable : pip install openai

import openai
from openai import OpenAI
import os

# Définissez votre clé API OpenAI. Il est recommandé d'utiliser une variable d'environnement.
# os.environ["OPENAI_API_KEY"] = "sk-..."
client = OpenAI()

# 1. Télécharger le fichier de données
try:
    file_response = client.files.create(
        file=open("training_data.jsonl", "rb"),
        purpose="fine-tune"
    )
    file_id = file_response.id
    print(f"Fichier téléchargé avec succès. ID du fichier : {file_id}")
except openai.APIStatusError as e:
    print(f"Erreur de téléchargement du fichier : {e.status_code} - {e.response}")
    exit()

# 2. Créer une tâche de réglage fin
try:
    ft_job_response = client.fine_tuning.jobs.create(
        training_file=file_id,
        model="gpt-3.5-turbo" # Vous pouvez spécifier une version spécifique, par exemple, "gpt-3.5-turbo-0125"
    )
    job_id = ft_job_response.id
    print(f"Tâche de réglage fin créée. ID de la tâche : {job_id}")
    print("Surveillez l'état de la tâche via l'API ou dans OpenAI Playground.")
except openai.APIStatusError as e:
    print(f"Erreur de création de la tâche : {e.status_code} - {e.response}")
    exit()

# Exemple de surveillance de l'état et d'obtention du nom du modèle (à exécuter après la création de la tâche) :
# # job_id = "ftjob-..." # Remplacez par l'ID de votre tâche
# # job_status = client.fine_tuning.jobs.retrieve(job_id)
# # print(f"État actuel de la tâche : {job_status.status}")
# # if job_status.status == "succeeded":
# #     fine_tuned_model_name = job_status.fine_tuned_model
# #     print(f"Nom du modèle réglé : {fine_tuned_model_name}")

# 3. Utilisation du modèle réglé (une fois qu'il est prêt)
# # Remplacez par le nom réel de votre modèle, obtenu après un réglage fin réussi
# # fine_tuned_model_name = "ft:gpt-3.5-turbo-0125:my-org::abcd123"

# # if 'fine_tuned_model_name' in locals() and fine_tuned_model_name:
# #     try:
# #         response = client.chat.completions.create(
# #             model=fine_tuned_model_name,
# #             messages=[
# #                 {"role": "user", "content": "J'ai un problème de connexion."}
# #             ]
# #         )
# #         print("\nRéponse du modèle réglé :")
# #         print(response.choices[0].message.content)
# #     except openai.APIStatusError as e:
# #         print(f"Erreur lors de l'utilisation du modèle : {e.status_code} - {e.response}")

5.2. Anthropic

Anthropic ne fournit pas d’API publique pour le réglage fin de ses modèles Claude 3 (Opus, Sonnet, Haiku) dans le même sens qu’OpenAI ou Google.

Anthropic se concentre sur la création de modèles de base très puissants qui, selon eux, fonctionnent parfaitement avec l’ingénierie de prompts avancée et les modèles RAG, minimisant le besoin de réglage fin dans la plupart des cas. Pour les grands clients d’entreprise ou les partenaires, il peut exister des programmes pour créer « custom » modèles ou intégrations spécialisées, mais ce n’est pas une fonction de réglage fin disponible publiquement via l’API.

If you are working with Claude 3, your primary focus should be on:

High-quality prompt engineering: Experiment with system instructions, few-shot examples, clear request formatting. Claude is known for its ability to strictly follow instructions, especially in XML tags.
RAG systems: Use external knowledge bases to provide the model with relevant context.

5.3. Google (Gemini)

Google développe activement les capacités de réglage fin via sa plateforme Google Cloud Vertex AI. This is a full-fledged ML platform that provides tools for data preparation, running training jobs, and deploying models. Fine-tuning is available for the Gemini family of models.

Process:

Prepare data (JSONL or CSV) in input_text/output_text format (for instruction tuning) or messages (for chat tuning).
Upload data to Google Cloud Storage (GCS).
Create and run a fine-tuning job via the Vertex AI Console or SDK.
Deploy the fine-tuned model to an Endpoint.
Use the fine-tuned model via this Endpoint.

Example data (file gemini_tuning_data.jsonl):

{"input_text": "Résumez les idées principales de ce livre : 'Le livre raconte le voyage d'un héros qui surmonte les obstacles et se trouve lui-même.'", "output_text": "Le personnage principal du livre se lance dans un voyage transformateur, faisant face à des défis et acquérant la découverte de soi."}

{"input_text": "Expliquez le principe d'un réacteur thermonucléaire en termes simples.", "output_text": "Un réacteur thermonucléaire tente de reproduire le processus qui se produit sur le Soleil : la fusion de noyaux atomiques légers à très hautes températures, libérant d'énormes quantités d'énergie."}

Example Python code (nécessite google-cloud-aiplatform):

Installez au préalable : pip install google-cloud-aiplatform et pip install google-cloud-storage

import os
from google.cloud import aiplatform
from google.cloud import storage

# --- Paramètres ---
# REMPLACEZ par vos valeurs :
PROJECT_ID = "your-gcp-project-id"
REGION = "us-central1"               # Choisissez une région qui prend en charge Gemini et Vertex AI
BUCKET_NAME = "your-gcs-bucket-for-tuning" # Nom de votre bucket GCS (doit être créé au préalable)
DATA_FILE_LOCAL_PATH = "gemini_tuning_data.jsonl"
GCS_DATA_URI = f"gs://{BUCKET_NAME}/{DATA_FILE_LOCAL_PATH}"
TUNED_MODEL_DISPLAY_NAME = "my-tuned-gemini-model"
# --- Fin des paramètres ---

# Initialiser Vertex AI
aiplatform.init(project=PROJECT_ID, location=REGION)

# 1. Créer le fichier de données (s'il n'existe pas)
with open(DATA_FILE_LOCAL_PATH, "w", encoding="utf-8") as f:
    f.write('{"input_text": "Résumez les idées principales de ce livre : \'Le livre raconte le voyage d\'un héros qui surmonte les obstacles et se trouve lui-même.'", "output_text": "Le personnage principal du livre se lance dans un voyage transformateur, faisant face à des défis et acquérant la découverte de soi."}\n')
    f.write('{"input_text": "Expliquez le principe d'un réacteur thermonucléaire en termes simples.", "output_text": "Un réacteur thermonucléaire tente de reproduire le processus qui se produit sur le Soleil : la fusion de noyaux atomiques légers à très hautes températures, libérant d'énormes quantités d'énergie."}\n')
print(f"Fichier de données '{DATA_FILE_LOCAL_PATH}' créé.")


# 2. Télécharger les données vers Google Cloud Storage
def upload_blob(bucket_name, source_file_name, destination_blob_name):
    """Télécharge un fichier vers un bucket GCS."""
    storage_client = storage.Client(project=PROJECT_ID)
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(destination_blob_name)
    blob.upload_from_filename(source_file_name)
    print(f"Fichier '{source_file_name}' téléchargé vers 'gs://{bucket_name}/{destination_blob_name}'.")

try:
    upload_blob(BUCKET_NAME, DATA_FILE_LOCAL_PATH, DATA_FILE_LOCAL_PATH)
except Exception as e:
    print(f"Erreur lors du téléchargement du fichier vers GCS. Assurez-vous que le bucket existe et que vous avez les autorisations : {e}")
    exit()

# 3. Créer et exécuter une tâche de réglage fin
print(f"\nDémarrage du réglage fin du modèle '{TUNED_MODEL_DISPLAY_NAME}'...")
try:
    # `tune_model` démarre la tâche et renvoie le modèle réglé une fois terminé
    tuned_model = aiplatform.Model.tune_model(
        model_display_name=TUNED_MODEL_DISPLAY_NAME,
        source_model_name="gemini-1.0-pro-001", # Modèle de base Gemini Pro
        training_data_path=GCS_DATA_URI,
        tuning_method="SUPERVISED_TUNING",
        train_steps=100, # Nombre d'étapes d'entraînement. La valeur optimale dépend de la taille des données.
        # batch_size=16, # Peut être spécifié
        # learning_rate_multiplier=1.0 # Peut être spécifié
    )
    print(f"Modèle '{TUNED_MODEL_DISPLAY_NAME}' réglé avec succès. ID du modèle : {tuned_model.name}")
    print("Le processus de réglage fin peut prendre un temps considérable.")
except Exception as e:
    print(f"Erreur de réglage fin. Vérifiez les journaux dans la console Vertex AI : {e}")
    exit()

# 4. Déployer le modèle réglé (pour utilisation)
print(f"\nDéploiement du modèle réglé '{TUNED_MODEL_DISPLAY_NAME}' sur le point de terminaison...")
try:
    endpoint = tuned_model.deploy(
        machine_type="n1-standard-4", # Type de machine pour le point de terminaison. Choisissez le plus approprié.
        min_replica_count=1,
        max_replica_count=1
    )
    print(f"Modèle déployé sur le point de terminaison : {endpoint.name}")
    print("Le déploiement peut également prendre plusieurs minutes.")
except Exception as e:
    print(f"Erreur lors du déploiement du modèle : {e}")
    exit()

# 5. Utiliser le modèle réglé
print("\nTest du modèle réglé...")
prompt = "Parlez-moi de vos capacités après l'entraînement."
instances = [{"prompt": prompt}] # Pour le réglage d'instructions. Si réglage de chat, alors {"messages": [...]}

try:
    response = endpoint.predict(instances=instances)
    print("\nRéponse du modèle réglé :")
    print(response.predictions[0])
except Exception as e:
    print(f"Erreur lors de l'utilisation du modèle réglé : {e}")

# Après avoir terminé, n'oubliez pas de supprimer le point de terminaison et le modèle pour éviter les coûts inutiles :
# endpoint.delete()
# tuned_model.delete()

6. Recommandations générales

Commencez petit : N’essayez pas d’entraîner le modèle sur des milliers d’exemples tout de suite. Commencez par un ensemble de données petit mais de haute qualité.
Itérez : Le réglage fin est un processus itératif. Entraînez, évaluez, ajustez les données ou les hyperparamètres, répétez.
Surveillance : Surveillez attentivement les métriques d’entraînement (perte) et utilisez un ensemble de données de validation pour éviter le surapprentissage.
Évaluation : Testez toujours le modèle réglé sur des données qu’il n’a *jamais vues* pendant l’entraînement pour évaluer sa capacité de généralisation.
Coût : N’oubliez pas que le réglage fin et le déploiement des points de terminaison sont payants. Tenez-en compte dans votre budget.
Documentation : Référez-vous toujours à la documentation officielle du fournisseur de LLM. Les API et les capacités évoluent constamment.