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 qui minimise :

Conditions d'optimalité

Pour minimiser , on annule les dérivées partielles :

Les équations normales

En développant, on obtient le système :

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

Solution

Par élimination de Gauss ou formule directe :

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 :

Ce système a équations et 2 inconnues. Si , il est surdéterminé.

Équations normales

La solution aux moindres carrés satisfait :

où est une matrice (carrée) et inversible si les colonnes de sont linéairement indépendantes.

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 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 = a + b*t

  Retourne:
      a, b : coefficients
      r2 : coefficient de détermination
  """
  m = 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 = m * sum_t2 - sum_t ** 2
  b = (m * sum_ty - sum_t * sum_y) / denom
  a = (sum_y - b * sum_t) / m

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

  return a, 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 = np.log(y)
  A, b, _ = regression_lineaire(x, z)
  a = np.exp(A)

  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])

a, b, r2 = regression_lineaire(T, R)
print(f"Régression linéaire : R = {a:.1f} + {b:.3f} * T")
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.