add pytest

Author: nomuramasahir0

.circleci/config.yml

@@ -0,0 +1,11 @@
+machine:
+  python:
+    version: 3.5.0
+
+dependencies:
+  pre:
+    - pip install -r ./requirements.txt
+
+test:
+  override:
+    - pytest

crfmnes/alg.py

@@ -32,14 +32,6 @@ def sort_indices_by(evals, z):
     return sorted_indices
 
 
-def calc_constraint_violation(x, lamb):
-    constraint_violation = np.zeros(lamb)
-    for i in range(lamb):
-        for j in range(x[:, i].size):
-            constraint_violation[i] += (-min(0.0, x[:, i][j]) + max(0.0, x[:, i][j] - 1.0)) * 1e5
-    return constraint_violation
-
-
 class CRFMNES:
     def __init__(self, dim, f, m, sigma, lamb, **kwargs):
 
@@ -55,7 +47,7 @@ def __init__(self, dim, f, m, sigma, lamb, **kwargs):
         self.D = np.ones([dim, 1])
         self.constraint = kwargs.get('constraint', [[- np.inf, np.inf] for _ in range(dim)])
         self.penalty_coef = kwargs.get('penalty_coef', 1e5)
-        self.use_constraint_violation = True
+        self.use_constraint_violation = kwargs.get('use_constraint_violation', True)
 
         self.w_rank_hat = (np.log(self.lamb / 2 + 1) - np.log(np.arange(1, self.lamb + 1))).reshape(self.lamb, 1)
         self.w_rank_hat[np.where(self.w_rank_hat < 0)] = 0
@@ -95,12 +87,12 @@ def calc_violations(self, x):
         violations = np.zeros(self.lamb)
         for i in range(self.lamb):
             for j in range(self.dim):
-                violations[i] += (- min(0, x[j][i] - self.constraint[j][0]) + max(0, x[j][i] - self.constraint[j][
-                    1])) * self.penalty_coef
+                violations[i] += (- min(0, x[j][i] - self.constraint[j][0]) + max(0, x[j][i] - self.constraint[j][1])) * self.penalty_coef
         return violations
 
     def optimize(self, iterations):
         for _ in range(iterations):
+            # print("f_best:{}".format(self.f_best))
             _ = self.one_iteration()
         return self.x_best, self.f_best
 
@@ -120,7 +112,7 @@ def one_iteration(self):
 
         violations = np.zeros(lamb)
         if self.use_constraint_violation:
-            violations = calc_constraint_violation(x, self.lamb)
+            violations = self.calc_violations(x)
             sorted_indices = sort_indices_by(evals_no_sort + violations, self.z)
         else:
             sorted_indices = sort_indices_by(evals_no_sort, self.z)
@@ -172,7 +164,7 @@ def one_iteration(self):
         b = -(1 - alphavd ** 2) * normv4 / gammav + 2 * alphavd ** 2
         H = np.ones([self.dim, 1]) * 2 - (b + 2 * alphavd ** 2) * vbarbar  # dim x 1
         invH = H ** (-1)
-        s_step1 = yy - normv2 / gammav * (yvbar * ip_yvbar) + np.ones([self.dim, self.lamb + 1])  # dim x lamb+1
+        s_step1 = yy - normv2 / gammav * (yvbar * ip_yvbar) - np.ones([self.dim, self.lamb + 1])  # dim x lamb+1
         ip_vbart = vbar.T @ t  # 1 x lamb+1
         s_step2 = s_step1 - alphavd / gammav * ((2 + normv2) * (t * vbar) - normv2 * vbarbar @ ip_vbart)  # dim x lamb+1
         invHvbarbar = invH * vbarbar
@@ -194,7 +186,7 @@ def one_iteration(self):
         # update s, D
         G_s = np.sum((self.z * self.z - np.ones([self.dim, self.lamb])) @ weights) / self.dim
         l_s = 1.0 if ps_norm >= self.chiN and G_s < 0 else 0.0
-        self.sigma = self.sigma * np.exp((1 - l_s) * eta_sigma / 2 * G_s) * nthrootdetAold
+        self.sigma = self.sigma * np.exp((1 - l_s) * eta_sigma / 2 * G_s) * nthrootdetA / nthrootdetAold
         self.D = self.D / nthrootdetA
 
         return xs_no_sort, evals_no_sort, violations

examples/demo_sphere.py

@@ -6,15 +6,16 @@
 
 
 def sphere(x):
+    x = x.reshape(-1)
     return np.sum(x**2)
 
 
 def main():
-    dim = 3
+    dim = 40
     mean = np.ones([dim, 1]) * 2
     sigma = 0.5
-    lamb = 6 # note that lamb (sample size) should be even number
-    iteration_number = 100
+    lamb = 16 # note that lamb (sample size) should be even number
+    iteration_number = 500
 
     cr = CRFMNES(dim, sphere, mean, sigma, lamb)
     x_best, f_best = cr.optimize(iteration_number)

requirements.txt

@@ -0,0 +1,2 @@
+numpy==1.15.2
+pytest==3.9.1

tests/__init__.py

@@ -0,0 +1 @@
+import crfmnes

tests/test_constraint_sphere.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from crfmnes import CRFMNES
+
+
+def const_sphere(x):
+    x = x.reshape(-1)
+    if np.sum(x < 0) > 0:
+        return np.inf
+    return np.sum(x**2)
+
+
+def test_run_d40_const_sphere():
+    print("test_run_d40:")
+    dim = 40
+    mean = np.ones([dim, 1]) * 10
+    sigma = 2.0
+    lamb = 16 # note that lamb (sample size) should be even number
+    allowable_evals = (19.4 + 1.1*3) * 1e3 # 2 sigma
+    iteration_number = int(allowable_evals / lamb) + 1
+
+    cr = CRFMNES(dim, const_sphere, mean, sigma, lamb)
+    x_best, f_best = cr.optimize(iteration_number)
+    print("f_best:{}".format(f_best))
+    assert f_best < 1e-12
+
+
+def test_run_d80_const_sphere():
+    print("test_run_d80:")
+    dim = 80
+    mean = np.ones([dim, 1]) * 10
+    sigma = 2.0
+    lamb = 32 # note that lamb (sample size) should be even number
+    allowable_evals = (48.8 + 1.4*3) * 1e3 # 2 sigma
+    iteration_number = int(allowable_evals / lamb) + 1
+
+    cr = CRFMNES(dim, const_sphere, mean, sigma, lamb)
+    x_best, f_best = cr.optimize(iteration_number)
+    print("f_best:{}".format(f_best))
+    assert f_best < 1e-12

tests/test_ellipsoid.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from crfmnes import CRFMNES
+
+
+def ellipsoid(x):
+    x = x.reshape(-1)
+    dim = len(x)
+    return np.sum([(1000**(i / (dim-1)) * x[i])**2 for i in range(dim)])
+
+
+def test_run_d40_ellipsoid():
+    print("test_run_d40:")
+    dim = 40
+    mean = np.ones([dim, 1]) * 3
+    sigma = 2.0
+    lamb = 16 # note that lamb (sample size) should be even number
+    allowable_evals = (8.8 + 0.5*3) * 1e3 # 2 sigma
+    iteration_number = int(allowable_evals / lamb) + 1
+
+    cr = CRFMNES(dim, ellipsoid, mean, sigma, lamb, use_constraint_violation=False)
+    x_best, f_best = cr.optimize(iteration_number)
+    print("f_best:{}".format(f_best))
+    assert f_best < 1e-12
+
+
+def test_run_d80_ellipsoid():
+    print("test_run_d80:")
+    dim = 80
+    mean = np.ones([dim, 1]) * 3
+    sigma = 2.0
+    lamb = 16 # note that lamb (sample size) should be even number
+    allowable_evals = (17.5 + 0.6*3) * 1e3 # 2 sigma
+    iteration_number = int(allowable_evals / lamb) + 1
+
+    cr = CRFMNES(dim, ellipsoid, mean, sigma, lamb, use_constraint_violation=False)
+    x_best, f_best = cr.optimize(iteration_number)
+    print("f_best:{}".format(f_best))
+    assert f_best < 1e-12

tests/test_ktablet.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from crfmnes import CRFMNES
+
+
+def ktablet(x):
+    x = x.reshape(-1)
+    dim = len(x)
+    k = int(dim / 4)
+    return np.sum(x[0:k]**2) + np.sum((100*x[k:dim])**2)
+
+
+def test_run_d40_ktablet():
+    print("test_run_d40:")
+    dim = 40
+    mean = np.ones([dim, 1]) * 3
+    sigma = 2.0
+    lamb = 16 # note that lamb (sample size) should be even number
+    allowable_evals = (9.1 + 0.6*3) * 1e3 # 2 sigma
+    iteration_number = int(allowable_evals / lamb) + 1
+
+    cr = CRFMNES(dim, ktablet, mean, sigma, lamb)
+    x_best, f_best = cr.optimize(iteration_number)
+    print("f_best:{}".format(f_best))
+    assert f_best < 1e-12
+
+
+def test_run_d80_ktablet():
+    print("test_run_d80:")
+    dim = 80
+    mean = np.ones([dim, 1]) * 3
+    sigma = 2.0
+    lamb = 16 # note that lamb (sample size) should be even number
+    allowable_evals = (18.6 + 0.8*3) * 1e3 # 2 sigma
+    iteration_number = int(allowable_evals / lamb) + 1
+
+    cr = CRFMNES(dim, ktablet, mean, sigma, lamb)
+    x_best, f_best = cr.optimize(iteration_number)
+    print("f_best:{}".format(f_best))
+    assert f_best < 1e-12

tests/test_rastrigin.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from crfmnes import CRFMNES
+import math
+
+
+def rastrigin(x):
+    x = x.reshape(-1)
+    dim = len(x)
+    return 10.0 * dim + np.sum([x[i] ** 2 - 10.0 * math.cos(2.0 * math.pi * x[i]) for i in range(dim)])
+
+
+def test_run_d40_rastrigin():
+    print("test_run_d40:")
+    dim = 40
+    mean = np.ones([dim, 1]) * 3
+    sigma = 2.0
+    lamb = 1130 # note that lamb (sample size) should be even number
+    allowable_evals = (148 + 8.8*3) * 1e3 # 2 sigma
+    iteration_number = int(allowable_evals / lamb) + 1
+
+    cr = CRFMNES(dim, rastrigin, mean, sigma, lamb, use_constraint_violation=False)
+    x_best, f_best = cr.optimize(iteration_number)
+    print("f_best:{}".format(f_best))
+    assert f_best < 1e-12
+
+
+def test_run_d80_rastrigin():
+    print("test_run_d80:")
+    dim = 80
+    mean = np.ones([dim, 1]) * 3
+    sigma = 2.0
+    lamb = 1600 # note that lamb (sample size) should be even number
+    allowable_evals = (296 + 8.0*3) * 1e3 # 2 sigma
+    iteration_number = int(allowable_evals / lamb) + 1
+
+    cr = CRFMNES(dim, rastrigin, mean, sigma, lamb, use_constraint_violation=False)
+    x_best, f_best = cr.optimize(iteration_number)
+    print("f_best:{}".format(f_best))
+    assert f_best < 1e-12

tests/test_rosenbrock_chain.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from crfmnes import CRFMNES
+
+
+def rosenbrock_chain(x):
+    x = x.reshape(-1)
+    return np.sum(100.0*(x[1:] - x[:-1]**2)**2 + (1-x[:-1])**2)
+
+def test_run_d40_rosen():
+    print("test_run_d40:")
+    dim = 40
+    mean = np.zeros([dim, 1])
+    sigma = 2.0
+    lamb = 40 # note that lamb (sample size) should be even number
+    allowable_evals = (52.2 + 1.5*3) * 1e3 # 2 sigma
+    iteration_number = int(allowable_evals / lamb) + 1
+
+    cr = CRFMNES(dim, rosenbrock_chain, mean, sigma, lamb)
+    x_best, f_best = cr.optimize(iteration_number)
+    print("f_best:{}".format(f_best))
+    assert f_best < 1e-12
+
+
+def test_run_d80_rosen():
+    print("test_run_d80:")
+    dim = 80
+    mean = np.zeros([dim, 1])
+    sigma = 2.0
+    lamb = 64 # note that lamb (sample size) should be even number
+    allowable_evals = (192 + 2.0*3) * 1e3 # 2 sigma
+    iteration_number = int(allowable_evals / lamb) + 1
+
+    cr = CRFMNES(dim, rosenbrock_chain, mean, sigma, lamb)
+    x_best, f_best = cr.optimize(iteration_number)
+    print("f_best:{}".format(f_best))
+    assert f_best < 1e-12