weights

Author: jacobdenobel

include/restart_criteria.hpp

@@ -119,7 +119,7 @@ namespace restart
 
 	struct TolX : Criterion
 	{
-		static inline Float tolerance = 10e-12;
+		static inline Float tolerance = 1e-12;
 		Vector tolx_vector;
 		TolX() : Criterion("TolX") {}
 		void update(const parameters::Parameters& p) override;

include/settings.hpp

@@ -25,9 +25,11 @@ namespace parameters
 		std::optional<Float> cc;
 		std::optional<Float> cmu;
 		std::optional<Float> c1;
+		std::optional<Float> damps;
 		bool verbose;
 		Float volume;
 		bool one_plus_one;
+		bool reformulated_learning_rate;
 
 		Settings(size_t dim,
 			std::optional<Modules> mod = std::nullopt,
@@ -44,8 +46,10 @@ namespace parameters
 			std::optional<Float> cc = std::nullopt,
 			std::optional<Float> cmu = std::nullopt,
 			std::optional<Float> c1 = std::nullopt,
+			std::optional<Float> damps = std::nullopt,
 			bool verbose = true,
-			bool always_compute_eigv = false
+			bool always_compute_eigv = false,
+			bool reformulated_learning_rate = false
 		) : dim(dim),
 			modules(mod.value_or(Modules())),
 			target(target),
@@ -61,9 +65,11 @@ namespace parameters
 			cc(cc),
 			cmu(cmu),
 			c1(c1),
+			damps(damps),
 			verbose(verbose),
 			volume(0.0),
-			one_plus_one(false)
+			one_plus_one(false),
+			reformulated_learning_rate(reformulated_learning_rate)
 		{
 			if (modules.mirrored == Mirror::PAIRWISE and lambda0 % 2 != 0)
 				lambda0++;

scripts/matrix/get_data.py

@@ -13,21 +13,51 @@
 np.random.seed(12)
 
 DIMS = 2, 3, 5, 10, 20, 40, #100
-FUNCTIONS = [3, 4, 5, 7] + list(range(15, 25)) #[1, 2, 6, 8, 9, 10, 11, 12, 13, 14]
+FUNCTIONS = [13] #[3, 4, 5, 7] + list(range(15, 25)) #[1, 2, 6, 8, 9, 10, 11, 12, 13, 14]
 N_REPEATS = 100
 BUDGET = 100_000
 ROOT = "data"
 
 
+def ert(runs, target = 1e-8):
+    total_evals = 0
+    n_suc = 0
+    for row in runs:
+        total_evals += row['evals']
+        if row['best_y'] <= target:
+            n_suc += 1
+
+    if n_suc <= 0:
+        return float("inf")
+    return total_evals / n_suc
+
 def run_modma(problem: ioh.ProblemType, 
               x0: np.ndarray, 
               logger_obj,
               matrix_adaptation = modcma.options.COVARIANCE
             ):
     modules = modcma.parameters.Modules()
     modules.matrix_adaptation = matrix_adaptation
+    modules.ssa = modcma.options.StepSizeAdaptation.CSA
     modules.restart_strategy = modcma.options.RestartStrategy.STOP
 
+    options = pycma.CMAOptions()
+    options['CMA_active'] = False
+    options["verbose"] = -1
+    options["CMA_diagonal"] = False
+    options["CSA_squared"] = False
+    options['conditioncov_alleviate'] = False
+    options['ftarget'] = problem.optimum.y + 1e-8
+    options['maxfevals'] = problem.meta_data.n_variables * BUDGET
+
+    pcma = pycma.CMAEvolutionStrategy(x0, 2.0, options=options)
+    problem2 = ioh.get_problem(problem.meta_data.problem_id, 1, problem.meta_data.n_variables)
+
+    while not pcma.stop():
+        X, y = pcma.ask_and_eval(problem2)
+        pcma.tell(X, y)
+        break
+
     settings = modcma.Settings(
         problem.meta_data.n_variables, 
         x0=x0,
@@ -37,10 +67,16 @@ def run_modma(problem: ioh.ProblemType,
         verbose=True,
         sigma0=2.0,
         target=problem.optimum.y + 1e-8,
-        budget=problem.meta_data.n_variables * BUDGET
+        budget=problem.meta_data.n_variables * BUDGET,
+        cs=pcma.adapt_sigma.cs,
+        c1=pcma.sp.c1,
+        cc=pcma.sp.cc,
+        cmu=pcma.sp.cmu,
     )
-    
+
+
     cma = modcma.ModularCMAES(settings)
+    cma.p.weights.damps = pcma.adapt_sigma.damps
 
     start = perf_counter()
     while not cma.break_conditions():
@@ -51,7 +87,18 @@ def run_modma(problem: ioh.ProblemType,
     if cma.p.criteria.any():
         logger_obj.update(cma.p.criteria.items)
 
-    cma.run(problem)
+    # print("modcma")
+    # print(cma.p.mutation.sigma)
+    # print(cma.p.adaptation.C)
+    # print(cma.p.pop.f)
+    # print(cma.p.criteria.reason())
+    # print(problem.state)
+    # print("\npycma")
+    # print(pcma.sigma)
+    # print(pcma.sm.C)
+    # print(problem2.state)
+    
+    # cma.run(problem)
     stop = perf_counter()
     elapsed = stop - start
     return elapsed, cma.p.stats.t, problem.state.evaluations, cma.p.stats.n_updates
@@ -91,12 +138,16 @@ def collect(name, option):
         for d in DIMS:
             problem = ioh.get_problem(fid, 1, d)
             problem.attach_logger(logger)
+            runs = []
             for i in range(N_REPEATS):
                 modcma.utils.set_seed(21 + fid * d * i)
                 collector.reset()
                 run_modma(problem, np.zeros(d), collector, option)
-                print(name, fid, d, problem.state.current_best_internal.y, problem.state.evaluations)
+                # print(name, fid, d, problem.state.current_best_internal.y, problem.state.evaluations)
+                runs.append(dict(evals=problem.state.evaluations, best_y=problem.state.current_best_internal.y))
                 problem.reset()
+            print("ert:", ert(runs))
+            print()
 
 def collect_modcma():
     options = modcma.options.MatrixAdaptationType.__members__
@@ -159,10 +210,12 @@ def collect_pycma():
 
 
 if __name__ == "__main__":
-    p1 = Process(target=collect_modcma)
-    p2 = Process(target=collect_pycma)
+    # p1 = Process(target=collect_modcma)
+    # p2 = Process(target=collect_pycma)
+
+    # p1.start()
+    # p2.start()
+    # p1.join()
+    # p2.join()
 
-    p1.start()
-    p2.start()
-    p1.join()
-    p2.join()
+    collect("COVARIANCE-2", modcma.options.MatrixAdaptationType.COVARIANCE)

scripts/matrix/plots.ipynb

@@ -606,7 +606,7 @@ void define_parameters(py::module& main)
 			std::optional<size_t>, std::optional<size_t>, std::optional<Vector>,
 			std::optional<Vector>, std::optional<Vector>,
 			std::optional<Float>, std::optional<Float>, std::optional<Float>,
-			std::optional<Float>, bool, bool>(),
+			std::optional<Float>, std::optional<Float>, bool, bool, bool>(),
 			py::arg("dim"),
 			py::arg("modules") = std::nullopt,
 			py::arg("target") = std::nullopt,
@@ -622,8 +622,11 @@ void define_parameters(py::module& main)
 			py::arg("cc") = std::nullopt,
 			py::arg("cmu") = std::nullopt,
 			py::arg("c1") = std::nullopt,
+			py::arg("damps") = std::nullopt,
 			py::arg("verbose") = false,
-			py::arg("always_compute_eigv") = false
+			py::arg("always_compute_eigv") = false,
+			py::arg("reformulated_learning_rate") = false
+
 		)
 		.def_readonly("dim", &Settings::dim)
 		.def_readonly("modules", &Settings::modules)
@@ -640,8 +643,11 @@ void define_parameters(py::module& main)
 		.def_readwrite("cc", &Settings::cc)
 		.def_readwrite("cmu", &Settings::cmu)
 		.def_readwrite("c1", &Settings::c1)
+		.def_readwrite("damps", &Settings::damps)
 		.def_readwrite("verbose", &Settings::verbose)
 		.def_readonly("volume", &Settings::volume)
+		.def_readonly("one_plus_one", &Settings::one_plus_one)
+		.def_readonly("reformulated_learning_rate", &Settings::reformulated_learning_rate)
 		.def("__repr__", [] (Settings& settings)
 			{
 				std::stringstream ss;

src/interface.cpp

@@ -61,7 +61,10 @@ namespace mutation
 		const Population& old_pop, const parameters::Stats& stats, const size_t lambda)
 
 	{
-		sigma *= std::exp((w.cs / w.damps) * ((adaptation->ps.norm() / w.expected_length_z) - 1));
+		Float l = (w.cs / w.damps) * ((adaptation->ps.norm() / w.expected_length_z) - 1);
+		// Clamping as seen in pycma
+		l = std::min(Float{1.0}, std::max(l, Float{-1.0}));
+		sigma *= std::exp(l);
 	}
 
 

src/mutation.cpp

@@ -123,7 +123,7 @@ namespace parameters
 		cmu = settings.cmu.value_or(get_default_cmu(settings, d, mueff, c1));
 		cs = settings.cs.value_or(get_default_cs(settings, mueff, d));
 		cc = settings.cmu.value_or(get_default_cc(settings, d, mueff, cs));
-		damps = get_default_damps(settings, mueff, d, cs);
+		damps = settings.damps.value_or(get_default_damps(settings, mueff, d, cs));
 
 		sqrt_cs_mueff = std::sqrt(cs * (2.0 - cs) * mueff);
 		sqrt_cc_mueff = std::sqrt(cc * (2.0 - cc) * mueff);