def test_user_function_wrapper_callable_single_output():
function = lambda x: 2 * x
function_input = np.array([[1], [2], [3]])
ufw = UserFunctionWrapper(function)
evaluated_output = ufw.evaluate(function_input)
called_output = ufw(function_input)
assert len(evaluated_output) == len(called_output)
assert all(eo == co for (eo, co) in zip(evaluated_output, called_output))
def test_user_function_wrapper_evaluation_single_output():
function = lambda x: 2 * x
function_input = np.array([[1], [2], [3]])
ufw = UserFunctionWrapper(function)
output = ufw.evaluate(function_input)
assert len(output) == function_input.shape[0]
for i, record in enumerate(output):
assert_array_equal(output[i].X, function_input[i])
assert_array_equal(output[i].Y, function(function_input[i]))
def test_user_function_wrapper():
def function_test(x):
return x[:, 0:1]**2 + x[:, 1:2]**2
user_function = UserFunctionWrapper(function_test)
results = user_function.evaluate(np.random.rand(10, 2))
assert len(results) == 10, "A different number of results were expected"
for res in results:
assert res.X.ndim == 1, "X results are expected to be 1 dimensional"
assert res.Y.ndim == 1, "Y results are expected to be 1 dimensional"
def test_user_function_wrapper_evaluation_with_cost():
function = lambda x: (2 * x, np.array([[1]] * x.shape[0]))
function_input = np.array([[1], [2], [3]])
ufw = UserFunctionWrapper(function, extra_output_names=['cost'])
output = ufw.evaluate(function_input)
assert len(output) == function_input.shape[0]
for i, record in enumerate(output):
assert_array_equal(output[i].X, function_input[i])
assert_array_equal(output[i].Y, function(function_input[i])[0])
assert_array_equal(output[i].cost, function(function_input[i])[1][0])
def test_user_function_wrapper_evaluation_no_cost():
function = lambda x: 2 * x
function_input = np.array([[1], [2], [3]])
ufw = UserFunctionWrapper(function)
output = ufw.evaluate(function_input)
assert len(output) == function_input.shape[0]
for i, record in enumerate(output):
assert_array_equal(output[i].X, function_input[i])
assert_array_equal(output[i].Y, function(function_input[i]))
assert output[i].cost is None
def test_user_function_wrapper_invalid_input():
# invalid input
with pytest.raises(ValueError):
function = lambda x: 2 * x
function_input = np.array([1])
ufw = UserFunctionWrapper(function)
ufw.evaluate(function_input)
# invalid function output
with pytest.raises(ValueError):
function = lambda x: np.array([2])
function_input = np.array([[1]])
ufw = UserFunctionWrapper(function)
ufw.evaluate(function_input)
# invalid function output type
with pytest.raises(ValueError):
function = lambda x: [2]
function_input = np.array([[1]])
ufw = UserFunctionWrapper(function)
ufw.evaluate(function_input)
def test_user_function_wrapper_invalid_input():
# invalid input
with pytest.raises(ValueError):
function = lambda x: 2 * x
function_input = np.array([1])
ufw = UserFunctionWrapper(function)
ufw.evaluate(function_input)
# invalid function output
with pytest.raises(ValueError):
function = lambda x: np.array([2])
function_input = np.array([[1]])
ufw = UserFunctionWrapper(function)
ufw.evaluate(function_input)
# invalid function output type
with pytest.raises(ValueError):
function = lambda x: [2]
function_input = np.array([[1]])
ufw = UserFunctionWrapper(function)
ufw.evaluate(function_input)
def test_user_function_too_few_outputs_outputs_fails():
function = lambda x: 2 * x
function_input = np.array([[1], [2], [3]])
ufw = UserFunctionWrapper(function, extra_output_names=['cost'])
with pytest.raises(ValueError):
ufw.evaluate(function_input)
def test_user_function_too_many_outputs_outputs_fails():
function = lambda x: (2 * x, np.array([1]))
function_input = np.array([[1], [2], [3]])
ufw = UserFunctionWrapper(function)
with pytest.raises(ValueError):
ufw.evaluate(function_input)