Cours 8 : Optimisation(s)

(1)

Cours 8 : Optimisation(s)

Vincent Guigue UPMC - LIP6

(2)

Stratégies simples... Algo. géné. AG : appli & implem

Optimisation du radar pour l’arrivée

◦ Avec Dijkstra, la voiture à peur de l’arrivée !

◦ Comment aller tout droit ?

◦ Comment optimiser la fin de course ?

Vincent Guigue 2i013 - Course de Voiture 2/27

(3)

◦ Avec Dijkstra, la voiture à peur de l’arrivée ! - Tous les faisceaux donnent le même score...

(4)

- On met l’angle 0 à la position de choix par défaut (la première en général)

(5)

- On met l’angle 0 à la position de choix par défaut (la première en général)

◦ Comment optimiser la fin de course ? - On affine le calcul des scores - Meilleur score = plus petit...

- Si tous à 0⇒affinage dans le négatif... Plus petite longueur = meilleur score

- Pour les faisceaux de score 0,newscore=−1/longueur

(6)

Résultats

(7)

Stratégie simple, robuste, efficace

Outils: Radar + longueur des faisceaux d_i + distance devant la voitured₀ +α_max

Paramètres:distsecu,accsecu,factangle−secu,accvirage,vitlimite

◦ Acc =1,Turn=α avecα= ^bestangle_braquage^radar

◦ Si :d <distsecu alors Acc =accsecu

◦ Si :d_bestangle <1.5∗dist_secu alors Acc =acc_secu

◦ Si :factangle−secu∗α_max <|α|alorsAcc =acc_virage

◦ Si vitesse <vitlimite AlorsAcc =1

(8)

Et hop...

Paramètres:dist_secu=46,acc_secu =−0.82,factangle−secu = 10,accvirage =−1,vitlimite =0.59

◦ Score = 2794

◦ Pour le circuit 3.. Score = 4354 (avec d’autres paramètres !)

(9)

Et hop...

Paramètres:dist_secu=46,acc_secu =−0.82,factangle−secu = 10,accvirage =−1,vitlimite =0.59

◦ Score = 2794

◦ Pour le circuit 3.. Score = 4354 (avec d’autres paramètres !) Mais comment a-t-on trouvé des paramètres aussi bizarres ? ? ?

(10)

1 Stratégies simples...

2 Algo. géné.

3 AG : appli & implem

(11)

Formulation du problème

◦ Algorithme génétique : algorithme d’optimisation d’une fonction

◦ Soit une fonctionf de plusieurs variables x₁,x₂, . . . ,x_d, on souhaite trouver la valeur des variables pour minimiser (ou maximiser) f.

◦ Idée générale :

1 Générer plein de points aléatoirement

2 Les évaluer

3 Isoler les meilleurs

4 Lesmixer et les modifier légèrement

5 Recommencernfois

6 Isoler le meilleur et le retourner

(12)

Sur un exemple

(13)

Comparaison avec d’autres approches

Génétique

+ Capable de traiter n’importe quel problème

+ Pas besoin de dériverf + Facile à programmer - Convergence lente - Demande beaucoup

d’évaluationf(x₁,x₂, . . .) - Solution approchée - Réglage des paramètres

Basé sur la dérivée + Solution optimale + Solution rapide

- Limité aux problèmes convexes - Calcul de dérivées (voire de

dérivées secondes)

(14)

Opérateurs : le croisement discret

Idée : mélanger les meilleurs éléments pour en faire sortir un encore mieux

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

◦ On crée un nouvel individu

◦ Pour chaque variable, on choisit un des deux parents pour initialiser le nouvel individu

◦ On choisit l’un ou l’autre des parents avec une probabilité 0.5 IndividuX3

x1 x2 x3 x4 x5 x6 x7

3

(15)

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

x1 x2 x3 x4 x5 x6 x7

3 9

(16)

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

x1 x2 x3 x4 x5 x6 x7

3 9 6

(17)

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

x1 x2 x3 x4 x5 x6 x7

3 9 6 9

(18)

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

x1 x2 x3 x4 x5 x6 x7

3 9 6 9 2

(19)

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

x1 x2 x3 x4 x5 x6 x7

3 9 6 9 2 1

(20)

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

x1 x2 x3 x4 x5 x6 x7

3 9 6 9 2 1 6

(21)

Opérateurs : le croisement continu

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

◦ Pour chaque variable, on fait une moyenne pondérée des deux parents

◦ On choisit les poids des parents aléatoirement entre 1 et 10 IndividuX3

x1 x2 x3 x4 x5 x6 x7

2.5

(22)

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

x1 x2 x3 x4 x5 x6 x7

2.5 6.1

(23)

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

x1 x2 x3 x4 x5 x6 x7

2.5 6.1 6

(24)

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

x1 x2 x3 x4 x5 x6 x7

2.5 6.1 6 8.2

(25)

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

x1 x2 x3 x4 x5 x6 x7

2.5 6.1 6 8.2 2

(26)

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

x1 x2 x3 x4 x5 x6 x7

2.5 6.1 6 8.2 2 2.4

(27)

Individu X1

x₁ x₂ x₃ x₄ x₅ x₆ x₇

1 9 6 8 2 1 5

Individu X2

x₁ x₂ x₃ x₄ x₅ x₆ x₇

3 5 6 9 2 3 6

x1 x2 x3 x4 x5 x6 x7

2.5 6.1 6 8.2 2 2.4 5.9

(28)

Bilan croisement

On choisit le croisement en fonction du type de donnée considéré :

◦ Si la variable est une catégorie, on fait un croisement discret

◦ Si la variable est unegrandeur, on fait un moyenne

◦ On prend garde à conserver des valeurs réalisables pour les variables

- les entiers restent des entiers

- on ne sort pas du terrain avec la voiture...

NB : il existe un croisement binaire qui n’est presque plus utilisé.

(29)

Mutation

Afin de ne pas se limiter à l’espace des points qui ont été générés au départ, on opère une mutation sur certain enfants.

Individu X3 Original

x1 x2 x3 x4 x5 x6 x7

2.5 6.1 6 8.2 2 2.4 5.9

Individu X₃ muté

x1 x2 x3 x4 x5 x6 x7

2.5 6.1 6 8.2 2 2.4 5.9

◦ Pour chaque variable on considère la mutation avec une probabilité de l’ordre de 0.2 (par exemple)

◦ Si on décide de muter, on applique une légère transformation (en décalage ou en multiplication)

◦ On fait attention à rester dans le domaine réalisable - les entiers restent des entiers

- les catégories restent des catégories - on ne sort pas du terrain avec la voiture...

(30)

Mutation

x1 x2 x3 x4 x5 x6 x7

2.5 6.1 6 8.2 2 2.4 5.9

Individu X₃ muté

x1 x2 x3 x4 x5 x6 x7

2.5 6.5 6 8.2 2 2.4 5.9

(31)

Mutation

x1 x2 x3 x4 x5 x6 x7

2.5 6.1 6 8.2 2 2.4 5.9

Individu X₃ muté

x1 x2 x3 x4 x5 x6 x7

2.5 6.5 6 8.2 2 2.4 5.9

(32)

Mutation

x1 x2 x3 x4 x5 x6 x7

2.5 6.1 6 8.2 2 2.4 5.9

Individu X₃ muté

x1 x2 x3 x4 x5 x6 x7

2.5 6.5 6 7.5 2 2.4 5.9

(33)

Mutation

x1 x2 x3 x4 x5 x6 x7

2.5 6.1 6 8.2 2 2.4 5.9

Individu X₃ muté

x1 x2 x3 x4 x5 x6 x7

2.5 6.5 6 7.5 2.1 2.4 5.9

(34)

Mutation

x1 x2 x3 x4 x5 x6 x7

2.5 6.1 6 8.2 2 2.4 5.9

Individu X₃ muté

x1 x2 x3 x4 x5 x6 x7

2.5 6.5 6 7.5 2.1 2.4 5.9

(35)

Mutation

x1 x2 x3 x4 x5 x6 x7

2.5 6.1 6 8.2 2 2.4 5.9

Individu X₃ muté

x1 x2 x3 x4 x5 x6 x7

2.5 6.5 6 7.5 2.1 2.4 5.9

(36)

Vue d’ensemble de la méthode

◦ Afin de trier les populations, on utilisera les fonctionssort du module Array ou List

◦ Méthode à appliquer

1 Sélectionner une liste desn meilleurs

2 Les croiser aléatoirement pour obtenirn/2 nouveaux individus

3 Les muter

4 Mélanger les nouveaux et les anciens

5 Tirer lesnmeilleurs

(37)

Application sur notre problème

But :

◦ Minimiser le nombre de coup...

◦ Evaluation = une simulation de course complète - Si la course est réussie :Fitness = nb coup - Sinon : Fitness = meilleur dijk + 100000 Mais que va-t-on optimiser ? ! ?

◦ Points de passage (type point à point)

◦ Zones dangeureuses (position, tailles...)

◦ Stratégie par zones (diviser la course en 10) et avoir des comportements spécifiques

◦ ...

(38)

But :

◦ Paramètres d’une stratégie radar

◦ ...

(39)

But :

◦ ...

(40)

But :

◦ ...

(41)

But :

◦ ...

(42)

Fourni/A faire

Fourni : cadre général A faire

A faire :

◦ Créer une population de base

- RandomGenerator : ()→ X

◦ Fonction de fitness :X →R

◦ Fonction de Mutation : X → X

◦ Fonction de Croisement : X × X → X

- Une fonction générique est fournie

(43)

Cas pratique : stratégie paramétrique

Paramètres =double[8]

◦ Distance de sécurité + acc associée

◦ ratio1 anglesouhaite

anglerealisable + acc associée

◦ ratio2 anglesouhaite

anglerealisable + acc associée

◦ Limite de réaccélération 1

◦ Limite de réaccélération 2 cf code ci-après

(44)

Cas pratique : stratégie paramétrique

1 p u b l i c Commande getCommande ( ) {

2 r a d a r . s c o r e s ( ) ;

3 d o u b l e com =

4 r a d a r . t h e t a s ( ) [ r a d a r . g e t B e s t I n d e x ( ) ] / c a r . g e t B r a q u a g e ( ) ;

5 d o u b l e t u r n A b s =

6 Math . min ( Math . a b s ( com ) , c a r . getMaxTurn ( ) ) ;

7

8 d o u b l e a c c = 1 ; // a c c é l é r a t i o n p a r d é f a u t

9 i f( R a d a r C l a s s i q u e . d i s t I n P i x e l s ( 0 , c a r , t r a c k )<param [ 0 ] )

10 a c c = param [ 1 ] ;

11 e l s e i f( R a d a r C l a s s i q u e . d i s t I n P i x e l s (

12 r a d a r . t h e t a s ( ) [ r a d a r . g e t B e s t I n d e x ( ) ] , c a r , t r a c k )

13 < param [ 0 ]∗1 . 5 )

14 a c c = param [ 1 ] ;

15 e l s e i f( param [ 2 ]∗t u r n A b s < Math . a b s ( com ) ) a c c = param [ 3 ] ;

16 e l s e i f( param [ 4 ]∗t u r n A b s < Math . a b s ( com ) ) a c c = param [ 5 ] ;

17

18 i f( c a r . g e t V i t e s s e ( ) < param [ 6 ] ) a c c = 0 . 5 ;

19 i f( c a r . g e t V i t e s s e ( ) < param [ 7 ] ) a c c = 1 ;

20

21 Commande c = new Commande ( a c c , t u r n A b s ∗ Math . s i g n u m ( com ) ) ;

22 r e t u r n c ;

23 }

(45)

Résultat de l’optimisation

Compétition actuelle

Génération aléatoire

it 1 it 2 ... it 10 Kechkar

4514

4382 4382 4360 4354 4344

Paramètres :

59.899 -1.0, 9.453 0.322 9.244 -1.0 0.1 0.6

◦ Il semble y avoir de la marge !

(46)

Outils fournis génériques

Déclarer les types comme pour une ArrayList, par exemple pour un algorithme surVecteur:

1 G e n e t i c A l g o r i t h m <V e c t e u r > ga

◦ On ne peut optimiser qu’une seule chose avec le code fourni : - Exemple précédent, type=Double(liste de paramètres) - Optimiser la position de points de contrôles,⇒type =Vecteur - Pas de mélange possible par défaut...

◦ Le génome = un individu (code fourni)

1 p u b l i c c l a s s Genome<Gene> e x t e n d s A r r a y L i s t <Gene>{

2 p r i v a t e d o u b l e f i t n e s s ;

3 p u b l i c Genome ( ) {

4 s u p e r( ) ;

5 f i t n e s s = G e n e t i c A l g o r i t h m . MIN_VALUE ;

6 }

7 . . .

◦ Ensuite, il faut définir les paramètres et les opérateurs.

(47)

Mutation Spécification

1 p u b l i c i n t e r f a c e M u t a t i o n O p e r a t o r <Gene> {

2 v o i d mute ( Genome<Gene> g ) ;

3 }

Implémentation spécifique

1 p u b l i c c l a s s M u t a t i o n O p e r a t o r I m p l D o u b l e im pleme nts

2 M u t a t i o n O p e r a t o r <Double >{

3 p r i v a t e d o u b l e r a t e ; p r i v a t e d o u b l e[ ] s i g m a ;

4 p r i v a t e s t a t i c Random r = new Random ( ) ;

5

6 p u b l i c M u t a t i o n O p e r a t o r I m p l D o u b l e (d o u b l e r a t e , d o u b l e[ ] s i g m a ) {

7 t h i s. r a t e = r a t e ;

8 t h i s. s i g m a = s i g m a ;

9 }

10

11 p u b l i c v o i d mute ( Genome<Double> g ) {

12 f o r(i n t i =0; i <g . s i z e ( ) ; i ++)

13 i f( r . n e x t D o u b l e () < r a t e )

14 g . s e t ( i , g . g e t ( i )+ r . n e x t G a u s s i a n ( )∗s i g m a [ i ] ) ;

15 }

(48)

Croisement de Vecteur

Spécification

1 p u b l i c i n t e r f a c e C r o s s i n g O p e r a t o r <Gene> {

2 Genome<Gene> c r o s s ( Genome<Gene> g1 , Genome<Gene> g2 ) ;

3 }

Proposition simple :

◦ jouer avec les probabilités pour prendre tantôt dans g1 et tantôt dans g2...

◦ implémentation fournie

(49)

Générateur de génome Spécification

1 p u b l i c i n t e r f a c e G e n o m e G e n e r a t o r <Gene> {

2 p u b l i c Genome<Gene> b u i l d ( ) ;

3 }

Implémentation

1 // q u a t r e t a b l e a u x :

2 // v a l e u r s p a r d é f a u t , s i g m a ( v a r i a t i o n s ) , min , max

3 p u b l i c Genome<Double> b u i l d ( ) {

4 Genome<Double> gen = new Genome<Double > ( ) ; // génome v i d e

5 f o r(i n t i =0; i <d e f a u l t. l e n g t h ; i ++){

6 // p a r c o u r s d ’ un t a b l e a u de v a l e u r s p a r d é f a u t

7

8 // g é n é r a t i o n a l é a t o i r e g a u s s i e n n e

9 d o u b l e d = r . n e x t G a u s s i a n ( ) ∗ d e f a u l t p a r a m S i g ( ) [ i ] + d e f a u l t p a r a m ( ) [ i ] ;

10 d = Math . min ( d , S t r a t e g y R a d a r . paramMax ( ) [ i ] ) ; // b o r n e

11 d = Math . max ( d , S t r a t e g y R a d a r . paramMin ( ) [ i ] ) ;

12 gen . add ( d ) ;

13 }

14 r e t u r n gen ;

15 }

(50)

Evaluation (fitness)

1 p u b l i c i n t e r f a c e F i t n e s s O p e r a t o r <Gene> {

2 d o u b l e f i t ( Genome<Gene> g ) ;

3 }

Implémentation

◦ ATTENTION : algo de maximisation

◦ Stocker le circuit (attention à ne pas relire à chaque fois)

◦ Générer une voiture, une stratégie à partir du génome

◦ Jouer la course

◦ score =

- si course OK : -nbCoups (ou 1./(double) nbCoups)

- sinon : -dernierDijk -1e6 (pour être sûr d’être moins bon que les bonnes courses)

(51)

Outils génériques Coté main :

1 S t r i n g f i l e n a m e = " t r a c k /3 _ s a f e . t r k ";

2 C i r c u i t c = C i r c u i t F a c t o r y F r o m F i l e . b u i l d ( f i l e n a m e ) ;

3 S t r a t e g y G e n e r a t o r B a s i c R a d a r P a r a m e t e r s t r G e n =

4 new S t r a t e g y G e n e r a t o r B a s i c R a d a r P a r a m e t e r ( ) ;

5

6 i n t p o p u l a t i o n S i z e = 2 0 0 ;

7 d o u b l e r a t e = 0 . 1 ; // p o u r l a m u t a t i o n

8 M u t a t i o n O p e r a t o r <Double> muteOp =

9 new M u t a t i o n O p e r a t o r I m p l D o u b l e ( r a t e , d e f a u l t p a r a m S i g ( ) ) ;

10 C r o s s i n g O p e r a t o r <Double> c r o s s O p =

11 new C r o s s i n g O p e r a t o r I m p l <Double > ( ) ;

12 F i t n e s s O p e r a t o r <Double> f i t n e s s O p =

13 new F i t n e s s O p e r a t o r I m p l <Double >(c , s t r G e n ) ;

14

15 G e n e t i c A l g o r i t h m <Double> ga =

16 new G e n e t i c A l g o r i t h m <Double >( p o p u l a t i o n S i z e , s t r G e n ,

17 muteOp , c r o s s O p , f i t n e s s O p ) ;

18 Genome<Double> r e s = ga . o p t i m i z e ( 1 0 ) ;

19

20 S y s t e m . o u t . p r i n t l n (" B e s t ␣ : ␣ "+r e s . g e t F i t n e s s ( ) ) ;

(52)

Quelques pièges à éviter

On a besoin de jouer des milliers de courses... Il faut être rapide

◦ Ne pas recharger le circuit à chaque itération

◦ Réinitialiser la voiture

- Piège de la position initiale

◦ La fonction d’évaluation est très importante... Mais assez dure à programmer. Plus elle est fine, plus vous pouvez être

efficace :

- Prendre en compte le temps de parcours

- Prendre en compte la distance à l’arrivée en cas de crash pour hiérarchiser les courses perdues

(53)

Alternative aux AG

Idée de base :dériver la fonction de coût pour la minimiser (comme en terminale !)

Problème : pas de fonction explicite. Solution : envisager des petits mouvements locaux :

◦ Pour chaque paramètre à optimiser : envisager quelques mouvements décrivant différentes directions

◦ Conserver la direction qui fait baisser le coût et faire une recherche linéaire pour trouver le pas optimal