Concepts liés aux grands modèles
Lorsque vous commencez à développer avec des grands modèles (LLM), un flot de nouveaux termes vous submerge : Token, RAG, Embedding, Agent... Ils peuvent sembler indépendants, mais ils sont en fait reliés en un pipeline technique complet.
Cet article relie ces concepts dans l’ordre « Qu’est-ce qu’un modèle → Comment entraîner → Comment utiliser → Comment optimiser », aidant les développeurs débutants à construire un cadre de connaissances clair.
Cet article n’est pas seulement un glossaire ; il utilise également du code Python réel et exécutable pour démontrer comment ces concepts sont appliqués.
Tous les exemples sont basés sur le protocole compatible OpenAI. Vous pouvez passer à des fournisseurs comme Alibaba Cloud Bailian, DeepSeek, etc., en changeant simplement le point de terminaison et la clé de l’API.
Référence Python OpenAI :https://www.example.com/python3/python-openai.html
Pipeline technique global
Avant de décomposer chaque concept, examinons le pipeline complet de la technologie des grands modèles afin de construire une compréhension globale.
De haut en bas, chaque couche résout un problème central : l'entraînement crée le modèle, l'optimisation le rend plus léger, l'inférence lui permet de produire des résultats, la récupération fournit les connaissances, et les outils permettent l'exécution.
Les sections suivantes se déploient couche par couche, de haut en bas, le long de ce pipeline.
Concepts de base : qu'est-ce qu'un modèle
Cette section répond à la question la plus fondamentale : qu'est-ce qu'un grand modèle exactement, et comment fonctionne-t-il ?
LLM (grand modèle de langage)
LLM signifie Large Language Model (grand modèle de langage), un modèle d'apprentissage profond entraîné sur des quantités massives de texte.
Son essence est un modèle probabiliste qui « prédit le mot suivant » : étant donné le texte précédent, il prédit le contenu le plus probable qui suit.
Des produits comme ChatGPT, Claude, Tongyi Qianwen, etc., ont tous des LLMs à leur cœur.
Transformer et mécanisme d'attention
Presque tous les LLMs modernes sont basés sur l'architecture Transformer.
Son innovation centrale estle mécanisme d'attention (Attention / Self-Attention): lorsqu'il traite un mot, le modèle peut dynamiquement « prêter attention » à d'autres mots pertinents dans la séquence d'entrée, ce qui lui permet de mieux comprendre les relations contextuelles.
Par exemple, lorsqu'un modèle lit une phrase, il ne la parcourt pas rigidement mot par mot ; au lieu de cela, il détermine automatiquement « quel mot précédent est le plus lié à ce mot ».
Token
Les modèles ne traitent pas le texte par « caractère » ou « mot » ; au lieu de cela, ils le traitent par tokens.
Un token peut être un caractère chinois, un mot anglais ou une partie d'un mot.
Comprendre les tokens a deux implications pratiques directes :
La limite de longueur de contexte du modèle est calculée en tokens ; la facturation des appels API est également calculée en tokens.
En utilisant la bibliothèque de tokenisation open source tiktoken d'OpenAI, vous pouvez directement voir en combien de tokens un texte est découpé :
Exemple
import tiktoken
# Différents modèles utilisent différents tokeniseurs ; encoding_for_model sélectionne automatiquement celui correspondant
enc = tiktoken.encoding_for_model("gpt-4o-mini")
tokens = enc.encode("Hello world") # Diviser le texte en une liste de tokens
print("Nombre de tokens :", len(tokens))
print("Résultat du découpage :", [enc.decode([t]) for t in tokens])
Sortie :
Token 数量:2 切分结果:['Hello', ' world']
Lorsque l'on passe au chinois ou à des mots plus longs, la méthode de tokenisation sera complètement différente, donc « estimer les jetons par le nombre de caractères » n'est pas précis.
Fenêtre de contexte
Désigne le nombre maximal de jetons que le modèle peut « voir » et traiter en une seule fois.
Par exemple, une fenêtre de contexte de 100K signifie qu'une seule conversation (messages historiques, votre question et la réponse du modèle combinés) ne peut pas dépasser 100,000 jetons.
Plus la fenêtre est grande, plus le modèle peut « mémoriser » de contenu, et plus les documents qu'il peut traiter en une seule fois sont longs.
Nombre de paramètres (Paramètres)
Le nombre de paramètres désigne le nombre de poids apprenables à l'intérieur du modèle, généralement mesuré en B (milliard), comme 7B, 70B.
Il reflète dans une certaine mesure l'échelle et le plafond de capacité du modèle, mais ce n'est pas la seule métrique—la qualité des données d'entraînement et la conception de l'architecture sont tout aussi importantes.
| Tailles de paramètres courantes | Échelle | Positionnement typique |
|---|---|---|
| 1B ~ 7B | Petit à moyen | Peut s'exécuter localement sur des GPU grand public, adapté aux tâches légères |
| 8B ~ 34B | Moyenne | Rapport coût-performance élevé, couvre la plupart des scénarios généraux |
| 70B ~ des centaines de B | grand | Capacité la plus puissante, généralement accessible via des API cloud |
Comment les modèles sont entraînés
Un LLM capable de converser naturellement passe généralement par plusieurs étapes d'entraînement, construisant ses capacités couche par couche.
Pré-entraînement
Le modèle apprend les schémas statistiques du langage à partir de quantités massives de texte non étiqueté (pages web, livres, code, etc.), comme la grammaire, le sens commun et les relations logiques.
Cette étape consomme le plus de puissance de calcul et constitue le fondement des capacités du modèle.
Cependant, à ce stade, le modèle n'est pas encore doué pour « faire les choses comme demandé » ; il ressemble plutôt à quelqu'un qui a beaucoup lu mais ne sait pas communiquer.
SFT (Ajustement fin supervisé)
SFT signifie Ajustement fin supervisé.
En utilisant des données de paires "question-réponse" annotées par des humains, on apprend au modèle à répondre aux questions selon les instructions humaines, plutôt qu'à continuer le texte de lui-même.
RLHF (Apprentissage par renforcement à partir des retours humains)
RLHF signifie Apprentissage par renforcement à partir des retours humains.
Les humains notent ou classent plusieurs réponses candidates du modèle, et ces retours sont ensuite utilisés pour entraîner le modèle, ce qui fait que ses sorties s'alignent mieux sur les préférences humaines (plus utiles, plus honnêtes et plus sûres).
Une technique similaire est RLAIF : utiliser l'IA au lieu des humains pour noter, ce qui réduit les coûts d'annotation.
Les deux partagent le même objectif ; la seule différence est de savoir si le "noteur" est un véritable humain ou une autre IA.
Alignement
L'alignement est un concept plus large : faire en sorte que le comportement et les valeurs du modèle soient conformes aux attentes et aux intentions humaines.
C'est un sujet central dans le domaine de la sécurité de l'IA, qui traverse diverses étapes d'entraînement telles que SFT et RLHF — essentiellement, SFT et RLHF sont tous deux des "méthodes d'alignement".
Fine-tuning
Sur la base d'un modèle général déjà entraîné, continuer l'entraînement avec des données d'un domaine spécifique (comme le droit, la santé, le service client).
Comparé à un pré-entraînement à partir de zéro, l'ajustement fin coûte beaucoup moins cher, et il est courant d'adapter des modèles généraux à des scénarios spécialisés.
MoE (mélange d'experts)
MoE signifie « mélange d'experts », un type d'architecture de modèle.
Le modèle contient plusieurs sous-réseaux « experts » ; chaque fois qu'il traite une entrée, seule une partie est activée, au lieu que tous les paramètres participent au calcul.
Cela permet d'étendre l'échelle globale du modèle tout en contrôlant le calcul réel, en obtenant « un grand nombre de paramètres, une inférence rapide ».
| Étapes d'entraînement | Anglais | Fonction principale | Données utilisées |
|---|---|---|---|
| Pré-entraînement | Pré-entraînement | Apprendre les schémas linguistiques et acquérir des capacités fondamentales | Quantités massives de texte non étiqueté |
| Affinage supervisé | SFT | Apprendre à répondre aux questions selon les instructions | Paires question-réponse annotées par des humains |
| Apprentissage par renforcement à partir de retours humains | RLHF | Des sorties mieux alignées sur les préférences humaines | Notation/classement humain des réponses |
| Alignement | Alignement | Rendre le modèle utile, honnête et sûr | Couvre toutes les étapes ci-dessus |
Comment les développeurs utilisent les grands modèles
C'est la partie sur laquelle les développeurs débutants doivent se concentrer le plus : comment faire en sorte que les grands modèles servent des applications via une API.
Cette section présente d'abord un exemple d'appel de dialogue de base et exécutable, puis développe chaque concept.
Appel de chat API de base
Le code suivant montre une requête de dialogue complète, en utilisant trois concepts : prompt système, messages utilisateur et température.
Exemple
from openai import OpenAI
import os
# Créer un client. Tout service utilisant un protocole compatible OpenAI peut réutiliser ce code,
# Pour passer à un autre fournisseur, il suffit de modifier api_key et base_url
client = OpenAI(
api_key=os.getenv("OPENAI_API_KEY"), # Lire la clé API depuis la variable d'environnement (obligatoire)
)
# Effectuer une requête de dialogue
response = client.chat.completions.create(
model="gpt-4o-mini", # Nom du modèle (requis), à modifier en fonction du fournisseur
messages=[
# Prompt système : Prédéfinir le rôle et les consignes de comportement du modèle
{"role": "system", "content": "Vous êtes un assistant professionnel de programmation Python et ne répondez qu'aux questions techniques."},
# Message utilisateur : la question réelle
{"role": "user", "content": "Qu'est-ce que Python ?"},
],
temperature=0.7, # Température de génération, plage 0~2, plus la valeur est élevée, plus le résultat est divergent (voir ci-dessous)
)
# Afficher la réponse du modèle
print("Réponse :", response.choices[0].message.content)
# Le champ usage enregistre le nombre de Tokens consommés par cet appel (base de facturation)
print("Nombre de tokens d'entrée :", response.usage.prompt_tokens)
print("Nombre de tokens de sortie :", response.usage.completion_tokens)
Sortie :
回答:example(Example)是一个提供编程教程的中文学习网站…… 输入 Token 数:33 输出 Token 数:18
Le champ usage dans la structure renvoyée est l'implémentation concrète du concept de Token mentionné ci-dessus : il vous indique combien de Tokens cet appel a consommés et constitue également la base de la facturation.
Prompt
Le Prompt est l'instruction ou la question que vous donnez au modèle, ce qui détermine directement la qualité de la sortie du modèle.
La technique consistant à étudier comment écrire des Prompts plus clairs et plus efficaces s'appellePrompt Engineering。
Les techniques courantes incluent : fournir des exemples concrets, exiger un raisonnement étape par étape, spécifier le format de sortie, etc.
Prompt système
Instructions prédéfinies pour le modèle avant l'entrée formelle de l'utilisateur, utilisées pour définir le rôle du modèle, les lignes directrices de comportement et les connaissances de fond.
La phrase "Vous êtes un assistant professionnel en programmation Python et ne répondez qu'aux questions techniques" dans l'exemple précédent est un System Prompt typique.
Différence entre le System Prompt et les messages utilisateur : le System Prompt définit "comment le modèle doit se comporter", tandis que les messages utilisateur précisent "ce qu'il faut faire précisément".
Placer des règles générales dans le System Prompt permet de garder un style de réponse cohérent à travers les conversations multi-tours.
Température
La température est un paramètre qui contrôle le caractère aléatoire de la sortie du modèle, généralement compris entre 0 et 2.
Plus la température est élevée, plus les réponses sont "créatives" et aléatoires, et plus elles sont sujettes aux erreurs ; plus la température est basse, plus les réponses sont conservatrices et stables.
| Plage de valeurs | Caractéristiques de sortie | Scénarios applicables |
|---|---|---|
| Proche de 0 | Quasiment déterministe, stable et reproductible | Écriture de code, extraction de données, questions-réponses factuelles |
| 0.3 ~ 0.7 | Une certaine variation mais contrôlable | Dialogue général, traduction, résumé |
| 0.8 ~ 1.2 | Créatif, diversifié | Brainstorming, rédaction publicitaire, création d'histoires |
| Supérieur à 1.2 | Très aléatoire, susceptible de dériver | À utiliser avec prudence, uniquement pour des scénarios créatifs particuliers |
Apprentissage en contexte
Il n'est pas du tout nécessaire de fine-tuner le modèle ; il suffit de fournir quelques exemples dans le Prompt, et le modèle peut les imiter pour accomplir de nouvelles tâches similaires.
Il s'agit de l'une des techniques les plus couramment utilisées en ingénierie de prompt, également appelée apprentissage few-shot.
Chaîne de pensée (CoT)
Guidez le modèle pour qu'il décompose les problèmes complexes en un processus de raisonnement étape par étape avant de donner la réponse finale, plutôt que de sauter directement à une conclusion.
La pratique a montré que cette approche améliore considérablement la précision du modèle sur des tâches complexes telles que les mathématiques et le raisonnement logique.
La façon la plus simple est d'ajouter « Veuillez réfléchir étape par étape » au prompt.
Hallucination
L'hallucination désigne le contenu que le modèle génère qui semble plausible et fluide mais qui est en réalité erroné ou fabriqué.
Il s'agit d'un défaut courant des LLM, car le modèle ne fait essentiellement que « continuer le texte le plus probable » plutôt que de « vérifier les faits ».
L'une des méthodes principales pour atténuer les hallucinations est le RAG, décrit ci-dessous : récupérer d'abord des informations réelles, puis laisser le modèle répondre en se basant sur ces informations.
Connecter le modèle au monde extérieur
Un LLM simple ne peut se fier qu'aux connaissances apprises pendant l'entraînement pour répondre aux questions ; il ne connaît pas les dernières informations et ne peut pas non plus entreprendre des actions de manière proactive.
Les techniques de cette section sont la clé pour résoudre ces deux lacunes.
Embedding
L'embedding convertit le texte, les images et d'autres contenus en une séquence de nombres (vecteurs).
Après conversion, l'ordinateur peut déterminer si deux contenus sont similaires en termes de « sémantique » en calculant la distance entre les vecteurs.
C'est le fondement sous-jacent d'applications telles que la recherche, la recommandation et le RAG.
Base de données vectorielle
Une base de données vectorielle est spécifiquement utilisée pour stocker et récupérer des vecteurs d'embedding, tels que Pinecone, Milvus et Chroma.
Il peut trouver rapidement le contenu le plus similaire à la sémantique de la requête parmi une immense quantité de vecteurs, et c'est un composant essentiel pour construire des systèmes RAG.
RAG (Génération augmentée par récupération)
RAG signifie Retrieval-Augmented Generation.
Son flux de travail est le suivant : d'abord convertir la base de connaissances externe en vecteurs et les stocker dans une base de données vectorielle ; lorsque l'utilisateur pose une question, récupérer le contenu le plus pertinent ; puis transmettre les résultats récupérés avec la question au modèle pour générer une réponse.
RAG peut efficacement réduire les hallucinations et permettre au modèle de répondre à de nouvelles connaissances au-delà des données d'entraînement.
Voici un exemple minimal de RAG qui ne dépend pas d'une base de données vectorielle externe et utilise OpenAI Embedding plus numpy, afin de rendre le principe plus facile à comprendre :
Exemple
from openai import OpenAI
import numpy as np
import os
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# Simuler une très petite "base de connaissances" : plusieurs documents
documents = [
"example est un site d'apprentissage du chinois qui fournit des tutoriels de programmation.",
"RAG réduit les hallucinations dans les grands modèles en récupérant des informations réelles puis en générant.",
"Python utilise l'indentation pour représenter les blocs de code, et il est généralement recommandé d'indenter de 4 espaces par niveau.",
]
# Étape 1 : Vectoriser la base de connaissances (à construire hors ligne, à ne faire qu'une seule fois)
doc_resp = client.embeddings.create(input=documents, model="text-embedding-3-small")
doc_vectors = [d.embedding for d in doc_resp.data]
# Étape 2 : Vectoriser la question de l'utilisateur
question = "Qu'est-ce que Python ?"
query_vector = client.embeddings.create(
input=question, model="text-embedding-3-small"
).data[0].embedding
# Étape 3 : Utiliser la similarité cosinus pour trouver le document le plus pertinent
def cosine(a, b):
a, b = np.array(a), np.array(b)
return float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b)))
scores = [cosine(query_vector, v) for v in doc_vectors]
best_doc = documents[int(np.argmax(scores))] # Le document avec la similarité la plus élevée
print("Documents récupérés :", best_doc)
# Étape 4 : Soumettre les documents récupérés ainsi que la question au modèle pour générer une réponse
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": "Veuillez répondre à la question en vous basant uniquement sur les documents fournis ci-dessous ; ne fabriquez pas d'informations qui ne figurent pas dans les documents."},
{"role": "user", "content": f"Documents : {best_doc}\n\nQuestion : {question}"},
],
)
print("Réponse :", response.choices[0].message.content)
Sortie :
检索到的资料:example 是一个提供编程教程的中文学习网站。 回答:example(Example)是一个提供编程教程的中文学习网站。
Dans les projets réels, il suffit de remplacer "le calcul de similarité en mémoire" à l'étape 3 par "l'appel à une base de données vectorielle pour la recherche", et le processus est exactement le même.
Appel de fonctions
L'appel de fonctions permet aux grands modèles d'appeler des outils externes ou des API pour accomplir des tâches, comme interroger la météo en temps réel, effectuer des calculs mathématiques, interroger des bases de données et envoyer des e-mails.
Il compense la lacune du modèle qui "ne peut que générer du texte, sans effectuer d'actions", et constitue une étape clé pour faire évoluer les grands modèles de simples chatbots vers des outils pratiques.
Son fonctionnement repose sur une interaction en deux tours : lors du premier tour, le modèle décide quelle fonction appeler et quels paramètres transmettre ; après que votre code a réellement exécuté la fonction, le résultat est renvoyé lors du second tour, ce qui permet au modèle de générer une réponse en langage naturel.
Exemple
import json
import os
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# Définir les outils (fonctions) pouvant être appelés par le modèle
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Interroger la météo en temps réel pour la ville spécifiée",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "Nom de la ville, par ex. Hangzhou"}
},
"required": ["city"],
},
},
}
]
# Fonction locale qui exécute réellement la requête (à remplacer par une vraie API météo en production)
def get_weather(city):
return f"{city} est ensoleillé aujourd'hui, température 28°C"
# Tour 1 : Transmettre la question au modèle, qui décide quel outil appeler et quels paramètres transmettre
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[{"role": "user", "content": "Quel temps fait-il à Hangzhou aujourd'hui ?"}],
tools=tools,
)
tool_call = response.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments) # Extraire les paramètres, par exemple, {"city": "Hangzhou"}
result = get_weather(args["city"]) # Exécuter réellement l'outil
print("Résultat de l'exécution de l'outil :", result)
# Tour 2 : Renvoyer le résultat de l'outil au modèle, pour qu'il génère une réponse en langage naturel à partir du résultat
follow_up = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "user", "content": "Quel temps fait-il à Hangzhou aujourd'hui ?"},
response.choices[0].message, # La décision du modèle d'« appeler l'outil » issue de l'étape précédente
{"role": "tool", "tool_call_id": tool_call.id, "content": result}, # Le résultat renvoyé par l'outil
],
tools=tools,
)
print("Réponse finale :", follow_up.choices[0].message.content)
Résultat de sortie :
工具执行结果:杭州 今天晴,气温 28°C 最终回答:杭州今天是晴天,气温大约 28°C,适合外出活动。
MCP (Model Context Protocol)
MCP signifie Model Context Protocol, un protocole ouvert qui permet aux grands modèles de se connecter à des outils et sources de données externes de manière standardisée.
On peut le comparer à un « port USB pour l’IA » : tant que différents outils et sources de données respectent ce protocole, ils peuvent être appelés de manière uniforme par divers grands modèles prenant en charge MCP.
Il résout le problème de « devoir intégrer chaque outil de manière répétée » de l’ère du Function Calling, ce qui réduit l’effort de développement.
Agent
Un Agent est un système construit sur de grands modèles qui peut planifier des tâches de manière autonome, appeler des outils et exécuter des opérations en plusieurs étapes.
Par rapport à une conversation questions-réponses, un Agent ressemble davantage à un « employé numérique » capable d’accomplir de manière autonome des tâches complexes, comme exécuter automatiquement l’ensemble du processus « recherche → code → test → correction de bugs ».
La boucle centrale sur laquelle il s’appuie est ReAct (Reason + Act) : réfléchir à l’étape suivante, appeler des outils, observer les résultats, puis réfléchir à nouveau, jusqu’à ce que la tâche soit terminée.
Multimodal
Multimodal désigne la capacité d’un modèle à comprendre et/ou générer simultanément plusieurs types de données, sans se limiter au texte, mais en incluant aussi les images, l’audio et la vidéo.
De nombreux grands modèles courants disposent désormais déjà de capacités multimodales telles que la lecture d’images et l’analyse de graphiques.
| Technologie | Problème qu’il résout | Compréhension en une phrase |
|---|---|---|
| Embedding | Permettre aux ordinateurs de comprendre la similarité sémantique | Convertir le texte en vecteurs calculables |
| Base de données vectorielle | Stockage et récupération efficaces de vecteurs | Dépôt spécialisé pour la recherche sémantique |
| RAG | Le modèle ne connaît pas les connaissances à jour ou peut les fabriquer | Rechercher d'abord l'information, puis répondre |
| Appel de fonctions | Les modèles peuvent seulement générer du texte et ne peuvent pas effectuer d'actions | Permettre aux modèles d'appeler des outils externes |
| MCP | Chaque fois que vous intégrez un outil, vous devez le développer à nouveau | Port USB unifié pour les outils d'IA |
| Agent | Les conversations à un seul tour ne peuvent pas accomplir de tâches complexes | Un employé numérique capable de planifier plusieurs étapes de manière autonome |
Rendre les modèles plus rapides et plus efficaces
Plus le modèle est puissant, plus il tend à être grand et plus son coût d'exécution est élevé.
Les deux concepts suivants visent à rendre les modèles plus légers et plus efficaces lors du déploiement réel.
Quantification
La quantification compresse les paramètres du modèle d'une haute précision (par exemple, virgule flottante 32 bits) vers une faible précision (par exemple, entiers 8 bits ou 4 bits).
Elle peut réduire considérablement la mémoire GPU occupée par le modèle et améliorer la vitesse d'inférence ; le compromis est une certaine perte de précision, mais elle est acceptable dans de nombreux scénarios.
Distillation de modèle
La distillation utilise la sortie d'un « modèle enseignant » puissant mais volumineux pour entraîner un « modèle étudiant » plus petit.
L'objectif est de permettre au petit modèle d'apprendre autant que possible les capacités du grand modèle. Le modèle distillé est plus petit, plus rapide en inférence et moins coûteux à déployer.
| Élément de comparaison | Quantification | Distillation |
|---|---|---|
| Ce qu’il fait | Compresser la précision des paramètres (32 bits → 8/4 bits) | Utiliser un grand modèle pour enseigner à un petit modèle |
| Ce qui change | La représentation numérique du même modèle | Obtenir un nouveau petit modèle |
| Principal avantage | Économise la mémoire GPU, augmente la vitesse | Le petit modèle est plus fort et plus rapide |
| Si un entraînement est nécessaire | Généralement, aucun réentraînement n'est nécessaire | Nécessite l'entraînement du modèle étudiant |
| Scénario typique | Faire tenir un grand modèle dans une mémoire GPU limitée | Déployer un petit modèle à la place d'un grand modèle |
Parcours d'apprentissage pour débutants
Pour les développeurs débutants, il n'est pas nécessaire de saisir tous les concepts d'un coup.
Il est recommandé de suivre l'ordre ci-dessous et de progresser étape par étape, ce qui facilite la construction d'un système complet plutôt que de mémoriser des concepts isolément.
| Étape | Concepts à maîtriser | Ce que vous pouvez faire |
|---|---|---|
| Étape 1 | LLM、Token、Prompt | Appeler l'API pour mener des conversations |
| Étape 2 | Embedding, bases de données vectorielles, RAG | Connecter des connaissances externes au modèle |
| Étape 3 | Function Calling、Agent | Laissez le modèle appeler des outils et accomplir des tâches de manière autonome |
| Étape 4 | Réglage fin, quantification, distillation | Déploiement et optimisation en production |
Il n'est pas nécessaire d'apprendre les définitions par cœur — il suffit d'exécuter vous-même les exemples de code de cet article, et vous acquerrez une compréhension bien plus profonde.
Référence rapide de la terminologie essentielle
Tous les termes clés de l'article sont résumés dans un seul tableau, regroupés par « étape » pour faciliter la consultation et la révision à tout moment.
| Terme | Anglais / Nom complet | Étape | Explication en une phrase |
|---|---|---|---|
| LLM | Grand modèle de langage | Concepts de base | Un modèle d'apprentissage profond entraîné sur d'énormes quantités de texte ; son essence est de « prédire le mot suivant » |
| Transformer | Transformer | Concepts de base | L'architecture réseau sous-jacente partagée par presque tous les LLM modernes |
| Mécanisme d'attention | Attention / Auto-attention | Concepts de base | Permet au modèle de se concentrer dynamiquement sur les mots pertinents de l'entrée pour comprendre les relations contextuelles |
| Token | Token | Concepts de base | La plus petite unité de texte traitée par le modèle ; la longueur de contexte et la facturation API sont toutes deux calculées sur cette base |
| Fenêtre de contexte | Fenêtre de contexte | Concepts de base | Le nombre maximal de Tokens que le modèle peut « voir » et traiter en une fois |
| Nombre de paramètres | Parameters | Concepts de base | Le nombre de poids apprenables à l'intérieur du modèle, souvent mesuré en B (milliards) |
| Pré-entraînement | Pré-entraînement | Entraînement | Apprendre les schémas linguistiques à partir de textes massifs non étiquetés, posant les bases des capacités |
| SFT | Fine-tuning supervisé | Entraînement | Apprendre au modèle à répondre aux questions selon les instructions à l'aide de données de paires questions-réponses |
| RLHF | Apprentissage par renforcement à partir du retour humain | Entraînement | Utiliser des évaluations humaines pour calibrer les sorties du modèle afin de mieux les aligner sur les préférences humaines |
| RLAIF | Apprentissage par renforcement à partir des retours de l'IA | Entraînement | Utiliser l'IA au lieu d'une notation humaine pour réduire les coûts d'annotation |
| Alignement | Alignement | Entraînement | Faire en sorte que le comportement du modèle soit conforme à l'intention humaine, afin qu'il soit utile, honnête et sûr |
| Fine-tuning | Fine-tuning | Entraînement | Poursuivre l'entraînement d'un modèle généraliste avec des données de domaine pour l'adapter à des scénarios spécialisés |
| MoE | Mélange d'experts | Entraînement | Plusieurs sous-réseaux experts sont activés à la demande ; grand nombre de paramètres mais inférence rapide |
| Prompt | Prompt | Utilisation | L'instruction ou la question saisie dans le modèle ; détermine directement la qualité de la sortie |
| Ingénierie de prompt | Ingénierie de prompt | Utilisation | L'étude des techniques pour écrire des prompts plus clairs et plus efficaces |
| Prompt système | Prompt système | Utilisation | Une instruction prédéfinie qui définit le rôle et les lignes directrices comportementales du modèle |
| Température | Température | Utilisation | Un paramètre contrôlant l'aléatoire de la sortie, allant de 0 à 2 ; des valeurs plus élevées produisent une sortie plus divergente |
| Apprentissage en contexte | Apprentissage en contexte | Utilisation | Donnez quelques exemples dans le prompt et le modèle suit ; aussi appelé Few-shot |
| Chaîne de pensée | Chaîne de pensée (CoT) | Utilisation | Guider le modèle à raisonner étape par étape avant de répondre, ce qui améliore la précision sur les tâches complexes |
| Hallucination | Hallucination | Utilisation | Le modèle génère un contenu fluide mais incorrect ou fabriqué |
| Embedding | Embedding | Monde extérieur | Conversion du contenu en vecteurs pour mesurer la similarité sémantique |
| Base de données vectorielle | Base de données vectorielle | Monde extérieur | Une base de données dédiée au stockage et à la récupération de vecteurs, comme Milvus, Chroma |
| RAG | Génération augmentée par récupération | Monde extérieur | Récupérer d'abord des informations réelles puis générer, afin d'atténuer les hallucinations et d'ajouter de nouvelles connaissances |
| Appel de fonctions | Appel de fonctions | Monde extérieur | Permettre au modèle d'appeler des outils externes ou des API pour effectuer des actions réelles |
| MCP | Protocole de contexte de modèle | Monde extérieur | Un protocole ouvert pour standardiser les connexions d'outils, l'« interface USB » de l'IA |
| Agent | Agent | Monde extérieur | Un système capable de planifier de manière autonome, d'appeler des outils et d'exécuter des tâches complexes en plusieurs étapes |
| ReAct | Raisonner + Agir | Monde extérieur | La boucle centrale de l'agent : Penser—Agir—Observer—Repenser |
| Multimodal | Multimodal | Monde extérieur | Comprendre et/ou générer simultanément plusieurs types de données tels que du texte, des images et de l’audio |
| Quantification | Quantification | Optimisation | Compresser la précision des paramètres (32 bits → 8/4 bits), économisant de la VRAM et augmentant la vitesse |
| Distillation de modèle | Distillation de modèle | Optimisation | Utiliser un grand modèle pour enseigner à un petit modèle, ce qui donne un modèle de déploiement plus petit et plus rapide |