def test_check_input_invalid_type_of_inputs(type_of_inputs):
"""Tests that an invalid type of inputs in check_inputs raises an error."""
with pytest.raises(ValueError) as e:
check_input([[0.2, 2.1], [0.2, .8]], type_of_inputs=type_of_inputs)
msg = ("Unknown value {} for type_of_inputs. Valid values are "
"'classic' or 'tuples'.".format(type_of_inputs))
assert str(e.value) == msg
def test_check_input_invalid_type_of_inputs(type_of_inputs):
"""Tests that an invalid type of inputs in check_inputs raises an error."""
with pytest.raises(ValueError) as e:
check_input([[0.2, 2.1], [0.2, .8]], type_of_inputs=type_of_inputs)
msg = ("Unknown value {} for type_of_inputs. Valid values are "
"'classic' or 'tuples'.".format(type_of_inputs))
assert str(e.value) == msg
def test_check_tuples_valid_with_preprocessor(tuples):
"""Test that valid inputs when using a preprocessor raises no warning"""
with pytest.warns(None) as record:
check_input(tuples,
type_of_inputs='tuples',
preprocessor=mock_preprocessor)
assert len(record) == 0
def test_check_classic_valid_with_preprocessor(points):
"""Test that valid inputs when using a preprocessor raises no warning"""
with pytest.warns(None) as record:
check_input(points,
type_of_inputs='classic',
preprocessor=mock_preprocessor)
assert len(record) == 0
def test_check_classic_invalid_dtype_not_convertible(preprocessor, points):
"""Checks that a value error is thrown if attempting to convert an
input not convertible to float
"""
with pytest.raises(ValueError):
check_input(points, type_of_inputs='classic',
preprocessor=preprocessor, dtype=np.float64)
def test_check_classic_invalid_dtype_not_convertible(preprocessor, points):
"""Checks that a value error is thrown if attempting to convert an
input not convertible to float
"""
with pytest.raises(ValueError):
check_input(points, type_of_inputs='classic',
preprocessor=preprocessor, dtype=np.float64)
def test_check_tuples_invalid_dtype_not_convertible_without_preprocessor():
"""Checks that a value error is thrown if attempting to convert an
input not convertible to float, when using no preprocessor
"""
tuples = np.full_like(tuples_no_prep(), 'a', dtype=object)
with pytest.raises(ValueError):
check_input(tuples, type_of_inputs='tuples',
preprocessor=None, dtype=np.float64)
def test_check_input_invalid_tuples_without_preprocessor(wrong_labels):
pairs = np.random.RandomState(42).randn(5, 2, 3)
expected_msg = ("When training on pairs, the labels (y) should contain "
"only values in [-1, 1]. Found an incorrect value.")
with pytest.raises(ValueError) as raised_error:
check_input(pairs, wrong_labels, preprocessor=None,
type_of_inputs='tuples')
assert str(raised_error.value) == expected_msg
def test_check_tuples_invalid_dtype_not_convertible_without_preprocessor():
"""Checks that a value error is thrown if attempting to convert an
input not convertible to float, when using no preprocessor
"""
tuples = np.full_like(tuples_no_prep(), 'a', dtype=object)
with pytest.raises(ValueError):
check_input(tuples, type_of_inputs='tuples',
preprocessor=None, dtype=np.float64)
def test_check_input_invalid_tuples_without_preprocessor(wrong_labels):
pairs = np.random.RandomState(42).randn(5, 2, 3)
expected_msg = ("When training on pairs, the labels (y) should contain "
"only values in [-1, 1]. Found an incorrect value.")
with pytest.raises(ValueError) as raised_error:
check_input(pairs, wrong_labels, preprocessor=None,
type_of_inputs='tuples')
assert str(raised_error.value) == expected_msg
def test_check_classic_invalid_complex_data():
"""Checks that the right error message is thrown if given complex data (
this comes from sklearn's check_array's message)"""
points = np.array([[[1 + 2j, 3 + 4j], [5 + 7j, 5 + 7j]],
[[1 + 3j, 2 + 4j], [5 + 8j, 1 + 7j]]])
msg = ("Complex data not supported\n" "{}\n".format(points))
with pytest.raises(ValueError) as raised_error:
check_input(points, type_of_inputs='classic')
assert str(raised_error.value) == msg
def test_check_classic_invalid_complex_data():
"""Checks that the right error message is thrown if given complex data (
this comes from sklearn's check_array's message)"""
points = np.array([[[1 + 2j, 3 + 4j], [5 + 7j, 5 + 7j]],
[[1 + 3j, 2 + 4j], [5 + 8j, 1 + 7j]]])
msg = ("Complex data not supported\n"
"{}\n".format(points))
with pytest.raises(ValueError) as raised_error:
check_input(points, type_of_inputs='classic')
assert str(raised_error.value) == msg
def test_check_input_invalid_tuples_with_preprocessor(wrong_labels):
n_samples, n_features, n_pairs = 10, 4, 5
rng = np.random.RandomState(42)
pairs = rng.randint(10, size=(n_pairs, 2))
preprocessor = rng.randn(n_samples, n_features)
expected_msg = ("When training on pairs, the labels (y) should contain "
"only values in [-1, 1]. Found an incorrect value.")
with pytest.raises(ValueError) as raised_error:
check_input(pairs, wrong_labels, preprocessor=ArrayIndexer(preprocessor),
type_of_inputs='tuples')
assert str(raised_error.value) == expected_msg
def test_check_input_invalid_tuples_with_preprocessor(wrong_labels):
n_samples, n_features, n_pairs = 10, 4, 5
rng = np.random.RandomState(42)
pairs = rng.randint(10, size=(n_pairs, 2))
preprocessor = rng.randn(n_samples, n_features)
expected_msg = ("When training on pairs, the labels (y) should contain "
"only values in [-1, 1]. Found an incorrect value.")
with pytest.raises(ValueError) as raised_error:
check_input(pairs, wrong_labels, preprocessor=ArrayIndexer(preprocessor),
type_of_inputs='tuples')
assert str(raised_error.value) == expected_msg
def test_check_tuples_valid_tuple_size(tuple_size):
"""For inputs that have the right matrix dimension (2D or 3D for instance),
checks that checking the number of tuples (pairs, quadruplets, etc) raises
no warning if there is the right number of points in a tuple.
"""
with pytest.warns(None) as record:
check_input(tuples_prep(), type_of_inputs='tuples',
preprocessor=mock_preprocessor, tuple_size=tuple_size)
check_input(tuples_no_prep(), type_of_inputs='tuples', preprocessor=None,
tuple_size=tuple_size)
assert len(record) == 0
def test_check_tuples_valid_tuple_size(tuple_size):
"""For inputs that have the right matrix dimension (2D or 3D for instance),
checks that checking the number of tuples (pairs, quadruplets, etc) raises
no warning if there is the right number of points in a tuple.
"""
with pytest.warns(None) as record:
check_input(tuples_prep(), type_of_inputs='tuples',
preprocessor=mock_preprocessor, tuple_size=tuple_size)
check_input(tuples_no_prep(), type_of_inputs='tuples', preprocessor=None,
tuple_size=tuple_size)
assert len(record) == 0
def test_check_tuples_invalid_dtype_not_convertible_with_preprocessor():
"""Checks that a value error is thrown if attempting to convert an
input not convertible to float, when using a preprocessor
"""
def preprocessor(indices):
# preprocessor that returns objects
return np.full((indices.shape[0], 3), 'a')
with pytest.raises(ValueError):
check_input(tuples_prep(), type_of_inputs='tuples',
preprocessor=preprocessor, dtype=np.float64)
def test_check_classic_invalid_n_features(estimator, context):
"""Checks that the right warning is printed if not enough features
Here we only test if no preprocessor (otherwise we don't ensure this)
"""
msg = ("Found array with 2 feature(s) (shape={}) while"
" a minimum of 3 is required{}.".format(points_no_prep().shape,
context))
with pytest.raises(ValueError) as raised_error:
check_input(points_no_prep(), type_of_inputs='classic',
preprocessor=None, ensure_min_features=3,
estimator=estimator)
assert str(raised_error.value) == msg
def test_check_tuples_invalid_dtype_not_convertible_with_preprocessor():
"""Checks that a value error is thrown if attempting to convert an
input not convertible to float, when using a preprocessor
"""
def preprocessor(indices):
# preprocessor that returns objects
return np.full((indices.shape[0], 3), 'a')
with pytest.raises(ValueError):
check_input(tuples_prep(), type_of_inputs='tuples',
preprocessor=preprocessor, dtype=np.float64)
def test_check_classic_invalid_n_features(estimator, context):
"""Checks that the right warning is printed if not enough features
Here we only test if no preprocessor (otherwise we don't ensure this)
"""
msg = ("Found array with 2 feature(s) (shape={}) while"
" a minimum of 3 is required{}.".format(points_no_prep().shape,
context))
with pytest.raises(ValueError) as raised_error:
check_input(points_no_prep(), type_of_inputs='classic',
preprocessor=None, ensure_min_features=3,
estimator=estimator)
assert str(raised_error.value) == msg
def test_check_tuples_invalid_n_samples(estimator, context, load_tuples,
preprocessor):
"""Checks that the right warning is printed if n_samples is too small"""
tuples = load_tuples()
msg = ("Found array with 2 sample(s) (shape={}) while a minimum of 3 "
"is required{}.".format((preprocess_tuples(tuples, preprocessor)
if (preprocessor is not None and
tuples.ndim == 2) else tuples).shape,
context))
with pytest.raises(ValueError) as raised_error:
check_input(tuples, type_of_inputs='tuples',
preprocessor=preprocessor,
ensure_min_samples=3, estimator=estimator)
assert str(raised_error.value) == msg
def test_check_tuples_invalid_n_samples(estimator, context, load_tuples,
preprocessor):
"""Checks that the right warning is printed if n_samples is too small"""
tuples = load_tuples()
msg = ("Found array with 2 sample(s) (shape={}) while a minimum of 3 "
"is required{}.".format((preprocess_tuples(tuples, preprocessor)
if (preprocessor is not None and
tuples.ndim == 2) else tuples).shape,
context))
with pytest.raises(ValueError) as raised_error:
check_input(tuples, type_of_inputs='tuples',
preprocessor=preprocessor,
ensure_min_samples=3, estimator=estimator)
assert str(raised_error.value) == msg
def test_check_tuples_invalid_tuple_size(estimator, context, load_tuples,
preprocessor):
"""Checks that the exception are raised if tuple_size is not the one
expected"""
tuples = load_tuples()
preprocessed_tuples = (preprocess_tuples(tuples, preprocessor)
if (preprocessor is not None and
tuples.ndim == 2) else tuples)
expected_msg = ("Tuples of 3 element(s) expected{}. Got tuples of 2 "
"element(s) instead (shape={}):\ninput={}.\n"
.format(context, preprocessed_tuples.shape,
preprocessed_tuples))
with pytest.raises(ValueError) as raised_error:
check_input(tuples, type_of_inputs='tuples', tuple_size=3,
preprocessor=preprocessor, estimator=estimator)
assert str(raised_error.value) == expected_msg
def test_check_tuples_invalid_tuple_size(estimator, context, load_tuples,
preprocessor):
"""Checks that the exception are raised if tuple_size is not the one
expected"""
tuples = load_tuples()
preprocessed_tuples = (preprocess_tuples(tuples, preprocessor)
if (preprocessor is not None and
tuples.ndim == 2) else tuples)
expected_msg = ("Tuples of 3 element(s) expected{}. Got tuples of 2 "
"element(s) instead (shape={}):\ninput={}.\n"
.format(context, preprocessed_tuples.shape,
preprocessed_tuples))
with pytest.raises(ValueError) as raised_error:
check_input(tuples, type_of_inputs='tuples', tuple_size=3,
preprocessor=preprocessor, estimator=estimator)
assert str(raised_error.value) == expected_msg
def test_check_tuples_invalid_shape(estimator, context, tuples, found,
expected, preprocessor):
"""Checks that a value error with the appropriate message is raised if
shape is invalid (not 2D with preprocessor or 3D with no preprocessor)
"""
tuples = np.array(tuples)
msg = ("{} expected{}{}. Found {}D array instead:\ninput={}. Reshape your "
"data{}.\n"
.format(expected, context, ' when using a preprocessor'
if preprocessor else '', found, tuples,
' and/or use a preprocessor' if
(not preprocessor and tuples.ndim == 2) else ''))
with pytest.raises(ValueError) as raised_error:
check_input(tuples, type_of_inputs='tuples',
preprocessor=preprocessor, ensure_min_samples=0,
estimator=estimator)
assert str(raised_error.value) == msg
def test_check_tuples_invalid_shape(estimator, context, tuples, found,
expected, preprocessor):
"""Checks that a value error with the appropriate message is raised if
shape is invalid (not 2D with preprocessor or 3D with no preprocessor)
"""
tuples = np.array(tuples)
msg = ("{} expected{}{}. Found {}D array instead:\ninput={}. Reshape your "
"data{}.\n"
.format(expected, context, ' when using a preprocessor'
if preprocessor else '', found, tuples,
' and/or use a preprocessor' if
(not preprocessor and tuples.ndim == 2) else ''))
with pytest.raises(ValueError) as raised_error:
check_input(tuples, type_of_inputs='tuples',
preprocessor=preprocessor, ensure_min_samples=0,
estimator=estimator)
assert str(raised_error.value) == msg
def test_preprocess_points_invalid_message(estimator):
"""Checks that if the preprocessor does some weird stuff, the preprocessed
input is detected as weird."""
context = make_context(estimator) + (' after the preprocessor '
'has been applied')
def preprocessor(sequence):
return np.ones((len(sequence), 2, 2)) # returns a 3D array instead of 2D
with pytest.raises(ValueError) as raised_error:
check_input(np.ones((3,)), type_of_inputs='classic',
preprocessor=preprocessor, estimator=estimator)
expected_msg = ("2D array of formed points expected{}. "
"Found 3D array instead:\ninput={}. Reshape your data{}.\n"
.format(context, np.ones((3, 2, 2)),
' and/or use a preprocessor' if preprocessor
is not None else ''))
assert str(raised_error.value) == expected_msg
def test_preprocess_points_invalid_message(estimator):
"""Checks that if the preprocessor does some weird stuff, the preprocessed
input is detected as weird."""
context = make_context(estimator) + (' after the preprocessor '
'has been applied')
def preprocessor(sequence):
return np.ones((len(sequence), 2, 2)) # returns a 3D array instead of 2D
with pytest.raises(ValueError) as raised_error:
check_input(np.ones((3,)), type_of_inputs='classic',
preprocessor=preprocessor, estimator=estimator)
expected_msg = ("2D array of formed points expected{}. "
"Found 3D array instead:\ninput={}. Reshape your data{}.\n"
.format(context, np.ones((3, 2, 2)),
' and/or use a preprocessor' if preprocessor
is not None else ''))
assert str(raised_error.value) == expected_msg
def test_check_tuples_invalid_dtype_convertible(estimator, context,
load_tuples, preprocessor):
"""Checks that a warning is raised if a convertible input is converted to
float"""
tuples = load_tuples().astype(object) # here the object conversion is
# useless for the tuples_prep case, but this allows to test the
# tuples_prep case
if preprocessor is not None: # if the preprocessor is not None we
# overwrite it to have a preprocessor that returns objects
def preprocessor(indices): #
# preprocessor that returns objects
return np.ones((indices.shape[0], 3)).astype(object)
msg = ("Data with input dtype object was converted to float64{}."
.format(context))
with pytest.warns(DataConversionWarning) as raised_warning:
check_input(tuples, type_of_inputs='tuples',
preprocessor=preprocessor, dtype=np.float64,
warn_on_dtype=True, estimator=estimator)
assert str(raised_warning[0].message) == msg
def test_check_tuples_behaviour_auto_dtype():
"""Checks that check_tuples allows by default every type if using a
preprocessor, and numeric types if using no preprocessor"""
tuples_prep = [['img1.png', 'img2.png'], ['img3.png', 'img5.png']]
with pytest.warns(None) as record:
check_input(tuples_prep, type_of_inputs='tuples',
preprocessor=mock_preprocessor)
assert len(record) == 0
with pytest.warns(None) as record:
check_input(tuples_no_prep(), type_of_inputs='tuples') # numeric type
assert len(record) == 0
# not numeric type
tuples_no_prep_bis = np.array([[['img1.png'], ['img2.png']],
[['img3.png'], ['img5.png']]])
tuples_no_prep_bis = tuples_no_prep_bis.astype(object)
with pytest.raises(ValueError):
check_input(tuples_no_prep_bis, type_of_inputs='tuples')
def test_check_classic_behaviour_auto_dtype():
"""Checks that check_input (for points) allows by default every type if
using a preprocessor, and numeric types if using no preprocessor"""
points_prep = ['img1.png', 'img2.png', 'img3.png', 'img5.png']
with pytest.warns(None) as record:
check_input(points_prep, type_of_inputs='classic',
preprocessor=mock_preprocessor)
assert len(record) == 0
with pytest.warns(None) as record:
check_input(points_no_prep(), type_of_inputs='classic') # numeric type
assert len(record) == 0
# not numeric type
points_no_prep_bis = np.array(['img1.png', 'img2.png', 'img3.png',
'img5.png'])
points_no_prep_bis = points_no_prep_bis.astype(object)
with pytest.raises(ValueError):
check_input(points_no_prep_bis, type_of_inputs='classic')
def test_check_tuples_behaviour_auto_dtype():
"""Checks that check_tuples allows by default every type if using a
preprocessor, and numeric types if using no preprocessor"""
tuples_prep = [['img1.png', 'img2.png'], ['img3.png', 'img5.png']]
with pytest.warns(None) as record:
check_input(tuples_prep, type_of_inputs='tuples',
preprocessor=mock_preprocessor)
assert len(record) == 0
with pytest.warns(None) as record:
check_input(tuples_no_prep(), type_of_inputs='tuples') # numeric type
assert len(record) == 0
# not numeric type
tuples_no_prep_bis = np.array([[['img1.png'], ['img2.png']],
[['img3.png'], ['img5.png']]])
tuples_no_prep_bis = tuples_no_prep_bis.astype(object)
with pytest.raises(ValueError):
check_input(tuples_no_prep_bis, type_of_inputs='tuples')
def test_check_classic_behaviour_auto_dtype(points_no_prep):
"""Checks that check_input (for points) allows by default every type if
using a preprocessor, and numeric types if using no preprocessor"""
points_prep = ['img1.png', 'img2.png', 'img3.png', 'img5.png']
with pytest.warns(None) as record:
check_input(points_prep,
type_of_inputs='classic',
preprocessor=mock_preprocessor)
assert len(record) == 0
with pytest.warns(None) as record:
check_input(points_no_prep, type_of_inputs='classic') # numeric type
assert len(record) == 0
# not numeric type
points_no_prep = np.array(['img1.png', 'img2.png', 'img3.png', 'img5.png'])
points_no_prep = points_no_prep.astype(object)
with pytest.raises(ValueError):
check_input(points_no_prep, type_of_inputs='classic')
def test_check_classic_by_default():
"""Checks that 'classic' is the default behaviour of check_input"""
assert (check_input([[2, 3], [3, 2]]) ==
check_input([[2, 3], [3, 2]], type_of_inputs='classic')).all()
def test_check_classic_valid_without_preprocessor(points):
"""Test that valid inputs when using no preprocessor raises no warning"""
with pytest.warns(None) as record:
check_input(points, type_of_inputs='classic', preprocessor=None)
assert len(record) == 0
def test_check_classic_by_default():
"""Checks that 'classic' is the default behaviour of check_input"""
assert (check_input([[2, 3],
[3,
2]]) == check_input([[2, 3], [3, 2]],
type_of_inputs='classic')).all()
def test_check_tuples_valid_without_preprocessor(tuples):
"""Test that valid inputs when using no preprocessor raises no warning"""
with pytest.warns(None) as record:
check_input(tuples, type_of_inputs='tuples', preprocessor=None)
assert len(record) == 0
