Addition et multiplication de matrices
Après avoir compris les opérations vectorielles, passez au niveau supérieur avec les matrices. La multiplication de matrices est la clé pour comprendre la propagation avant dans les réseaux de neurones — l’essence d’une couche entièrement connectée est la multiplication de matrices.
Addition de matrices : additionner les positions correspondantes
Pour deux matrices de même forme, additionnez les éléments aux positions correspondantes — aussi intuitif que l’addition vectorielle.
Multiplication de matrices : produit scalaire des lignes et des colonnes
La multiplication matricielle n'est pas aussi simple que « multiplier les positions correspondantes ». Pourquoi ?
Le sens profond d'une matrice est une « transformation linéaire » — elle transforme un vecteur en un autre vecteur.
La signification géométrique du produit de deux matrices AB est : appliquer d'abord la transformation B, puis appliquer la transformation A. Par conséquent, la règle de calcul de AB doit refléter la structure mathématique des « transformations composées », et non une simple multiplication terme à terme.
Par exemple : A représente un « étirement horizontal d'un facteur 2 », B représente une « rotation de 90° dans le sens antihoraire ». AB signifie « tourner d'abord, puis étirer » — c'est complètement différent de BA (étirer d'abord, puis tourner), donc la multiplication matricielle ne satisfait pas la loi commutative.
La règle de calcul est :
i-ème ligne →
j-ème colonne ↓
(i, j)
Le produit scalaire de la i-ème ligne de la matrice de gauche et de la j-ème colonne de la matrice de droite → la valeur à la position (i, j) de la matrice résultante.
Règles de correspondance des dimensions
\( (m \times \color{#e74c3c}{n}) \;\times\; (\color{#e74c3c}{n} \times p) = (m \times p) \)
Le nombre de colonnes de Adoit être égal àle nombre de lignes de B. Les deux n surlignés en rouge doivent être égaux.
La forme du résultat = (nombre de lignes de A, nombre de colonnes de B)
La multiplication matriciellene respecte pas la loi de commutativité: AB ≠ BA (en général).
Les dimensions peuvent même ne pas correspondre, ce qui rend BA non défini — c'est ici que les débutants se trompent le plus facilement.
L'essence de la multiplication matricielle est la composition de transformations linéaires
Multiplier par la matrice A → effectuer une transformation ; puis multiplier par la matrice B → effectuer la seconde transformation.
Composer deux transformations = une transformation (BA). C'est pourquoi la multiplication matricielle est définie ainsi.
Exemples du quotidien
Calcul du chiffre d'affaires d'une supérette
Matrice des ventes sur trois jours (lignes = dates, colonnes = produits) :
| Cola | Chips | Nouilles instantanées | |
|---|---|---|---|
| lundi | 10 | 5 | 3 |
| mardi | 8 | 7 | 4 |
| mercredi | 12 | 4 | 6 |
Matrice des prix (lignes = produits, colonnes = magasins) :
| Magasin 1 | Magasin 2 | |
|---|---|---|
| Cola | 3 | 3.5 |
| Chips | 5 | 5.5 |
| Nouilles instantanées | 4 | 4.0 |
Matrice des ventes (3×3) × matrice des prix (3×2) = matrice des revenus (3×2).
Chaque cellule du résultat = revenu total d’un certain jour dans un certain magasin.
Définition mathématique
Addition matricielle
\[ (\mathbf{A} + \mathbf{B})_{ij} = a_{ij} + b_{ij} \]Prérequis : A et B doivent avoir exactement la même forme.
Multiplication matricielle
Soit A une matrice m×n, B une matrice n×p, alors C = AB est m×p:
\[ c_{ij} = \sum_{k=1}^{n} a_{ik} b_{kj} \]Exercice pratique Python
Exemples
A_example = np.array([[10, 5, 3], [8, 7, 4], [12, 4, 6]])
price = np.array([[3, 3.5], [5, 5.5], [4, 4.0]])
# Addition de matrices (même forme)
bonus = np.array([[1, 0, 1], [0, 1, 0], [1, 1, 0]])
total = A_example + bonus
print("A + bonus:\n", total)
# Multiplication de matrices: (3×3) @ (3×2) = (3×2)
revenue = A_example @ price
print("\nMatrice des revenus A @ price:\n", revenue)
print("Forme:", revenue.shape)
# Vérifier manuellement la position (0,0)
manual = A_example[0,0]*price[0,0] + A_example[0,1]*price[1,0] + A_example[0,2]*price[2,0]
print(f"\nVérification manuelle [0,0]: {manual} == {revenue[0,0]}")
# Piège d'incompatibilité de dimensions
print(f"\nForme de A : {A_example.shape}") # (3, 3)
print(f"Forme de price.T : {price.T.shape}") # (2, 3)
# A @ price.T → (3,3) @ (2,3) incompatibilité !
# Correct : price.T @ A → (2,3) @ (3,3) = (2,3)
print(f"Forme de price.T @ A : {(price.T @ A_example).shape}") # (2, 3)
收入矩阵 A @ price: [[67. 72. ] [75. 79.5] [80. 88. ]] 形状: (3, 2) A 形状: (3, 3) price.T 形状: (2, 3) price.T @ A 形状: (2, 3)
Visualisation interactive de la multiplication matricielle
Ci-dessous, on montre une matrice A 2×2 multipliée par un vecteur v 2×1 ; observez comment la transformation linéaire transforme les points d'un cercle en une ellipse :
Scénarios d'application en IA
Couche entièrement connectée = Multiplication matricielle
nn.Linear(d_in, d_out)L'essentiel : la matrice de poids W (d_out × d_in) multipliée par le vecteur d'entrée x (dimensions d_in), fournit une sortie (dimensions d_out).
Lors du traitement de données par lots, l'entrée X est une matrice (batch, d_in), et l'on calcule \( Y = XW^T \) ou \( Y = WX^T \). Il s'agit d'une seule multiplication matricielle qui effectue le calcul de propagation avant pour l'ensemble du lot. Les GPU disposent d'une accélération matérielle spécialisée pour la multiplication matricielle (Tensor Core).
QK^T dans le mécanisme d'attention
Dans le Transformer, Q et K sont tous deux des matrices (seq_len, d_k). \( QK^T \) est seq_len×d_k multiplié par d_k×seq_len, ce qui donne une matrice de scores d'attention (seq_len, seq_len).
Dans les grands modèles du niveau de GPT-4, seq_len peut atteindre 128K, et le coût de calcul de cette multiplication matricielle représente une part importante de l'ensemble du coût d'inférence. L'algorithme FlashAttention optimise spécifiquement le schéma d'accès mémoire de cette multiplication matricielle.
Implémentation de la convolution sous forme de multiplication matricielle (im2col)
L'opération de convolution peut être développée en multiplication matricielle : déplier l'image d'entrée en une grande matrice à l'aide de fenêtres glissantes (im2col), puis aplatir le noyau de convolution en une matrice, et multiplier les deux. Cela permet à la convolution de tirer parti de bibliothèques GEMM (General Matrix Multiplication) hautement optimisées pour l'accélération.
Décomposition matricielle dans le fine-tuning LoRA
LoRA ajoute le produit de deux petites matrices A et B à côté des poids pré-entraînés : \( W' = W + AB \). Ici, AB est une multiplication matricielle — A est d×r, B est r×d, et le produit est une matrice de rang faible d×d. Une seule multiplication matricielle permet d'obtenir un fine-tuning efficace en paramètres.
Autres extensions