Aster/Cata/cataSTA10/Macro/reca_evol.py

   1 #@ MODIF reca_evol Macro  DATE 11/05/2010   AUTEUR COURTOIS M.COURTOIS
   2
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2009  EDF R&D                  WWW.CODE-ASTER.ORG
   6 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   7 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   8 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   9 # (AT YOUR OPTION) ANY LATER VERSION.
  10 #
  11 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  12 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  13 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  14 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  15 #
  16 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  17 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  18 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  19 # ======================================================================
  20 #
  21
  22 '''
  23 Le programme d'optimisation d'une fonctionelle base sur l'algorithm genetique,
  24 developpement issu du contrat PdM-AMA
  25 '''
  26
  27 import numpy
  28 import math
  29 import random
  30
  31
  32
  33 def evolutivo(fonc,val,nb_iter,err_min,nb_parents,nb_fils,sigma,borne_inf,borne_sup,graine):
  34
  35 #initialisation du vecteur des parametres
  36     par_ini=[]
  37 #les valeurs initiales des parametres sont recuperees
  38     for ind in val:
  39         if ind:
  40             par_ini.append(ind)
  41
  42 #valeur du critere d arret
  43     val_crit=nb_iter
  44
  45 #initialisation et remplisage du vecteur des parents
  46     Parents_ini=[]
  47     for ind in range(nb_parents):
  48         Parents_ini.append(par_ini)
  49     #P sera le vecteur des parents retourne par la fonction figli
  50     P=[]
  51     erreurs=[]
  52     erreurs_ini=[]
  53     #le premier vecteur d erreurs sera calcule par la fonction errore
  54     #a partir des valeurs initiales des parents
  55
  56     # On affiche egalement la fenetre MAC pour un appariement manual
  57     fonc.graph_mac=True
  58     err_ini=fonc.calcul_F(par_ini)
  59     #on rempli l'erreur pour chaque parent initial
  60     for ind in range(nb_parents):
  61         erreurs_ini.append(err_ini)
  62     P.append(Parents_ini)
  63     erreurs.append(erreurs_ini[:])
  64     in_ciclo=True
  65     iter=1
  66     #ici on demarre la boucle de minimisation de la fonction erreur
  67     while in_ciclo:
  68         if graine != None: random.seed(graine)
  69         F=fils(P[-1],nb_parents,nb_fils,sigma,borne_inf, borne_sup)
  70
  71         #on fait la selection des meilleurs fils - p
  72         (p,err)=selection(fonc,F,P[-1],erreurs[-1],nb_parents)
  73
  74         #P est le nouveau jeu de parents
  75         #attention on stocke ici tous l historique des parents et c'est le meme pour les erreurs dans erreurs
  76         P.append(p)
  77
  78         erreurs.append(err)
  79         #on lance un calcul avec le meilleur jeu de parametres juste pour l'appariement des MAC
  80         fonc.graph_mac=True
  81         err_mac=fonc.calcul_F(P[-1][0])
  82         if erreurs[-1][0]<=err_min:
  83             in_ciclo=False
  84         iter+=1
  85         if iter>val_crit:
  86             in_ciclo=False
  87
  88     return P[-1][0]
  89
  90
  91
  92 def selection(fonc,fils,parents,err_parents,nb_parents):
  93
  94     """
  95     Selection des meilleurs fils a chaque iteration
  96     """
  97
  98     famille=[]
  99     err=[]
 100     for ind in fils:
 101         fonc.graph_mac=False
 102         err.append(fonc.calcul_F(ind))
 103     for ind in err_parents:
 104         err.append(ind)
 105     for ind in fils:
 106         famille.append(ind)
 107     for ind in parents:
 108         famille.append(ind)
 109
 110     ordre=numpy.argsort(err).tolist()
 111     fam_ordonne=[]
 112     err_ordonne=[]
 113     for ind in ordre:
 114         fam_ordonne.append(famille[ind])
 115         err_ordonne.append(err[ind])
 116
 117     return fam_ordonne[0:int(nb_parents)], err_ordonne[0:int(nb_parents)]
 118
 119
 120
 121
 122 def fils(parents,nb_parents,nb_fils,sigma,borne_inf, borne_sup):
 123     """
 124     Creation des fils
 125     """
 126
 127     F=[]
 128     for ind in range(int(math.floor(nb_fils/nb_parents))):
 129         for ind2 in range(nb_parents):
 130             F.append(genere_fils(parents[ind2],sigma,borne_inf, borne_sup))
 131 #le dernier parent est le plus prolific car il va completer le nombres de fils
 132 #mais il est aussi le meilleur parent car correspond a l'erreur minimale
 133     for ind2 in range(nb_fils%nb_parents):
 134         F.append(genere_fils(parents[ind2],sigma,borne_inf, borne_sup))
 135
 136     return F
 137
 138 #les fils sont generes ici
 139 def genere_fils(parent,sigma,borne_inf, borne_sup):
 140
 141     """
 142     Creation d'un seul fils avec prise en compte des bornes
 143     """
 144     errate=True
 145     while errate:
 146         errate=False
 147 #F est le vecteur de fils a remplir ici avec la fonction random
 148 #a partir des valeurs du parent courant
 149         F=[]
 150         for ind in parent:
 151             F.append(ind+ind/100.*random.gauss(0,sigma))
 152 #la variable parametre initialise ici est un index pour defiler les valeurs de F
 153         parametre=0
 154         for ind in parent:
 155             test1=F[parametre]>=borne_inf[parametre]
 156             test2=F[parametre]<=borne_sup[parametre]
 157             if test1 & test2:
 158                 pass
 159             else:
 160                 errate=True
 161 #                print "parametre hors bornes"
 162             parametre+=1
 163 #        print 'fils genere:',F
 164     return F
 165