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

# Installation : pip install tiktoken
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ÉchellePositionnement typique
1B ~ 7BPetit à moyenPeut s'exécuter localement sur des GPU grand public, adapté aux tâches légères
8B ~ 34BMoyenneRapport coût-performance élevé, couvre la plupart des scénarios généraux
70B ~ des centaines de BgrandCapacité 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.

LLM 训练流程图

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înementAnglaisFonction principaleDonnées utilisées
Pré-entraînementPré-entraînementApprendre les schémas linguistiques et acquérir des capacités fondamentalesQuantités massives de texte non étiqueté
Affinage superviséSFTApprendre à répondre aux questions selon les instructionsPaires question-réponse annotées par des humains
Apprentissage par renforcement à partir de retours humainsRLHFDes sorties mieux alignées sur les préférences humainesNotation/classement humain des réponses
AlignementAlignementRendre le modèle utile, honnête et sûrCouvre 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

# Installation : pip install openai
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 valeursCaractéristiques de sortieScénarios applicables
Proche de 0Quasiment déterministe, stable et reproductibleÉcriture de code, extraction de données, questions-réponses factuelles
0.3 ~ 0.7Une certaine variation mais contrôlableDialogue général, traduction, résumé
0.8 ~ 1.2Créatif, diversifiéBrainstorming, rédaction publicitaire, création d'histoires
Supérieur à 1.2Trè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.

RAG 检索增强生成流程图

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

# Installer : pip install openai numpy
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

from openai import OpenAI
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.

Agent 智能体工作循环图

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.

TechnologieProblème qu’il résoutCompréhension en une phrase
EmbeddingPermettre aux ordinateurs de comprendre la similarité sémantiqueConvertir le texte en vecteurs calculables
Base de données vectorielleStockage et récupération efficaces de vecteursDépôt spécialisé pour la recherche sémantique
RAGLe modèle ne connaît pas les connaissances à jour ou peut les fabriquerRechercher d'abord l'information, puis répondre
Appel de fonctionsLes modèles peuvent seulement générer du texte et ne peuvent pas effectuer d'actionsPermettre aux modèles d'appeler des outils externes
MCPChaque fois que vous intégrez un outil, vous devez le développer à nouveauPort USB unifié pour les outils d'IA
AgentLes conversations à un seul tour ne peuvent pas accomplir de tâches complexesUn 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 comparaisonQuantificationDistillation
Ce qu’il faitCompresser la précision des paramètres (32 bits → 8/4 bits)Utiliser un grand modèle pour enseigner à un petit modèle
Ce qui changeLa représentation numérique du même modèleObtenir un nouveau petit modèle
Principal avantageÉconomise la mémoire GPU, augmente la vitesseLe petit modèle est plus fort et plus rapide
Si un entraînement est nécessaireGénéralement, aucun réentraînement n'est nécessaireNécessite l'entraînement du modèle étudiant
Scénario typiqueFaire tenir un grand modèle dans une mémoire GPU limitéeDé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.

ÉtapeConcepts à maîtriserCe que vous pouvez faire
Étape 1LLM、Token、PromptAppeler l'API pour mener des conversations
Étape 2Embedding, bases de données vectorielles, RAGConnecter des connaissances externes au modèle
Étape 3Function Calling、AgentLaissez le modèle appeler des outils et accomplir des tâches de manière autonome
Étape 4Réglage fin, quantification, distillationDé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.

TermeAnglais / Nom completÉtapeExplication en une phrase
LLMGrand modèle de langageConcepts de baseUn modèle d'apprentissage profond entraîné sur d'énormes quantités de texte ; son essence est de « prédire le mot suivant »
TransformerTransformerConcepts de baseL'architecture réseau sous-jacente partagée par presque tous les LLM modernes
Mécanisme d'attentionAttention / Auto-attentionConcepts de basePermet au modèle de se concentrer dynamiquement sur les mots pertinents de l'entrée pour comprendre les relations contextuelles
TokenTokenConcepts de baseLa 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 contexteFenêtre de contexteConcepts de baseLe nombre maximal de Tokens que le modèle peut « voir » et traiter en une fois
Nombre de paramètresParametersConcepts de baseLe nombre de poids apprenables à l'intérieur du modèle, souvent mesuré en B (milliards)
Pré-entraînementPré-entraînementEntraînementApprendre les schémas linguistiques à partir de textes massifs non étiquetés, posant les bases des capacités
SFTFine-tuning superviséEntraînementApprendre au modèle à répondre aux questions selon les instructions à l'aide de données de paires questions-réponses
RLHFApprentissage par renforcement à partir du retour humainEntraînementUtiliser des évaluations humaines pour calibrer les sorties du modèle afin de mieux les aligner sur les préférences humaines
RLAIFApprentissage par renforcement à partir des retours de l'IAEntraînementUtiliser l'IA au lieu d'une notation humaine pour réduire les coûts d'annotation
AlignementAlignementEntraînementFaire en sorte que le comportement du modèle soit conforme à l'intention humaine, afin qu'il soit utile, honnête et sûr
Fine-tuningFine-tuningEntraînementPoursuivre 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
MoEMélange d'expertsEntraînementPlusieurs sous-réseaux experts sont activés à la demande ; grand nombre de paramètres mais inférence rapide
PromptPromptUtilisationL'instruction ou la question saisie dans le modèle ; détermine directement la qualité de la sortie
Ingénierie de promptIngénierie de promptUtilisationL'étude des techniques pour écrire des prompts plus clairs et plus efficaces
Prompt systèmePrompt systèmeUtilisationUne instruction prédéfinie qui définit le rôle et les lignes directrices comportementales du modèle
TempératureTempératureUtilisationUn 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 contexteApprentissage en contexteUtilisationDonnez quelques exemples dans le prompt et le modèle suit ; aussi appelé Few-shot
Chaîne de penséeChaîne de pensée (CoT)UtilisationGuider le modèle à raisonner étape par étape avant de répondre, ce qui améliore la précision sur les tâches complexes
HallucinationHallucinationUtilisationLe modèle génère un contenu fluide mais incorrect ou fabriqué
EmbeddingEmbeddingMonde extérieurConversion du contenu en vecteurs pour mesurer la similarité sémantique
Base de données vectorielleBase de données vectorielleMonde extérieurUne base de données dédiée au stockage et à la récupération de vecteurs, comme Milvus, Chroma
RAGGénération augmentée par récupérationMonde extérieurRé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 fonctionsAppel de fonctionsMonde extérieurPermettre au modèle d'appeler des outils externes ou des API pour effectuer des actions réelles
MCPProtocole de contexte de modèleMonde extérieurUn protocole ouvert pour standardiser les connexions d'outils, l'« interface USB » de l'IA
AgentAgentMonde extérieurUn système capable de planifier de manière autonome, d'appeler des outils et d'exécuter des tâches complexes en plusieurs étapes
ReActRaisonner + AgirMonde extérieurLa boucle centrale de l'agent : Penser—Agir—Observer—Repenser
MultimodalMultimodalMonde extérieurComprendre et/ou générer simultanément plusieurs types de données tels que du texte, des images et de l’audio
QuantificationQuantificationOptimisationCompresser la précision des paramètres (32 bits → 8/4 bits), économisant de la VRAM et augmentant la vitesse
Distillation de modèleDistillation de modèleOptimisationUtiliser un grand modèle pour enseigner à un petit modèle, ce qui donne un modèle de déploiement plus petit et plus rapide
Autres extensions