Méthode du gradient conjugué

De testwiki
Aller à la navigation Aller à la recherche
Illustration de la méthode du gradient conjugué.

En analyse numérique, la méthode du gradient conjugué est un algorithme pour résoudre des systèmes d'équations linéaires dont la matrice est symétrique définie positive. Cette méthode, imaginée en 1950 simultanément par Cornelius Lanczos, Eduard Stiefel et Magnus Hestenes[1], est une méthode itérative qui converge en un nombre fini d'itérations (au plus égal à la dimension du système linéaire). Toutefois, son grand intérêt pratique du point de vue du temps de calcul vient de ce qu’une initialisation astucieuse (dite « préconditionnement ») permet d'aboutir en seulement quelques passages à une estimation très proche de la solution exacte : c'est pourquoi, en pratique, on se borne à un nombre d'itérations bien inférieur au nombre d'inconnues.

La méthode du gradient biconjugué fournit une généralisation pour les matrices non symétriques.

Principe

L'objectif est de minimiser la fonction f:x12(𝐀x,x)(b,x)Modèle:Math est une matrice carrée symétrique définie positive de taille n.

Le calcul montre qu'une solution du problème est la solution du système 𝐀x=b : en effet, on a f(x)=𝐀xb.

Intuitivement, la fonction Modèle:Mvar peut donc être vue comme une primitive (littéralement un potentiel scalaire) du résidu 𝐀xb. En annulant le gradient de Modèle:Mvar, on obtient le vecteur Modèle:Mvar qui minimise l'erreur.

La méthode du gradient conjugué vue comme une méthode directe

On rappelle que deux vecteurs non nuls Modèle:Mvar et Modèle:Mvar sont conjugués par rapport à Modèle:Math si

uT𝐀v=0.

Sachant que Modèle:Math est symétrique définie positive, on en déduit un produit scalaire

u,v𝐀:=𝐀u,v=u,𝐀Tv=u,𝐀v=uT𝐀v.

Ainsi, deux vecteurs sont conjugués s'ils sont orthogonaux pour ce produit scalaire.

La conjugaison est une relation symétrique : si Modèle:Mvar est conjugué à Modèle:Mvar pour Modèle:Math, alors Modèle:Mvar est conjugué à Modèle:Mvar.

Supposons que Modèle:Formule est une suite de Modèle:Mvar directions conjuguées deux à deux. Alors les Modèle:Formule forment une base de Rn, ainsi la solution Modèle:Math de Modèle:Formule dans cette base :

x*=i=1nαipi

Les coefficients sont donnés par

b=𝐀x*=i=1nαi𝐀pi.
pkTb=pkT𝐀x*=i=1nαipkT𝐀pi=αkpkT𝐀pk. (car ik,pi,pk sont conjugués deux à deux)
αk=pkTbpkT𝐀pk=pk,bpk,pk𝐀=pk,bpk𝐀2.

On a ainsi l'idée directrice de la méthode pour résoudre le système Modèle:Formule : trouver une suite de Modèle:Mvar directions conjuguées, et calculer les coefficients Modèle:Mvar.

La méthode du gradient conjugué vue comme une méthode itérative

En choisissant correctement les directions conjuguées Modèle:Mvar, il n'est pas nécessaire de toutes les déterminer pour obtenir une bonne approximation de la solution Modèle:Math. Il est ainsi possible de considérer la méthode du gradient conjugué comme une méthode itérative. Ce choix permet ainsi de considérer la résolution de systèmes de très grande taille, où le calcul de l'ensemble des directions aurait été très long.

On considère ainsi un premier vecteur Modèle:Math, qu'on pourra supposer nul (sinon, il faut considérer le système Modèle:Formule). L'algorithme va consister, partant de Modèle:Math, à se « rapprocher » de la solution Modèle:Math inconnue, ce qui suppose la définition d'une métrique. Cette métrique vient du fait que la solution Modèle:Math est l'unique minimiseur de la forme quadratique :

f(𝐱)=12xT𝐀xxTb,xn.

Ainsi, si Modèle:Formule diminue après une itération, alors on s'approche de Modèle:Math.

Ceci suggère donc de prendre la première direction Modèle:Math comme l'opposé du gradient de Modèle:Mvar à Modèle:Formule. Le gradient vaut Modèle:Formule, d'après notre première hypothèse. Les vecteurs suivants de la base seront ainsi conjugués au gradient, d'où le nom « méthode du gradient conjugué ».

Soit Modèle:Mvar le résidu à la kModèle:E itération :

rk=b𝐀xk.

Notons que Modèle:Mvar est l'opposé du gradient de Modèle:Mvar en Modèle:Formule, ainsi, l'algorithme du gradient indique d'évoluer dans la direction Modèle:Mvar. On rappelle que les directions Modèle:Mvar sont conjuguées deux à deux. On veut aussi que la direction suivante soit construite à partir du résidu courant et des directions précédemment construites, ce qui est une hypothèse raisonnable en pratique.

La contrainte de conjugaison est une contrainte d'orthonormalité, aussi le problème partage des similitudes avec le procédé de Gram-Schmidt.

On a ainsi

pk=rkik1piT𝐀rkpiT𝐀pipi

Suivant cette direction, le point suivant est donné par

xk+1=xk+αkpk
où le pas αk est déterminé de manière à minimiser g(α)=f(xk+αpk)=12α2pkT𝐀pk+αpkT(𝐀xkb)+constante;
le minimum de Modèle:Mvar est atteint pour dgdα(αk)=0 et comme Modèle:Math est définie positive, pkT𝐀pk>0 ,
on a donc : αk=pkT(b𝐀xk)pkT𝐀pk=pkTrkpkT𝐀pk
Une analyse plus détaillée de cette algorithme (un raisonnement par récurrence) montre que 𝐫i est orthogonal à 𝐫j, i.e. 𝐫i𝖳𝐫j=0 pour ij (voir ci-après) et que 𝐩i est 𝐀-orthogonal à 𝐩j , i.e. 𝐩i𝖳𝐀𝐩j=0 , pour ij.

Algorithme

Pour amorcer la récurrence, il faut partir d’une estimation initiale Modèle:Math du vecteur Modèle:Mvar recherché ; et le nombre d'itérations N nécessaire pour que xNx<ε (où ε est un nombre positif arbitrairement proche de zéro) dépend du Modèle:Math choisi. Malheureusement, les méthodes de « préconditionnement » à la fois sûres et générales (c'est-à-dire efficaces pour toutes sortes de matrices symétriques positives) pour former un Modèle:Math correct sont aussi elles-mêmes coûteuses en temps de calcul. En pratique, l'intuition physique, guidée par la nature physique du problème à résoudre, suggère parfois une initialisation efficace : ces idées ont donné lieu depuis plus de trente ans à une littérature spécialisée abondante[2].

Algorithme itératif en pseudo-code

L'algorithme ci-dessous résout Modèle:Math, où Modèle:Math est une matrice réelle, symétrique, et définie positive. Le vecteur d'entrée Modèle:Math peut être une approximation de la solution initiale ou 0. Cette algorithme est issu de la méthode itérative exacte présentée dans le paragraphe précédent, les valeurs des coefficients αk semblent différentes mais en utilisant les relations de l'algorithme ci-dessous, en particulier : 𝐩k=𝐫k+βk1𝐩k1, et le fait que les résidus 𝐫k et 𝐫k1 soient orthogonaux , on peut montrer par récurrence que l'on a bien : αk=pkTrkpkT𝐀pk=rkTrkpkT𝐀pk. Ci-dessous le coefficient αk est choisi pour que les résidus 𝐫k+1 et 𝐫k soient orthogonaux et non pas minimiser g comme dans le paragraphe précédent, mais en fait les deux approches reviennent à la même formule pour αk et le coefficient βk est choisi pour que 𝐩k+1 soit A-conjugué de 𝐩k.

𝐫0:=𝐛𝐀𝐱0𝐩0:=𝐫0k:=0répéterαk:=𝐫k𝖳𝐫k𝐩k𝖳𝐀𝐩k𝐱k+1:=𝐱k+αk𝐩k𝐫k+1:=𝐫kαk𝐀𝐩ksi rk+1 est suffisamment petit, alors on sort de la boucleβk:=𝐫k+1𝖳𝐫k+1𝐫k𝖳𝐫k𝐩k+1:=𝐫k+1+βk𝐩kk:=k+1fin de répéterLe résultat est 𝐱k+1
Cet algorithme du gradient conjugué est celui qui est très souvent utilisé. Il est intéressant de constater que le coefficient βk de cet algorithme a la même expression que celui qui est utilisé dans la méthode 'Fletcher-Reeves' du gradient conjugué non-linéaire.
On peut également remarquer que x1 est déduit de x0 en utilisant la méthode du gradient et que prendre βk=0, revient à appliquer la méthode du gradient et peut donc être utilisé pour réinitialiser un calcul de gradient conjugué en cours. Réinitialiser un calcul en cours peut ralentir la convergence, mais peu également en augmenter la stabilité en particulier en réduisant les erreurs dus à l'accumulation d'imprécisions numériques (round-off errors).
Les formules 𝐱k+1:=𝐱k+αk𝐩k et 𝐫k:=𝐛𝐀𝐱k, qui sont exactes, impliquent que les deux formules 𝐫k+1:=𝐫kαk𝐀𝐩k et 𝐫k+1:=𝐛𝐀𝐱k+1 sont mathématiquement équivalentes. La première formule 𝐫k+1:=𝐫kαk𝐀𝐩k est utilisé dans l'algorithme pour éviter une multiplication supplémentaire par 𝐀 car le vector 𝐀𝐩k est déjà calculé pour évaluer αk. La deuxième formule 𝐫k+1:=𝐛𝐀𝐱k+1 peut par contre être plus précise car elle réduit l'accumulation des imprécisions numérique et elle est donc parfois recommandée[3].

Exemple numérique

Considérons le système linéaire Ax = b suivant :

𝐀𝐱=[4113][x1x2]=[12],

Deux itérations de l'algorithme du gradient conjugué vont être réalisées pas à pas à en partant du vecteur initial

𝐱0=[21]
Il est rappelé, que s'il n'y avait pas d'imprécision numérique dans les calculs le présent exemple est résolu en seulement n = 2 itérations, puisque ici la matrice est de dimension 2x2 et donc que x2 devrait aux erreurs numériques près retrouver la solution exacte.

Solution

La solution exacte de ce système linéaire est obtenu en inversant simplement la matrice A :

𝐀1=[3114]/11 et 𝐱=𝐀1[12]=[111711][0.09090.6364]

Les valeurs initiales de l'algorithme itératifs sont :

𝐫0=𝐛𝐀𝐱0=[12][4113][21]=[83]=𝐩0.
α0=𝐫0𝖳𝐫0𝐩0𝖳𝐀𝐩0=[83][83][83][4113][83]=733310.2205

Lors de la première itération la valeur x1 est une meilleur approximation de la solution exacte:

𝐱1=𝐱0+α0𝐩0=[21]+73331[83][0.23560.3384].

et le résidu associé r1 est égal à :

𝐫1=𝐫0α0𝐀𝐩0=[83]73331[4113][83][0.28100.7492].

Ce résidu est encore grand et donc il est nécessaire de poursuivre la deuxième itération et donc de calculer les paramètres qui vont être utile pour calculer x2: (i) d'abord Modèle:Math puis (ii) la nouvelle direction de recherche p1 et ensuite (iii) Modèle:Math :

β0=𝐫1𝖳𝐫1𝐫0𝖳𝐫0[0.28100.7492][0.28100.7492][83][83]=0.0088.

𝐩1=𝐫1+β0𝐩0[0.28100.7492]+0.0088[83]=[0.35110.7229].
α1=𝐫1𝖳𝐫1𝐩1𝖳𝐀𝐩1[0.28100.7492][0.28100.7492][0.35110.7229][4113][0.35110.7229]=0.4122.
𝐱2=𝐱1+α1𝐩1[0.23560.3384]+0.4122[0.35110.7229]=[0.09090.6364].

x2 est une bien meilleur approximation de la solution que x1 et x0 et cela est numériquement déterminé en évaluant le résidu r2.

𝐫2=𝐫1α1𝐀𝐩1=[0.28100.7492]0.4122[4113][0.35110.7229][0.000090.00001].

Il est également intéressant de vérifier que : 𝐫1𝖳𝐫1=𝐩1𝖳𝐫1 :

𝐫1𝖳𝐫1=[0.28100.7492][0.28100.7492]=0.6402 et

𝐩1𝖳𝐫1=[0.35110.7229][0.28100.7492]=0.6402

Convergence

On peut montrer le résultat suivant sur la convergence de l'algorithme :

x*xk𝐀2(κ(𝐀)1κ(𝐀)+1)kx*x0𝐀,

κ(𝐀) désigne le conditionnement de la matrice et z𝐀=zT𝐀z.

La méthode du gradient conjugué a donc une convergence superlinéaire, qui peut être mise à mal par un mauvais conditionnement de la matrice. Elle reste toutefois meilleure que les algorithmes à direction de plus forte pente.

Solveur

  • Modèle:En M1CG1 - A solver of symmetric linear systems by conjugate gradient iterations, using/building a BFGS/ℓ-BFGS preconditioner. Écrit en Fortran-77. Le solveur a l'intérêt d'offrir la possibilité de construire un préconditionneur BFGS ou Modèle:Lien, qui pourra être utile pour la résolution d'un système linéaire avec une matrice proche et un second membre différent.

Notes et références

Notes

  1. Modèle:Article
  2. Selon Dianne O'Leary (cf. bibliographie), l'article de Modèle:Article marque une étape décisive dans l'idée de préconditionner un système linéaire avant de lui appliquer l'algorithme. Cet article pionnier proposait le pré-conditionnement par Décomposition LU incomplète. Suivirent entre autres le pré-conditionnement par SOR interrompu (Modèle:Article), et par Méthode de Gauss-Seidel interrompue (Modèle:Ouvrage). On trouvera un aperçu des différentes techniques dans, entre autres : Modèle:Ouvrage ; Modèle:Ouvrage, etc.
  3. Modèle:Ouvrage

Bibliographie

Voir aussi

Articles connexes

Liens externes

Modèle:Traduction/Référence


Modèle:Portail