예제 #1
0
def test_time_delay_transform_matches_input(data_random):
    x = data_random

    observables = TimeDelay(delay=2, n_delays=4)
    observables.fit(x)

    y = observables.transform(x)
    assert_array_equal(y[1], x[[9, 7, 5, 3, 1]].flatten())
예제 #2
0
def test_time_delay_inverse(data_random):
    x = data_random
    delay = 2
    n_delays = 3
    n_deleted_rows = delay * n_delays

    observables = TimeDelay(delay=delay, n_delays=n_delays)
    y = observables.fit_transform(x)
    # First few rows of x are deleted which don't have enough
    # time history
    assert_array_equal(observables.inverse(y), x[n_deleted_rows:])
예제 #3
0
def test_simulate_with_time_delay(data_2D_superposition):
    x = data_2D_superposition

    observables = TimeDelay()
    model = Koopman(observables=observables)
    model.fit(x)

    n_steps = 10
    n_consumed_samples = observables.n_consumed_samples
    x_pred = model.simulate(x[:n_consumed_samples + 1], n_steps=n_steps)
    assert_allclose(x[n_consumed_samples + 1:n_consumed_samples + n_steps + 1],
                    x_pred)
예제 #4
0

def test_score_complex_data(data_random_complex):
    x = data_random_complex
    model = Koopman().fit(x)

    with pytest.raises(ValueError):
        model.score(x, cast_as_real=False)


@pytest.mark.parametrize(
    "observables",
    [
        Identity(),
        Polynomial(),
        TimeDelay(),
        pytest.lazy_fixture("data_custom_observables"),
    ],
)
def test_observables_integration(data_random, observables):
    x = data_random
    model = Koopman(observables=observables).fit(x)
    check_is_fitted(model)

    y = model.predict(x)
    assert y.shape[1] == x.shape[1]


@pytest.mark.parametrize(
    "observables",
    [
예제 #5
0
def test_time_delay_output_shape(data_random, delay, n_delays):
    x = data_random
    y = TimeDelay(delay=delay, n_delays=n_delays).fit_transform(x)

    assert y.shape == (x.shape[0] - delay * n_delays,
                       (n_delays + 1) * x.shape[1])
예제 #6
0
from pykoopman.observables import Polynomial
from pykoopman.observables import TimeDelay


@pytest.fixture
def data_small():
    t = linspace(0, 5, 10)
    return stack((t, t**2), axis=1)


@pytest.mark.parametrize(
    "observables",
    [
        Identity(),
        Polynomial(),
        TimeDelay(),
        pytest.lazy_fixture("data_custom_observables"),
    ],
)
def test_if_fitted(observables, data_random):
    x = data_random
    with pytest.raises(NotFittedError):
        observables.transform(x)

    with pytest.raises(NotFittedError):
        observables.inverse(x)

    with pytest.raises(NotFittedError):
        observables.get_feature_names()

    observables.fit(x)