pymc-extras 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

tests/statespace/test_distributions.py

@@ -1,270 +0,0 @@
-import numpy as np
-import pymc as pm
-import pytensor
-import pytensor.tensor as pt
-import pytest
-
-from numpy.testing import assert_allclose
-from scipy.stats import multivariate_normal
-
-from pymc_extras.statespace import structural
-from pymc_extras.statespace.filters.distributions import (
-    LinearGaussianStateSpace,
-    SequenceMvNormal,
-    _LinearGaussianStateSpace,
-)
-from pymc_extras.statespace.utils.constants import (
-    ALL_STATE_DIM,
-    OBS_STATE_DIM,
-    TIME_DIM,
-)
-from tests.statespace.utilities.shared_fixtures import (  # pylint: disable=unused-import
-    rng,
-)
-from tests.statespace.utilities.test_helpers import (
-    delete_rvs_from_model,
-    fast_eval,
-    load_nile_test_data,
-)
-
-floatX = pytensor.config.floatX
-
-# TODO: These are pretty loose because of all the stabilizing of covariance matrices that is done inside the kalman
-#  filters. When that is improved, this should be tightened.
-ATOL = 1e-5 if floatX.endswith("64") else 1e-4
-RTOL = 1e-5 if floatX.endswith("64") else 1e-4
-
-filter_names = [
-    "standard",
-    "cholesky",
-    "univariate",
-]
-
-
-@pytest.fixture(scope="session")
-def data():
-    return load_nile_test_data()
-
-
-@pytest.fixture(scope="session")
-def pymc_model(data):
-    with pm.Model() as mod:
-        data = pm.Data("data", data.values)
-        P0_diag = pm.Exponential("P0_diag", 1, shape=(2,))
-        P0 = pm.Deterministic("P0", pt.diag(P0_diag))
-        initial_trend = pm.Normal("initial_trend", shape=(2,))
-        sigma_trend = pm.Exponential("sigma_trend", 1, shape=(2,))
-
-    return mod
-
-
-@pytest.fixture(scope="session")
-def pymc_model_2(data):
-    coords = {
-        ALL_STATE_DIM: ["level", "trend"],
-        OBS_STATE_DIM: ["level"],
-        TIME_DIM: np.arange(101, dtype="int"),
-    }
-
-    with pm.Model(coords=coords) as mod:
-        P0_diag = pm.Exponential("P0_diag", 1, shape=(2,))
-        P0 = pm.Deterministic("P0", pt.diag(P0_diag))
-        initial_trend = pm.Normal("initial_trend", shape=(2,))
-        sigma_trend = pm.Exponential("sigma_trend", 1, shape=(2,))
-        sigma_me = pm.Exponential("sigma_error", 1)
-
-    return mod
-
-
-@pytest.fixture(scope="session")
-def ss_mod_me():
-    ss_mod = structural.LevelTrendComponent(order=2)
-    ss_mod += structural.MeasurementError(name="error")
-    ss_mod = ss_mod.build("data", verbose=False)
-
-    return ss_mod
-
-
-@pytest.fixture(scope="session")
-def ss_mod_no_me():
-    ss_mod = structural.LevelTrendComponent(order=2)
-    ss_mod = ss_mod.build("data", verbose=False)
-
-    return ss_mod
-
-
-@pytest.mark.parametrize("kfilter", filter_names, ids=filter_names)
-def test_loglike_vectors_agree(kfilter, pymc_model):
-    # TODO: This test might be flakey, I've gotten random failures
-    ss_mod = structural.LevelTrendComponent(order=2).build(
-        "data", verbose=False, filter_type=kfilter
-    )
-    with pymc_model:
-        ss_mod._insert_random_variables()
-        matrices = ss_mod.unpack_statespace()
-
-        filter_outputs = ss_mod.kalman_filter.build_graph(pymc_model["data"], *matrices)
-        filter_mus, pred_mus, obs_mu, filter_covs, pred_covs, obs_cov, ll = filter_outputs
-
-    test_ll = fast_eval(ll)
-
-    # TODO: BUG: Why does fast eval end up with a 2d output when filter is "single"?
-    obs_mu_np = obs_mu.eval()
-    obs_cov_np = fast_eval(obs_cov)
-    data_np = fast_eval(pymc_model["data"])
-
-    scipy_lls = []
-    for y, mu, cov in zip(data_np, obs_mu_np, obs_cov_np):
-        scipy_lls.append(multivariate_normal.logpdf(y, mean=mu, cov=cov))
-    assert_allclose(test_ll, np.array(scipy_lls).ravel(), atol=ATOL, rtol=RTOL)
-
-
-def test_sequence_mvn_distribution():
-    # Base Case
-    mu_sequence = pt.tensor("mu_sequence", shape=(100, 3))
-    cov_sequence = pt.tensor("cov_sequence", shape=(100, 3, 3))
-    logp = pt.tensor("logp", shape=(100,))
-
-    dist = SequenceMvNormal.dist(mu_sequence, cov_sequence, logp)
-    assert dist.type.shape == (100, 3)
-
-    # With batch dimension
-    mu_sequence = pt.tensor("mu_sequence", shape=(10, 100, 3))
-    cov_sequence = pt.tensor("cov_sequence", shape=(10, 100, 3, 3))
-    logp = pt.tensor(
-        "logp",
-        shape=(
-            10,
-            100,
-        ),
-    )
-
-    dist = SequenceMvNormal.dist(mu_sequence, cov_sequence, logp)
-    assert dist.type.shape == (10, 100, 3)
-
-
-@pytest.mark.parametrize("output_name", ["states_latent", "states_observed"])
-def test_lgss_distribution_from_steps(output_name, ss_mod_me, pymc_model_2):
-    with pymc_model_2:
-        ss_mod_me._insert_random_variables()
-        matrices = ss_mod_me.unpack_statespace()
-
-        # pylint: disable=unpacking-non-sequence
-        latent_states, obs_states = LinearGaussianStateSpace("states", *matrices, steps=100)
-        # pylint: enable=unpacking-non-sequence
-
-        idata = pm.sample_prior_predictive(draws=10)
-        delete_rvs_from_model(["states_latent", "states_observed", "states_combined"])
-
-    assert idata.prior.coords["states_latent_dim_0"].shape == (101,)
-    assert not np.any(np.isnan(idata.prior[output_name].values))
-
-
-@pytest.mark.parametrize("output_name", ["states_latent", "states_observed"])
-def test_lgss_distribution_with_dims(output_name, ss_mod_me, pymc_model_2):
-    with pymc_model_2:
-        ss_mod_me._insert_random_variables()
-        matrices = ss_mod_me.unpack_statespace()
-
-        # pylint: disable=unpacking-non-sequence
-        latent_states, obs_states = LinearGaussianStateSpace(
-            "states",
-            *matrices,
-            steps=100,
-            dims=[TIME_DIM, ALL_STATE_DIM, OBS_STATE_DIM],
-            sequence_names=[],
-            k_endog=ss_mod_me.k_endog,
-        )
-        # pylint: enable=unpacking-non-sequence
-        idata = pm.sample_prior_predictive(draws=10)
-        delete_rvs_from_model(["states_latent", "states_observed", "states_combined"])
-
-    assert idata.prior.coords["time"].shape == (101,)
-    assert all(
-        [dim in idata.prior.states_latent.coords.keys() for dim in [TIME_DIM, ALL_STATE_DIM]]
-    )
-    assert all(
-        [dim in idata.prior.states_observed.coords.keys() for dim in [TIME_DIM, OBS_STATE_DIM]]
-    )
-    assert not np.any(np.isnan(idata.prior[output_name].values))
-
-
-@pytest.mark.parametrize("output_name", ["states_latent", "states_observed"])
-def test_lgss_with_time_varying_inputs(output_name, rng):
-    X = rng.random(size=(10, 3), dtype=floatX)
-    ss_mod = structural.LevelTrendComponent() + structural.RegressionComponent(
-        name="exog", k_exog=3
-    )
-    mod = ss_mod.build("data", verbose=False)
-
-    coords = {
-        ALL_STATE_DIM: ["level", "trend", "beta_1", "beta_2", "beta_3"],
-        OBS_STATE_DIM: ["level"],
-        TIME_DIM: np.arange(10, dtype="int"),
-    }
-
-    with pm.Model(coords=coords):
-        exog_data = pm.Data("data_exog", X)
-        P0_diag = pm.Exponential("P0_diag", 1, shape=(mod.k_states,))
-        P0 = pm.Deterministic("P0", pt.diag(P0_diag))
-        initial_trend = pm.Normal("initial_trend", shape=(2,))
-        sigma_trend = pm.Exponential("sigma_trend", 1, shape=(2,))
-        beta_exog = pm.Normal("beta_exog", shape=(3,))
-
-        mod._insert_random_variables()
-        mod._insert_data_variables()
-        matrices = mod.unpack_statespace()
-
-        # pylint: disable=unpacking-non-sequence
-        latent_states, obs_states = LinearGaussianStateSpace(
-            "states",
-            *matrices,
-            steps=9,
-            sequence_names=["d", "Z"],
-            dims=[TIME_DIM, ALL_STATE_DIM, OBS_STATE_DIM],
-        )
-        # pylint: enable=unpacking-non-sequence
-        idata = pm.sample_prior_predictive(draws=10)
-
-    assert idata.prior.coords["time"].shape == (10,)
-    assert all(
-        [dim in idata.prior.states_latent.coords.keys() for dim in [TIME_DIM, ALL_STATE_DIM]]
-    )
-    assert all(
-        [dim in idata.prior.states_observed.coords.keys() for dim in [TIME_DIM, OBS_STATE_DIM]]
-    )
-    assert not np.any(np.isnan(idata.prior[output_name].values))
-
-
-def test_lgss_signature():
-    # Base case
-    x0 = pt.tensor("x0", shape=(None,))
-    P0 = pt.tensor("P0", shape=(None, None))
-    c = pt.tensor("c", shape=(None,))
-    d = pt.tensor("d", shape=(None,))
-    T = pt.tensor("T", shape=(None, None))
-    Z = pt.tensor("Z", shape=(None, None))
-    R = pt.tensor("R", shape=(None, None))
-    H = pt.tensor("H", shape=(None, None))
-    Q = pt.tensor("Q", shape=(None, None))
-
-    lgss = _LinearGaussianStateSpace.dist(x0, P0, c, d, T, Z, R, H, Q, steps=100)
-    assert (
-        lgss.owner.op.extended_signature
-        == "(s),(s,s),(s),(p),(s,s),(p,s),(s,r),(p,p),(r,r),[rng]->[rng],(t,n)"
-    )
-    assert lgss.owner.op.ndim_supp == 2
-    assert lgss.owner.op.ndims_params == [1, 2, 1, 1, 2, 2, 2, 2, 2]
-
-    # Case with time-varying matrices
-    T = pt.tensor("T", shape=(None, None, None))
-    lgss = _LinearGaussianStateSpace.dist(
-        x0, P0, c, d, T, Z, R, H, Q, steps=100, sequence_names=["T"]
-    )
-
-    assert (
-        lgss.owner.op.extended_signature
-        == "(s),(s,s),(s),(p),(t,s,s),(p,s),(s,r),(p,p),(r,r),[rng]->[rng],(t,n)"
-    )
-    assert lgss.owner.op.ndim_supp == 2
-    assert lgss.owner.op.ndims_params == [1, 2, 1, 1, 3, 2, 2, 2, 2]

tests/statespace/test_kalman_filter.py

@@ -1,326 +0,0 @@
-import numpy as np
-import pytensor
-import pytensor.tensor as pt
-import pytest
-
-from numpy.testing import assert_allclose, assert_array_less
-
-from pymc_extras.statespace.filters import (
-    KalmanSmoother,
-    SquareRootFilter,
-    StandardFilter,
-    UnivariateFilter,
-)
-from pymc_extras.statespace.filters.kalman_filter import BaseFilter
-from tests.statespace.utilities.shared_fixtures import (  # pylint: disable=unused-import
-    rng,
-)
-from tests.statespace.utilities.test_helpers import (
-    get_expected_shape,
-    get_sm_state_from_output_name,
-    initialize_filter,
-    make_test_inputs,
-    nile_test_test_helper,
-)
-
-floatX = pytensor.config.floatX
-
-# TODO: These are pretty loose because of all the stabilizing of covariance matrices that is done inside the kalman
-#  filters. When that is improved, this should be tightened.
-ATOL = 1e-6 if floatX.endswith("64") else 1e-3
-RTOL = 1e-6 if floatX.endswith("64") else 1e-3
-
-standard_inout = initialize_filter(StandardFilter())
-cholesky_inout = initialize_filter(SquareRootFilter())
-univariate_inout = initialize_filter(UnivariateFilter())
-
-f_standard = pytensor.function(*standard_inout, on_unused_input="ignore")
-f_cholesky = pytensor.function(*cholesky_inout, on_unused_input="ignore")
-f_univariate = pytensor.function(*univariate_inout, on_unused_input="ignore")
-
-filter_funcs = [f_standard, f_cholesky, f_univariate]
-
-filter_names = [
-    "StandardFilter",
-    "CholeskyFilter",
-    "UnivariateFilter",
-]
-
-output_names = [
-    "filtered_states",
-    "predicted_states",
-    "smoothed_states",
-    "filtered_covs",
-    "predicted_covs",
-    "smoothed_covs",
-    "log_likelihood",
-    "ll_obs",
-]
-
-
-def test_base_class_update_raises():
-    filter = BaseFilter()
-    inputs = [None] * 7
-    with pytest.raises(NotImplementedError):
-        filter.update(*inputs)
-
-
-@pytest.mark.parametrize("filter_func", filter_funcs, ids=filter_names)
-def test_output_shapes_one_state_one_observed(filter_func, rng):
-    p, m, r, n = 1, 1, 1, 10
-    inputs = make_test_inputs(p, m, r, n, rng)
-    outputs = filter_func(*inputs)
-
-    for output_idx, name in enumerate(output_names):
-        expected_output = get_expected_shape(name, p, m, r, n)
-        assert (
-            outputs[output_idx].shape == expected_output
-        ), f"Shape of {name} does not match expected"
-
-
-@pytest.mark.parametrize("filter_func", filter_funcs, ids=filter_names)
-def test_output_shapes_when_all_states_are_stochastic(filter_func, rng):
-    p, m, r, n = 1, 2, 2, 10
-    inputs = make_test_inputs(p, m, r, n, rng)
-
-    outputs = filter_func(*inputs)
-    for output_idx, name in enumerate(output_names):
-        expected_output = get_expected_shape(name, p, m, r, n)
-        assert (
-            outputs[output_idx].shape == expected_output
-        ), f"Shape of {name} does not match expected"
-
-
-@pytest.mark.parametrize("filter_func", filter_funcs, ids=filter_names)
-def test_output_shapes_when_some_states_are_deterministic(filter_func, rng):
-    p, m, r, n = 1, 5, 2, 10
-    inputs = make_test_inputs(p, m, r, n, rng)
-
-    outputs = filter_func(*inputs)
-    for output_idx, name in enumerate(output_names):
-        expected_output = get_expected_shape(name, p, m, r, n)
-        assert (
-            outputs[output_idx].shape == expected_output
-        ), f"Shape of {name} does not match expected"
-
-
-@pytest.fixture
-def f_standard_nd():
-    ksmoother = KalmanSmoother()
-    data = pt.tensor(name="data", dtype=floatX, shape=(None, None))
-    a0 = pt.vector(name="a0", dtype=floatX)
-    P0 = pt.matrix(name="P0", dtype=floatX)
-    c = pt.vector(name="c", dtype=floatX)
-    d = pt.vector(name="d", dtype=floatX)
-    Q = pt.tensor(name="Q", dtype=floatX, shape=(None, None, None))
-    H = pt.tensor(name="H", dtype=floatX, shape=(None, None, None))
-    T = pt.tensor(name="T", dtype=floatX, shape=(None, None, None))
-    R = pt.tensor(name="R", dtype=floatX, shape=(None, None, None))
-    Z = pt.tensor(name="Z", dtype=floatX, shape=(None, None, None))
-
-    inputs = [data, a0, P0, c, d, T, Z, R, H, Q]
-
-    (
-        filtered_states,
-        predicted_states,
-        observed_states,
-        filtered_covs,
-        predicted_covs,
-        observed_covs,
-        ll_obs,
-    ) = StandardFilter().build_graph(*inputs)
-
-    smoothed_states, smoothed_covs = ksmoother.build_graph(T, R, Q, filtered_states, filtered_covs)
-
-    outputs = [
-        filtered_states,
-        predicted_states,
-        smoothed_states,
-        filtered_covs,
-        predicted_covs,
-        smoothed_covs,
-        ll_obs.sum(),
-        ll_obs,
-    ]
-
-    f_standard = pytensor.function(inputs, outputs)
-
-    return f_standard
-
-
-def test_output_shapes_with_time_varying_matrices(f_standard_nd, rng):
-    p, m, r, n = 1, 5, 2, 10
-    data, a0, P0, c, d, T, Z, R, H, Q = make_test_inputs(p, m, r, n, rng)
-    T = np.concatenate([np.expand_dims(T, 0)] * n, axis=0)
-    Z = np.concatenate([np.expand_dims(Z, 0)] * n, axis=0)
-    R = np.concatenate([np.expand_dims(R, 0)] * n, axis=0)
-    H = np.concatenate([np.expand_dims(H, 0)] * n, axis=0)
-    Q = np.concatenate([np.expand_dims(Q, 0)] * n, axis=0)
-
-    outputs = f_standard_nd(data, a0, P0, c, d, T, Z, R, H, Q)
-
-    for output_idx, name in enumerate(output_names):
-        expected_output = get_expected_shape(name, p, m, r, n)
-        assert (
-            outputs[output_idx].shape == expected_output
-        ), f"Shape of {name} does not match expected"
-
-
-@pytest.mark.parametrize("filter_func", filter_funcs, ids=filter_names)
-def test_output_with_deterministic_observation_equation(filter_func, rng):
-    p, m, r, n = 1, 5, 1, 10
-    inputs = make_test_inputs(p, m, r, n, rng)
-
-    outputs = filter_func(*inputs)
-
-    for output_idx, name in enumerate(output_names):
-        expected_output = get_expected_shape(name, p, m, r, n)
-        assert (
-            outputs[output_idx].shape == expected_output
-        ), f"Shape of {name} does not match expected"
-
-
-@pytest.mark.parametrize(
-    ("filter_func", "filter_name"), zip(filter_funcs, filter_names), ids=filter_names
-)
-def test_output_with_multiple_observed(filter_func, filter_name, rng):
-    p, m, r, n = 5, 5, 1, 10
-    inputs = make_test_inputs(p, m, r, n, rng)
-
-    outputs = filter_func(*inputs)
-    for output_idx, name in enumerate(output_names):
-        expected_output = get_expected_shape(name, p, m, r, n)
-        assert (
-            outputs[output_idx].shape == expected_output
-        ), f"Shape of {name} does not match expected"
-
-
-@pytest.mark.parametrize(
-    ("filter_func", "filter_name"), zip(filter_funcs, filter_names), ids=filter_names
-)
-@pytest.mark.parametrize("p", [1, 5], ids=["univariate (p=1)", "multivariate (p=5)"])
-def test_missing_data(filter_func, filter_name, p, rng):
-    m, r, n = 5, 1, 10
-    inputs = make_test_inputs(p, m, r, n, rng, missing_data=1)
-
-    outputs = filter_func(*inputs)
-    for output_idx, name in enumerate(output_names):
-        expected_output = get_expected_shape(name, p, m, r, n)
-        assert (
-            outputs[output_idx].shape == expected_output
-        ), f"Shape of {name} does not match expected"
-
-
-@pytest.mark.parametrize("filter_func", filter_funcs, ids=filter_names)
-@pytest.mark.parametrize("output_idx", [(0, 2), (3, 5)], ids=["smoothed_states", "smoothed_covs"])
-def test_last_smoother_is_last_filtered(filter_func, output_idx, rng):
-    p, m, r, n = 1, 5, 1, 10
-    inputs = make_test_inputs(p, m, r, n, rng)
-    outputs = filter_func(*inputs)
-
-    filtered = outputs[output_idx[0]]
-    smoothed = outputs[output_idx[1]]
-
-    assert_allclose(filtered[-1], smoothed[-1])
-
-
-@pytest.mark.parametrize(
-    "filter_func, filter_name", zip(filter_funcs, filter_names), ids=filter_names
-)
-@pytest.mark.parametrize("n_missing", [0, 5], ids=["n_missing=0", "n_missing=5"])
-@pytest.mark.skipif(floatX == "float32", reason="Tests are too sensitive for float32")
-def test_filters_match_statsmodel_output(filter_func, filter_name, n_missing, rng):
-    fit_sm_mod, [data, a0, P0, c, d, T, Z, R, H, Q] = nile_test_test_helper(rng, n_missing)
-    if filter_name == "CholeskyFilter":
-        P0 = np.linalg.cholesky(P0)
-    inputs = [data, a0, P0, c, d, T, Z, R, H, Q]
-    outputs = filter_func(*inputs)
-
-    for output_idx, name in enumerate(output_names):
-        ref_val = get_sm_state_from_output_name(fit_sm_mod, name)
-        val_to_test = outputs[output_idx].squeeze()
-
-        if name == "smoothed_covs":
-            # TODO: The smoothed covariance matrices have large errors (1e-2) ONLY in the first few states -- no idea why.
-            assert_allclose(
-                val_to_test[5:],
-                ref_val[5:],
-                atol=ATOL,
-                rtol=RTOL,
-                err_msg=f"{name} does not match statsmodels",
-            )
-        elif name.startswith("predicted"):
-            # statsmodels doesn't throw away the T+1 forecast in the predicted states like we do
-            assert_allclose(
-                val_to_test,
-                ref_val[:-1],
-                atol=ATOL,
-                rtol=RTOL,
-                err_msg=f"{name} does not match statsmodels",
-            )
-        else:
-            # Need atol = 1e-7 for smoother tests to pass
-            assert_allclose(
-                val_to_test,
-                ref_val,
-                atol=ATOL,
-                rtol=RTOL,
-                err_msg=f"{name} does not match statsmodels",
-            )
-
-
-@pytest.mark.parametrize(
-    "filter_func, filter_name", zip(filter_funcs[:-1], filter_names[:-1]), ids=filter_names[:-1]
-)
-@pytest.mark.parametrize("n_missing", [0, 5], ids=["n_missing=0", "n_missing=5"])
-@pytest.mark.parametrize("obs_noise", [True, False])
-def test_all_covariance_matrices_are_PSD(filter_func, filter_name, n_missing, obs_noise, rng):
-    if (floatX == "float32") & (filter_name == "UnivariateFilter"):
-        # TODO: These tests all pass locally for me with float32 but they fail on the CI, so i'm just disabling them.
-        pytest.skip("Univariate filter not stable at half precision without measurement error")
-
-    fit_sm_mod, [data, a0, P0, c, d, T, Z, R, H, Q] = nile_test_test_helper(rng, n_missing)
-    if filter_name == "CholeskyFilter":
-        P0 = np.linalg.cholesky(P0)
-
-    H *= int(obs_noise)
-    inputs = [data, a0, P0, c, d, T, Z, R, H, Q]
-    outputs = filter_func(*inputs)
-
-    for output_idx, name in zip([3, 4, 5], output_names[3:-2]):
-        cov_stack = outputs[output_idx]
-        w, v = np.linalg.eig(cov_stack)
-
-        assert_array_less(0, w, err_msg=f"Smallest eigenvalue of {name}: {min(w.ravel())}")
-        assert_allclose(
-            cov_stack,
-            np.swapaxes(cov_stack, -2, -1),
-            rtol=RTOL,
-            atol=ATOL,
-            err_msg=f"{name} is not symmetrical",
-        )
-
-
-@pytest.mark.parametrize(
-    "filter",
-    [StandardFilter, SquareRootFilter],
-    ids=["standard", "cholesky"],
-)
-def test_kalman_filter_jax(filter):
-    pytest.importorskip("jax")
-    from pymc.sampling.jax import get_jaxified_graph
-
-    # TODO: Add UnivariateFilter to test; need to figure out the broadcasting issue when 2nd data dim is defined
-
-    p, m, r, n = 1, 5, 1, 10
-    inputs, outputs = initialize_filter(filter(), mode="JAX", p=p, m=m, r=r, n=n)
-    inputs_np = make_test_inputs(p, m, r, n, rng)
-
-    f_jax = get_jaxified_graph(inputs, outputs)
-    f_pt = pytensor.function(inputs, outputs, mode="FAST_COMPILE")
-
-    jax_outputs = f_jax(*inputs_np)
-    pt_outputs = f_pt(*inputs_np)
-
-    for name, jax_res, pt_res in zip(output_names, jax_outputs, pt_outputs):
-        assert_allclose(jax_res, pt_res, atol=ATOL, rtol=RTOL, err_msg=f"{name} failed!")