def test_2():
"""This function tests that the BLACKBOX results are unaffected by the size of the batch."""
d, box, n, m, batch, strategy = get_valid_request()
rslt_base = None
for batch in range(1, 5):
rslt = search(rosen, box, n, m, batch, strategy)
if rslt_base is None:
rslt_base = rslt
np.testing.assert_almost_equal(rslt, rslt_base)
def test_3():
"""This function tests that the results line up with the original algorithm."""
# Unfortunately, there will be small differences when using the FORTRAN implementation
# of selected functions. However, this test always passes when the PYTHON versions are
# used. I test all implementations against each other in other tests and as the interface
# is identical, I am confident that the discrepancies here are only due to small numerical
# differences in the PYTHON and FORTRAN calculations that accumulate if all are used at once.
open(PYTHON_FNAME, 'a').close()
d, box, n, m, batch, strategy = get_valid_request()
np.random.seed(123)
alg_original = bb_search(rosen, box, n, m, batch, resfile='output.csv')
alg_revised = search(rosen, box, n, m, batch, strategy, legacy=True)
np.testing.assert_almost_equal(alg_original, alg_revised)
os.remove(PYTHON_FNAME)
def test_5():
"""This test function ensures that the results are unaffected by using either the FORTRAN or
PYTHON function."""
d, box, n, m, batch, strategy = get_valid_request()
rslt_base = None
for is_python in [True, False]:
if is_python:
open(PYTHON_FNAME, 'a').close()
rslt = search(rosen, box, n, m, batch, strategy)
if rslt_base is None:
rslt_base = rslt
np.testing.assert_almost_equal(rslt, rslt_base)
if os.path.exists(PYTHON_FNAME):
os.remove(PYTHON_FNAME)
def test_4():
"""This test function compares the output from the F2PY functions to their PYTHON
counterparts."""
for _ in range(100):
d, _, n, _, _, _ = get_valid_request()
points = np.random.uniform(size=(n, d + 1))
points[:, 0:-1] = latin(n, d)
mat, eval_points = np.identity(d), np.random.rand(d)
lam, b, a = rbf(points, mat)
k = np.random.choice(range(n))
r = np.random.uniform()
x = np.random.uniform(size=d)
rslts_base = None
for is_python in [True, False]:
if is_python:
open(PYTHON_FNAME, 'a').close()
rslts = list()
rslts.append(fit_full(lam, b, a, mat, points[:, 0:-1],
eval_points))
rslts.append(constraint_full(points, r, k, x))
rslts.append(get_capital_phi(points[:, 0:-1], mat, n, d))
rslts.append(spread(points[:, 0:-1], n, d))
if os.path.exists(PYTHON_FNAME):
os.remove(PYTHON_FNAME)
if rslts_base is None:
rslts_base = rslts
for i, rslt in enumerate(rslts):
np.testing.assert_almost_equal(rslt, rslts_base[i])
if os.path.exists(PYTHON_FNAME):
os.remove(PYTHON_FNAME)
def test_8():
"""This test function compares the output from the F2PY functions to their PYTHON
counterparts. These are only used in the FORTRAN codes and only exposed through F2PY for
testing purposes."""
for _ in range(100):
d, _, n, _, _, _ = get_valid_request()
points = np.random.uniform(size=(n, d + 1))
points[:, 0:-1] = latin(n, d)
mat, eval_points = np.identity(d), np.random.rand(d)
lam, b, a = rbf(points, mat)
# We test the derivative calculation of the criterion function.
args = [lam, b, a, mat, points[:, :-1]]
pyth = approx_fprime(eval_points,
partial(pyth_fit_full, *args),
epsilon=1e-6)
fort = replacements_f2py.f2py_derivative_function(
eval_points, *args + [n, d])
np.testing.assert_almost_equal(fort, pyth)
import os
from scipy.optimize import rosen
import numpy as np
from blackbox.tests.auxiliary import get_valid_request
from blackbox import search
import blackbox
is_creation = False
if is_creation:
num_tests = 100
tests = []
for seed in range(num_tests):
request = [rosen] + list(get_valid_request())[1:]
rslt = search(*request)
tests.append([request, rslt])
pkl.dump(tests, open('regression_vault.blackbox.pkl', 'wb'))
# TODO: These are only working on heracles at the moment, portability is still an issue.
FNAME_VAULT = os.path.dirname(
blackbox.__file__) + '/tests/material/regression_vault.blackbox.pkl'
for i, test in enumerate(pkl.load(open(FNAME_VAULT, 'rb'))):
print(" running test " + str(i))
request, rslt = test
stat = search(*request)
np.testing.assert_equal(rslt, stat)
# pyth = approx_fprime(x, fit_partial, epsilon=1e-6)
# fort = replacements_f2py.f2py_derivative_function(x, lam, b, a, T, points[:, :-1], n, d)
#
# # replacements_f2py.f2py_derivative_constraints(points[:, :-1], r, x, n, d)
#
#
# np.testing.assert_almost_equal(fort, pyth)
#
# raise SystemExit('.. exit for now')
import scipy
np.random.seed(123)
for _ in range(0):
print(_)
d, _, n, _, _, _ = get_valid_request()
points = np.random.uniform(size=(n, d + 1))
points[:, 0:-1] = latin(n, d)
#d = points.shape[1] - 1
#n = points.shape[0]
r = np.random.uniform() + 0.01
mat, start = np.identity(d), np.random.rand(d)
lam, b, a = rbf(points, mat)
T = mat
cons = list()
for k in range(n):
constraint = partial(constraint_full, points, r, k)
cons.append(constraint)