← Retour au blog
MATHÉMATIQUES 4 octobre 2020

Algèbre Linéaire pour l'IA — Rappels Essentiels

Algèbre LinéaireMatricesVecteursGradientPython

Introduction

L'algèbre linéaire est le fondement mathématique de l'intelligence artificielle et du machine learning. Que vous travailliez sur des réseaux de neurones, de la régression linéaire, de la classification ou de la réduction de dimensionnalité, vous manipulez des vecteurs et des matrices. Comprendre les opérations fondamentales de l'algèbre linéaire vous permet non seulement de mieux comprendre les algorithmes, mais aussi d'optimiser votre code et de déboguer efficacement.

Cet article propose une revue des concepts essentiels : notations, définitions, opérations courantes et applications pratiques en Python.

Notations Générales

Avant de plonger dans les opérations, établissons les conventions de notation :

  • Scalaire : un nombre réel noté en minuscule sans symbole particulier (ex: $x$)
  • Vecteur : un vecteur colonne noté en minuscule gras ou avec une flèche (ex: $\mathbf{x}$ ou $\vec{x}$)
  • Matrice : une matrice notée en majuscule gras (ex: $\mathbf{A}$)

Définitions Fondamentales

Vecteurs

Un vecteur $\mathbf{x} \in \mathbb{R}^n$ est une suite ordonnée de n nombres réels, souvent représentée comme une colonne :

$$ \mathbf{x} = [x_1, x_2, ..., x_n]^T $$

Les éléments x₁, x₂, ..., xₙ sont appelés les composantes ou entrées du vecteur.

Matrices

Une matrice $\mathbf{M} \in \mathbb{R}^{m \times n}$ est un tableau rectangulaire de m lignes et n colonnes :

$$ \mathbf{M} = \begin{bmatrix} M_{11} & M_{12} & \dots & M_{1n} \\ M_{21} & M_{22} & \dots & M_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ M_{m1} & M_{m2} & \dots & M_{mn} \end{bmatrix} $$

Matrice Identité

La matrice identité $\mathbf{I}$ est une matrice carrée avec des 1 sur la diagonale et des 0 ailleurs :

$$ \mathbf{I} = \begin{bmatrix} 1 & 0 & \dots & 0 \\ 0 & 1 & \dots & 0 \\ \vdots & \vdots & \ddots & \vdots \\ 0 & 0 & \dots & 1 \end{bmatrix} $$

Matrice Diagonale

Une matrice diagonale $\mathbf{D}$ a des valeurs non nulles uniquement sur sa diagonale principale.

Opérations Principales

Produit Scalaire

Le produit scalaire (ou dot product) de deux vecteurs $\mathbf{x}$ et $\mathbf{y}$ est :

$$ \mathbf{x}^T \mathbf{y} = \sum_i x_i y_i $$

Il retourne un scalaire et mesure la similarité entre deux vecteurs.

Produit Dyadique

Le produit dyadique (ou outer product) retourne une matrice m×n :

$$ \mathbf{x}\cdot \mathbf{y}^T \in \mathbb{R}^{m \times n} $$

Chaque élément (i,j) est le produit $x_i \cdot y_j$.

Produit Matrice-Vecteur

Pour $\mathbf{A} \in \mathbb{R}^{m \times n}$ et $\mathbf{x} \in \mathbb{R}^n$, le produit $\mathbf{A}\mathbf{x}$ retourne un vecteur de ℝᵐ.

Produit Matrice-Matrice

Le produit de deux matrices $\mathbf{A} \in \mathbb{R}^{m \times n}$ et $\mathbf{B} \in \mathbb{R}^{n \times p}$ est une matrice $\mathbf{C} \in \mathbb{R}^{m \times p}$ :

$$ \mathbf{C} = \mathbf{A}\mathbf{B} $$

Les dimensions doivent être compatibles : le nombre de colonnes de A doit égaler le nombre de lignes de B.

Exemple :

$$ \mathbf{A} = [1 7] , \mathbf{B} = [3 3] , \mathbf{AB} = [38 17] \\ [2 4] [5 2] [26 14] $$ 
import numpy as np

# Produit matrice-matrice
A = np.array([[1, 7], [2, 4]])
B = np.array([[3, 3], [5, 2]])
C = A @ B
print(C)  # [[38 17]
          #  [26 14]]

Transposée

La transposée d'une matrice $\mathbf{A}$, notée $\mathbf{A}^T$, échange les lignes et les colonnes :

$$ (\mathbf{A}^T)_{ij} = \mathbf{A}_{ji} $$ 
# Transposée
A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(A.T)
# [[1 4 7]
#  [2 5 8]
#  [3 6 9]]

Inverse Matricielle

Pour une matrice carrée inversible $\mathbf{A}$, l'inverse $\mathbf{A}^{-1}$ satisfait :

$$ \mathbf{A}\cdot \mathbf{A}^{-1} = \mathbf{I} $$

L'inverse n'existe que pour les matrices de rang complet (déterminant non nul).

# Inverse
A = np.array([[1, 2], [3, 4]])
A_inv = np.linalg.inv(A)
print(A_inv)
print(A @ A_inv)  # Identité (à la précision numérique près)

Trace

La trace d'une matrice carrée $\mathbf{A}$ est la somme de ses éléments diagonaux :

$$ \text{tr}(\mathbf{A}) = \sum_i \mathbf{A}_{ii} $$

La trace est utilisée dans l'optimisation et l'analyse spectrale.

Analyse Matricielle

Gradient

Le gradient d'une fonction scalaire f par rapport à une matrice $\mathbf{A}$ est une matrice de dérivées partielles :

$$ \nabla_\mathbf{A} f(\mathbf{A}) = \begin{bmatrix} \frac{\partial f}{\partial A_{11}} & \frac{\partial f}{\partial A_{12}} & \dots \\ \frac{\partial f}{\partial A_{21}} & \frac{\partial f}{\partial A_{22}} & \dots \\ \vdots & \vdots & \ddots \end{bmatrix} $$

Le gradient indique la direction de plus grande augmentation de la fonction.

Hessienne

La Hessienne (ou matrice Hessienne) est la matrice des dérivées secondes :

$$ \nabla^2_\mathbf{x} f(\mathbf{x}) = \begin{bmatrix} \frac{\partial^2 f}{\partial x_1^2} & \frac{\partial^2 f}{\partial x_1 \partial x_2} & \dots \\ \frac{\partial^2 f}{\partial x_2 \partial x_1} & \frac{\partial^2 f}{\partial x_2^2} & \dots \\ \vdots & \vdots & \ddots \end{bmatrix} $$

Elle est utile pour l'optimisation du second ordre et l'étude de la convexité.

Application : Régression Linéaire par Gradient Descent

Pour illustrer ces concepts, considérons la régression linéaire. Nous cherchons à trouver les coefficients θ₀ et θ₁ qui minimisent l'erreur quadratique :

$$ \min J(\theta) = \frac{1}{2m} \sum_{i=1}^m (\hat{y}_i - y_i)^2 $$

où $ \hat{y}_i = \theta_0 + \theta_1 x_i $

Équations Normales

La solution analytique (fermée) utilise l'algèbre linéaire :

$$ \theta = (\mathbf{X}^T\mathbf{X})^{-1} \mathbf{X}^T\mathbf{y} $$

où X est la matrice de design augmentée avec une colonne de 1s.

# Régression linéaire via équations normales
np.random.seed(42)
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)

# Matrice de design (ajouter colonne de 1s)
X_b = np.column_stack([np.ones((100, 1)), X])

# Équations normales
theta = np.linalg.inv(X_b.T @ X_b) @ X_b.T @ y
print(f"θ₀ = {theta[0,0]:.4f}, θ₁ = {theta[1,0]:.4f}")
# Résultat : θ₀ ≈ 4.0, θ₁ ≈ 3.0

Cette approche démontre comment l'algèbre linéaire fournit une solution exacte en un seul calcul matriciel, sans itération.

Conclusion

L'algèbre linéaire est indispensable pour comprendre et implémenter les algorithmes de machine learning. Les opérations présentées ici—produits scalaires, matriciels, transposées et inverses—sont les briques élémentaires de la plupart des modèles d'IA modernes. En maîtrisant ces concepts et en les pratiquant avec NumPy, vous serez mieux équipé pour explorer des sujets plus avancés comme la décomposition en valeurs singulières, les valeurs propres et les espaces vectoriels.

← Retour au blog