Note : Ce texte est basé en partie sur le mémoire de DEA de Mathématiques de Mamadou Boli Ba (Université de Limoges, Juin 1998). Je remercie M. Ba pour sa collaboration.

1. Introduction

   1. Les méthodes de descente aléatoire pure

   2. Le recuit simulé

      1. Principe
      2. Implémentation
      
      
   
   

2. Programmation en Turbo Pascal

   1. L'unité OPTIM.PAS

      1. Types et variables globales
      2. Procédure de recuit simulé
      
      

   2. Programme de démonstration

   
   

3. Conclusion

I. Introduction

De nombreux problèmes reviennent à chercher le minimum ou le maximum d'une fonction de plusieurs variables (un exemple typique est fourni par la régression non linéaire). L'optimisation stochastique a pour but d'approcher cet extrêmum au moyen d'une recherche aléatoire. Sous la forme du recuit simulé, elle permet en théorie de trouver l'extrêmum global de la fonction, alors que la plupart des méthodes classiques (déterministes) se limitent à un extrêmum local.

Nous n'envisagerons ici que le cas de la minimisation (puisque maximiser une fonction F revient à minimiser -F). Nous étudierons successivement :

• Les méthodes de descente aléatoire pure
• Le recuit simulé

I.A. Les méthodes de descente aléatoire pure

Soit F(X) une fonction de n variables x₁, x₂, ..., x_n, dont on cherche le minimum (X est le vecteur des variables). Un algorithme de descente aléatoire se présenterait comme suit :

Le passage de X_r à X se fait par tirage aléatoire, p. ex. selon une loi normale centrée sur X (Voir le cours sur les nombres aléatoires).

L'inconvénient de cette méthode est qu'elle n'accepte que des diminutions de la fonction. L'algorithme risque ainsi de se trouver bloqué dans un minimum local.

I.B. Le recuit simulé

I.B.1. Principe

Le recuit simulé (simulated annealing) permet de sortir d'un minimum local (et donc, en théorie, d'atteindre le minimum global) en acceptant, avec une certaine probabilité, une augmentation de la fonction.

Cette technique s'inspire de la thermodynamique. En effet, les systèmes physiques atteignent rapidement leur état d'équilibre (minimum d'énergie) en dépit du nombre immense de configurations que peuvent prendre les particules constituant le système. Au cours de cette transition vers l'équilibre, l'énergie peut localement augmenter.

Or, la probabilité p pour qu'un système physique passe du niveau d'énergie E₁ au niveau E₂ > E₁ est donnée par la loi de Boltzmann :

p = exp(-(E2 - E1) / kT)

(1)

où k est la constante de Boltzmann et T la température absolue.

La probabilité d'observer une augmentation de l'énergie est donc d'autant plus grande que la température est élevée.

Dans le recuit simulé :

• Une diminution de la fonction sera toujours acceptée.
• Une augmentation de la fonction sera acceptée avec une probabilité définie selon une formule analogue à (1), avec ici k = 1 et T un paramètre formel jouant le rôle de la température.

I.B.2. Implémentation

Un algorithme de recuit simulé se présente sous la forme générale suivante :

La fonction Accepte(dF, T) se présente ainsi :

où Random(0, 1) désigne un nombre aléatoire uniforme sur l'intervalle [0, 1[

Pour implémenter cet algorithme, il nous faut donc :

1. Une procédure de détermination de la température initiale :

   Au début des itérations, alors qu'on est éloigné du minimum, on choisit une probabilité d'acceptation élevée, p.ex. p = 0,5. On peut alors effectuer un certain nombre de tirages aléatoires et calculer la valeur médiane M des augmentations de la fonction (la médiane est la valeur qui partage une distribution en deux parties égales). La température initiale T₀ s'en déduit par :

   p = exp(- M / T₀) = 0,5

   d'où :

   T₀ = - M / ln p ~ 1,44 M

2. Un schéma de décroissance de la température (le "recuit") :

   On choisit habituellement une décroissance géométrique :

   T_n+1 = R_T T_n

   soit :

   Tn= T0 (RT)n

   (2)

3. Un critère d'arrêt :

   On peut arrêter les itérations lorsque la température est devenue inférieure à une fraction donnée de la température initiale, p. ex. T_n < 10^-6 T₀

Il ne s'agit là que de l'algorithme de base. De nombreuses améliorations sont possibles (voir p.ex. le programme ASA de Lester Ingber).

II. Programmation en Turbo Pascal

L'optimisation par le recuit simulé peut être réalisé au moyen de la bibliothèque TP MATH.

II.A. L'unité OPTIM.PAS

L'unité OPTIM.PAS, contenue dans TPMATH1.ZIP, fournit une procédure de recuit simulé, ainsi que quelques méthodes déterministes :

• la méthode de Marquardt (voir cours sur la régression non linéaire).
• la méthode BFGS (Broyden-Fletcher-Goldfarb-Shanno).
• la méthode du simplexe.

Note : ces deux dernières méthodes seront décrites dans un autre cours.

II.A.1. Types et variables globales

• Le type de la fonction à minimiser est défini comme suit :

    type
      TFuncNVar = function(X : PVector) : Float;
  

  Remarque : Pour la signification du type PVector, voir le cours sur le calcul matriciel.

• Les variables globales suivantes sont utilisées pour contrôler l'algorithme de recuit :

    const
      SA_Nt        : Integer = 50;   { Nb d'itérations à chaque température }
      SA_Cv        : Float   = 0.5;  { Coef. de variation des nombres aléatoires }
      SA_MinSigma  : Float   = 1.0;  { Ecart-type minimal des nombres aléatoires }
      SA_SigmaFact : Float   = 0.1;  { Facteur de réduction global de l'écart-type }
      SA_NCycles   : Integer = 1;    { Nombre de cycles de recuit }
  

  Remarques :

  1. Le tirage d'un nouveau vecteur aléatoire à partir du vecteur courant X se fait selon une loi normale centrée sur X et telle que l'écart-type du paramètre x_i est donné par :

     MinSigma + Cv * |x_i|

     où MinSigma et Cv sont initialisés à SA_MinSigma et SA_Cv, respectivement, et diminués à chaque changement de température, de sorte que leurs valeurs finales soient à SA_SigmaFact de leurs valeurs initiales. Cette diminution progressive de l'écart-type permet de réduire la taille de la portion d'espace explorée à mesure que l'on se rapproche du minimum.

  2. En modifiant la valeur de SA_NCycles, on peut effectuer plusieurs cycles de recuit simulé, en recalculant à chaque fois la température initiale. Ceci permet de relancer l'algorithme s'il s'est arrêté à trop grande distance du minimum.

• Les deux variables globales suivantes permettent d'écrire un fichier log qui contiendra le détail des itérations (ceci pour les 4 méthodes d'optimisation) :

    const
      WriteLogFile : Boolean = False;       { Indique si le fichier doit être écrit ou non }
      LogFileName  : String  = 'OPTIM.LOG'; { Nom du fichier }
  

  Le fichier log est réécrit à chaque appel d'une procédure d'optimisation. Dans le cas du recuit simulé, il contient, pour chaque étape de recuit :

  • La température
  • La dernière valeur acceptée de la fonction
  • Le nombre d'augmentations de la fonction
  • Le nombre d'augmentations acceptées

  ---

  II.A.2. Procédure de recuit simulé

  La procédure de recuit simulé est définie comme suit :

    function SimAnn(Func           : TFuncNVar;
                    X              : PVector;
                    Lbound, Ubound : Integer;
                    MaxIter        : Integer;
                    T_Ratio        : Float;
                    var F_min      : Float) : Integer;
  

  La signification des paramètres est la suivante :

    En entrée
    ------------------------------------------------------------
    Func    = Fonction à minimiser
    X       = Coordonnées approchées du minimum
    Lbound  = Indice de la première variable
    Ubound  = Indice de la dernière variable
    MaxIter = Nombre d'étapes de recuit
    T_Ratio = Rapport de la température finale à la température initiale
  
    En sortie
    ------------------------------------------------------------
    X       = Coordonnées affinées du minimum
    F_min   = Valeur de la fonction en X
  

  Remarques :

  1. Le générateur de nombres aléatoires est réinitialisé à chaque appel de la fonction. On obtiendra donc des résultats différents à chaque appel. Il est conseillé de lancer plusieurs fois la fonction et de comparer les résultats.

  2. Le facteur de réduction de la température R_T est déterminé par les valeurs de MaxIter et T_Ratio selon l'équation (2) :

     R_T = (T_Ratio)^1/MaxIter

     p. ex. avec MaxIter = 100 et T_Ratio = 10^-6 on a :

     R_T = (10^-6)^1/100 ~ 0,87

  3. La fonction retourne toujours 0.

  ---

  
  

  II.B. Programme de démonstration

  Le programme MINFUNC.PAS, disponible dans TPMATH2.ZIP, permet de tester le recuit simulé, ainsi que les 3 autres algorithmes d'optimisation proposés.

  Il y a 10 fonctions tests, codées dans des fichiers à inclure (MINFUNC0.INC à MINFUNC9.INC).

  A titre d'exemple, considérons la fonction de deux variables, codée dans MINFUNC9.INC (NB : Pour simplifier, nous avons écrit les variables sous forme x, y au lieu de x₁, x₂) :

  F(x, y) = x² + y² - cos(12x) - cos(18y)

  Le graphique ci-dessous montre que cette fonction possède de nombreux mimima locaux. Le minimum global se trouve en (0,0), avec F(0,0) = -2.

  

  Figure 1

  Graphe de la fonction F(x, y) = x² + y² - cos(12x) - cos(18y)

  (Graphique réalisé avec Maple)

  
  

  Nous avons lancé 5 fois le recuit simulé en partant du point (2, -3) avec MaxIter = 50, T_Ratio = 10^-8, et toutes les variables globales ayant leurs valeurs par défaut. Nous avons obtenu les résultats suivants :

  x	0,0153	-0,0025	-0,0010	-0,0063	-0,0022
  y	-0,0055	0,0004	-0,0014	-0,0033	-0,0013
  F	-1,98	-2,00	-2,00	-2,00	-2,00

  On constate que le recuit simulé donne une bonne approximation du minimum global. A titre de comparaison, les méthodes classiques ont donné les résultats suivants :

  	Marquardt	BFGS	Simplexe
  x	2,06	-1,03	1,03
  y	-3,12	-1,39	0,00
  F	12,13	1,02	-0,92

  La méthode du simplexe donne les meilleurs résultats mais reste tout de même "piégée" dans un minimum local.

  ---

  III. Conclusion

  Bien que le recuit simulé soit souvent présenté comme une méthode d'optimisation réservée aux fonctions à variables discrètes, il peut également fournir de bonnes approximations du minimum global dans le cas d'une fonction à variables continues. Ces approximations peuvent ensuite être affinées par l'une des méthodes classiques d'optimisation locale.