Comprendre l'IA
avant d'écrire
la première ligne.

1.1 La bascule mentale : de la boucle au tableau

En Django, additionner deux listes appelle une boucle. En IA, ce réflexe devient un piège de performance. Tout repose sur NumPy et son ndarray, qui applique une opération à des millions de nombres d'un coup : la vectorisation.

# Réflexe "dev classique" — lent
c = []
for i in range(len(a)):
    c.append(a[i] + b[i])

# Réflexe "IA" — vectorisé, ~100× plus rapide
import numpy as np
c = np.array(a) + np.array(b)   # une seule opération

1.2 Scalaire, vecteur, matrice, tenseur

Tous les objets de l'IA sont un tableau de nombres, avec plus ou moins de dimensions. L'échelle la plus importante à intérioriser :

1.3 La forme (shape) : l'obsession n°1

La majorité des bugs en IA sont des erreurs de forme. Réflexe avant chaque opération : quelle est la forme de mon tableau, et laquelle l'opération attend-elle ? Les axes sont numérotés à partir de 0.

x = np.zeros((32, 128, 128, 3))
x.shape        # (32, 128, 128, 3)
x.ndim         # 4  → nombre de dimensions
x.size         # 1 572 864  → total d'éléments
# axe 0 = le lot (32 images) · axe 3 = les canaux couleur (R,V,B)

1.4 Les trois « multiplications » à ne pas confondre

Le point qui fait trébucher tout le monde : plusieurs façons de « multiplier » des tableaux, aux effets radicalement différents.

a) Élément par élément (*)

a * b          # [1,2,3] * [4,5,6] → [4,10,18]

b) Produit matriciel (@ ou np.dot)

L'opération reine. Combine lignes et colonnes. Règle d'or : (m, k) @ (k, n) → (m, n) — les dimensions intérieures doivent être égales.

A = np.array([[1,2],[3,4]])   # (2,2)
x = np.array([1,0])           # (2,)
A @ x          # [1, 3]

c) La transposée (.T)

A.T            # (2,3) devient (3,2)

Le produit matriciel pas à pas

La règle unique : chaque nombre du résultat est le produit scalaire d'une ligne de A avec le vecteur x — on multiplie terme à terme, puis on additionne.

Anime-le toi-même

Le même mouvement, mais interactif : fais avancer les deux pointeurs et regarde la somme se construire, case après case. (Ici A = [[2,1],[0,3]] et y = [1,4].)

Matrice × matrice : même principe

Le résultat en (i, j) = produit scalaire de la ligne i de la première par la colonne j de la seconde.

A = np.array([[2, 1],
              [0, 3]])
y = np.array([1, 1])
z = np.array([0, 2])

1.5 Le broadcasting : la magie (et le piège)

NumPy combine des tableaux de formes différentes en « étirant » le plus petit. Pratique — et source de bugs silencieux.

images = np.random.rand(32, 128, 128, 3)  # un lot
moyenne = np.array([0.4, 0.5, 0.6])       # (3,) une moyenne par canal
images - moyenne   # NumPy étire (3,) sur tout le lot ✓

a)  np.zeros((8, 3)) + np.ones((3,))
b)  A @ v      # A (10, 4), v (4,)
c)  M.T        # M (2, 5)
d)  np.ones((32, 3)) * np.ones((4,))

1.6 Le réseau de neurones, vu de l'intérieur

C'est le cœur de la formation. En une phrase : un réseau prend des entrées, les combine avec des poids ajustables pour produire une sortie, puis corrige ces poids grâce à un retour sur ses erreurs. Décortiquons chacune de ces idées avec un schéma. La vue reste simple ; déplie les « Approfondir » quand tu veux creuser.

1 · Un neurone : entrées → poids → sortie

Les poids sont les seuls nombres que le réseau « apprend ». Un poids élevé = cette entrée compte beaucoup ; un poids proche de zéro = elle est ignorée. Tout l'apprentissage consiste à trouver les bons poids.

2 · Beaucoup de neurones : les couches

C'est ici que la Partie 1 se referme : comme chaque couche multiplie le vecteur d'entrée par une matrice de poids, un réseau n'est qu'une suite de produits matriciels séparés par des activations. Voilà pourquoi @ et les shapes sont si centraux.

3 · Comment il apprend : la boucle de feedback

for etape in range(1000):
    prediction = modele(X)                  # passe avant : entrées → sortie
    perte      = mse(prediction, y)          # écart avec la cible
    gradients  = perte.backward()            # rétropropagation : pente de chaque poids
    poids      = poids - 0.01 * gradients    # un pas vers le bas (0.01 = learning rate)

1.7 L'écosystème : qui fait quoi

Objectif : installer le vocabulaire commun et distinguer les familles d'apprentissage.

Les 3 grands types d'apprentissage

• Supervisé — exemples étiquetés (photo → « chat »). ~80 % de l'IA appliquée.
• Non supervisé — pas d'étiquettes ; le modèle découvre des structures (clustering).
• Par renforcement — un agent apprend par récompenses (semaine 5).

Le vocabulaire fondateur

Un modèle reçoit des features (entrées) et produit une prédiction, comparée à l'étiquette attendue. Deux phases : l'entraînement puis l'inférence. On sépare toujours train et test ; un modèle excellent en train mais faible en test a surappris (overfitting).

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

# X = features (surface, pièces, ...) · y = label (prix)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2)

modele = LinearRegression()
modele.fit(X_tr, y_tr)          # entraînement
modele.score(X_te, y_te)        # évaluation sur des données JAMAIS vues

Feature / Label

Variable d'entrée / réponse correcte fournie.

Train / test split

Découpage pour évaluer honnêtement la généralisation.

Overfitting

Le modèle mémorise au lieu de généraliser.

Objectif : faire « voir » une machine, et découvrir l'astuce qui rend l'IA accessible : l'apprentissage par transfert.

Une image = un tenseur

Une image couleur est un tenseur (H, L, 3) ; chaque pixel = 3 nombres (R, V, B). Un CNN fait glisser de petits filtres (la convolution) : les premières couches captent bords et textures, les suivantes composent formes puis objets.

from tensorflow.keras.applications import ResNet50
from tensorflow.keras import layers, Model

base = ResNet50(weights="imagenet", include_top=False)  # modèle pré-entraîné
base.trainable = False                               # on gèle ce qu'il a appris

x = layers.GlobalAveragePooling2D()(base.output)
sortie = layers.Dense(3, activation="softmax")(x)      # 3 classes = NOTRE problème
modele = Model(base.input, sortie)                    # on ne réentraîne que la fin

Convolution / CNN

Filtre glissant détectant un motif local / réseau spécialisé images.

Modèle pré-entraîné

Réseau déjà entraîné sur d'immenses données, réutilisable.

Fine-tuning

Réajuster finement un modèle pré-entraîné sur ses données.

Objectif : un paradigme sans « bonne réponse » donnée : un agent apprend par essais, erreurs et récompenses.

La boucle agent ↔ environnement

Un agent observe un état, choisit une action, reçoit une récompense et un nouvel état. Il cherche la politique qui maximise la récompense cumulée. Le Q-learning estime, pour chaque (état, action), la récompense future attendue ; quand les états sont trop nombreux, le DQN remplace la table par un réseau de neurones.

ancien = Q[etat, action]
futur  = max(Q[nouvel_etat])                         # meilleure valeur atteignable ensuite
Q[etat, action] = ancien + alpha * (recompense + gamma * futur - ancien)
#                          ^taux            ^gain immédiat  ^escompte du futur

Agent / Environnement

Le décideur, et le monde avec lequel il interagit.

Politique

La stratégie : quelle action dans quel état.

DQN

Q-learning où un réseau approxime les valeurs Q.

Objectif : traiter du texte et construire un modèle de langue. Le socle direct des LLM.

Du texte aux nombres

Un modèle ne comprend que des nombres. Deux étapes : la tokenisation (découper en tokens numérotés) puis le plongement (embedding : chaque token → un vecteur qui capte le sens, au point que roi − homme + femme ≈ reine).

De la mémoire à l'attention

Les anciens RNN/LSTM lisaient mot à mot et oubliaient le contexte lointain. Le Transformer (2017) résout ça par l'attention : chaque mot pondère l'importance de tous les autres. Un modèle de langue ne fait qu'une chose : prédire le token suivant — répété, cela produit des phrases.

from transformers import AutoTokenizer, pipeline

tok = AutoTokenizer.from_pretrained("gpt2")
tok("Le chat dort")["input_ids"]     # → [1026, 4758, 8501] (identifiants)

gen = pipeline("text-generation", model="gpt2")
gen("En 2026, l'IA appliquée", max_length=20)  # prédit les tokens suivants

Token / Embedding

Unité de texte numérotée / vecteur représentant son sens.

Attention

Pondère l'importance de chaque mot du contexte.

Transformer

Architecture fondée sur l'attention, base des LLM.

Les semaines 6–8 expliquent comment un modèle de langue fonctionne. Mais quand tu ouvriras le rapport technique d'un vrai modèle récent, tu croiseras un vocabulaire de plus : « 2,8 billions de paramètres », « Mixture-of-Experts », « fenêtre de 1M de tokens », « RLHF », « effort de raisonnement »… Voici ces pièces manquantes, expliquées simplement. (Exemples chiffrés tirés du rapport Kimi K3, un modèle ouvert de 2026.)

1 · Les paramètres = la taille du modèle

Souviens-toi : apprendre, c'est ajuster des poids. Les paramètres d'un modèle, ce sont justement tous ces poids réunis. On les compte en milliards, voire en billions (1 billion = mille milliards). Kimi K3 en a 2,8 billions. En gros : plus de paramètres = plus de « capacité » à mémoriser et à généraliser — mais ce n'est pas le seul facteur (les données et l'entraînement comptent autant).

2 · Mixture-of-Experts : n'activer que ce qu'il faut

Faire passer chaque mot par 2,8 billions de paramètres coûterait une fortune. L'astuce Mixture-of-Experts (MoE) : au lieu d'un seul gros cerveau, le modèle contient une grande équipe de « spécialistes » (des experts), et un petit routeur choisit, pour chaque token, les quelques experts les plus pertinents.

3 · La fenêtre de contexte

La fenêtre de contexte, c'est la quantité de texte que le modèle peut « garder en tête » en une fois, mesurée en tokens. Kimi K3 monte à 1 million de tokens — l'équivalent de plusieurs livres, ou d'un énorme projet de code. Au-delà, le plus ancien « sort » de la fenêtre et est oublié. C'est directement lié à l'attention (semaines 6–8) : relier chaque mot à tous les autres devient très coûteux quand le texte est long, d'où les recherches sur des attentions plus « efficaces ».

4 · Comment un LLM devient un assistant

Un modèle fraîchement pré-entraîné sait beaucoup, mais ne sait pas obéir : il complète du texte, sans forcément répondre à ta question. Le rapport décrit le parcours en plusieurs étapes qui le transforme en assistant utile :

• Pré-entraînement — prédire le mot suivant sur d'immenses quantités de texte (et d'images). Il acquiert des connaissances et le langage.
• SFT (fine-tuning supervisé) — on lui montre des milliers d'exemples « question → bonne réponse » : il apprend à suivre des instructions.
• RL avec feedback (souvent appelé RLHF) — on récompense ses meilleures réponses (via un « modèle de récompense » qui les note) pour l'aligner sur nos préférences. C'est l'apprentissage par renforcement de la semaine 5, appliqué au langage.
• Distillation — plusieurs modèles « experts » (un par domaine) servent de professeurs pour entraîner un seul modèle final qui hérite de leurs compétences.

5 · Le « raisonnement » et l'effort

Les modèles récents peuvent « réfléchir » avant de répondre : ils génèrent d'abord une suite de pensées intermédiaires (une chaîne de pensée), invisible ou repliée, puis la réponse finale. Donner plus de « budget de réflexion » améliore souvent la qualité sur les problèmes difficiles — au prix de plus de temps et de calcul. Kimi K3 propose d'ailleurs plusieurs niveaux d'effort (bas / élevé / max). On appelle ça le calcul au moment de la réponse (test-time compute) : un deuxième levier, en plus de la taille du modèle.

6 · Multimodal : texte + images dans un seul modèle

Longtemps, la vision (semaines 3–4) et le langage (semaines 6–8) étaient deux mondes séparés. Un modèle multimodal « natif » comme Kimi K3 comprend les deux d'un coup : on peut lui donner une image et du texte dans la même conversation. Techniquement, l'image est transformée en tokens (via une « tour de vision ») que le modèle traite comme des mots.

Objectif : passer de l'IA qui classe à l'IA qui crée, et adapter de grands modèles.

Deux familles pour générer des images

• GAN — deux réseaux s'affrontent : un générateur fabrique de fausses images, un discriminateur les démasque. La compétition pousse au réalisme.
• Diffusion — on apprend à retirer du bruit ; à l'usage, on part d'un bruit pur qu'on « débruite » jusqu'à une image, guidé par un texte.

Le fine-tuning

Réentraîner un GPT complet coûte des millions. Le fine-tuning reprend un grand modèle et l'ajuste sur un petit jeu de données spécifique : c'est ce qui rend ces modèles exploitables en entreprise.

from diffusers import StableDiffusionPipeline

pipe = StableDiffusionPipeline.from_pretrained("stable-diffusion-v1-5")
image = pipe("un chat astronaute, style aquarelle").images[0]  # prompt → image
image.save("chat.png")

Générateur / Discriminateur

Les deux réseaux rivaux d'un GAN.

Diffusion

Génération par débruitage progressif.

Fine-tuning / Prompt

Adapter un grand modèle / la consigne qui guide la génération.

Objectif : dépasser le modèle qui répond pour un agent qui raisonne, utilise des outils et agit en plusieurs étapes. Ta connaissance du dev web y est un atout.

Qu'est-ce qu'un agent ?

Un agent = un LLM dans une boucle, doté d'outils (recherche, API, code, fichiers). Le schéma ReAct alterne Réflexion → Action → Observation jusqu'à l'objectif. Le function calling est le pont : le LLM émet un appel structuré, ton code l'exécute. Le RAG injecte des documents récupérés pour ancrer les réponses.

while not objectif_atteint:
    pensee   = modele.reflechir(contexte)    # que faire ?
    action   = modele.choisir_outil(pensee)   # ex: rechercher(...)
    resultat = executer(action)                # appel réel
    contexte = contexte + resultat             # on mémorise l'observation

outils = [{
    "name": "meteo",
    "description": "Météo d'une ville pour un jour donné",
    "parameters": {"ville": "str", "jour": "str"}
}]
reponse = modele.chat(messages, tools=outils)
if reponse.appel_outil:                   # le LLM DEMANDE d'appeler l'outil
    obs = meteo(**reponse.arguments)      # TON code l'exécute vraiment
    messages.append(obs)                  # on renvoie l'observation au modèle

Agent / Outil

LLM en boucle avec objectif / fonction externe qu'il peut appeler.

Function calling

Le LLM produit un appel structuré exécuté par ton code.

RAG

Injecter des documents récupérés pour ancrer les réponses.

Objectif : tout mettre en œuvre sur un projet réel, évalué devant un jury (20–30 h, mémoire d'une dizaine de pages).

Une démarche en 6 temps

1. Cadrer le problème comme une tâche d'IA claire (classer ? prédire ? générer ?).
2. Réunir et explorer les données — ~60 % du travail (pandas + Matplotlib).
3. Choisir simple — souvent scikit-learn ou un modèle pré-entraîné suffit.
4. Établir une baseline puis itérer ; surveiller l'écart train/test.
5. Évaluer honnêtement sur des données jamais vues ; assumer les limites.
6. Présenter le raisonnement, pas seulement la performance.