Beispiel #1
0
def test_compute_affinity_matrix_args(almost_equal_decimals=5):
    """ test the compute_affinity_matrix parameter arguments """
    input_types = ['data', 'adjacency', 'affinity']
    params = [{'radius': 4}, {'radius': 5}]
    adjacency_method = 'auto'
    for affinity_method in affinity_methods():
        X = np.random.uniform(size=(10, 2))
        D = compute_adjacency_matrix(X, adjacency_method, **params[1])
        A = compute_affinity_matrix(D, affinity_method, **params[1])
        for init_params in params:
            for kwarg_params in params:
                true_params = init_params.copy()
                true_params.update(kwarg_params)
                affinity_true = compute_affinity_matrix(
                    D, adjacency_method, **true_params)
                for input in input_types:
                    G = Geometry(adjacency_method=adjacency_method,
                                 adjacency_kwds=params[1],
                                 affinity_method=affinity_method,
                                 affinity_kwds=init_params)
                    if input in ['data', 'adjacency']:
                        if input in ['data']:
                            G.set_data_matrix(X)
                        else:
                            G.set_adjacency_matrix(D)
                        affinity_queried = G.compute_affinity_matrix(
                            **kwarg_params)
                        assert_array_almost_equal(affinity_true.todense(),
                                                  affinity_queried.todense(),
                                                  almost_equal_decimals)
                    else:
                        G.set_affinity_matrix(A)
                        msg = distance_error_msg
                        assert_raise_message(ValueError, msg,
                                             G.compute_affinity_matrix)
Beispiel #2
0
def test_assert_raise_message():
    def _raise_ValueError(message):
        raise ValueError(message)

    def _no_raise():
        pass

    assert_raise_message(ValueError, "test",
                         _raise_ValueError, "test")

    assert_raises(AssertionError,
                  assert_raise_message, ValueError, "something else",
                  _raise_ValueError, "test")

    assert_raises(ValueError,
                  assert_raise_message, TypeError, "something else",
                  _raise_ValueError, "test")

    assert_raises(AssertionError,
                  assert_raise_message, ValueError, "test",
                  _no_raise)

    # multiple exceptions in a tuple
    assert_raises(AssertionError,
                  assert_raise_message, (ValueError, AttributeError),
                  "test", _no_raise)
Beispiel #3
0
def test_compute_affinity_matrix_args(almost_equal_decimals=5):
    """ test the compute_affinity_matrix parameter arguments """
    input_types = ['data', 'adjacency', 'affinity']
    params = [{'radius':4}, {'radius':5}]
    adjacency_method = 'auto'
    for affinity_method in affinity_methods():
        X = np.random.uniform(size=(10, 2))
        D = compute_adjacency_matrix(X, adjacency_method, **params[1])
        A = compute_affinity_matrix(D, affinity_method, **params[1])
        for init_params in params:
            for kwarg_params in params:
                true_params = init_params.copy()
                true_params.update(kwarg_params)
                affinity_true = compute_affinity_matrix(D, adjacency_method,
                                                        **true_params)
                for input in input_types:
                    G = Geometry(adjacency_method = adjacency_method,
                                 adjacency_kwds = params[1],
                                 affinity_method = affinity_method,
                                 affinity_kwds = init_params)
                    if input in ['data', 'adjacency']:
                        if input in ['data']:
                            G.set_data_matrix(X)
                        else:
                            G.set_adjacency_matrix(D)
                        affinity_queried = G.compute_affinity_matrix(**kwarg_params)
                        assert_array_almost_equal(affinity_true.todense(), affinity_queried.todense(), almost_equal_decimals)
                    else:
                        G.set_affinity_matrix(A)
                        msg = distance_error_msg
                        assert_raise_message(ValueError, msg, G.compute_affinity_matrix)
Beispiel #4
0
def test_compute_adjacency_matrix_args(almost_equal_decimals=5):
    """ test the compute_adjacency_matrix parameter arguments """
    input_types = ['data', 'adjacency', 'affinity']
    params = [{'radius':1}, {'radius':2}]
    for adjacency_method in adjacency_methods():
        if adjacency_method == 'pyflann':
            try:
                import pyflann as pyf
            except ImportError:
                raise SkipTest("pyflann not installed.")
        X = np.random.uniform(size=(10, 2))
        D = compute_adjacency_matrix(X, adjacency_method, **params[1])
        A = compute_affinity_matrix(D, radius=1)
        for init_params in params:
            for kwarg_params in params:
                true_params = init_params.copy()
                true_params.update(kwarg_params)
                adjacency_true = compute_adjacency_matrix(X, adjacency_method, **true_params)
                G = Geometry(adjacency_method=adjacency_method, adjacency_kwds=init_params)
                for input in input_types:
                    G = Geometry(adjacency_kwds = init_params)
                    if input in ['data']:
                        G.set_data_matrix(X)
                        adjacency_queried = G.compute_adjacency_matrix(**kwarg_params)
                        assert_allclose(adjacency_true.toarray(),
                                        adjacency_queried.toarray(), rtol=1E-5)
                    else:
                        if input in ['adjacency']:
                            G.set_adjacency_matrix(D)
                        else:
                            G.set_affinity_matrix(A)
                        msg = distance_error_msg
                        assert_raise_message(ValueError, msg, G.compute_adjacency_matrix)
def test_predict_error_not_fitted(seed=36):
    """ Test predict function raises an error when .fit() has not been called"""
    radius = 4.0
    geom_params = {'affinity_kwds':{'radius':radius}, 'adjacency_kwds':{'radius':radius}, 'adjacency_method':'brute',
                'laplacian_method':'geometric'}
    se = SpectralEmbedding(n_components=2,eigen_solver="arpack",
                           random_state=np.random.RandomState(seed), geom = geom_params)
    S_train = S[:900,:]
    S_test = S[-100:, :]
    msg = 'the .fit() function must be called before the .predict() function'
    assert_raise_message(RuntimeError, msg, se.predict, S_test)
def test_predict_error_no_data(seed=36):
    """ Test predict raises an error when data X are not passed"""
    radius = 4.0
    se = SpectralEmbedding(n_components=2,
                           random_state=np.random.RandomState(seed))
    G = geom.Geometry(adjacency_method = 'brute', adjacency_kwds = {'radius':radius},
                      affinity_kwds = {'radius':radius})
    G.set_data_matrix(S)
    S_test = S[-100:, :]
    A = G.compute_affinity_matrix()
    embed = se.fit_transform(A, input_type = 'affinity')
    msg = 'method only implemented when X passed as data'
    assert_raise_message(NotImplementedError, msg, se.predict, S_test)
Beispiel #7
0
def test_predict_error_no_data(seed=36):
    """ Test predict raises an error when data X are not passed"""
    radius = 4.0
    se = SpectralEmbedding(n_components=2,
                           random_state=np.random.RandomState(seed))
    G = geom.Geometry(adjacency_method='brute',
                      adjacency_kwds={'radius': radius},
                      affinity_kwds={'radius': radius})
    G.set_data_matrix(S)
    S_test = S[-100:, :]
    A = G.compute_affinity_matrix()
    embed = se.fit_transform(A, input_type='affinity')
    msg = 'method only implemented when X passed as data'
    assert_raise_message(NotImplementedError, msg, se.predict, S_test)
Beispiel #8
0
def test_predict_error_not_fitted(seed=36):
    """ Test predict function raises an error when .fit() has not been called"""
    radius = 4.0
    geom_params = {
        'affinity_kwds': {
            'radius': radius
        },
        'adjacency_kwds': {
            'radius': radius
        },
        'adjacency_method': 'brute',
        'laplacian_method': 'geometric'
    }
    se = SpectralEmbedding(n_components=2,
                           eigen_solver="arpack",
                           random_state=np.random.RandomState(seed),
                           geom=geom_params)
    S_train = S[:900, :]
    S_test = S[-100:, :]
    msg = 'the .fit() function must be called before the .predict() function'
    assert_raise_message(RuntimeError, msg, se.predict, S_test)
Beispiel #9
0
def test_assert_raise_message():
    def _raise_ValueError(message):
        raise ValueError(message)

    def _no_raise():
        pass

    assert_raise_message(ValueError, "test", _raise_ValueError, "test")

    assert_raises(AssertionError, assert_raise_message, ValueError,
                  "something else", _raise_ValueError, "test")

    assert_raises(ValueError, assert_raise_message, TypeError,
                  "something else", _raise_ValueError, "test")

    assert_raises(AssertionError, assert_raise_message, ValueError, "test",
                  _no_raise)

    # multiple exceptions in a tuple
    assert_raises(AssertionError, assert_raise_message,
                  (ValueError, AttributeError), "test", _no_raise)
Beispiel #10
0
def test_compute_adjacency_matrix_args(almost_equal_decimals=5):
    """ test the compute_adjacency_matrix parameter arguments """
    input_types = ['data', 'adjacency', 'affinity']
    params = [{'radius': 1}, {'radius': 2}]
    for adjacency_method in adjacency_methods():
        if adjacency_method == 'pyflann':
            try:
                import pyflann as pyf
            except ImportError:
                raise SkipTest("pyflann not installed.")
        X = np.random.uniform(size=(10, 2))
        D = compute_adjacency_matrix(X, adjacency_method, **params[1])
        A = compute_affinity_matrix(D, radius=1)
        for init_params in params:
            for kwarg_params in params:
                true_params = init_params.copy()
                true_params.update(kwarg_params)
                adjacency_true = compute_adjacency_matrix(
                    X, adjacency_method, **true_params)
                G = Geometry(adjacency_method=adjacency_method,
                             adjacency_kwds=init_params)
                for input in input_types:
                    G = Geometry(adjacency_kwds=init_params)
                    if input in ['data']:
                        G.set_data_matrix(X)
                        adjacency_queried = G.compute_adjacency_matrix(
                            **kwarg_params)
                        assert_allclose(adjacency_true.toarray(),
                                        adjacency_queried.toarray(),
                                        rtol=1E-5)
                    else:
                        if input in ['adjacency']:
                            G.set_adjacency_matrix(D)
                        else:
                            G.set_affinity_matrix(A)
                        msg = distance_error_msg
                        assert_raise_message(ValueError, msg,
                                             G.compute_adjacency_matrix)
Beispiel #11
0
def test_check_array_min_samples_and_features_messages():
    # empty list is considered 2D by default:
    msg = "0 feature(s) (shape=(1, 0)) while a minimum of 1 is required."
    assert_raise_message(ValueError, msg, check_array, [[]])

    # If considered a 1D collection when ensure_2d=False, then the minimum
    # number of samples will break:
    msg = "0 sample(s) (shape=(0,)) while a minimum of 1 is required."
    assert_raise_message(ValueError, msg, check_array, [], ensure_2d=False)

    # Invalid edge case when checking the default minimum sample of a scalar
    msg = "Singleton array array(42) cannot be considered a valid collection."
    assert_raise_message(TypeError, msg, check_array, 42, ensure_2d=False)

    # But this works if the input data is forced to look like a 2 array with
    # one sample and one feature:
    X_checked = assert_warns(DeprecationWarning, check_array, [42],
                             ensure_2d=True)
    assert_array_equal(np.array([[42]]), X_checked)
Beispiel #12
0
def test_check_array_min_samples_and_features_messages():
    # empty list is considered 2D by default:
    msg = "0 feature(s) (shape=(1, 0)) while a minimum of 1 is required."
    assert_raise_message(ValueError, msg, check_array, [[]])

    # If considered a 1D collection when ensure_2d=False, then the minimum
    # number of samples will break:
    msg = "0 sample(s) (shape=(0,)) while a minimum of 1 is required."
    assert_raise_message(ValueError, msg, check_array, [], ensure_2d=False)

    # Invalid edge case when checking the default minimum sample of a scalar
    msg = "Singleton array array(42) cannot be considered a valid collection."
    assert_raise_message(TypeError, msg, check_array, 42, ensure_2d=False)

    # But this works if the input data is forced to look like a 2 array with
    # one sample and one feature:
    X_checked = assert_warns(DeprecationWarning,
                             check_array, [42],
                             ensure_2d=True)
    assert_array_equal(np.array([[42]]), X_checked)