0.14.31

Author: bartzbeielstein

pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spotpython"
-version = "0.14.30"
+version = "0.14.31"
 authors = [
   { name="T. Bartz-Beielstein", email="tbb@bartzundbartz.de" }
 ]

test/test_add_core_model_to_fun_control.py

@@ -1,17 +1,11 @@
-import pytest
 from spotPython.light.regression.netlightregression import NetLightRegression
 from spotPython.utils.init import fun_control_init
 from spotPython.hyperdict.light_hyper_dict import LightHyperDict
 from spotPython.hyperparameters.values import add_core_model_to_fun_control
 
+
 def test_add_core_model_to_fun_control():
     fun_control = fun_control_init()
-    add_core_model_to_fun_control(core_model=NetLightRegression,
-                                fun_control=fun_control,
-                                hyper_dict=LightHyperDict)
+    add_core_model_to_fun_control(core_model=NetLightRegression, fun_control=fun_control, hyper_dict=LightHyperDict)
     assert fun_control["core_model"].__name__ == "NetLightRegression"
     assert isinstance(fun_control["core_model_hyper_dict"], dict)
-
-
-if __name__ == "__main__":
-    pytest.main(["-v", __file__])

test/test_aggregate_mean_var.py

@@ -19,14 +19,15 @@ def test_aggregate_mean_var_var():
     """
     import numpy as np
     from spotPython.utils.aggregate import aggregate_mean_var
-    X_1 = np.ones((2,3))
+
+    X_1 = np.ones((2, 3))
     y_1 = np.sum(X_1, axis=1)
     y_2 = 2 * y_1
-    X_2 = np.append(X_1, 2*X_1, axis=0)
+    X_2 = np.append(X_1, 2 * X_1, axis=0)
     X = np.append(X_2, X_1, axis=0)
     y = np.append(y_1, y_2, axis=0)
     y = np.append(y, y_2, axis=0)
-    Z = aggregate_mean_var(X,y)
-    assert (Z[0] == np.array([[1., 1., 1.],[2., 2., 2.]])).all()
-    assert (Z[1] == np.array([4.5, 6. ])).all()
-    assert (Z[2] == np.array([3., 0.])).all()
+    Z = aggregate_mean_var(X, y)
+    assert (Z[0] == np.array([[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]])).all()
+    assert (Z[1] == np.array([4.5, 6.0])).all()
+    assert (Z[2] == np.array([3.0, 0.0])).all()

test/test_branin.py

@@ -4,24 +4,24 @@ def test_branin():
     """
     from spotPython.fun.objectivefunctions import analytical
     import numpy as np
+
     pi = np.pi
     # some value, e.g. at 0,0:
     X_0 = np.array([[0, 0]])
     # there are 3 min values: disregarding rounding errors, they
     # should be the same for the following three points:
     X_1 = np.array([[-pi, 12.275], [pi, 2.275], [9.42478, 2.475]])
-    # first of the three points should be identical to X_0, the 
+    # first of the three points should be identical to X_0, the
     # other two should be shifted by 10 in y-direction (plus and minus)
-    X_2 = np.array([[0,0,0], [0,0,1], [0,0,2]])
+    X_2 = np.array([[0, 0, 0], [0, 0, 1], [0, 0, 2]])
     fun = analytical()
     y_0 = fun.fun_branin(X_0)
     y_1 = fun.fun_branin(X_1)
     y_2 = fun.fun_branin_factor(X_2)
 
-    assert round(y_1[0], 2) == round(y_1[1],2)
-    assert round(y_1[0], 2) == round(y_1[2],2)
+    assert round(y_1[0], 2) == round(y_1[1], 2)
+    assert round(y_1[0], 2) == round(y_1[2], 2)
 
     assert (y_2[0] == y_0)[0]
     assert (y_2[1] == y_0 + 10)[0]
     assert (y_2[2] == y_0 - 10)[0]
-    

test/test_build_Psi.py

@@ -5,54 +5,49 @@ def test_build_Psi():
     from spotPython.build.kriging import Kriging
     import numpy as np
     import copy
-    import matplotlib.pyplot as plt
-    from numpy import append, ndarray, multiply, isinf, linspace, meshgrid, ravel, argmin
-    from numpy import ones, zeros, arange, log, var, float64
-    from numpy import spacing, empty_like
+    from numpy import argmin
+    from numpy import ones, zeros, log, var, float64
+    from numpy import empty_like
     from numpy import array
     from spotPython.design.spacefilling import spacefilling
-    import spotPython
     from spotPython.fun.objectivefunctions import analytical
     from spotPython.spot import spot
     from spotPython.utils.repair import repair_non_numeric
-    from spotPython.utils.init import fun_control_init, optimizer_control_init, surrogate_control_init, design_control_init
+    from spotPython.utils.init import (
+        fun_control_init,
+        surrogate_control_init,
+        design_control_init,
+    )
 
     # number of points:
     ni = 7
 
     fun = analytical().fun_sphere
     fun_control = fun_control_init(
-        lower = np.array([-1,-1]),
-        upper = np.array([1,1]),
-        fun_evals = 25, 
-        noise = False,
-        log_level = 50)
-    design_control= design_control_init(init_size=ni)
+        lower=np.array([-1, -1]), upper=np.array([1, 1]), fun_evals=25, noise=False, log_level=50
+    )
+    design_control = design_control_init(init_size=ni)
     surrogate_control = surrogate_control_init()
 
     # Spot: to generate initial design
-    S_spot = spot.Spot(fun=fun,
-                fun_control=fun_control,
-                design_control=design_control, 
-                surrogate_control=surrogate_control)
+    S_spot = spot.Spot(
+        fun=fun, fun_control=fun_control, design_control=design_control, surrogate_control=surrogate_control
+    )
 
-    X = S_spot.generate_design(size=S_spot.design_control["init_size"],
-                               repeats=S_spot.design_control["repeats"],
-                               lower=S_spot.lower, 
-                               upper=S_spot.upper)
+    X = S_spot.generate_design(
+        size=S_spot.design_control["init_size"],
+        repeats=S_spot.design_control["repeats"],
+        lower=S_spot.lower,
+        upper=S_spot.upper,
+    )
     X = repair_non_numeric(X, S_spot.var_type)
     # (S-3): Eval initial design:
     y = fun(X)
     S_spot.min_y = min(y)
     S_spot.min_X = X[argmin(y)]
     # Kriging:
 
-
-    S = Kriging(name='kriging',
-                seed=124, 
-                n_theta=2, 
-                noise=True, 
-                cod_type="norm")
+    S = Kriging(name="kriging", seed=124, n_theta=2, noise=True, cod_type="norm")
     S.nat_X = copy.deepcopy(X)
     S.nat_y = copy.deepcopy(y)
     S.n = S.nat_X.shape[0]
@@ -62,7 +57,7 @@ def test_build_Psi():
     # assume all variable types are "num" if "num" is
     # specified once:
     if len(S.var_type) == 1:
-        S.var_type = S.var_type * S.k    
+        S.var_type = S.var_type * S.k
     S.num_mask = array(list(map(lambda x: x == "num", S.var_type)))
     S.factor_mask = array(list(map(lambda x: x == "factor", S.var_type)))
     S.int_mask = array(list(map(lambda x: x == "int", S.var_type)))
@@ -86,25 +81,21 @@ def test_build_Psi():
     S.Lambda = None
     # build_Psi() and build_U() are called in fun_likelihood
     S.set_de_bounds()
-    if S.model_optimizer.__name__ == 'dual_annealing':
-        result = S.model_optimizer(func=S.fun_likelihood,
-                                        bounds=S.de_bounds)
-    elif S.model_optimizer.__name__ == 'differential_evolution':
-        result = S.model_optimizer(func=S.fun_likelihood,
-                                        bounds=S.de_bounds,
-                                        maxiter=S.model_fun_evals,
-                                        seed=S.seed)
-    elif S.model_optimizer.__name__ == 'direct':
-        result = S.model_optimizer(func=S.fun_likelihood,
-                                        bounds=S.de_bounds,
-                                        # maxfun=S.model_fun_evals,
-                                        eps=1e-2)
-    elif S.model_optimizer.__name__ == 'shgo':
-        result = S.model_optimizer(func=S.fun_likelihood,
-                                        bounds=S.de_bounds)
-    elif S.model_optimizer.__name__ == 'basinhopping':
-        result = S.model_optimizer(func=S.fun_likelihood,
-                                        x0=S.min_X)
+    if S.model_optimizer.__name__ == "dual_annealing":
+        result = S.model_optimizer(func=S.fun_likelihood, bounds=S.de_bounds)
+    elif S.model_optimizer.__name__ == "differential_evolution":
+        result = S.model_optimizer(func=S.fun_likelihood, bounds=S.de_bounds, maxiter=S.model_fun_evals, seed=S.seed)
+    elif S.model_optimizer.__name__ == "direct":
+        result = S.model_optimizer(
+            func=S.fun_likelihood,
+            bounds=S.de_bounds,
+            # maxfun=S.model_fun_evals,
+            eps=1e-2,
+        )
+    elif S.model_optimizer.__name__ == "shgo":
+        result = S.model_optimizer(func=S.fun_likelihood, bounds=S.de_bounds)
+    elif S.model_optimizer.__name__ == "basinhopping":
+        result = S.model_optimizer(func=S.fun_likelihood, x0=S.min_X)
     else:
         result = S.model_optimizer(func=S.fun_likelihood, bounds=S.de_bounds)
     # Finally, set new theta and p values and update the surrogate again
@@ -115,4 +106,3 @@ def test_build_Psi():
     assert S.Psi.shape[0] == ni
     assert S.Psi.shape[1] == ni
     assert (S.Psi == S.Psi.T).all()
-    

test/test_build_U.py

@@ -5,49 +5,43 @@ def test_build_U():
     from spotPython.build.kriging import Kriging
     import numpy as np
     import copy
-    import matplotlib.pyplot as plt
-    from numpy import append, ndarray, multiply, isinf, linspace, meshgrid, ravel, argmin
-    from numpy import ones, zeros, arange, log, var, float64
-    from numpy import spacing, empty_like
+    from numpy import argmin
+    from numpy import ones, zeros, log, var, float64
+    from numpy import empty_like
     from numpy import array
     from spotPython.design.spacefilling import spacefilling
-    import spotPython
     from spotPython.fun.objectivefunctions import analytical
     from spotPython.spot import spot
     from spotPython.utils.repair import repair_non_numeric
-    from spotPython.utils.init import fun_control_init, optimizer_control_init, surrogate_control_init, design_control_init
+    from spotPython.utils.init import (
+        fun_control_init,
+        design_control_init,
+    )
 
     # number of points:
     ni = 7
 
     fun = analytical().fun_sphere
     fun_control = fun_control_init(
-        lower = np.array([-1,-1]),
-        upper = np.array([1,1]),
-        fun_evals = 25, 
-        noise = False,
-        log_level = 50)
-    design_control= design_control_init(init_size=ni)
+        lower=np.array([-1, -1]), upper=np.array([1, 1]), fun_evals=25, noise=False, log_level=50
+    )
+    design_control = design_control_init(init_size=ni)
     # Spot: to generate initial design
-    S_spot = spot.Spot(fun=fun,
-                fun_control=fun_control,
-                design_control=design_control)
+    S_spot = spot.Spot(fun=fun, fun_control=fun_control, design_control=design_control)
 
-    X = S_spot.generate_design(size=S_spot.design_control["init_size"],
-                               repeats=S_spot.design_control["repeats"],
-                               lower=S_spot.lower, 
-                               upper=S_spot.upper)
+    X = S_spot.generate_design(
+        size=S_spot.design_control["init_size"],
+        repeats=S_spot.design_control["repeats"],
+        lower=S_spot.lower,
+        upper=S_spot.upper,
+    )
     X = repair_non_numeric(X, S_spot.var_type)
     # (S-3): Eval initial design:
     y = fun(X)
     S_spot.min_y = min(y)
     S_spot.min_X = X[argmin(y)]
     # Kriging:
-    S = Kriging(name='kriging',
-                seed=124, 
-                n_theta=2, 
-                noise=True, 
-                cod_type="norm")
+    S = Kriging(name="kriging", seed=124, n_theta=2, noise=True, cod_type="norm")
     S.nat_X = copy.deepcopy(X)
     S.nat_y = copy.deepcopy(y)
     S.n = S.nat_X.shape[0]
@@ -57,7 +51,7 @@ def test_build_U():
     # assume all variable types are "num" if "num" is
     # specified once:
     if len(S.var_type) == 1:
-        S.var_type = S.var_type * S.k    
+        S.var_type = S.var_type * S.k
     S.num_mask = array(list(map(lambda x: x == "num", S.var_type)))
     S.factor_mask = array(list(map(lambda x: x == "factor", S.var_type)))
     S.int_mask = array(list(map(lambda x: x == "int", S.var_type)))
@@ -81,25 +75,21 @@ def test_build_U():
     S.Lambda = None
     # build_Psi() and build_U() are called in fun_likelihood
     S.set_de_bounds()
-    if S.model_optimizer.__name__ == 'dual_annealing':
-        result = S.model_optimizer(func=S.fun_likelihood,
-                                        bounds=S.de_bounds)
-    elif S.model_optimizer.__name__ == 'differential_evolution':
-        result = S.model_optimizer(func=S.fun_likelihood,
-                                        bounds=S.de_bounds,
-                                        maxiter=S.model_fun_evals,
-                                        seed=S.seed)
-    elif S.model_optimizer.__name__ == 'direct':
-        result = S.model_optimizer(func=S.fun_likelihood,
-                                        bounds=S.de_bounds,
-                                        # maxfun=S.model_fun_evals,
-                                        eps=1e-2)
-    elif S.model_optimizer.__name__ == 'shgo':
-        result = S.model_optimizer(func=S.fun_likelihood,
-                                        bounds=S.de_bounds)
-    elif S.model_optimizer.__name__ == 'basinhopping':
-        result = S.model_optimizer(func=S.fun_likelihood,
-                                        x0=S.min_X)
+    if S.model_optimizer.__name__ == "dual_annealing":
+        result = S.model_optimizer(func=S.fun_likelihood, bounds=S.de_bounds)
+    elif S.model_optimizer.__name__ == "differential_evolution":
+        result = S.model_optimizer(func=S.fun_likelihood, bounds=S.de_bounds, maxiter=S.model_fun_evals, seed=S.seed)
+    elif S.model_optimizer.__name__ == "direct":
+        result = S.model_optimizer(
+            func=S.fun_likelihood,
+            bounds=S.de_bounds,
+            # maxfun=S.model_fun_evals,
+            eps=1e-2,
+        )
+    elif S.model_optimizer.__name__ == "shgo":
+        result = S.model_optimizer(func=S.fun_likelihood, bounds=S.de_bounds)
+    elif S.model_optimizer.__name__ == "basinhopping":
+        result = S.model_optimizer(func=S.fun_likelihood, x0=S.min_X)
     else:
         result = S.model_optimizer(func=S.fun_likelihood, bounds=S.de_bounds)
     # Finally, set new theta and p values and update the surrogate again
@@ -109,4 +99,4 @@ def test_build_U():
     S.build_Psi()
     S.build_U()
     assert S.U.shape[0] == ni
-    assert S.U.shape[1] == ni
+    assert S.U.shape[1] == ni

test/test_build_psi_vec.py

@@ -5,26 +5,17 @@ def test_build_psi_vec():
     import numpy as np
     from spotPython.build.kriging import Kriging
 
-    X_train = np.array([[1., 2.],
-                        [2., 4.],
-                        [3., 6.]])
-    y_train = np.array([1., 2., 3.])
+    X_train = np.array([[1.0, 2.0], [2.0, 4.0], [3.0, 6.0]])
+    y_train = np.array([1.0, 2.0, 3.0])
 
-    S = Kriging(name='kriging',
-                seed=123,
-                log_level=50,
-                n_theta=1,
-                noise=False,
-                cod_type="norm")
+    S = Kriging(name="kriging", seed=123, log_level=50, n_theta=1, noise=False, cod_type="norm")
     S.fit(X_train, y_train)
 
     # force theta to simple values:
     S.theta = np.array([0.0])
-    cod_x = np.array([1., 0.])
+    cod_x = np.array([1.0, 0.0])
     S.psi = np.zeros((S.n, 1))
     S.build_psi_vec(cod_x)
-    res = np.array([[np.exp(-4)],
-        [np.exp(-17)],
-        [np.exp(-40)]])
+    res = np.array([[np.exp(-4)], [np.exp(-17)], [np.exp(-40)]])
 
     assert np.array_equal(S.psi, res)

test/test_california_housing.py

@@ -6,14 +6,11 @@ def test_california_housing():
     dataset = CaliforniaHousing()
 
     # Expected outputs
-    expected_names = [
-        'MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population',
-        'AveOccup', 'Latitude', 'Longitude'
-    ]
+    expected_names = ["MedInc", "HouseAge", "AveRooms", "AveBedrms", "Population", "AveOccup", "Latitude", "Longitude"]
     expected_length = 20640
 
     # Assert if get_names() returns the correct feature names
     assert dataset.get_names() == expected_names, "The feature names do not match the expected values."
 
     # Assert if the length of the dataset is correct
-    assert len(dataset) == expected_length, "The length of the dataset does not match the expected value."
+    assert len(dataset) == expected_length, "The length of the dataset does not match the expected value."