Normes vectorielles et matricielles

Objectifs d'apprentissage

À la fin de cette leçon, vous serez en mesure de :

• Calculer différentes normes vectorielles (1, 2, infinie)
• Comprendre les propriétés axiomatiques des normes
• Calculer les normes matricielles induites
• Vérifier la compatibilité entre normes vectorielles et matricielles
• Interpréter géométriquement les différentes normes

Prérequis

• Algèbre linéaire de base
• Notion de distance

Pourquoi les normes ?

En calcul numérique, nous avons constamment besoin de mesurer des quantités :

• Quelle est la taille d'une erreur ? Si notre solution approchée est $x^* = (2{,}001, 3{,}002)^T$ au lieu de $x = (2, 3)^T$, l'erreur est-elle acceptable ?
• Est-ce qu'un algorithme converge ? Les itérations successives se rapprochent-elles de la solution ?
• À quel point une matrice amplifie-t-elle les erreurs ? Si les données d'entrée ont une petite erreur, l'erreur de sortie sera-t-elle grande ?

Les normes généralisent la notion de « longueur » ou « taille » à des vecteurs et matrices de dimension quelconque. Elles permettent de répondre rigoureusement à ces questions.

Normes vectorielles

Définition axiomatique

Une norme sur $\mathbb{R}^n$ est une fonction $\|\cdot\| : \mathbb{R}^n \to \mathbb{R}$ vérifiant :

Les normes p

La famille des normes p est définie par :

Normes courantes

Les trois normes les plus utilisées en pratique correspondent à $p = 1, 2, \infty$.

Norme 1 (Manhattan, taxicab) :

Norme 2 (euclidienne) :

Norme infinie (max, Tchebychev) :

Boules unités : interprétation géométrique

La boule unité d'une norme est l'ensemble des vecteurs de norme inférieure ou égale à 1 :

La forme de la boule unité révèle le « caractère » de chaque norme :

• Norme 1 : Losange (diamant). Favorise les vecteurs « sparse » (peu de composantes non nulles).
• Norme 2 : Cercle. Traite toutes les directions de manière égale.
• Norme ∞ : Carré. Limite chaque composante individuellement.

Exemples de calcul

Pour $x = (3, -4)^T$ :

import numpy as np

def norme_vecteur(x, p=2):
  """
  Calcule la norme p du vecteur x.
  """
  if p == np.inf:
      return np.max(np.abs(x))
  else:
      return np.sum(np.abs(x) ** p) ** (1/p)

# Exemple
x = np.array([3, -4])

print(f"||x||_1   = {norme_vecteur(x, 1)}")
print(f"||x||_2   = {norme_vecteur(x, 2)}")
print(f"||x||_inf = {norme_vecteur(x, np.inf)}")

Équivalence des normes

Pour les normes 1, 2 et infinie :

Normes matricielles

Les normes vectorielles mesurent la « taille » des vecteurs. Mais comment mesurer la « taille » d'une matrice ?

Une matrice $A$ transforme des vecteurs : elle prend un vecteur $x$ et produit $Ax$. La question naturelle est : de combien la matrice peut-elle amplifier un vecteur ?

Norme induite (naturelle)

La norme matricielle induite par une norme vectorielle est :

Exemple concret : Considérons $A = \begin{pmatrix} 2 & 0 \\ 0 & 3 \end{pmatrix}$. Cette matrice étire les vecteurs par 2 dans la direction $x$ et par 3 dans la direction $y$. Le facteur d'amplification maximal est donc 3 (atteint pour $x = (0, 1)^T$).

Formules pour les normes induites

Contrairement à la définition (qui nécessite un maximum sur tous les vecteurs), les normes induites ont des formules explicites simples :

Norme 1 matricielle :

Norme infinie matricielle :

Norme 2 matricielle (spectrale) :

où $\sigma_{\max}$ est la plus grande valeur singulière de $A$.

Exemple de calcul détaillé

Pour $A = \begin{pmatrix} 1 & -2 \\ 3 & 4 \end{pmatrix}$ :

Norme 1 : On calcule la somme des valeurs absolues de chaque colonne :

• Colonne 1 : $|1| + |3| = 4$
• Colonne 2 : $|-2| + |4| = 6$
• $\|A\|_1 = \max(4, 6) = 6$

Norme ∞ : On calcule la somme des valeurs absolues de chaque ligne :

• Ligne 1 : $|1| + |-2| = 3$
• Ligne 2 : $|3| + |4| = 7$
• $\|A\|_\infty = \max(3, 7) = 7$

Propriétés des normes matricielles

Normes consistantes et compatibles

Ces deux notions sont fondamentales pour l'analyse numérique. Elles garantissent que les normes « se comportent bien » lors des opérations matricielles.

Norme consistante (sous-multiplicative)

Une norme matricielle $\|\cdot\|$ est consistante (ou sous-multiplicative) si :

pour toutes matrices $A$ et $B$ de dimensions compatibles.

Exemple : Les normes induites ($\|\cdot\|_1, \|\cdot\|_2, \|\cdot\|_\infty$) et la norme de Frobenius sont toutes consistantes.

Norme compatible (avec une norme vectorielle)

Une norme matricielle $\|\cdot\|_M$ est compatible avec une norme vectorielle $\|\cdot\|_V$ si :

pour toute matrice $A$ et tout vecteur $x$.

Propriété clé : Les normes induites sont automatiquement compatibles avec la norme vectorielle qui les a induites. C'est leur définition même !

Tableau récapitulatif

Norme de Frobenius

La norme de Frobenius est une norme matricielle non induite mais extrêmement utilisée en pratique. Elle généralise la norme euclidienne aux matrices : c'est simplement la racine carrée de la somme des carrés de tous les éléments.

Exemple de calcul

Pour $A = \begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix}$ :

À comparer avec :

• $\|A\|_1 = \max(4, 6) = 6$
• $\|A\|_\infty = \max(3, 7) = 7$
• $\|A\|_2 \approx 5{,}46$ (plus grande valeur singulière)

Propriétés

Relation avec la norme spectrale :

où $r = \text{rang}(A)$. L'égalité $\|A\|_2 = \|A\|_F$ est atteinte si et seulement si $A$ est de rang 1.

Pourquoi utiliser Frobenius plutôt que les normes induites ?

Applications pratiques de la norme de Frobenius

1. Approximation de rang faible (compression de données)

En apprentissage automatique et traitement d'images, on cherche souvent à approximer une matrice $A$ par une matrice $\hat{A}$ de rang $k < r$. Le problème d'optimisation est :

La solution est donnée par la SVD tronquée : on garde les $k$ plus grandes valeurs singulières. C'est la base de la compression d'images et de la réduction de dimensionnalité (PCA).

2. Régularisation en apprentissage automatique

Dans la régression ridge et les réseaux de neurones, on pénalise la norme de Frobenius des poids pour éviter le surapprentissage :

où $W$ est la matrice des poids et $\lambda$ le coefficient de régularisation.

3. Distance entre matrices

La norme de Frobenius définit naturellement une distance entre matrices :

Utile pour mesurer à quel point deux matrices sont « proches », par exemple :

• Comparer une matrice de covariance empirique à une matrice théorique
• Mesurer l'erreur d'une factorisation matricielle
• Évaluer la convergence d'un algorithme itératif sur matrices

4. Sensibilité numérique

Pour analyser comment une perturbation $\delta A$ affecte un calcul matriciel, on utilise souvent :

comme mesure de l'erreur relative sur la matrice.

Calcul en Python

import numpy as np

def norme_matrice_1(A):
  """Norme 1 matricielle : max des sommes de colonnes."""
  return np.max(np.sum(np.abs(A), axis=0))

def norme_matrice_inf(A):
  """Norme infinie matricielle : max des sommes de lignes."""
  return np.max(np.sum(np.abs(A), axis=1))

def norme_matrice_2(A):
  """Norme 2 matricielle (spectrale)."""
  return np.max(np.linalg.svd(A, compute_uv=False))

def norme_frobenius(A):
  """Norme de Frobenius."""
  return np.sqrt(np.sum(A ** 2))

# Exemple
A = np.array([[1, 2],
            [3, 4]])

print(f"||A||_1   = {norme_matrice_1(A)}")
print(f"||A||_inf = {norme_matrice_inf(A)}")
print(f"||A||_2   = {norme_matrice_2(A):.4f}")
print(f"||A||_F   = {norme_frobenius(A):.4f}")

# Avec NumPy
print(f"\nNumPy:")
print(f"||A||_1   = {np.linalg.norm(A, 1)}")
print(f"||A||_inf = {np.linalg.norm(A, np.inf)}")
print(f"||A||_2   = {np.linalg.norm(A, 2):.4f}")
print(f"||A||_F   = {np.linalg.norm(A, 'fro'):.4f}")

Applications

Mesure des erreurs

Pour mesurer l'erreur entre une solution approchée $x^*$ et la solution exacte $x$ :

• Erreur absolue : $\|x - x^*\|$
• Erreur relative : $\frac{\|x - x^*\|}{\|x\|}$

Exemple : On résout un système et on obtient $x^* = (2.001, 2.998, 4.002)^T$ au lieu de $x = (2, 3, 4)^T$.

L'erreur est $e = x - x^* = (-0.001, 0.002, -0.002)^T$.

• $\|e\|_1 = 0.001 + 0.002 + 0.002 = 0.005$
• $\|e\|_2 = \sqrt{0.001^2 + 0.002^2 + 0.002^2} \approx 0.003$
• $\|e\|_\infty = \max(0.001, 0.002, 0.002) = 0.002$

L'erreur relative (norme 2) est : $\|e\|_2 / \|x\|_2 = 0.003 / \sqrt{29} \approx 0.06\%$

Quelle norme choisir ?

Convergence d'algorithmes

Un algorithme itératif converge si $\|x^{(k+1)} - x^{(k)}\| \to 0$.

Exemple : La méthode de Jacobi pour résoudre $Ax = b$ produit une suite $x^{(0)}, x^{(1)}, x^{(2)}, \ldots$. On s'arrête quand $\|x^{(k+1)} - x^{(k)}\| < \varepsilon$ pour une tolérance $\varepsilon$ choisie (par exemple $10^{-8}$).

Conditionnement (prochaine leçon)

Le nombre de condition utilise les normes pour mesurer la sensibilité d'un système aux perturbations :

• Si $\kappa(A) \approx 1$ : le système est bien conditionné, les erreurs restent petites.
• Si $\kappa(A) \gg 1$ : le système est mal conditionné, de petites erreurs dans $b$ peuvent causer de grandes erreurs dans $x$.

Remarques sur les normes

Deux propriétés importantes découlent de la sous-multiplicativité des normes matricielles.

1. La norme de l'identité est toujours ≥ 1

Pour toute matrice $A$ et la matrice identité $I$ :

En divisant par $\|A\|$ (pour $A \neq 0$), on obtient :

2. La norme de l'inverse est bornée inférieurement

Pour une matrice inversible $A$, en utilisant $A \cdot A^{-1} = I$ :

En divisant par $\|A\|$ :

Résumé

Propriété clé de compatibilité : $\|A x\| \leq \|A\| \cdot \|x\|$

Pour aller plus loin

La prochaine leçon utilisera les normes pour définir le conditionnement d'une matrice, qui mesure la sensibilité d'un système linéaire aux perturbations.