Lissage par moindres carrés

Objectifs d'apprentissage

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

• Distinguer interpolation (passage exact) et lissage (ajustement)
• Formuler et résoudre un problème de régression linéaire
• Établir les équations normales pour les moindres carrés
• Étendre la méthode aux polynômes de degré supérieur
• Appliquer la méthode à des modèles non linéaires par linéarisation

Prérequis

• Systèmes linéaires surdéterminés (Chapitre 3)
• Résolution de systèmes par élimination
• Notion de dérivée partielle

Interpolation vs lissage

Le problème de l'interpolation

Dans les leçons précédentes, nous avons cherché un polynôme passant exactement par tous les points de données. Mais cette approche pose des problèmes :

1. Données bruitées : les mesures expérimentales contiennent des erreurs. Forcer le passage par des points erronés propage ces erreurs.

2. Trop de données : avec beaucoup de points, le polynôme de degré élevé oscille dangereusement.

L'approche du lissage

Le lissage cherche une courbe simple (par exemple une droite) qui s'approche au mieux des données, sans nécessairement passer par chaque point.

Principe des moindres carrés

Formulation

Soit points de données . On cherche une fonction qui minimise la somme des carrés des erreurs (résidus) :

Pourquoi les carrés ?

• Les erreurs positives et négatives ne se compensent pas
• Les grandes erreurs sont pénalisées davantage
• La fonction à minimiser est différentiable (contrairement à la valeur absolue)
• La solution possède une forme analytique simple

Régression linéaire

Le modèle

On cherche la droite (pente , ordonnée à l'origine ) qui minimise :

Conditions d'optimalité

est une somme de carrés, donc une fonction convexe (paraboloïde orienté vers le haut). Elle admet un unique minimum global, et aucun maximum. Il suffit d'annuler les dérivées partielles pour le trouver :

Développement vers les équations normales

Développons la première équation. On divise par et on distribue la somme :

Comme et sont des constantes (ne dépendent pas de ) :

De même pour la seconde équation (diviser par , distribuer) :

Les équations normales

On obtient le système des équations normales :

Sous forme matricielle :

Exemple : résistance vs température

Données expérimentales

On mesure la résistance électrique d'un matériau à différentes températures :

Calculs préliminaires

Système à résoudre

On cherche . Le système normal est :

Solution

On résout le système 2×2. De la première équation, on isole :

On substitue dans la seconde équation et on résout pour :

Application numérique pour (la pente) :

Puis (l'ordonnée à l'origine) :

Résultat

La résistance augmente d'environ 3.4 ohms par degré Celsius.

Formulation matricielle générale

Lien avec les systèmes surdéterminés

Le problème de régression peut s'écrire comme un système surdéterminé :

Ce système a équations et 2 inconnues. Si , il est surdéterminé (pas de solution exacte en général).

Équations normales

La solution aux moindres carrés satisfait :

Vérifions que c'est exactement le même système que les équations normales trouvées plus haut. Calculons et :

On retrouve bien le système avec les sommes de la section précédente. La formulation matricielle est simplement une écriture compacte des mêmes équations.

Extension aux polynômes de degré n

Modèle polynomial

On cherche qui minimise :

Matrice de design

Système normal

où .

Régression non linéaire par linéarisation

Motivation

Certains phénomènes suivent des lois non linéaires :

• Décroissance exponentielle :
• Loi de puissance :

Exemple : modèle exponentiel

Données :

Modèle :

Linéarisation : En prenant le logarithme :

où .

Transformation des données :

Régression linéaire sur (x, z) :

Solution : ,

Donc :

Modèle final :

Qualité de l'ajustement

Coefficient de détermination R²

Le coefficient mesure la qualité de l'ajustement :

où est la valeur prédite et la moyenne des .

• : ajustement parfait
• : le modèle n'explique rien (pas mieux qu'une constante)
• ou plus : bon ajustement

Erreur standard

où est le nombre de points et le degré du polynôme.

Autres méthodes de lissage

Norme R∞ (minimax)

Minimiser l'erreur maximale :

Plus robuste aux outliers, mais plus difficile à résoudre.

Norme R₁

Minimiser la somme des valeurs absolues :

Plus robuste aux outliers que R², mais pas de solution analytique simple.

Algorithme Python

import numpy as np

def regression_lineaire(t, y):
  """
  Régression linéaire : y = m*t + b

  Retourne:
      m, b : pente et ordonnée à l'origine
      r2 : coefficient de détermination
  """
  N = len(t)
  sum_t = np.sum(t)
  sum_y = np.sum(y)
  sum_t2 = np.sum(t ** 2)
  sum_ty = np.sum(t * y)

  # Résoudre le système normal
  denom = N * sum_t2 - sum_t ** 2
  m = (N * sum_ty - sum_t * sum_y) / denom
  b = (sum_y - m * sum_t) / N

  # Coefficient R²
  y_pred = m * t + b
  ss_res = np.sum((y - y_pred) ** 2)
  ss_tot = np.sum((y - np.mean(y)) ** 2)
  r2 = 1 - ss_res / ss_tot

  return m, b, r2

def regression_polynomiale(t, y, degre):
  """
  Régression polynomiale : y = a_0 + a_1*t + ... + a_n*t^n

  Retourne:
      coeffs : coefficients [a_0, a_1, ..., a_n]
      r2 : coefficient de détermination
  """
  # Construire la matrice de design
  A = np.vander(t, degre + 1, increasing=True)

  # Équations normales
  ATA = A.T @ A
  ATy = A.T @ y

  # Résoudre
  coeffs = np.linalg.solve(ATA, ATy)

  # Coefficient R²
  y_pred = A @ coeffs
  ss_res = np.sum((y - y_pred) ** 2)
  ss_tot = np.sum((y - np.mean(y)) ** 2)
  r2 = 1 - ss_res / ss_tot

  return coeffs, r2

def regression_exponentielle(x, y):
  """
  Régression exponentielle : y = a * exp(b*x)
  par linéarisation.

  Retourne:
      a, b : coefficients
  """
  # Linéarisation : ln(y) = ln(a) + b*x  =>  z = b*x + ln(a)
  z = np.log(y)
  pente, ordonnee, _ = regression_lineaire(x, z)
  a = np.exp(ordonnee)
  b = pente

  return a, b

# Exemple : résistance vs température
T = np.array([20.5, 32.7, 51.0, 73.2, 95.7])
R = np.array([765, 826, 873, 942, 1032])

pente, ordonnee, r2 = regression_lineaire(T, R)
print(f"Régression linéaire : R = {pente:.3f} * T + {ordonnee:.1f}")
print(f"R² = {r2:.4f}")

# Régression polynomiale de degré 2
coeffs, r2_poly = regression_polynomiale(T, R, 2)
print(f"\nRégression quadratique : R = {coeffs[0]:.1f} + {coeffs[1]:.3f}*T + {coeffs[2]:.5f}*T²")
print(f"R² = {r2_poly:.4f}")

# Exemple exponentiel
x_exp = np.array([1.0, 2.0, 4.0])
y_exp = np.array([2.0, 7.2, 500.1])

a_exp, b_exp = regression_exponentielle(x_exp, y_exp)
print(f"\nRégression exponentielle : y = {a_exp:.2f} * exp({b_exp:.2f} * x)")

Résumé

Conclusion du chapitre

Ce chapitre a couvert les principales méthodes d'interpolation et de lissage polynomiales :

1. Interpolation exacte : Lagrange, Newton-Gregory, différences divisées
2. Instabilité : phénomène de Runge pour les polynômes de degré élevé
3. Splines cubiques : polynômes par morceaux avec continuité C²
4. Courbes paramétriques : Bézier et B-splines pour la conception
5. Interpolation 2D : par étapes ou polynôme bidimensionnel
6. Lissage : moindres carrés pour les données bruitées

Ces outils sont fondamentaux en analyse numérique et trouvent des applications dans tous les domaines de la science et de l'ingénierie.