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 Neurones, perte et gradient

La formation demande des « notions de maths appliquées ». Le minimum utile :

• Un réseau = un empilement de produits matriciels entrecoupés de fonctions d'activation non-linéaires (ex. ReLU). Sans elles, tout se réduirait à une seule matrice.
• Apprendre = ajuster les nombres des matrices de poids pour rapprocher la sortie de la bonne réponse.
• « Se rapprocher » se mesure par la fonction de perte (loss) : un nombre, plus bas = mieux.

for etape in range(1000):
    prediction = modele(X)                 # passe avant
    perte      = mse(prediction, y)         # écart aux étiquettes
    gradients  = perte.backward()           # pente pour chaque poids (rétropropagation)
    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.

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.