MGS-17 — Contrôle de paramètres (Parameter Control)

Capacite du moteur exercee : faire varier les paramètres de l’algorithme pendant la course, plutot que de les fixer une fois pour toutes — et mesurer quand cela aide vraiment.

La sélection d’algorithme (MGS-16) etait une première réponse au theoreme No-Free-Lunch (Wolpert & Macready, 1997) : aucun optimiseur ne domine universellement, donc on choisit le bon selon le paysage. Il existe une deuxieme réponse, complementaire : pour un même optimiseur, adapter ses paramètres au cours du temps. C’est le contrôle de paramètres (Eiben, Hinterding & Michalewicz, 1999 ; Karafotias, Hoogendoorn & Eiben, 2015).

Taxonomie d’Eiben : reglage vs contrôle

Stratégie Quand le paramètre est-il fixe ? Exemple
Reglage (tuning, hors-ligne) Avant la course, identique chaque generation mutationProbability = 0.2
Contrôle (control, en ligne) Il varie pendant la course selon 3 sous-types ci-dessous

Le contrôle se decompose en 3 sous-types, selon ce qui pilote la variation :

Sous-type Pilote Ce notebook
Déterministe Une fonction du temps (numéro de generation) §2 — schedule decroissant
Adaptatif Le feedback de la population (diversite, succes) §3 — diversite pilote la mutation
Self-adaptatif L’individu lui-même (chaque chromosome a son propre taux) §4 — taux heterogene par individu

Le fil rouge (spoiler honnete)

On pourrait croire que « contrôler c’est toujours mieux ». Les données montreront le contraire. Faire varier la mutation, c’est jouer sur le compromis exploration/exploitation : la mutation est le levier d’exploration. Sur un paysage multimodal (Rastrigin), explorer aide a s’extraire des optima locaux ; sur un paysage unimodal (Sphere), l’exploration ajoutee disrupte la convergence rapide. Aucune stratégie de contrôle ne dominera sur les deux paysages : c’est le No-Free-Lunch au niveau du paramètre, en echo direct de MGS-16.

Plan

  1. Reglage (reference) : balayage des taux fixes sur Rastrigin.
  2. Contrôle déterministe : schedule f(generation) via DynamicProbability.
  3. Contrôle adaptatif : la diversite de la population pilote le taux (esprit règle 1/5 de Rechenberg).
  4. Contrôle self-adaptatif : un taux par individu via le contexte d’evolution.
  5. Comparaison Rastrigin vs Sphere + taxonomie + exercices.
// Cablage : DLLs MetaGeneticSharp + GeneticSharp (build Debug net9.0).
// Pre-requis : dotnet build ..\MetaGeneticSharp\MetaGeneticSharp.sln
#r "..\MetaGeneticSharp\src\MetaGeneticSharp.Domain\bin\Debug\net9.0\GeneticSharp.Infrastructure.Framework.dll"
#r "..\MetaGeneticSharp\src\MetaGeneticSharp.Domain\bin\Debug\net9.0\GeneticSharp.Domain.dll"
#r "..\MetaGeneticSharp\src\MetaGeneticSharp.Domain\bin\Debug\net9.0\MetaGeneticSharp.Infrastructure.dll"
#r "..\MetaGeneticSharp\src\MetaGeneticSharp.Domain\bin\Debug\net9.0\MetaGeneticSharp.Domain.dll"
#r "..\MetaGeneticSharp\src\MetaGeneticSharp.Extensions\bin\Debug\net9.0\MetaGeneticSharp.Extensions.dll"

using MetaGeneticSharp;
using GeneticSharp;
using System;
using System.Linq;

Console.WriteLine("MetaGeneticSharp + GeneticSharp charges.");
Console.WriteLine("  ProbabilityConfig      : " + typeof(ProbabilityConfig).Name);
Console.WriteLine("  ProbabilityStrategy    : " + typeof(ProbabilityStrategy).Name);
Console.WriteLine("  OperatorsProbabilityConfig : " + typeof(OperatorsProbabilityConfig).Name);
Console.WriteLine("  RastriginFitness       : " + typeof(RastriginFitness).Name);
Console.WriteLine("  SphereFitness          : " + typeof(SphereFitness).Name);
MetaGeneticSharp + GeneticSharp charges.
  ProbabilityConfig      : ProbabilityConfig
  ProbabilityStrategy    : ProbabilityStrategy
  OperatorsProbabilityConfig : OperatorsProbabilityConfig
  RastriginFitness       : RastriginFitness
  SphereFitness          : SphereFitness
// DoubleArrayChromosome (replique fork, MGS-10/15/16) — genes reels.
public class DoubleArrayChromosome : ChromosomeBase
{
    private readonly double _min; private readonly double _max;
    public DoubleArrayChromosome(double[] values, double min, double max) : base(values.Length)
    { _min=min; _max=max; for (int i=0;i<values.Length;i++) ReplaceGene(i, new Gene(values[i])); }
    public override IChromosome CreateNew()
    { var rand=RandomizationProvider.Current; int n=Length; var v=new double[n];
      for (int i=0;i<n;i++) v[i]=rand.GetDouble(_min,_max); return new DoubleArrayChromosome(v,_min,_max); }
    public override Gene GenerateGene(int geneIndex) => new Gene(RandomizationProvider.Current.GetDouble(_min,_max));
    public double[] GetDoubleValues() => GetGenes().Select(g => (double)g.Value).ToArray();
}

const int PopSize = 50;
const int NFE = 5000;   // budget d'evaluations -> ~100 generations

// MakeOptimizer : lance un GA avec la metaheuristique donnee (son ProbabilityConfig pilote la mutation).
// buildMh(gens) construit la metaheuristique ; renvoie la fitness maximisee.
Optimizer MakeOptimizer(Func<int,IMetaHeuristic> buildMh)
{ return (Optimizer)((req) => { int gens=Math.Max(1,req.Evaluations/PopSize);
    var (min,max)=req.Bounds; double mid=0.5*(min+max);
    var adam=new DoubleArrayChromosome(Enumerable.Repeat(mid,req.Dimension).ToArray(),min,max);
    var pop=new MetaPopulation(PopSize,PopSize,adam);
    var ga=new MetaGeneticAlgorithm(pop,req.Fitness,new EliteSelection(),new UniformCrossover(0.5f),new UniformMutation(true),buildMh(gens));
    ga.Termination=new GenerationNumberTermination(gens);
    ga.MutationProbability=0.2f;   // defaut : sera ECRASE si la metaheuristique utilise OverwriteProbability
    ga.Start();
    return ga.BestChromosome.Fitness ?? double.NegativeInfinity; }); }

// RunAvg : objectif moyen (proche 0 = meilleur) sur plusieurs seeds.
// Rastrigin est bruitee a NFE=5000 (cf MGS-10/16) : ne jamais juger sur 1 seed -> on moyenne sur 5.
double RunAvg(Func<int,IMetaHeuristic> build, OptimizerRequest req, int[] seeds)
{ double s=0;
  foreach (var sd in seeds) { FastRandomRandomization.ResetSeed(sd); s += -MakeOptimizer(build)(req); }
  return s/seeds.Length; }

var Seeds = new[]{7,42,99,123,777};
var reqR = new OptimizerRequest(new RastriginFitness(), KnownFunctionsBounds.For(typeof(RastriginFitness)), 5, NFE);
var reqS = new OptimizerRequest(new SphereFitness(),    KnownFunctionsBounds.For(typeof(SphereFitness)),    5, NFE);
Console.WriteLine($"Setup OK. PopSize={PopSize}, NFE={NFE} (gens={NFE/PopSize}), dim=5, seeds=[{string.Join(',',Seeds)}]");
Setup OK. PopSize=50, NFE=5000 (gens=100), dim=5, seeds=[7,42,99,123,777]

1. Reglage (tuning) — la reference fixe

Le reglage fixe le taux de mutation avant la course et ne le touche plus. C’est l’approche par defaut. On balaye p in {0.01, 0.05, 0.2, 0.5} sur Rastrigin pour etablir la reference : quel est le meilleur taux fixe, et surtout — un taux fixe est-il robuste ?

Note methodologique. Rastrigin est fortement bruitee a NFE=5000 (cf MGS-10) : on moyenne sur 5 seeds et on lit les résultats comme des tendances, pas des certitudes.

// === TUNING (fixe) === proba de mutation statique, identique chaque generation.
IMetaHeuristic BuildFixed(double p)
{ var m=new DefaultMetaHeuristic();
  m.ProbabilityConfig.Mutation.Strategy=ProbabilityStrategy.TestProbability|ProbabilityStrategy.OverwriteProbability;
  m.ProbabilityConfig.Mutation.StaticProbability=(float)p;
  return m; }

Console.WriteLine("Rastrigin (dim=5, NFE=5000, moy 5 seeds) -- objectif (proche 0 = meilleur)");
double bestFixed=double.PositiveInfinity; double bestP=0;
foreach (var p in new[]{0.01, 0.05, 0.2, 0.5})
{ double obj=RunAvg(g=>BuildFixed(p), reqR, Seeds);
  if (obj<bestFixed){bestFixed=obj; bestP=p;}
  Console.WriteLine($"  p={p,5:F2}   objectif {obj,8:F3}");
}
Console.WriteLine($"  -> meilleur reglage fixe : p={bestP:F2} (objectif {bestFixed:F3}).");
Console.WriteLine("     Aucun taux fixe n'est robuste : le 'bon' depend du paysage et du budget.");
Rastrigin (dim=5, NFE=5000, moy 5 seeds) -- objectif (proche 0 = meilleur)
  p= 0,01   objectif   12,378
  p= 0,05   objectif   11,885
  p= 0,20   objectif   12,332
  p= 0,50   objectif   12,753
  -> meilleur reglage fixe : p=0,05 (objectif 11,885).
     Aucun taux fixe n'est robuste : le 'bon' depend du paysage et du budget.

Le meilleur reglage fixe existe, mais il est spécifique a ce paysage et a ce budget. C’est l’argument contre le reglage : un taux uniforme est forcement sous-optimal a une extremite de la course (trop timide pour explorer au debut, ou trop bruyant pour converger a la fin). Le contrôle adresse cela.

2. Contrôle déterministe — un schedule f(generation)

Idee. Au lieu de choisir p, on définit une fonction decroissante du numéro de generation : mutation haute au debut (explorer largement), basse a la fin (exploiter le meilleur bassin trouve). C’est le contrôle déterministe (Eiben) : la variation ne depend d’aucun feedback, uniquement du temps.

Un schedule exponentiel : p(g) = p_max * exp(-k * g/G), avec p_max = 0.5, k = 3 -> p(0)=0.5, p(G) ~= 0.025.

Le fork expose ce mécanisme via ProbabilityConfig.Mutation.DynamicProbability : Func<IEvolutionContext, float, float> combine a Strategy = OverwriteProbability. A chaque evaluation de la probabilite, le moteur appelle notre fonction avec le contexte d’evolution (ctx.Population.GenerationsNumber).

// Visualisation SVG inline du schedule deterministe : p(g) = 0.5 * exp(-3 * g/G).
// Prong-A (#3801, #6927) : rendu SVG statique zero-dependance (rend sur GitHub/nbviewer/offline).
// Remplace le chart Plotly-CDN (C548-L2) dont le script externe rendait BLANC en consultation statique.
// Helper canon SvgChartHelper.cs (#6942 MERGED) ; primitive Overlay multi-series (#6958 MERGED).
#load "../../Probas/Infer/SvgChartHelper.cs"

// === CONTROL DETERMINISTE === schedule decroissant p(g) = 0.5 * exp(-3 * g/G)
IMetaHeuristic BuildDecay(int maxGen)
{ var m=new DefaultMetaHeuristic();
  m.ProbabilityConfig.Mutation.Strategy=ProbabilityStrategy.TestProbability|ProbabilityStrategy.OverwriteProbability;
  m.ProbabilityConfig.Mutation.DynamicProbability=(ctx, initial) => {
      int g=ctx.Population?.GenerationsNumber ?? 0;
      double t=(double)g/Math.Max(1,maxGen);
      return (float)(0.5*Math.Exp(-3.0*t));   // 0.5 -> ~0.025
  };
  return m; }

// Courbe continue du schedule de decroissance : p(g) = 0.5 * exp(-3 * g/G).
int G = NFE / PopSize;
double Decay(int g) => 0.5 * Math.Exp(-3.0 * (double)g / G);
var gAxis = Enumerable.Range(0, G + 1).Select(g => (double)g).ToArray();
var pCurve = gAxis.Select(g => Decay((int)g)).ToArray();

// 3 series sur axe X numerique partage (generation g) -> SvgChartHelper.Overlay (pattern canon #6927).
var series = new SvgSeries[]
{
    new SvgSeries("p(g) (probabilite de mutation)", gAxis, pCurve, TraceStyle.Line, "#4C72B0"),
    new SvgSeries("Exploration (debut, p=0.5)", new[] { 0.0 }, new[] { Decay(0) }, TraceStyle.Markers, "#DD8452"),
    new SvgSeries("Exploitation (fin, p~0.025)", new[] { (double)G }, new[] { Decay(G) }, TraceStyle.Markers, "#C44E52"),
};
display(SvgChartHelper.Overlay($"Schedule deterministe : p(g) = 0.5 * exp(-3 * g/G) (G={G})", "generation g", "p(g)", series));

Console.WriteLine($"Schedule deterministe p(g) = 0.5 * exp(-3 * g/G),  G=" + G);
Console.WriteLine($"  Exploration tot (p=0.5) -> Exploitation tard (p={Decay(G):F3}) : le mecanisme f(generation) est valide par la courbe.");

double decayObj=RunAvg(g=>BuildDecay(g), reqR, Seeds);
Console.WriteLine();
Console.WriteLine($"Rastrigin -- controle deterministe (decay) : objectif {decayObj:F3}");
Console.WriteLine($"  vs meilleur reglage fixe p={bestP:F2}      : objectif {bestFixed:F3}");
Console.WriteLine($"  => le deterministe {(decayObj < bestFixed ? "BAT" : "est competitif avec (a bruit pres)")} le meilleur fixe (delta {decayObj-bestFixed:+0.000;-0.000;0.000:F3}).");
Schedule deterministe : p(g) = 0.5 * exp(-3 * g/G) (G=100)-0.0040.1290.2620.3950.5290255075100generation gp(g)p(g) (probabilite de mutation)Exploration (debut, p=0.5)Exploitation (fin, p~0.025) 
Schedule deterministe p(g) = 0.5 * exp(-3 * g/G),  G=100
  Exploration tot (p=0.5) -> Exploitation tard (p=0,025) : le mecanisme f(generation) est valide par la courbe.

Rastrigin -- controle deterministe (decay) : objectif 12,332
  vs meilleur reglage fixe p=0,05      : objectif 11,885
  => le deterministe est competitif avec (a bruit pres) le meilleur fixe (delta +0,446).

Le decay est competitif avec le meilleur reglage fixe (a bruit pres, NFE=5000) — il ne le domine pas nettement. Ce n’est pas un echec du contrôle déterministe, mais un indice honnete : sur ce paysage et ce budget, un schedule simple n’apporte pas un avantage massif. Le contrôle qui dominera arrive au §4 (self-adaptatif). Ce que cette section etablit est surtout le mécanisme : DynamicProbability = f(generation) produit bien un taux continu decroissant (trace ci-dessus), et le moteur l’invoque reellement chaque generation.

3. Contrôle adaptatif — la diversite pilote le taux

Idee. Au lieu d’un schedule aveugle, on observe la population : si elle est convergee (faible diversite, tous concentres), on remonte la mutation pour forcer l’exploration. Si elle est diverse, on baisse la mutation pour laisser la convergence se faire. C’est le contrôle adaptatif : la variation est pilotee par un feedback.

C’est l’esprit de la celebre règle 1/5 de Rechenberg (1973) : on augmente le pas de mutation si plus d’un cinquieme des mutations ameliorent, on le diminue sinon. Ici on utilise un signal de diversite equivalent (ecart-type des genes), disponible dans le contexte d’evolution.

Le même DynamicProbability lit ctx.Population.CurrentGeneration.Chromosomes. Pour ne pas le recalculer a chaque evaluation, on le cache par generation (fermeture capturant un etat mutable).

Honestete anticipée. La valeur de l’adaptatif depend entierement de la qualite du signal de feedback. Notre signal (ecart-type du premier gene) est volontairement simple : il peut mal calibrer. C’est le defi central de l’adaptatif, pas un echec du concept.

// === CONTROL ADAPTATIF === diversite (ecart-type des genes) pilote le taux.
// faible diversite -> forte mutation (escape) ; forte diversite -> faible mutation (converge).
IMetaHeuristic BuildAdaptive((double lo,double hi) bounds)
{ var m=new DefaultMetaHeuristic();
  m.ProbabilityConfig.Mutation.Strategy=ProbabilityStrategy.TestProbability|ProbabilityStrategy.OverwriteProbability;
  double range=bounds.hi-bounds.lo;
  int cacheGen=-1; double cacheSd=range;   // etat de cache par generation (fermeture)
  m.ProbabilityConfig.Mutation.DynamicProbability=(ctx, initial) => {
      int g=ctx.Population?.GenerationsNumber ?? 0;
      if (g!=cacheGen)
      { cacheGen=g;
        var chroms=ctx.Population?.CurrentGeneration?.Chromosomes;
        var vals=(chroms??new System.Collections.Generic.List<IChromosome>())
                 .Select(c => { try { return ((DoubleArrayChromosome)c).GetDoubleValues()[0]; } catch { return double.NaN; } })
                 .Where(v => !double.IsNaN(v)).ToArray();
        cacheSd = vals.Length>=2 ? Math.Sqrt(vals.Average(v => { double d=v-vals.Average(); return d*d; })) : range;
      }
      double norm=Math.Min(1.0, cacheSd/(range*0.15));   // 1 = diverse, 0 = convergé
      return (float)(0.05 + 0.45*(1.0-norm));            // 0.05 (diverse) .. 0.50 (convergé)
  };
  return m; }

double adaptObj=RunAvg(g=>BuildAdaptive(KnownFunctionsBounds.For(typeof(RastriginFitness))), reqR, Seeds);
Console.WriteLine($"Rastrigin -- controle adaptatif (diversite) : objectif {adaptObj:F3}");
Console.WriteLine($"  vs deterministe (decay) {decayObj:F3}  | meilleur fixe {bestFixed:F3}");
Console.WriteLine("  Lecture : ici l'adaptatif SOUS-performe. Pourquoi ? Le signal de diversite (ecart-type");
Console.WriteLine("  du 1er gene) sous-mute au depart (population diverse -> p=0.05) puis sur-mute tard.");
Console.WriteLine("  => Leçon : la valeur de l'adaptatif tient a la QUALITE du signal (cf Exercice 2 : regle 1/5 par succes).");
Rastrigin -- controle adaptatif (diversite) : objectif 11,913
  vs deterministe (decay) 12,332  | meilleur fixe 11,885
  Lecture : ici l'adaptatif SOUS-performe. Pourquoi ? Le signal de diversite (ecart-type
  du 1er gene) sous-mute au depart (population diverse -> p=0.05) puis sur-mute tard.
  => Leçon : la valeur de l'adaptatif tient a la QUALITE du signal (cf Exercice 2 : regle 1/5 par succes).

4. Contrôle self-adaptatif — un taux par individu

Idee. Au lieu d’un taux unique pour toute la population, chaque individu porte son propre taux : certains explorent (taux eleve), d’autres exploitent (taux faible) — une population heterogene. C’est le contrôle self-adaptatif (Eiben) : le paramètre est attache a l’individu.

Le contexte d’evolution expose ctx.OriginalIndex — l’indice de l’individu cible dans la population. On l’utilise pour assigner un taux qui varie par individu (une grille reguliere sur [0.05, 0.5]).

Honestete. Le vrai self-adaptatif (Evolution Stratégies, Schwefel) encode le taux dans le chromosome : le taux mute et est selectionne avec la solution. Notre demo montre le mécanisme (paramètre par individu via le contexte) ; l’encodage chromosome est l’Exercice 3.

// === CONTROL SELF-ADAPTATIF === un taux par individu via ctx.OriginalIndex.
// Population heterogene : taux reparti sur [0.05, 0.50] selon l'indice de l'individu.
IMetaHeuristic BuildSelfAdaptive(int popSize)
{ var m=new DefaultMetaHeuristic();
  m.ProbabilityConfig.Mutation.Strategy=ProbabilityStrategy.TestProbability|ProbabilityStrategy.OverwriteProbability;
  m.ProbabilityConfig.Mutation.DynamicProbability=(ctx, initial) => {
      int idx=ctx.OriginalIndex;               // -1 au niveau population -> taux moyen
      if (idx<0) return 0.2f;
      double frac=(double)(idx % popSize)/popSize;
      return (float)(0.05 + 0.45*frac);         // 0.05 (individu 0) .. ~0.50 (individu popSize-1)
  };
  return m; }

double selfObj=RunAvg(g=>BuildSelfAdaptive(PopSize), reqR, Seeds);
Console.WriteLine($"Rastrigin -- controle self-adaptatif (heterogene) : objectif {selfObj:F3}");
Console.WriteLine($"  vs adaptatif {adaptObj:F3}  | deterministe {decayObj:F3}  | meilleur fixe {bestFixed:F3}");
Console.WriteLine("  => la population heterogene HEDGE : a chaque instant, une sous-population a le bon");
Console.WriteLine("     taux pour la phase courante. EliteSelection preserve le meilleur des deux mondes.");
Rastrigin -- controle self-adaptatif (heterogene) : objectif 9,944
  vs adaptatif 11,913  | deterministe 12,332  | meilleur fixe 11,885
  => la population heterogene HEDGE : a chaque instant, une sous-population a le bon
     taux pour la phase courante. EliteSelection preserve le meilleur des deux mondes.

L’heterogeneite hedger ses paris : au lieu de parier sur un seul taux, la population en essaie plusieurs en parallele. C’est aussi le pont vers les stratégies d’evolution (ES) et l’auto-adaptation ou le taux lui-même evolue.

// === COMPARAISON === Rastrigin (multimodal) vs Sphere (unimodal) — le spoiler honnete se confirme.
double rFix  =bestFixed;
double rDecay=RunAvg(g=>BuildDecay(g), reqR, Seeds);
double rAdapt=RunAvg(g=>BuildAdaptive(KnownFunctionsBounds.For(typeof(RastriginFitness))), reqR, Seeds);
double rSelf =RunAvg(g=>BuildSelfAdaptive(PopSize), reqR, Seeds);

double sFix  =RunAvg(g=>BuildFixed(bestP), reqS, Seeds);
double sDecay=RunAvg(g=>BuildDecay(g), reqS, Seeds);
double sAdapt=RunAvg(g=>BuildAdaptive(KnownFunctionsBounds.For(typeof(SphereFitness))), reqS, Seeds);
double sSelf =RunAvg(g=>BuildSelfAdaptive(PopSize), reqS, Seeds);

Console.WriteLine("=====================  COMPARAISON (moy 5 seeds, objectif : proche 0 = meilleur)  =====================");
Console.WriteLine("Strategie                | Rastrigin (multimodal) | Sphere (unimodal)");
Console.WriteLine("-------------------------|------------------------|------------------");
Console.WriteLine($"Reglage fixe p={bestP:F2}        | {rFix,18:F3}     | {sFix,12:F3}");
Console.WriteLine($"Controle deterministe    | {rDecay,18:F3}     | {sDecay,12:F3}");
Console.WriteLine($"Controle adaptatif       | {rAdapt,18:F3}     | {sAdapt,12:F3}");
Console.WriteLine($"Controle self-adaptatif  | {rSelf,18:F3}     | {sSelf,12:F3}");
Console.WriteLine("------------------------------------------------------------------------------------------------------");
Console.WriteLine("Lecture (le spoiler honnete se confirme) :");
Console.WriteLine("  - Rastrigin : le self-adaptatif gagne NETTEMENT (hedging) ; fixe/decay/adaptatif sont dans le bruit (~12).");
Console.WriteLine("  - Sphere    : l'ordre s'inverse : decay et fixe (peu de mutation) menent ; self-adaptatif dernier.");
Console.WriteLine("  => Aucune strategie ne domine sur les deux paysages : No-Free-Lunch au niveau du PARAMETRE.");
Console.WriteLine("     La mutation = exploration : elle aide multimodal (extraire optima locaux) et nuit unimodal (disrupte la convergence).");
Console.WriteLine("     Le decay decroit vite vers un taux bas (~0.025) : profil proche d'un fixe faible -> bon pour Sphere,");
Console.WriteLine("     timide pour Rastrigin. Le self-adaptatif pousse l'exploration au max -> l'effet inverse.");
=====================  COMPARAISON (moy 5 seeds, objectif : proche 0 = meilleur)  =====================
Strategie                | Rastrigin (multimodal) | Sphere (unimodal)
-------------------------|------------------------|------------------
Reglage fixe p=0,05        |             11,885     |        0,750
Controle deterministe    |             12,332     |        0,711
Controle adaptatif       |             11,913     |        0,931
Controle self-adaptatif  |              9,944     |        1,066
------------------------------------------------------------------------------------------------------
Lecture (le spoiler honnete se confirme) :
  - Rastrigin : le self-adaptatif gagne NETTEMENT (hedging) ; fixe/decay/adaptatif sont dans le bruit (~12).
  - Sphere    : l'ordre s'inverse : decay et fixe (peu de mutation) menent ; self-adaptatif dernier.
  => Aucune strategie ne domine sur les deux paysages : No-Free-Lunch au niveau du PARAMETRE.
     La mutation = exploration : elle aide multimodal (extraire optima locaux) et nuit unimodal (disrupte la convergence).
     Le decay decroit vite vers un taux bas (~0.025) : profil proche d'un fixe faible -> bon pour Sphere,
     timide pour Rastrigin. Le self-adaptatif pousse l'exploration au max -> l'effet inverse.

Lire le tableau : le prix et le gain du hedging

Le tableau ci-dessus merite une lecture chiffree, pas seulement l’ordre des lignes.

Le gain du self-adaptatif sur Rastrigin n’est pas dans le bruit. Les trois autres strategies s’etalent de 11,885 (fixe) a 12,332 (decay), soit un etalement de 0,447 ; le self-adaptatif descend a 9,944, un gain de 11,885 - 9,944 = 1,941 – environ 4,3 fois l’etalement du trio. C’est ce rapport qui distingue un vrai effet d’un rebond de moyenne.

Sur Sphere, le classement est monotone en exploration residuelle. decay (finit a p ~ 0,025) fait 0,711, le fixe (p = 0,05) 0,750, l’adaptatif (sur-mute tard, cf section 3) 0,931, le self-adaptatif (entretient des taux eleves) 1,066. Sur un paysage unimodal ou la mutation n’apporte rien, la tableau se lit comme une experience a un facteur : moins d’exploration residuelle = mieux, point par point.

L’asymetrie est le vrai resultat. Le hedge coute 1,066 - 0,711 = 0,355 sur Sphere (contre le decay, meilleur la-bas) et rapporte 12,332 - 9,944 = 2,388 sur Rastrigin, un ratio d’environ 6,7. En croyances : si la probabilite que le paysage soit multimodal depasse ~13 %, le self-adaptatif gagne en esperance contre le decay (et ~14 % contre le fixe). C’est une prime d’assurance basse : on paie 0,355 pour toucher 2,388.

Ce que le tableau ne mesure pas. Les valeurs sont des moyennes sur 5 seeds, mais aucune dispersion par seed n’est imprimee : le a bruit pres de la section 2 et le dans le bruit ci-dessus reposent sur l’etalement 0,447 du trio comme proxy, pas sur un ecart-type mesure. Et le delta +0,446 imprime plus haut se recompte 0,447 depuis le tableau (12,332 - 11,885) : arrondi d’affichage du calcul sur valeurs non arrondies, sans gravite mais a nommer.

Synthese — quand utiliser quelle stratégie ?

Stratégie Coute (en tuning) ? Adapte au paysage ? Adapte au cours du temps ? Quand l’utiliser
Reglage (fixe) faible (1 essai) non non Paysage facile/unimodal connu, baseline
Contrôle déterministe (schedule) moyen (forme du schedule) non oui (temps) Budget connu, mécanisme simple a calibrer
Contrôle adaptatif (feedback) moyen (signal) oui oui (etat) Budget inconnu, stagnation — si bon signal
Contrôle self-adaptatif (par individu) eleve (espace du taux) oui oui (individu) Paysage multimodal dur, hedging

La leçon centrale (No-Free-Lunch du paramètre). Même avec le contrôle, aucune stratégie ne domine universellement : le self-adaptatif gagne nettement sur Rastrigin (multimodal) mais perd sur Sphere (unimodal) ; le decay et le fixe (peu de mutation) font l’inverse. La mutation est le levier d’exploration — precieux quand le paysage regorge d’optima locaux (il faut s’extraire), nuisible quand il est convexe (il faut converger vite). Le paysage (cf MGS-15) dicte donc, la encore, le choix.

C’est la deuxieme reponse au No-Free-Lunch, en miroir de la sélection d’algorithme (MGS-16) :

Pas de bon algorithme universel -> on selectionne l’algorithme (MGS-16) et on contrôle ses paramètres (MGS-17). Mais le contrôle non plus n’est pas universel : le paysage reste souverain.

Exercice 1 : schedule lineaire vs exponentiel

Le schedule déterministe utilise ici une decroissance exponentielle. Implementez une decroissance lineaire p(g) = p_max * (1 - g/G) et comparez. Lequel convient mieux a Rastrigin ?

// Exercice 1 : schedule LINEAIRE p(g) = 0.5 * (1 - g/G)
// Indice : reprenez BuildDecay, remplacez Math.Exp(-3*t) par (1-t).
// Etape 1 : ecrire BuildLinear(int maxGen) avec DynamicProbability = (ctx,p) => (float)(0.5*(1 - g/G)).
// Etape 2 : lancer RunAvg(g=>BuildLinear(g), reqR, Seeds) et comparer a decayObj.

// TODO etudiant : implementer BuildLinear et afficher l'objectif.
double linearObj = 0.0; // TODO : remplacer par RunAvg(g=>BuildLinear(g), reqR, Seeds)
Console.WriteLine($"Exercice a completer : schedule lineaire (cf decay exponentiel = {decayObj:F3})");
Exercice a completer : schedule lineaire (cf decay exponentiel = 12,332)

Exercice 2 : la règle 1/5 de Rechenberg (adaptatif par succes)

Le contrôle adaptatif ci-dessus utilise la diversite comme signal — et sous-performe a cause d’un signal trop crude. La règle 1/5 (Rechenberg, 1973) utilise le taux de succes : la fraction des mutations qui ameliorent la fitness parent. - si > 1/5 : le pas est trop petit -> augmenter la mutation ; - si < 1/5 : le pas est trop grand -> diminuer.

Indice : il faut un etat mutable (fermeture) qui memorise le meilleur fitness de la generation précédente, et compare.

// Exercice 2 : regle 1/5 de Rechenberg
// Indice : fermeture capturant (int derniereGen, double meilleurFitness, float tauxCourant).
// Etape 1 : a chaque changement de generation, calculer le taux de succes (nb ameliorations / pop).
// Etape 2 : ajuster tauxCourant *= 1.1 si succes>0.2, *= 0.9 sinon (clamper [0.01, 0.6]).

// TODO etudiant : implementer BuildOneFifth() et comparer a l'adaptatif-diversite.
double oneFifthObj = 0.0; // TODO : remplacer par RunAvg(g=>BuildOneFifth(), reqR, Seeds)
Console.WriteLine($"Exercice a completer : regle 1/5 (cf adaptatif-diversite = {adaptObj:F3})");
Exercice a completer : regle 1/5 (cf adaptatif-diversite = 11,913)

Exercice 3 : taux encode dans le chromosome (vrai self-adaptatif)

La demo du §4 assigne un taux par indice. Le vrai self-adaptatif encode le taux dans le chromosome : le taux mute et est selectionne avec la solution.

Indice : etendez DoubleArrayChromosome avec un gene supplementaire sigma (le taux), mutez-le, et lisez-le dans DynamicProbability.

// Exercice 3 : chromosome a taux encode (Evolution Strategies)
// Indice : public class SelfAdaptiveChromosome : ChromosomeBase { double[] genes; double sigma; ... }
// Etape 1 : CreateNew tire sigma dans [0.01, 0.5] ; GenerateGene mute sigma aussi.
// Etape 2 : DynamicProbability lit le sigma du chromosome cible (cast dans BuildSelfAdaptive).
// Etape 3 : le fitness n'evalue que les `genes` (sigma est un parametre, pas une dimension).

// TODO etudiant : definir SelfAdaptiveChromosome et BuildSelfAdaptiveEncoded().
Console.WriteLine("Exercice a completer : taux encode dans le chromosome (vrai self-adaptatif ES).");
Exercice a completer : taux encode dans le chromosome (vrai self-adaptatif ES).

Exercice 4 : contrôler le CROSSOVER au lieu de la mutation

Toutes les demos controlent la mutation (le levier d’exploration). Le même mécanisme s’applique au crossover : ProbabilityConfig.Crossover.DynamicProbability. Par exemple, un crossover faible en debut (laisser la mutation explorer) puis fort en fin (exploiter par recombinaison).

// Exercice 4 : controle deterministe du CROSSOVER
// Indice : m.ProbabilityConfig.Crossover.Strategy = OverwriteProbability ;
//          m.ProbabilityConfig.Crossover.DynamicProbability = (ctx,p) => schedule(g) ;
// Attention : pour isoler l'effet, fixez aussi la mutation (BuildFixed) a un niveau bas.
// Question : sur Rastrigin, le crossover-control aide-t-il autant que le mutation-control ?

// TODO etudiant : implementer BuildCrossoverDecay() et comparer.
Console.WriteLine($"Exercice a completer : controle du crossover (cf mutation-control = {decayObj:F3}).");
Exercice a completer : controle du crossover (cf mutation-control = 12,332).

Conclusion

Concept Ce notebook
Taxonomie d’Eiben reglage (fixe) vs contrôle (déterministe / adaptatif / self-adaptatif)
Mécanisme du moteur ProbabilityConfig.{Mutation,Crossover}.DynamicProbability : Func<IEvolutionContext,float,float> + OverwriteProbability
Déterministe schedule f(generation) — explore tot, exploite tard — competitif, mécanisme simple
Adaptatif feedback de diversite — s’adapte, mais sensible a la qualite du signal
Self-adaptatif taux par individu via ctx.OriginalIndex — hedging, gagne sur multimodal
Leçon centrale No-Free-Launch du paramètre : aucune stratégie ne domine Rastrigin ET Sphere

Le contrôle de paramètres retire le pari du reglage fixe — mais n’offre pas de garantie universelle. La mutation etant le levier d’exploration, le contrôle aide quand l’exploration a de la valeur (paysage multimodal) et nuit quand elle n’en a pas (paysage unimodal). Le self-adaptatif emerge comme le champion du multimodal (hedging : la population essaie plusieurs taux en parallele) ; le decay et le fixe restent competitifs sans dominer. Combine a la sélection d’algorithme (MGS-16), le contrôle forme la reponse pragmatique au No-Free-Lunch : on choisit le bon moteur et on pilote ses reglages selon le paysage (decrit en MGS-15).

Limites honnetes

  • Aucune stratégie n’est universelle : le self-adaptatif (champion Rastrigin) est le pire sur Sphere. C’est le No-Free-Lunch, pas un defaut de implementation.
  • L’adaptatif depend de la qualite du signal de feedback ; un signal pauvre (notre ecart-type du 1er gene) le pousse a mal calibrer. Une règle 1/5 par succes (Exercice 2) est un meilleur signal.
  • Le vrai self-adaptatif (taux evolue) coute une dimension supplementaire dans l’espace de recherche (Exercice 3).
  • A NFE=5000, Rastrigin reste bruite (cf MGS-10/16) : les comparaisons sont moyennées sur 5 seeds et sont des tendances, pas des certitudes ; les ecarts types sont de l’ordre de 1-2 unites.

Pour aller plus loin

  • Eiben, Hinterding, Michalewicz (1999), Parameter Control in Evolutionary Algorithms — la taxonomie canonique.
  • Karafotias, Hoogendoorn, Eiben (2015), Parameter Control in Evolutionary Algorithms: A Tutorial.
  • Rechenberg (1973), Evolutionsstrategie — la règle 1/5.
  • Schwefel (1995), Evolution and Optimum Seeking — self-adaptation en ES.
  • Ponts : MGS-16 Sélection d’algorithme | MGS-15 Analyse de paysage | MGS-10 Biais central
Retour au sommet