Add MOO xp variants (#1004)

* MOO variants

* Update experiments.py

* better_alignment

* better_doc

* fix

nevergrad/benchmark/experiments.py

@@ -1532,48 +1532,71 @@ def double_o_seven(seed: tp.Optional[int] = None) -> tp.Iterator[Experiment]:
 
 
 @registry.register
-def multiobjective_example(seed: tp.Optional[int] = None) -> tp.Iterator[Experiment]:
+def multiobjective_example(
+    seed: tp.Optional[int] = None, hd: bool = False, many: bool = False
+) -> tp.Iterator[Experiment]:
     """Optimization of 2 and 3 objective functions in Sphere, Ellipsoid, Cigar, Hm.
     Dimension 6 and 7.
     Budget 100 to 3200
     """
     seedg = create_seed_generator(seed)
-    optims: tp.List[tp.Any] = [
-        "NaiveTBPSA",
-        "PSO",
-        "DE",
-        "LhsDE",
-        "RandomSearch",
-        "NGO",
-        "Shiwa",
-        "DiagonalCMA",
-        "CMA",
-        "OnePlusOne",
-        "TwoPointsDE",
-        "NGOpt10",
-    ]
+    optims = get_optimizers("structure", "structured_moo", seed=next(seedg))
     optims += [
         ng.families.DifferentialEvolution(multiobjective_adaptation=False).set_name("DE-noadapt"),
         ng.families.DifferentialEvolution(crossover="twopoints", multiobjective_adaptation=False).set_name(
             "TwoPointsDE-noadapt"
         ),
     ]
+    optims += ["DiscreteOnePlusOne", "DiscreteLenglerOnePlusOne"]
+    popsizes = [20, 40, 80]
+    optims += [
+        ng.families.EvolutionStrategy(
+            recombination_ratio=recomb, only_offsprings=only, popsize=pop, offsprings=pop * 5
+        )
+        for only in [True, False]
+        for recomb in [0.1, 0.5]
+        for pop in popsizes
+    ]
+
     mofuncs: tp.List[fbase.MultiExperiment] = []
+    dim = 2000 if hd else 7
     for name1, name2 in itertools.product(["sphere"], ["sphere", "hm"]):
         mofuncs.append(
             fbase.MultiExperiment(
-                [ArtificialFunction(name1, block_dimension=7), ArtificialFunction(name2, block_dimension=7)],
-                upper_bounds=[100, 100],
+                [
+                    ArtificialFunction(name1, block_dimension=dim),
+                    ArtificialFunction(name2, block_dimension=dim),
+                ]
+                + (
+                    [
+                        ArtificialFunction(name1, block_dimension=dim),  # Addendum for many-objective optim.
+                        ArtificialFunction(name2, block_dimension=dim),
+                    ]
+                    if many
+                    else []
+                ),
+                upper_bounds=[100, 100] * (2 if many else 1),
             )
         )
         mofuncs.append(
             fbase.MultiExperiment(
                 [
-                    ArtificialFunction(name1, block_dimension=6),
-                    ArtificialFunction("sphere", block_dimension=6),
-                    ArtificialFunction(name2, block_dimension=6),
-                ],
-                upper_bounds=[100, 100, 100.0],
+                    ArtificialFunction(name1, block_dimension=dim - 1),
+                    ArtificialFunction("sphere", block_dimension=dim - 1),
+                    ArtificialFunction(name2, block_dimension=dim - 1),
+                ]
+                + (
+                    [
+                        ArtificialFunction(
+                            name1, block_dimension=dim - 1
+                        ),  # Addendum for many-objective optim.
+                        ArtificialFunction("sphere", block_dimension=dim - 1),
+                        ArtificialFunction(name2, block_dimension=dim - 1),
+                    ]
+                    if many
+                    else []
+                ),
+                upper_bounds=[100, 100, 100.0] * (2 if many else 1),
             )
         )
     for mofunc in mofuncs:
@@ -1583,6 +1606,24 @@ def multiobjective_example(seed: tp.Optional[int] = None) -> tp.Iterator[Experim
                     yield Experiment(mofunc, optim, budget=budget, num_workers=nw, seed=next(seedg))
 
 
+@registry.register
+def multiobjective_example_hd(seed: tp.Optional[int] = None) -> tp.Iterator[Experiment]:
+    """Counterpart of moo with high dimension."""
+    return multiobjective_example(seed, hd=True)
+
+
+@registry.register
+def multiobjective_example_many_hd(seed: tp.Optional[int] = None) -> tp.Iterator[Experiment]:
+    """Counterpart of moo with high dimension and more objective functions."""
+    return multiobjective_example(seed, hd=True, many=True)
+
+
+@registry.register
+def multiobjective_example_many(seed: tp.Optional[int] = None) -> tp.Iterator[Experiment]:
+    """Counterpart of moo with more objective functions."""
+    return multiobjective_example(seed, many=True)
+
+
 @registry.register
 def pbt(seed: tp.Optional[int] = None) -> tp.Iterator[Experiment]:
     # prepare list of parameters to sweep for independent variables