Commençons par ce qu'est réellement un LLM : une fonction mathématique massive qui prédit le mot suivant dans une séquence. C'est tout. Pas de conscience, pas de compréhension au sens humain, juste un appariement statistique de modèles à une échelle qui commence à sembler étrangement intelligente. Quand vous tapez "La capitale de la France est" dans Claude ou ChatGPT, le modèle ne "sait" pas que Paris existe. Il calcule que, basé sur des milliards d'exemples d'entraînement, le jeton "Paris" a la plus grande probabilité d'apparaître ensuite. C'est de l'autocomplétion qui a lu tout l'internet. L'architecture qui rend cela possible est appelée un transformeur, inventé par des chercheurs de Google en 2017. Voici l'explication étape par étape de comment le texte devient une réponse :

  1. Tokenisation : Votre texte d'entrée est découpé en morceaux appelés jetons (environ 3/4 d'un mot chacun). "Bonjour le monde" devient ["Bonjour", " le monde"].
  1. Embedding : Chaque jeton se convertit en un vecteur, une liste de centaines de chiffres représentant sa signification dans l'espace mathématique. Les mots avec des significations similaires se regroupent dans cette géométrie abstraite.
  1. Mécanisme d'attention : C'est la sauce secrète. Le modèle calcule quels jetons doivent "prêter attention" à quels autres jetons. Dans "L'animal n'a pas traversé la rue parce qu'il était trop fatigué", l'attention aide le modèle à lier "il" à "animal" plutôt qu'à "rue".
  1. Couches de traitement : Les LLM modernes comme GPT-4 ou Claude 3 ont des dizaines de couches de transformeurs, chacune affinant la représentation. Les premières couches détectent les modèles syntaxiques, les couches intermédiaires comprennent les sémantiques, les couches finales gèrent le raisonnement.
  1. Prédiction : La couche finale produit des probabilités pour chaque possible prochain jeton. Le modèle échantillonne à partir de cette distribution (avec un peu de hasard pour la créativité) et produit un mot. Ensuite, il réintègre ce mot et prédit le suivant. Répétez jusqu'à ce que ce soit terminé.

Voici à quoi cela ressemble réellement en pseudocode et math. Ceci est simplifié mais capture la logique de base : function generate_text(input_text, max_tokens): tokens = tokenize(input_text) for i in range(max_tokens): # Convertir les jetons en embeddings (vecteurs) embeddings = embedding_layer(tokens) # forme des embeddings : [longueur_sequence, dim_embedding] # Appliquer les couches de transformateur hidden_state = embeddings for layer in transformer_layers: hidden_state = layer.apply(hidden_state) # Obtenir les probabilités pour le prochain jeton logits = output_layer(hidden_state[-1]) # Utiliser la dernière position probabilities = softmax(logits) # forme des probabilités : [taille_vocabulaire] # Échantillonner le prochain jeton (avec température pour le hasard) next_token = sample(probabilities, temperature=0.7) tokens.append(next_token) if next_token == END_TOKEN: break return detokenize(tokens) function transformer_layer(hidden_state): # Auto-attention multi-tête attention_output = multi_head_attention(hidden_state) hidden_state = layer_norm(hidden_state + attention_output) # Connexion résiduelle # Réseau feed-forward ff_output = feed_forward(hidden_state) hidden_state = layer_norm(hidden_state + ff_output) # Connexion résiduelle return hidden_state function multi_head_attention(X): # forme X: [long_sequence, d_model] # Diviser en plusieurs têtes d'attention outputs = [] for head in range(num_heads): # Projections linéaires vers Query, Key, Value Q = X @ W_q[head] # [long_seq, d_k] K = X @ W_k[head] # [long_seq, d_k] V = X @ W_v[head] # [long_seq, d_v] # Attention à produit scalaire normalisé # scores[i,j] = à quel point la position i prête attention à la position j scores = (Q @ K.transpose()) / sqrt(d_k) # [long_seq, long_seq] # Masquer les positions futures (ne peut pas regarder en avant) scores = mask_future(scores) # Convertir en probabilités attention_weights = softmax(scores) # [long_sec, long_sec] # Appliquer l'attention aux valeurs output = attention_weights @ V # [long_sec, d_v] outputs.append(output) # Concaténer toutes les têtes et projeter return concatenate(outputs) @ W_o Les mathématiques derrière l'attention sont là où la magie opère. Pour chaque position dans la séquence, le modèle calcule : Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) * V Ce que cela signifie : Q (query) demande "ce que je recherche ?", K (key) répond "qu'est-ce que je contiens ?", et V (value) fournit "voici mon information réelle." Le produit scalaire QK^T mesure la similarité entre les requêtes et les clés. Les positions avec une haute similarité obtiennent des poids d'attention élevés après le softmax. Ces poids extraient ensuite les informations pertinentes des valeurs. Par exemple, lors du traitement de "Le chat s'est assis sur le tapis parce qu'il était doux" :

  • Lors de la prédiction après "il", la requête pour "il" calcule une haute similarité avec la clé pour "tapis" (le softmax pourrait donner un poids de 0,7) et une faible similarité avec "chat" (poids de 0,1)
  • Les vecteurs de valeur sont pondérés par ces scores, donc "il" extrait principalement de la représentation de "tapis"
  • Cela passe à travers des dizaines de couches, affinant chaque fois les associations

Le processus d'entraînement repose sur la descente de gradient à grande échelle : function train_llm(training_data, num_epochs): # Initialiser des milliards de paramètres aléatoirement model = initialize_model(num_parameters=175_000_000_000) for epoch in range(num_epochs): for batch in training_data: # Masquer certains jetons à prédire input_tokens = batch[:-1] # Tout sauf le dernier target_tokens = batch[1:] # Tout sauf le premier # Passer à l'avance : prédire les prochains jetons predictions = model.forward(input_tokens) # Calculer la perte : à quel point avons-nous eu tort ? loss = cross_entropy(predictions, target_tokens) # Entropie croisée : -somme(cible * log(prédiction)) # Pénalise fortement les mauvaises prédictions confiantes # Passer à l'arrière : calculer les gradients gradients = compute_gradients(loss, model.parameters) # Mettre à jour les paramètres pour réduire la perte for param, grad in zip(model.parameters, gradients): param -= learning_rate * grad return model Chaque mise à jour de paramètre vise à minimiser la perte d'entropie croisée : à quel point le modèle est-il surpris par le prochain jeton réel ? S'il a prédit "Paris" avec 95 % de probabilité et que "Paris" était correct, la perte est minuscule. S'il a prédit "Londres" avec 60 % de probabilité mais que "Paris" était correct, la perte est énorme. Faites cela sur des trillions d'exemples et des milliards de paramètres, et le modèle apprend la structure statistique du langage. Le processus d'apprentissage est là où les choses deviennent coûteuses et sauvages. Ces modèles apprennent par un processus appelé apprentissage non supervisé sur des ensembles de données textuelles massives : livres, sites Web, dépôts de code, articles scientifiques. Pendant le pré-entraînement, les chercheurs montrent au modèle du texte avec certains mots masqués et le font les prédire. Chaque devinette erronée génère un signal d'erreur qui pousse des milliards de paramètres (les nombres réglables à l'intérieur du modèle) un peu plus près de meilleures prédictions. Le GPT-4 aurait plus de 1 trillion de paramètres et aurait coûté plus de 100 millions de dollars pour être entraîné sur des dizaines de milliers de GPU fonctionnant pendant des mois. Après le pré-entraînement vient l'ajustement fin, où des formateurs humains évaluent les réponses du modèle, lui apprenant à être utile plutôt que juste précis. C'est pourquoi Claude ne rédigera pas votre manifeste ou ChatGPT refusera certaines demandes. L'apprentissage par renforcement à partir des commentaires humains (RLHF) reprogramme littéralement les distributions de probabilités pour éviter les sorties toxiques. Le modèle apprend que certains modèles de réponse obtiennent des scores plus élevés de la part des humains, donc il favorise ces modèles. Voici pourquoi les industries prédictives se font écraser. Tout domaine où le succès signifie reconnaître des modèles et prévoir des résultats est fondamentalement un problème de LLM. Prévision météorologique ? Apparier les données atmosphériques historiques. Trading boursier ? Trouver des corrélations dans les mouvements de prix et le sentiment des nouvelles. Diagnostic médical ? Apparier les symptômes avec des modèles de maladies à partir de millions d'historiques de cas. Révision de documents légaux ? Identifier les précédents pertinents et les clauses contractuelles. Service client ? Prédire quelle réponse résout le problème basé sur des tickets passés. L'avantage de l'IA est brutal et simple : l'échelle. Un radiologue humain peut examiner 50 000 radiographies dans une carrière. Un modèle d'IA s'entraîne sur 50 millions. Un analyste de fonds de placement lit des centaines de rapports de résultats chaque trimestre. Un LLM traite chaque transcription d'appel de résultats, dépôt SEC, et note d'analyste publiée mondialement en temps réel. L'avantage de reconnaissance de modèles se cumule jusqu'à ce que l'expertise humaine devienne décorative plutôt que fonctionnelle. Nous voyons déjà l'accélération de la reprise. Bloomberg GPT, formé spécifiquement sur les données financières, surpasse les analystes humains dans la prédiction des mouvements de marché à partir des nouvelles. AlphaFold de DeepMind a résolu le problème du repliement des protéines qui a dérouté les biologistes pendant 50 ans en traitant les structures moléculaires comme une tâche de prédiction. GitHub Copilot écrit 40 % du code dans les dépôts où il est activé. Ce ne sont pas des outils étroits aidant les humains, ce sont des technologies de remplacement qui rendent des ensembles de compétences entiers obsolètes. La vérité inconfortable est que la plupart des travaux de connaissance sont de la prédiction déguisée en expertise. Les avocats prédisent les résultats des affaires et rédigent des documents suivant des modèles. Les comptables prédisent la responsabilité fiscale et le risque d'audit. Les marketeurs prédisent quel message résonnera avec quel public. Les enseignants prédisent quelle explication clarifiera un concept. Les médecins prédisent quel traitement guérira quelle maladie. Si votre travail implique de regarder des données et de dire "en fonction de X, je pense que Y se produira", vous êtes dans le rayon de l'explosion. La seule question est celle du timing.