Introduction aux Modèles de Langage Larges

Introduction

Qu'est-ce exactement qu'un Modèle de Langage Large ? Pour répondre à cette question, commençons par quelque chose de familier. Imaginez que vous composez un message texte sur votre téléphone. Après avoir tapé quelques mots, votre téléphone suggère le mot suivant — et parfois c'est si précis que vous cliquez juste sur la suggestion pour continuer à taper. Cette fonctionnalité de texte prédictif est une forme très simple de modèle de langage. Un Modèle de Langage Large (LLM) fonctionne selon la même idée de base, mais à une échelle considérablement plus grande.

Un LLM est un réseau neuronal entraîné sur d'énormes volumes de texte — livres, articles, sites web, code et plus encore. Pendant ce processus d'entraînement, le modèle lit des milliards de phrases et apprend les relations statistiques entre les mots et les phrases. Il découvre des motifs tels que : quand certains mots apparaissent, quels mots ont tendance à suivre ; comment les phrases sont structurées ; comment le contexte change la signification ; et comment différentes informations sont liées les unes aux autres. Une fois l'entraînement terminé, le modèle peut générer du texte cohérent et contextuellement approprié en réponse à une instruction que vous fournissez.

Le « Large » dans Modèle de Langage Large fait référence à deux choses simultanément. Premièrement, l'échelle des données d'entraînement — les LLM modernes sont entraînés sur des ensembles de données contenant des centaines de milliards à des billions de tokens (où un token est approximativement un mot ou une partie de mot). Deuxièmement, le modèle lui-même — ces modèles contiennent des milliards de paramètres, qui sont les valeurs numériques internes qui encodent tout ce que le modèle a appris. Un modèle avec 7 milliards de paramètres, par exemple, a 7 milliards de nombres ajustables qui représentent ensemble sa connaissance du langage.

Pourquoi cela compte-t-il pour vous en tant que développeur Jetson ? Jusqu'à récemment, exécuter un modèle de cette échelle nécessitait des serveurs cloud coûteux avec plusieurs GPU haut de gamme. La percée majeure des deux dernières années est que des techniques comme la quantification — comprimer la précision numérique du modèle — rendent maintenant possible l'exécution de LLM capables sur des appareils edge comme le NVIDIA Jetson Orin Nano et Orin NX. Cela signifie que vous pouvez créer des applications alimentées par l'IA qui s'exécutent entièrement hors ligne, gardant vos données privées et éliminant la dépendance à la connectivité Internet.

Comment Fonctionnent les LLM

Maintenant que vous comprenez ce qu'est un LLM, la question naturelle est : comment produit-il réellement du texte ? La réponse tourne autour d'une opération centrale — prédire le prochain token dans une séquence.

Tokens : Les Blocs de Construction

Avant de discuter de la façon dont le modèle génère du texte, nous devons clarifier ce que signifie traiter le texte comme des « tokens ». Un LLM ne lit pas le texte brut comme les humains. Au lieu de cela, un tokeniseur divise votre entrée en unités plus petites appelées tokens. Un token pourrait être un mot entier comme « ordinateur », un fragment de mot courant comme « the », ou même un seul caractère dans une langue inconnue. Par exemple :

"The reComputer runs Linux"
→ ["The", " re", "Computer", " runs", " Linux"]   (5 tokens)

Le vocabulaire du tokeniseur contient généralement entre 30 000 et 100 000 tokens. Chaque fragment de texte que le modèle voit est converti en une séquence de ces tokens avant tout traitement.

Le Processus d'Entraînement

Entraîner un LLM implique trois étapes clés, chacune construisant sur la précédente :

Étape 1 — Pré-entraînement sur texte brut. Le modèle est alimenté avec d'énormes quantités de texte (les sources courantes incluent Common Crawl, Wikipedia, les dépôts GitHub et les livres publiés). Pendant cette étape, la tâche du modèle est délicieusement simple : étant donnée une séquence de tokens, prédire le prochain token. Par exemple, quand le modèle voit « The Eiffel Tower is located in », il apprend que « Paris » est le prochain token le plus probable. En répétant cet exercice à travers des milliards d'exemples, le modèle construit progressivement une représentation interne de la grammaire, des faits, des motifs de raisonnement et même de la logique de programmation.

Étape 2 — Ajustement Fin Supervisé (SFT). Après le pré-entraînement, le modèle a des connaissances larges mais ne sait pas comment se comporter comme un assistant utile. À cette étape, des annotateurs humains créent des exemples de paires instruction-réponse de haute qualité. Le modèle est entraîné sur ces exemples pour apprendre le format et le style des réponses utiles.

Étape 3 — Alignement (RLHF ou similaire). À l'étape finale, des évaluateurs humains classent plusieurs réponses du modèle de la meilleure à la pire. Ce retour d'information entraîne un modèle de récompense, qui à son tour guide le LLM pour produire des réponses plus utiles, inoffensives et honnêtes. C'est pourquoi les modèles de chat modernes produisent des réponses plus cohérentes et utiles que ce que l'étape de pré-entraînement seule ne le suggère.

Inférence : Générer du Texte Un Token à la Fois

Une fois l'entraînement terminé, le modèle génère du texte par un processus appelé inférence. Voici exactement ce qui se passe quand vous tapez une instruction :

Le tokeniseur convertit cela en IDs de tokens. Le modèle traite ces tokens et produit une distribution de probabilité sur tous les tokens de son vocabulaire. Le token « Paris » reçoit la probabilité la plus élevée, il est donc sélectionné et ajouté à la sortie. La séquence mise à jour lit maintenant « The capital of France is Paris », et le modèle répète le processus — prédisant le prochain token à nouveau. Cela continue jusqu'à ce que le modèle émette un token spécial de fin de séquence, ou jusqu'à ce qu'une limite de longueur maximale soit atteinte.

Étape 1 : "The capital of France is"         → prédire "Paris"
Étape 2 : "The capital of France is Paris"    → prédire "and"
Étape 3 : "The capital of France is Paris and"→ prédire " the"
Étape 4 : ...continue jusqu'à complétion

Un point critique à comprendre : le modèle ne « connaît » pas la réponse de la façon dont fonctionne une recherche en base de données. Il produit du texte qui est statistiquement probable étant donné ses données d'entraînement. C'est pourquoi les LLM peuvent parfois générer des déclarations qui semblent plausibles mais sont incorrectes — une limitation que vous devriez garder à l'esprit lors de la construction d'applications.

L'ensemble du processus — de votre instruction à la réponse complète — est ce qui se passe lors de chaque interaction avec un LLM. Dans la section suivante, nous examinerons l'architecture de réseau neuronal spécifique qui rend tout cela possible.

_{Comment les Modèles de Langage Larges Traitent et Génèrent du Texte}

L'Architecture Transformer

Presque tous les LLM modernes sont basés sur l'architecture Transformer, introduite dans l'article fondateur « Attention Is All You Need » (2017) par des chercheurs de Google. Cet article unique a fondamentalement changé la trajectoire de l'IA — et les modèles que vous exécuterez sur Jetson (Llama, Qwen, DeepSeek, Gemma) sont tous des descendants directs de cette architecture.

L'innovation clé est le mécanisme d'auto-attention, qui permet au modèle de peser l'importance des différents mots lors du traitement du texte — lui permettant de comprendre le contexte, les relations et la signification à un niveau sans précédent.

_{Le Transformer : Fondement des LLM Modernes}

Du Séquentiel au Parallèle : Pourquoi les Transformers ont Gagné

Avant les Transformers, des modèles comme les RNN (Réseaux Neuronaux Récurrents) et les LSTM traitaient le texte un mot à la fois, séquentiellement de gauche à droite. Cela causait deux problèmes majeurs :

1. Lent : Chaque mot dépendait du calcul du mot précédent — aucune parallélisation possible
2. Oubliant : Quand le modèle atteignait le 100e mot, il avait largement « oublié » le 1er mot

RNN (Ancien) :     "The" → "cat" → "sat" → "on" → "the" → "mat"   (lent, séquentiel)
Transformer :       ["The", "cat", "sat", "on", "the", "mat"] → tous à la fois !   (rapide, parallèle)

Le Transformer a résolu les deux problèmes en traitant tous les mots simultanément via l'auto-attention. Cela a rendu l'entraînement dramatiquement plus rapide et a permis aux modèles de capturer efficacement les relations à longue portée.

Comment Fonctionne l'Auto-Attention

L'auto-attention est l'innovation centrale du Transformer. Comprenons-la à travers un exemple concret.

Une Analogie du Monde Réel — Le Processus de Sélection d'Entretiens :

Imaginez que vous recrutez pour un poste et avez reçu 5 CV. Vous devez évaluer chaque candidat en le comparant à une « description de poste » (ce que vous recherchez). Voici comment fonctionne l'auto-attention :

• Chaque CV est à la fois candidat et description de poste — cela semble étrange, mais c'est exactement ainsi que l'auto-attention traite chaque mot dans une phrase
• La « description de poste » pour évaluer le candidat A s'appelle la Query (Q)
• Chaque CV a une section « qualifications » — ce sont les Keys (K)
• Le contenu réel du CV (expérience, compétences, éducation) est la Value (V)

Maintenant imaginez que vous voulez découvrir à quoi le mot « it » se réfère dans cette phrase :

« The robot picked up the ball because it was heavy. »

Voici le processus étape par étape :

Étape 1 : Générer Q/K/V pour chaque mot

Chaque mot dans la phrase génère ses propres vecteurs Query, Key et Value. Considérez cela comme chaque mot préparant à la fois une « question de recherche » et du « contenu à partager » :

Étape 2 : Calculer les scores de pertinence — le produit scalaire

Pour le mot « it », nous prenons son vecteur Query et calculons les produits scalaires avec les vecteurs Key de TOUS les autres mots :

"it" Query × "robot" Key = 0.2 (faible pertinence — les robots ne sont typiquement pas décrits comme lourds dans ce contexte)
"it" Query × "picked" Key = 0.1 (irrelevant — « picked » n'a rien à dire sur le poids)
"it" Query × "ball" Key = 0.9 (forte pertinence — les balles peuvent définitivement être lourdes !)

Étape 3 : Appliquer softmax pour normaliser

Ces scores bruts passent par softmax, qui les convertit en probabilités qui summent à 1 :

"ball":  0.82 (82% — « it » très probablement se réfère à « ball »)
"robot": 0.15 (15%)
"picked": 0.03 (3%)

Étape 4 : Somme pondérée des Values

Maintenant nous combinons tous les vecteurs Value en utilisant ces poids :

Nouvelle représentation de "it" = 0.82 × ball.Value + 0.15 × robot.Value + 0.03 × picked.Value

Le résultat ? Le mot « it » sait maintenant qu'il se réfère à la balle, et porte cette signification en avant.

Étape 5 : Répéter pour CHAQUE mot

Ce processus exact se produit pour chaque mot dans la phrase simultanément. « robot » regarde « ball », « picked », etc. pour comprendre son contexte. « ball » regarde « robot » et « picked ». Tout le monde regarde simultanément tout le monde à travers le mécanisme Query-Key-Value.

Les Mathématiques :

Ce processus peut s'écrire comme :

Où dₖ est la dimension du vecteur et √dₖ est un facteur d'échelle qui empêche les nombres de devenir trop grands pendant le calcul du produit scalaire. L'essentiel n'est pas la formule — c'est ceci : chaque mot calcule combien chaque autre mot est pertinent pour lui-même, puis rassemble l'information en conséquence.

_{Auto-Attention : Les Mots Prêtent Attention les Uns aux Autres}

Attention Multi-Têtes

Dans la section précédente, vous avez vu comment l'auto-attention permet à chaque mot de regarder chaque autre mot et de calculer les scores de pertinence. Le résultat est un nouvel ensemble de vecteurs où chaque mot a déjà mélangé le contexte des mots auxquels il a prêté attention. C'est puissant, mais cela a une limitation : un seul passage d'attention ne peut capturer qu'un type de relation à la fois.

Considérez « The robot picked up the ball because it was heavy. » Le lien entre « it » et « ball » (référence de pronom) et le lien entre « robot » et « picked » (sujet-verbe) sont deux types fondamentalement différents de relations. Un seul calcul d'attention peut découvrir l'un, mais pour capturer plusieurs types de relations simultanément, vous avez besoin de plusieurs passages d'attention en parallèle.

L'Attention Multi-Têtes fait exactement cela. L'idée est simple : au lieu d'exécuter l'attention une fois, exécutez-la plusieurs fois en parallèle, laissant chaque « tête » apprendre son propre motif indépendant de relations.

Concrètement, chaque tête a son propre ensemble séparé de matrices de poids Q, K, V. Cela signifie que pour le même mot, chaque tête le mappe en vecteurs Q, K, V différents, l'amenant à prêter attention à différents autres mots. Quatre têtes traitant la même phrase sont comme quatre observateurs regardant à travers des filtres de couleurs différentes, chacun voyant une « facette » différente de la phrase :

Phrase : [The] [robot] [picked] [up] [the] [ball] [because] [it] [was] [heavy]

Tête 1 (grammaire) :       robot ↔ picked   picked ↔ up
Tête 2 (proximité) :       the ↔ robot      picked ↔ up
Tête 3 (sémantique) :      heavy ↔ ball     robot ↔ machine
Tête 4 (référence) :       it ↔ ball

Les quatre têtes s'exécutent simultanément, chacune produisant sa propre sortie d'attention. Les quatre sorties sont ensuite concaténées et passées à travers une transformation linéaire pour les fusionner en une seule sortie unifiée :

   Tête 1 (grammaire)    Tête 2 (proximité)    Tête 3 (sémantique)    Tête 4 (référence)
        ↓                    ↓                      ↓                    ↓
   [sortie 1]           [sortie 2]             [sortie 3]           [sortie 4]
        ↓                    ↓                      ↓                    ↓
                      Concaténer + Transformation Linéaire
                                   ↓
                    [Sortie unifiée portant les quatre types d'information]

Cette sortie unifiée porte les quatre dimensions d'information relationnelle à la fois, prête pour la couche suivante du réseau. C'est pourquoi les Transformers comprennent si profondément le langage — au lieu de voir une phrase d'un seul angle, ils l'analysent de plusieurs dimensions en parallèle.

Structure du Bloc Transformer

Vous comprenez maintenant le cœur de l'attention multi-têtes : à travers plusieurs têtes d'attention en parallèle, chaque mot peut simultanément comprendre la phrase du point de vue grammatical, sémantique et de référence. Mais l'attention seule n'est pas toute l'image. Un modèle Transformer est construit en empilant de nombreux blocs identiques les uns sur les autres — Llama 3.2 3B, par exemple, empile 28 d'entre eux. Ces blocs de construction sont appelés Blocs Transformer, et chacun suit le même flux interne.

Étape 1 — Auto-Attention Multi-Têtes. Comme vous le savez déjà, chaque mot regarde chaque autre mot, calcule les scores de pertinence via l'appariement Query-Key, et rassemble l'information de ses voisins les plus pertinents. La sortie est une nouvelle représentation pour chaque mot qui porte maintenant l'information contextuelle de toute la phrase.

Étape 2 — Réseau Feed-Forward (FFN). Après que l'attention a enrichi chaque mot avec du contexte, le FFN traite chaque mot indépendamment. Pensez-y comme un petit réseau neuronal à deux couches dont le travail est de demander : « Maintenant que je connais le contexte, quelles caractéristiques plus profondes puis-je extraire de ce mot ? » Le FFN stocke une partie surprenante du « savoir » réel du modèle — il agit comme un moteur de raisonnement par mot.

Entre et autour de ces deux étapes, deux garde-fous importants maintiennent le réseau profond entraînable :

• Connexion Résiduelle (Add) : Après les deux étapes d'Attention et de FFN, l'entrée originale est ajoutée à la sortie. C'est comme installer un fusible sur un appareil — même si un module intermédiaire produit un résultat imparfait, l'information originale n'est jamais perdue. Sans ce mécanisme, dans un empilement de 28 couches, le signal d'entraînement (gradient) décroîtrait vers zéro pendant la rétropropagation, et le modèle échouerait entièrement à apprendre.

• Normalisation de Couche : Après l'addition résiduelle, toutes les valeurs sont re-scalées à une plage stable. Pensez-y comme à un régulateur de tension dans un circuit électrique — il empêche le signal de « exploser » après avoir traversé 28 étapes d'amplification consécutives.

L'idée critique est que chaque bloc successif construit un niveau plus profond d'abstraction. Les blocs précoces capturent la syntaxe de base — quels mots sont voisins, quels mots sont sujets ou objets. Les blocs du milieu commencent à assembler la sémantique — « the ball » est une phrase nominale, « was heavy » est une description. Aux blocs finaux, le modèle a construit une compréhension riche et multicouche de toute l'entrée, prête pour la prédiction précise du prochain token.

Encodeur vs. Décodeur

L'architecture Transformer originale décrite dans « Attention Is All You Need » (2017) avait en fait deux moitiés, chacune avec un travail différent. Comprendre cette division aide à expliquer pourquoi les LLM modernes sont construits comme ils le sont.

L'Encodeur — le lecteur. Le travail de l'Encodeur est de lire une phrase d'entrée entière en un seul passage et de construire une compréhension profonde de chaque mot en contexte. Il utilise l'attention bidirectionnelle — ce qui signifie que chaque mot peut regarder chaque autre mot, à sa gauche et à sa droite. Parce qu'il voit la phrase complète à la fois, l'Encodeur excelle dans les tâches de compréhension : résumer un paragraphe, classifier le sentiment ou extraire le sujet principal d'un document. BERT est le modèle encodeur-seul le plus connu, et Qwen et Gemma offrent également des variantes encodeur.

Le Décodeur — l'écrivain. Le travail du Décodeur est fondamentalement différent : il génère du texte un token à la fois, de gauche à droite. Il utilise l'auto-attention masquée, ce qui signifie que lors de la prédiction du troisième mot, il ne peut voir que les premier et deuxième mots — jamais le futur. Cette cécité forcée est essentielle : si le modèle pouvait « tricher » en regardant la réponse, il n'apprendrait jamais à générer par lui-même. GPT, Llama et DeepSeek utilisent tous cette architecture décodeur-seul.

Encodeur-Décodeur — les deux ensemble. Certaines tâches nécessitent à la fois compréhension et génération : traduire une phrase de l'anglais au chinois, par exemple, nécessite d'abord de lire toute la phrase anglaise (Encodeur), puis de générer la traduction chinoise mot par mot (Décodeur). Whisper (le modèle de reconnaissance vocale que vous avez rencontré plus tôt dans ce chapitre) utilise cette architecture combinée.

La raison pour laquelle les LLM modernes comme Llama, GPT, Qwen et DeepSeek se sont établis sur décodeur-seul est élégamment simple : un Décodeur entraîné sur suffisamment de données apprend à la fois à comprendre et à générer du texte. Quand il prédit le prochain token, il doit implicitement comprendre tout ce qui a précédé — et cette compréhension implicite s'avère suffisante pour une gamme remarquablement large de tâches.

Encodage Positionnel : Connaître l'Ordre des Mots

Dans les sections précédentes, vous avez vu comment l'auto-attention permet à chaque mot de regarder chaque autre mot et de calculer les scores de pertinence. Mais il y a une subtilité facile à manquer : l'attention n'a aucune idée de l'ordre dans lequel les mots apparaissent. Elle calcule la pertinence entre toutes les paires de mots, mais le calcul est entièrement indépendant de la position.

Cela signifie que si vous fournissiez « The cat chased the dog » et « The dog chased the cat » au modèle, du point de vue de l'attention les calculs seraient identiques — les deux phrases contiennent exactement les mêmes mots, juste dans un ordre différent. C'est clairement inacceptable : réarranger les mêmes mots change entièrement la signification.

L'encodage positionnel est conçu pour résoudre exactement ce problème. L'idée est intuitive : avant que le vecteur de chaque mot ne soit introduit dans l'attention, ajoutez une empreinte de position — un vecteur conçu mathématiquement dont le seul but est de dire « ce mot est à cette position ». Pensez-y comme à un numéro de siège dans un cinéma : le numéro de siège ne vous dit rien sur le film, mais il vous permet toujours de distinguer la rangée 3 siège 5 de la rangée 10 siège 2.

En pratique, l'empreinte de chaque position est générée en utilisant des fonctions sinus et cosinus :

Position 0 : "What"   + [0.00, 1.00, 0.00, 1.00, ...]
Position 1 : "is"     + [0.84, 0.54, 0.84, 0.54, ...]
Position 2 : "Jet"    + [0.91, -0.42, 0.91, -0.42, ...]

Pourquoi sinus et cosinus ? Parce que les positions adjacentes produisent toujours des valeurs d'empreinte légèrement différentes, et ces valeurs sont continues (pas de simples entiers 0, 1, 2). Cela signifie que même si le modèle n'a été entraîné que sur des phrases allant jusqu'à 100 positions de long, il peut généraliser à des phrases de 200 positions — le « rythme » de l'encodage positionnel est prévisible et régulier.

Les modèles modernes comme Llama et Qwen sont passés à RoPE (Embedding Positionnel Rotatif). Au lieu d'ajouter une valeur de position, RoPE fait tourner le vecteur de chaque mot dans l'espace de haute dimension selon un angle déterminé par sa position. Cela apporte un benefit supplémentaire : la distance relative entre deux mots (combien de positions les séparent) est directement reflétée dans la différence d'angle entre leurs vecteurs tournés, pas seulement dans leurs positions absolues. Cela rend le modèle plus stable et flexible lors du traitement de texte de différentes longueurs.

Pas à Pas : Comment un Transformer Traite le Texte

Maintenant que vous avez appris tous les composants centraux d'un Transformer, suivons un exemple complet pour voir comment ils fonctionnent ensemble. Nous suivrons la question : « Qu'est-ce que Jetson ? »

Étape 1 — Tokenisation Le texte d'entrée brut est divisé en tokens (typiquement des fragments de sous-mots) :

Étape 2 — Embedding Chaque token est converti en un vecteur numérique de haute dimension. Llama 3.2 3B, par exemple, produit un vecteur de 3072 dimensions pour chaque token :

"What" → [0.23, -0.45, 0.67, ..., 0.12]   (3072 nombres)
"is"   → [0.12, 0.89, -0.34, ..., 0.56]
"Jet"  → [0.78, 0.11, 0.56, ..., -0.33]
"son"  → [0.45, -0.23, 0.91, ..., 0.78]
"?"    → [0.67, 0.34, -0.12, ..., 0.45]

Étape 3 — Ajouter l'Encodage Positionnel Un vecteur d'encodage positionnel est ajouté à l'embedding de chaque token, donnant au modèle conscience de l'ordre des mots, comme expliqué en détail dans la section précédente.

Étape 4 — Auto-Attention (répétée sur N couches) Le modèle calcule les scores d'attention entre tous les tokens pour trouver les relations :

"What" prête le plus attention à :   "?" (0.5), "Jet" (0.4), "is" (0.3)
"is"  prête le plus attention à :   "What" (0.4), "Jetson" (0.5)
"Jet" prête le plus attention à :   "son" (0.8), "is" (0.3)

Après l'attention, la représentation de chaque token contient maintenant l'information des mots auxquels il a prêté attention.

Étape 5 — Réseau Feed-Forward La représentation enrichie de chaque token est traitée indépendamment à travers un petit réseau neuronal pour extraire des caractéristiques de niveau supérieur.

Étape 6 — Répéter (N couches empilées) Les étapes 4 et 5 se répètent plusieurs fois (28 fois pour Llama 3.2 3B). Chaque couche construit un niveau de compréhension plus profond :

• Couches précoces capturent la syntaxe de base et les relations locales (ordre des mots, collocations)
• Couches moyennes assemblent la sémantique (« Jetson » est un nom référant à une plateforme informatique)
• Couches tardives forment une compréhension de haut niveau, spécifique à la tâche, prête pour la prédiction

Étape 7 — Prédiction de Sortie La représentation du dernier token est projetée sur tout le vocabulaire, et le token avec la probabilité la plus élevée est sélectionné comme prédiction du modèle pour le prochain mot :

{"NVIDIA": 0.92, "AI": 0.03, "a": 0.02, ...}
→ Prédiction : "NVIDIA" (probabilité la plus élevée)

Concepts Clés du Transformer

Lois de Mise à l'Échelle : Pourquoi les Modèles Plus Grands Sont Plus Intelligents

L'une des découvertes les plus frappantes dans la recherche en IA est que les performances du Transformer suivent des lois de mise à l'échelle — des améliorations prévisibles à mesure que vous augmentez l'échelle du modèle, des données ou du budget de calcul. Cette découverte explique le bond rapide des capacités d'IA au cours de la dernière décennie.

Les lois de mise à l'échelle impliquent trois dimensions clés :

• Plus de Paramètres (Taille du Modèle) : Augmenter le nombre de paramètres — de 3 milliards à 70 milliards, par exemple — augmente significativement la profondeur de compréhension et l'expressivité du modèle. Les modèles plus grands peuvent capturer des motifs plus subtils et stocker plus de connaissances.

• Plus de Données d'Entraînement : Un modèle plus grand entraîné sur des données insuffisantes est comme un gros mangeur auquel on donne un petit repas — il ne peut atteindre son potentiel. La recherche montre que la taille du modèle et le nombre de tokens d'entraînement devraient idéalement mettre à l'échelle ensemble, approximativement dans un rapport de 1:1.

• Plus de Calcul : Entraîner des modèles plus grands exige plus de temps GPU et de budget. Les principaux laboratoires d'IA peuvent spend hundreds of millions de dollars on a single training run, which is why their proprietary models far exceed what open-source projects can achieve.

Parce que les trois dimensions ont mis à l'échelle ensemble, le domaine a progressé du Transformer original en 2017 (seulement 110 millions de paramètres) aux modèles actuels de plus de 70 milliards de paramètres. Pour votre appareil Jetson, l'implication plus importante est celle-ci : même les modèles de 1 à 3 milliards de paramètres possèdent des capacités solides de compréhension et de génération — plus que suffisantes pour fournir des services d'IA pratiques à l'edge.

Tailles de Modèle et Déploiement Local

Tous les LLM n'ont pas la même taille. Comprendre l'échelle du modèle est crucial pour choisir le bon pour votre matériel — le nombre de paramètres détermine directement les besoins en mémoire et la vitesse d'inférence :

Pour les appareils Jetson, le point idéal est 1B à 8B. Les modèles dans la plage 1B–3B offrent des expériences interactives très fluides sur Orin Nano, tandis que les modèles 7B–8B s'exécutent de manière fiable sur le Orin NX 16GB.

Conseil : Après la quantification (traitée ci-dessous), l'utilisation de la mémoire chute dramatiquement. Un modèle 7B en quantification INT4 nécessite seulement environ 3.5GB de mémoire — assez petit pour s'exécuter sur pratiquement n'importe quel appareil Jetson.

Familles Populaires de LLM Open Source

Voici les familles de LLM open source les plus prominentes, toutes offrant des variantes qui fonctionnent bien sur Jetson :

Llama (Meta)

Le LLM open source de Meta — actuellement la communauté la plus active et l'écosystème le plus riche.

• Llama 3.2 vient en tailles 1B et 3B, construit spécifiquement pour les appareils edge avec un excellent équilibre performance-encombrement
• Supporte plusieurs langues ; la communauté fournit une large gamme de variantes ajustées
• Famille de modèles la mieux supportée dans les écosystèmes Ollama et llama.cpp

Qwen (Alibaba Cloud)

Le LLM open source d'Alibaba, leader parmi les modèles ouverts en capacité de langue chinoise.

• Qwen3.5 s'étend de 0.8B à 122B paramètres ; la variante 0.8B est idéale pour les scénarios edge à ressources contraintes
• Excellent support bilingue en chinois et anglais
• Supporte nativement l'utilisation d'outils et le raisonnement en chaîne de pensée

DeepSeek

Une famille de modèles focalisée sur le raisonnement, excellant en mathématiques, codage et tâches logiques.

• DeepSeek-R1 propose des versions distillées (1.5B, 7B, 8B) qui surpassent significativement les modèles de même taille sur les benchmarks de raisonnement
• Bien adapté pour les applications d'IA edge nécessitant une analyse logique précise
• La version distillée 7B est l'un des meilleurs modèles de raisonnement rapport qualité-prix sur Jetson

Phi (Microsoft)

La famille de modèles compacts de Microsoft, construite sur la philosophie « moins de paramètres, qualité supérieure ».

• Phi-4-mini n'a que 3.8 milliards de paramètres mais égalise ou dépasse de nombreux modèles 7B sur les benchmarks standard
• Conçu spécifiquement pour les environnements à ressources contraintes — un ajustement naturel pour le déploiement edge
• Entraîné sur des données de haute qualité « de niveau manuel » en utilisant une méthodologie d'entraînement distinctive

Gemma (Google)

La famille de modèles open source légers de Google, couvrant 1B à 27B paramètres.

• Gemma 4 dans ses variantes 2B et 4B fonctionne très bien sur Jetson
• Performance solide tanto nell comprensione del linguaggio che nella generazione di codice
• Disponible tanto nelle versioni pre-addestrate che in quelle ottimizzate per istruzioni

Quantification : Rendre les Modèles Plus Petits

Pour exécuter un modèle de 7 milliards de paramètres sans problème sur un appareil edge comme un Jetson, vous devez appliquer la quantification — réduire la précision numérique des poids internes du modèle, échanger des nombres de haute précision « parfaits mais lourds » contre des nombres de basse précision « grossiers mais assez bons », réduisant drastiquement l'utilisation de la mémoire.

Intuitivement, c'est comme comprimer une image 4K à 720p : le contenu est entièrement préservé, mais la taille du fichier diminue plusieurs fois. Pour un modèle 7B, les économies de mémoire à différents niveaux de précision sont substantielles :

La quantification INT4 est le cheval de bataille du déploiement edge : un modèle 7B tient dans 3.5GB de mémoire, assez petit pour s'exécuter sans problème sur la plupart des appareils Jetson.

Formats de Quantification Courants

Différents moteurs d'inférence supportent différents formats de fichiers quantifiés, chacun avec ses propres forces :

• GGUF (écosystème llama.cpp) : Le format dominant pour l'inférence locale — supporté nativement par Ollama et llama.cpp, auto-descriptif et prêt à l'emploi
• SafeTensors (écosystème HuggingFace) : Plus sûr (n'exécute pas de code arbitraire au chargement), et le format standard pour vLLM et les pipelines basés sur HuggingFace
• AWQ (Quantification de Poids Consciente de l'Activation) : Optimisé pour l'inférence GPU, couramment utilisé avec vLLM, et le meilleur performer pour les scénarios à haut débit

Vue d'Ensemble des Frameworks d'Inférence

Une fois qu'un modèle est entraîné, vous avez besoin d'un framework d'inférence pour réellement l'exécuter sur votre Jetson. Ce chapitre couvre trois frameworks mainstream — chacun conçu pour une étape différente du voyage, du débutant au déploiement en production.

Ollama — La Manière la Plus Simple de Commencer

Ollama est le chemin le plus rapide pour exécuter un LLM localement. Installation en une ligne, téléchargement et gestion de modèles intégrés — ça marche out of the box et est très convivial pour les débutants :

# Installer Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Exécuter un modèle (le premier lancement télécharge automatiquement)
ollama run llama3.2:3b

Le mieux pour : Première expérience LLM, prototypage rapide, apprentissage et exploration

llama.cpp — Le Contrôle le Plus Précis

llama.cpp est une implémentation légère en C/C++ qui exécute des modèles efficacement sur CPU et GPU. Ses forces sont l'utilisation minimale de ressources et le support large des formats quantifiés — en faisant le choix privilégié pour les appareils edge à ressources contraintes :

# Cloner et construire
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make -j$(nproc)

# Exécuter l'inférence
./llama-cli -m model.gguf -p "Hello, how are you?"

Le mieux pour : Scénarios qui exigent un contrôle maximum et une optimisation des performances ; déploiement edge léger

vLLM — Service de Niveau Production

vLLM est un framework de service d'inférence haute performance conçu pour les déploiements en production. Il supporte des fonctionnalités avancées comme PagedAttention (gestion de pagination mémoire qui augmente dramatiquement la concurrence) et le batching continu, avec une API compatible OpenAI :

# Installer vLLM
pip install vllm

# Démarrer le serveur API
vllm serve meta-llama/Llama-3.2-3B --host 0.0.0.0 --port 8000

Le mieux pour : Service API en production, haute concurrence, scénarios à haut débit

Tableau Comparatif

Chaque framework a ses forces. Le bon choix dépend de vos besoins spécifiques :

Ce Que Vous Apprendrez dans Ce Chapitre

Le reste de ce chapitre vous guidera à travers la configuration de LLM sur votre Jetson et la construction d'une application complète d'IA vocale :

Module 5.2 : Premiers Pas avec Ollama

Installez Ollama sur votre Jetson from scratch, tirez votre premier modèle, et avez une conversation locale avec une IA — entièrement hors ligne.

Module 5.3 : Exécuter des LLM avec llama.cpp

Allez plus loin : construisez llama.cpp depuis la source, apprenez à charger et exécuter des modèles GGUF quantifiés, et maîtrisez les techniques d'optimisation granulaires pour les appareils edge.

Module 5.4 : Inférence Haute Performance avec vLLM

Configurez une infrastructure de service LLM de niveau production avec une API compatible OpenAI, transformant votre Jetson en backend d'IA local.

Module 5.5 : Démarrage Rapide Jetson Examples

Déployez des LLM avec une seule commande en utilisant des conteneurs Docker pré-construits du dépôt jetson-examples, en跳过 toute la configuration fastidieuse de l'environnement.

Module 5.6 : Pipeline ASR + LLM + TTS

Enchaînez reconnaissance vocale (ASR), un modèle de langage large (LLM) et texte-vers-parole (TTS) en un assistant d'IA vocale complet — tout s'exécutant hors ligne sur votre Jetson.

Pratique : Évaluez Votre Matériel

Avant de passer aux modules de déploiement, vérifiez les capacités matérielles de votre appareil Jetson pour pouvoir choisir le bon modèle :

# Vérifier la mémoire disponible
free -h

# Vérifier le modèle GPU et la VRAM
nvidia-smi

# Vérifier la version JetPack (détermine les versions CUDA et TensorRT)
dpkg -l | grep nvidia-jetpack

# Vérifier le stockage disponible
df -h /

Enregistrez vos résultats :

• RAM Totale : ______ GB
• VRAM GPU : ______ MB
• Stockage Libre : ______ GB
• Version JetPack : ___________

Avec ces chiffres, vous pouvez déterminer quelles tailles de modèle s'exécuteront confortablement sur votre appareil.

Pratique : Détecter des Objets avec un Modèle de Langage Vision

Maintenant que vous comprenez comment les LLM traitent le texte, voyons un Modèle de Langage Vision (VLM) en action — un qui peut voir des images et décrire ce qu'elles contiennent. L'exemple ci-dessous utilise Ollama pour envoyer une image locale à un VLM, qui renvoie les noms d'objets et les coordonnées de pixels. OpenCV dessine ensuite des boîtes englobantes étiquetées sur l'image.

Prérequis

pip install ollama opencv-python Pillow
ollama pull llava:7b   # première fois seulement, ~4.7GB

Exécuter

cd code/
python vlm_object_detector.py --image your_photo.jpg
python vlm_object_detector.py --image photo.jpg --model minicpm-v --output results.jpg

Les VLM ne sont pas des détecteurs spécialisés comme YOLO (Chapitre 4) — la précision des boîtes englobantes varie selon le modèle. Le but de cet exercice est de vous donner une expérience pratique avec le même raisonnement basé sur les tokens derrière les LLM, étendu aux images à travers les modèles multimodaux — texte et vision suivent le même chemin à l'intérieur d'un Transformer.

Questions Fréquentes

Puis-je exécuter ChatGPT sur Jetson ?

Pas exactement. ChatGPT est le système propriétaire d'OpenAI fonctionnant sur des grappes de serveurs massives. Cependant, vous pouvez exécuter localement sur votre Jetson des modèles open source qui offrent des capacités conversationnelles similaires, avec l'avantage supplémentaire d'une confidentialité totale des données.

Ai-je besoin d'un accès Internet pour utiliser des LLM sur Jetson ?

Après le téléchargement initial du modèle, vous pouvez exécuter des LLM entièrement hors ligne. C'est l'un des avantages clés pour les déploiements edge dans les zones à connectivité limitée.

Combien de temps faut-il pour générer une réponse ?

Le temps de réponse dépend de la taille du modèle et de votre matériel. Sur un Jetson Orin NX 16GB exécutant un modèle 3B, attendez-vous à 10-30 tokens par seconde — assez rapide pour des conversations en temps réel.

Références

• Attention Is All You Need (Article Original du Transformer)
• The Illustrated Transformer - Guide visuel par Jay Alammar
• https://huggingface.co/blog/Esmail-AGumaan/attention-is-all-you-need
• Cours Hugging Face sur les LLM - Fondamentaux NLP et LLM
• Fiche Modèle Llama 3.2
• Documentation Qwen3
• NVIDIA Jetson AI Lab - Ressources de développement IA pour Jetson

Suivant : Continuez vers Module 5.2 : Premiers Pas avec Ollama pour exécuter votre premier LLM sur Jetson !