Régression non linéaire

Dernière mise à jour : 20 Septembre 1999


  1. Théorie

    1. Position du problème

    2. Principe de la méthode de Marquardt

      1. L'algorithme de Newton-Raphson
      2. L'algorithme de Marquardt

    3. Qualité de l'ajustement

      1. Coefficients de détermination
      2. Variance expliquée, variance résiduelle
      3. Précision des paramètres

  2. Programmation en Turbo Pascal

    1. Types
    2. Procédures et fonctions

    I. Théorie


    I.A. Position du problème

    On cherche à exprimer la relation entre deux variables x et y sous forme d'une fonction f qui dépend de manière non linéaire d'un vecteur de paramètres B :

    Soit par exemple une fonction exponentielle (Fig. 1) :


    Figure 1 : Régression non linéaire (Exemple : fonction exponentielle)


    Comme pour la régression linéaire, nous allons chercher les valeurs des paramètres B qui rendent minimale la somme des carrés des écarts pondérée :

    Lorsque f est une fonction non linéaire des paramètres B, le minimum ne peut être trouvé que par une méthode itérative : on part avec une estimation initiale des paramètres, que l'on affine à chaque étape jusqu'à ce que les paramètres ne varient plus.

    Ce problème peut en principe être résolu par n'importe lequel des nombreux algorithmes de minimisation disponibles. Toutefois, nous n'étudierons ici que l'algorithme de Marquardt, qui est le plus utilisé. Les autres algorithmes seront présentés dans un autre cours.

    Notons que, pour la plupart des méthodes d'optimisation non linéaire, le minimum obtenu est un minimum local, situé au voisinage de l'estimation initiale. Cette dernière devra donc être déterminée avec soin.


    I.B. Principe de la méthode de Marquardt

    L'algorithme de Marquardt est en fait une amélioration d'un algorithme plus classique, celui de Newton-Raphson.


    I.B.1. L'algorithme de Newton-Raphson

    Si B désigne le vecteur des paramètres estimé à l'itération courante, une meilleure estimation B' est donnée par la formule :

    G désigne le vecteur gradient de la fonction à minimiser, et H la matrice hessienne, ou matrice des dérivées secondes :

    k représente le déplacement qui minimise la fonction dans la direction du vecteur H-1G.

    Pour la régression non linéaire, on utilise les approximations suivantes de G et H :

    où Dik désigne la dérivée de la fonction de régression par rapport au paramètre bi, évaluée au point xk.

    Remarques :

    1. La transposée de la matrice D ainsi définie est la matrice jacobienne J = DT
    2. Les formules (6) équivalent à diviser G et H par 2 et à négliger dans l'expression de Hij le terme contenant ek2, avec :

    En effet ce terme tend vers zéro à mesure que les itérations progressent et que la valeur calculée de y se rapproche de la valeur observée.


    I.B.2. L'algorithme de Marquardt

    En vue d'améliorer la convergence de l'algorithme de Newton-Raphson, Marquardt (J. Soc. Indust. Appl. Math., 1963, 11, 431-441) remplace la matrice hessienne H par la matrice A définie par :

    est un scalaire initialisé (p. ex. à 1) au début des itérations, puis divisé par 10 si l'itération est efficace (c'est-à-dire si SSr diminue) ou sinon multiplié par 10. La valeur de diminue ainsi à mesure que SSr tend vers son minimum.

    Une fois le minimum atteint, on fait une dernière itération avec = 0 pour pouvoir calculer H-1 (qui servira à estimer la matrice de variance-covariance des paramètres).


    I.C. Qualité de l'ajustement


    I.C.1. Coefficients de détermination

    Par analogie avec la régression linéaire, on définit :

    où p désigne le nombre de paramètres du modèle, et :

    Mais si le modèle s'ajuste mal aux données, ou si le minimum est mal localisé, on peut avoir SSe > SSt et donc r2 > 1. Dans ce cas le coefficient de détermination n'est pas exploitable. C'est le signe d'un mauvais ajustement. Par exemple, si la courbe calculée passe toujours au-dessus des points, on a :


    I.C.2. Variance expliquée, variance résiduelle

    Comme pour la régression linéaire, on définit :

    Sous l'hypothèse de normalité des résidus, le rapport F = Ve / Vr suit approximativement une loi de Snedecor à (p - 1) et (n - p) degrés de liberté.

    Ces critères sont utiles pour comparer différents modèles. Pour une fonction de variance donnée, le meilleur modèle est celui qui correspond à la plus faible valeur de Vr et aux plus fortes valeurs de r2a et F.


    I.C.3. Précision des paramètres

    La matrice de variance-covariance des paramètre est estimée par V = Vr . H-1, où H est la matrice hessienne, définie en I.B.1. On en déduit les écart-types des paramètres : si = (Vii)½

    Sous l'hypothèse de normalité des résidus, les paramètres suivent approximativement une loi de Student à (n - p) degrés de liberté. On peut donc comparer chaque paramètre à zéro au moyen du rapport : ti = bi / si.


    II. Programmation en Turbo Pascal

    La programmation des calculs précédents peut être réalisée au moyen de la bibliothèque TP MATH.

    L'archive TPMATH1.ZIP contient deux unités relatives à la régression :

    Nous ne présentons ici que les procédures de régression non linéaire contenues dans REGRESS.PAS. L'unité MODELS.PAS, ainsi que les programmes de démonstration, font l'objet d'un chapitre séparé.


    II.A. Types

    L'unité REGRESS.PAS définit les deux types procéduraux suivants :

      type TRegFunc = function(X : Float;
                               B : PVector) : Float;
    

    Ce type définit la fonction de régression. B est le vecteur des paramètres.

      type TDerivProc = procedure(RegFunc : TRegFunc;
                                  X, Y    : Float;
                                  B, D    : PVector);
    

    Ce type définit la procédure utilisée pour calculer les dérivées partielles de la fonction de régression par rapport aux paramètres, au point (X, Y). La dérivée par rapport au Ième paramètre est retournée dans D^[I].


    II.B. Procédures et fonctions

    Les fonctions et procédures suivantes sont disponibles dans l'unité REGRESS.PAS :


    procedure SetOptAlgo(Algo : TOptAlgo); 
    

    Cette procédure permet de choisir l'algorithme d'optimisation. Le type TOptAlgo définit les choix possibles :

      type TOptAlgo = (
        NL_MARQ,         { Algorithme de Marquardt }
        NL_SIMP,         { Algorithme du Simplexe }
        NL_BFGS,         { Algorithme BFGS (Broyden-Fletcher-Goldfarb-Shanno) }
        NL_SA);          { Recuit simulé (Simulated Annealing) }
    

    function NLFit(RegFunc                    : TRegFunc; 
                   DerivProc                  : TDerivProc;
                   X, Y                       : PVector; 
                   N, Lbound, Ubound, MaxIter : Integer;   
                   Tol                        : Float; 
                   B                          : PVector; 
                   V                          : PMatrix) : Integer;
    

    Cette fonction calcule la régression non linéaire sans pondération. La signification des paramètres est la suivante :

      En entrée
      -------------------------------------------------------
      RegFunc   = Fonction de régression
      DerivProc = Procédure de calcul des dérivées partielles
      X, Y      = Coordonnées des points
      N         = Nombre de points
      Lbound    = Indice du premier paramètre ajusté
      Ubound    = Indice du dernier paramètre ajusté
      MaxIter   = Nombre maximal d'itérations
      Tol       = Erreur relative tolérée sur les paramètres
    
      En sortie
      -------------------------------------------------------
      B = Valeurs affinées des paramètres
      V = Inverse de la matrice hessienne
    

    La fonction retourne l'un des codes d'erreur suivants :

      Symbole      Valeur   Signification
      -------------------------------------------------------------
      MAT_OK          0     Pas d'erreur
      MAT_SINGUL     -1     Singularité de la matrice hessienne
      BIG_LAMBDA     -2     Paramètre Lambda trop élevé
      NON_CONV       -3     Nombre d'itérations supérieur à MaxIter
    

    function WNLFit(RegFunc                    : TRegFunc;
                    DerivProc                  : TDerivProc;             
                    X, Y, W                    : PVector; 
                    N, Lbound, Ubound, MaxIter : Integer;   
                    Tol                        : Float; 
                    B                          : PVector; 
                    V                          : PMatrix) : Integer; 
    

    Cette fonction calcule la régression non linéaire avec pondération. W (paramètre en entrée) est le vecteur des poids.


    procedure NumDeriv(RegFunc : TRegFunc; 
                       X, Y    : Float; 
                       B, D    : PVector); 
    

    Cette procédure calcule approximativement les dérivées partielles de la fonction de régression par dérivation numérique.

    Il est recommandé de calculer les dérivées analytiquement lorsque c'est possible, et donc d'écrire une procédure de dérivation spécifique pour chaque fonction de régression.