Limited Nelder Mead with sigmoid

Author: Ícaro

pyduino/__init__.py

@@ -5,11 +5,14 @@
 load_dotenv()
 load_dotenv(dotenv_path=".env.local")
 
+log_file_path = os.environ.get('PYDUINO_SLAVE_LOG','/var/log/pyduino/slave.log')
+os.makedirs(os.path.dirname(log_file_path), exist_ok=True)
+
 logging.basicConfig(
     level=logging.DEBUG,
     format='%(asctime)s %(levelname)s %(message)s',
     handlers=[
-        logging.FileHandler(os.environ.get('PYDUINO_SLAVE_LOG','/var/log/pyduino/slave.log')),
+        logging.FileHandler(log_file_path),
         logging.StreamHandler()
     ]
 )

pyduino/optimization/nelder_mead.py

@@ -2,8 +2,13 @@
 from typing import Callable, List
 from . import Optimizer, linmap
 
+def sigmoid(x):
+    return 1 / (1 + np.exp(-x))
+def logit(x, inf=100):
+    return np.where(x==0, -inf, np.where(x==1, inf, np.log(x) - np.log(1-x)))
+
 class NelderMead(Optimizer):
-    def __init__(self, population_size: int, ranges: List[float], rng_seed: int = 0):
+    def __init__(self, population_size: int, ranges: List[float], rng_seed: int = 0, hypercube_radius = 100):
         """
         This Nelder-Mead algorithm assumes that the optimization function 'f' is to be minimized and time independent.
 
@@ -20,8 +25,9 @@ def __init__(self, population_size: int, ranges: List[float], rng_seed: int = 0)
         self.rng_seed = np.random.default_rng(rng_seed)
 
         # Derived attributes
-        self.invlinmap = linmap(self.ranges, np.array([[0, 1]] * len(self.ranges)))
-        self.linmap = linmap(np.array([[0, 1]] * len(self.ranges)), self.ranges)
+        self.a = 1/hypercube_radius
+        self.backward = lambda x: logit(linmap(self.ranges, np.array([[0, 1]] * len(self.ranges)))(x))/self.a
+        self.forward = lambda x: linmap(np.array([[0, 1]] * len(self.ranges)), self.ranges)(sigmoid(self.a * x))
 
         # Initialize the population (random position and initial momentum)
         self.population = self.rng_seed.random((self.population_size, len(self.ranges)))
@@ -33,19 +39,19 @@ def view(self, x):
         """
         Maps the input from the domain to the codomain.
         """
-        return self.linmap(x)
+        return self.forward(x)
 
     def view_g(self):
         """
         Maps the input from the domain to the codomain.
         """
-        return self.linmap(self.population)
+        return self.forward(self.population)
 
     def inverse_view(self, x):
         """
         Maps the input from the codomain to the domain.
         """
-        return self.invlinmap(x)
+        return self.backward(x)
 
     def ask_oracle(self, X: np.ndarray) -> np.ndarray:
         return super().ask_oracle()

tests/__init__.py

@@ -0,0 +1,3 @@
+import dotenv
+dotenv.load_dotenv()
+dotenv.load_dotenv(dotenv_path=".env.local")

tests/test_linmap.py

@@ -2,6 +2,9 @@
 import sys
 import os
 import numpy as np
+import dotenv
+dotenv.load_dotenv()
+dotenv.load_dotenv(dotenv_path=".env.local")
 
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 from pyduino.optimization import linmap

tests/test_optim.py

@@ -1,42 +1,61 @@
 import sys
 import os
 import numpy as np
+import dotenv
+import dotenv
+import pytest
+dotenv.load_dotenv()
+dotenv.load_dotenv(dotenv_path=".env.local")
 
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 from pyduino.optimization.nelder_mead import NelderMead
 
-def test_nelder_mead_parabola():
+class TestOptim:
     optimizer = NelderMead(population_size=10, ranges=[(-10, 10)] * 4)
-    class Oracle:
-        def ask(self, X):
-            return (X**2).sum(axis=1)
-    oracle = Oracle()
-    optimizer.ask_oracle = oracle.ask
-
-    # Set initial population to oracle
-    optimizer.init_oracle()
-
-    for i in range(100):
-        optimizer.step()
-    assert optimizer.view(optimizer.population).shape == (10, 4)
-    assert optimizer.view_g().shape == (10, 4)
-    assert optimizer.inverse_view(optimizer.view(optimizer.population)).shape == (10, 4)
-    assert np.isclose(optimizer.y.min(), 0, atol=1e-4), f"Oracle: {optimizer.y.min()}"
-
-def test_nelder_mead_rosenbrock():
-    optimizer = NelderMead(population_size=10, ranges=[(-10, 10)] * 4)
-    class Oracle:
-        def ask(self, X):
-            return ((1 - X[:, :-1])**2).sum(axis=1) + 100 * ((X[:, 1:] - X[:, :-1]**2)**2).sum(axis=1)
-    oracle = Oracle()
-    optimizer.ask_oracle = oracle.ask
-
-    # Set initial population to oracle
-    optimizer.init_oracle()
-
-    for i in range(1000):
-        optimizer.step()
-    assert optimizer.view(optimizer.population).shape == (10, 4)
-    assert optimizer.view_g().shape == (10, 4)
-    assert optimizer.inverse_view(optimizer.view(optimizer.population)).shape == (10, 4)
-    assert np.isclose(optimizer.y.min(), 0, atol=1e-4), f"Oracle: {optimizer.y.min()}"
+
+    def test_logic(self):
+        x = (2*np.random.random((10, 4))-1)*100
+
+        print("X")
+        print(x)
+        print("Forward -> Backward")
+        print(self.optimizer.backward(self.optimizer.forward(x)))
+
+        assert np.allclose(x, self.optimizer.backward(self.optimizer.forward(x)))
+        assert np.allclose(x, self.optimizer.inverse_view(self.optimizer.view(x)))
+
+        assert np.all(self.optimizer.backward(np.zeros((10,4))) < 1)
+
+    def test_nelder_mead_parabola(self):
+        class Oracle:
+            def ask(self, X):
+                return (X**2).sum(axis=1)
+        oracle = Oracle()
+        self.optimizer.ask_oracle = oracle.ask
+
+        # Set initial population to oracle
+        self.optimizer.init_oracle()
+
+        for i in range(100):
+            self.optimizer.step()
+        assert self.optimizer.view(self.optimizer.population).shape == (10, 4)
+        assert self.optimizer.view_g().shape == (10, 4)
+        assert self.optimizer.inverse_view(self.optimizer.view(self.optimizer.population)).shape == (10, 4)
+        assert np.isclose(self.optimizer.y.min(), 0, atol=1e-4), f"Oracle: {self.optimizer.y.min()}"
+
+    def test_nelder_mead_rosenbrock(self):
+        class Oracle:
+            def ask(self, X):
+                return ((1 - X[:, :-1])**2).sum(axis=1) + 100 * ((X[:, 1:] - X[:, :-1]**2)**2).sum(axis=1)
+        oracle = Oracle()
+        self.optimizer.ask_oracle = oracle.ask
+
+        # Set initial population to oracle
+        self.optimizer.init_oracle()
+
+        for i in range(1000):
+            self.optimizer.step()
+        assert self.optimizer.view(self.optimizer.population).shape == (10, 4)
+        assert self.optimizer.view_g().shape == (10, 4)
+        assert self.optimizer.inverse_view(self.optimizer.view(self.optimizer.population)).shape == (10, 4)
+        assert np.isclose(self.optimizer.y.min(), 0, atol=1e-4), f"Oracle: {self.optimizer.y.min()}"

tests/test_spectra.py

@@ -2,6 +2,9 @@
 import os
 import numpy as np
 import pandas as pd
+import dotenv
+dotenv.load_dotenv()
+dotenv.load_dotenv(dotenv_path=".env.local")
 
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 from pyduino.spectra import Spectra, PATHS

tests/test_utils.py

@@ -2,6 +2,9 @@
 import os
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 from pyduino.utils import get_param
+import dotenv
+dotenv.load_dotenv()
+dotenv.load_dotenv(dotenv_path=".env.local")
 
 def test_get_param():
     # Test case 1: No IDs provided