IntermédiaireLes Bases de l'IA
13 min de lecture28 vues

Les Mathématiques Essentielles pour l'IA

Maîtrisez les fondations mathématiques de l'IA : algèbre linéaire, calcul différentiel, probabilités et statistiques appliqués au Machine Learning.

Pourquoi les Maths Comptent en IA

Pas besoin d'être un génie des mathématiques pour faire de l'IA. Mais comprendre les intuitions derrière les maths vous permettra de débugger vos modèles, de choisir les bons hyperparamètres et de ne pas être un simple "utilisateur de bibliothèques".

Les 4 Piliers Mathématiques

Chaque algorithme de ML utilise au moins 2 de ces piliers. Les comprendre, c'est comprendre pourquoi un modèle fonctionne ou échoue.

Pilier 1 : Algèbre Linéaire

L'algèbre linéaire est le langage natif du Machine Learning. Les données sont des matrices, les opérations sont des transformations matricielles.

Vecteurs : La Brique de Base

Un vecteur est simplement une liste de nombres. En IA, chaque donnée est un vecteur.

  • Un pixel RGB = vecteur [255, 128, 0]
  • Un mot (embedding) = vecteur de 768 nombres
  • Un client = vecteur [âge, revenu, nb_achats]

Le Produit Scalaire (Dot Product)

Le produit scalaire mesure la similarité entre deux vecteurs. C'est la base de toute recherche sémantique et des mécanismes d'attention dans les Transformers.

import numpy as np

# Deux vecteurs qui représentent des "goûts"
alice = np.array([5, 1, 4, 0])  # Aime action, pas romance, aime SF, pas horreur
bob   = np.array([4, 0, 5, 1])  # Profil similaire à Alice
carol = np.array([0, 5, 1, 4])  # Goûts opposés

# Produit scalaire = mesure de similarité
print(f"Alice · Bob   = {np.dot(alice, bob)}")   # Score élevé (similaires)
print(f"Alice · Carol = {np.dot(alice, carol)}")  # Score bas (différents)

Plus le produit scalaire est élevé, plus les vecteurs "pointent dans la même direction", donc plus les données sont similaires. C'est exactement ce que font les moteurs de recherche sémantique.

Matrices : Transformer les Données

Une matrice est un tableau de nombres. En IA, les matrices servent à transformer des données d'un espace à un autre.

import numpy as np

# Matrice de données : 3 étudiants, 4 notes
notes = np.array([
    [15, 12, 18, 14],  # Étudiant 1
    [8,  16, 10, 13],  # Étudiant 2
    [17, 14, 19, 16],  # Étudiant 3
])

# Opérations de base
print(f"Forme : {notes.shape}")            # (3, 4)
print(f"Moyenne par étudiant : {notes.mean(axis=1)}")
print(f"Moyenne par matière : {notes.mean(axis=0)}")
print(f"Transposée :\n{notes.T}")  # Inverser lignes/colonnes

Quand un réseau de neurones fait output = W @ input + b, il multiplie une matrice de poids (W) par le vecteur d'entrée. C'est une transformation linéaire.

Pilier 2 : Calcul Différentiel

Le calcul différentiel répond à une question simple : "Si je change un peu cette valeur, de combien le résultat change-t-il ?". C'est le cœur de l'entraînement des réseaux de neurones.

Le Gradient : La Boussole du ML

Le gradient indique la direction de la plus forte pente. Pour minimiser une erreur, il suffit d'aller dans la direction opposée au gradient.

La Descente de Gradient

C'est l'algorithme qui entraîne tous les réseaux de neurones :

  1. Calculer l'erreur (loss)
  2. Calculer le gradient de l'erreur par rapport à chaque poids
  3. Ajuster les poids dans la direction opposée au gradient
  4. Répéter

Micro-Exercice : Descente de Gradient à la Main

import numpy as np

# Fonction à minimiser : f(x) = (x - 3)² → minimum en x = 3
def f(x):
    return (x - 3) ** 2

# Dérivée : f'(x) = 2(x - 3)
def gradient(x):
    return 2 * (x - 3)

# Descente de gradient
x = 10.0                # Point de départ (loin du minimum)
learning_rate = 0.1      # Taille du pas

print(f"Départ : x = {x}, f(x) = {f(x)}")

for i in range(20):
    grad = gradient(x)
    x = x - learning_rate * grad  # LA formule clé
    if (i + 1) % 5 == 0:
        print(f"Étape {i+1:2d} : x = {x:.4f}, f(x) = {f(x):.6f}")

print(f"\nRésultat : x ≈ {x:.4f} (optimal = 3.0)")

Vous verrez x converger vers 3.0 — le minimum de la fonction. C'est exactement ce que fait PyTorch quand vous appelez loss.backward() et optimizer.step().

Le Learning Rate : Paramètre Critique

Learning RateComportementRésultat
Trop petit (0.0001)Convergence très lenteEntraînement interminable
Correct (0.001 - 0.01)Convergence stableBon optimum
Trop grand (1.0)Oscillations, divergenceLe modèle n'apprend rien

Le learning rate est l'hyperparamètre le plus important à régler. Un mauvais LR peut ruiner un entraînement même avec une architecture parfaite.

Pilier 3 : Probabilités et Théorème de Bayes

Les probabilités sont partout en IA : un modèle ne dit jamais "c'est un chat", il dit "il y a 92% de chances que ce soit un chat".

Le Théorème de Bayes

La formule la plus importante en ML :

P(A|B) = P(B|A) × P(A) / P(B)

En français : "La probabilité de A sachant B dépend de la probabilité de B sachant A, pondérée par nos croyances initiales."

Micro-Exercice : Bayes Appliqué au Spam

# Problème : Un email contient le mot "gratuit".
# Est-ce du spam ?

# Données connues
p_spam = 0.3               # 30% des emails sont du spam
p_pas_spam = 0.7            # 70% ne le sont pas
p_gratuit_si_spam = 0.8     # 80% des spams contiennent "gratuit"
p_gratuit_si_pas_spam = 0.1 # 10% des emails normaux contiennent "gratuit"

# Probabilité totale de voir "gratuit"
p_gratuit = (p_gratuit_si_spam * p_spam) + (p_gratuit_si_pas_spam * p_pas_spam)

# Théorème de Bayes : P(spam | "gratuit")
p_spam_si_gratuit = (p_gratuit_si_spam * p_spam) / p_gratuit

print(f"P(spam | 'gratuit') = {p_spam_si_gratuit:.1%}")
# ≈ 77.4% — L'email est probablement du spam

Le filtre anti-spam Naive Bayes utilise exactement ce calcul, mais sur des milliers de mots simultanément. C'est l'un des algorithmes les plus simples et les plus efficaces en classification de texte.

Pilier 4 : Statistiques Descriptives

Les Métriques Essentielles

import numpy as np

data = np.array([25000, 28000, 32000, 35000, 42000, 120000])

print(f"Moyenne  : {data.mean():,.0f}€")   # Sensible aux valeurs extrêmes
print(f"Médiane  : {np.median(data):,.0f}€") # Robuste aux outliers
print(f"Écart-type : {data.std():,.0f}€")   # Mesure de la dispersion
print(f"Min/Max  : {data.min():,} - {data.max():,}€")

La moyenne (47 000€) est trompeuse ici à cause du salaire de 120 000€. La médiane (33 500€) reflète mieux la réalité. C'est pourquoi la normalisation des données est cruciale avant d'entraîner un modèle.

Corrélation : Trouver les Relations

import numpy as np

# Données : surface (m²) et prix (k€)
surface = np.array([20, 35, 50, 65, 80, 100])
prix    = np.array([95, 160, 240, 310, 380, 480])

correlation = np.corrcoef(surface, prix)[0, 1]
print(f"Corrélation surface/prix : {correlation:.3f}")
# ≈ 0.999 — Corrélation quasi-parfaite
CorrélationInterprétation
0.9 à 1.0Relation forte positive
0.5 à 0.9Relation modérée
-0.5 à 0.5Relation faible ou inexistante
-1.0 à -0.5Relation inverse

Comprendre la corrélation vous aide à sélectionner les bonnes features pour vos modèles. Inutile de donner au modèle deux features qui disent la même chose.

Specialiste IA — Master Intelligence Artificielle

Diplome d'un Master en Intelligence Artificielle, je travaille au quotidien sur des projets IA en entreprise. J'ai cree IwanttolearnAI pour rendre l'apprentissage de l'IA accessible a tous, gratuitement.