Example #1
0
        observation_cov=observation_cov,
        explosion_scale=EXPLOSION_SCALE,
        contamination_probability=CONTAMINATION,
        seed=SIMULATOR_SEED)
    vanilla_bpf_data, student_bpf_data, symmetric_robust_data, asymmetric_robust_data = [], [], [], []
    for _ in trange(runs):
        simulator, vanilla_bpf, student_bpfs, s_robust_bpfs, a_robust_bpf = experiment_step(
            simulator)
        vanilla_bpf_data.append(
            compute_mse_and_coverage(simulator, vanilla_bpf))
        student_bpf_data.append([
            compute_mse_and_coverage(simulator, t_bpf)
            for t_bpf in student_bpfs
        ])
        symmetric_robust_data.append([
            compute_mse_and_coverage(simulator, robust_bpf)
            for robust_bpf in s_robust_bpfs
        ])
        asymmetric_robust_data.append(
            compute_mse_and_coverage(simulator, a_robust_bpf))

    return np.array(vanilla_bpf_data), np.array(student_bpf_data),\
           np.array(symmetric_robust_data), np.array(asymmetric_robust_data)


if __name__ == '__main__':
    results = run(NUM_RUNS)
    pickle_save(
        f'./results/constant-velocity/asymmetric_noise/student_t_comparison.pk',
        results)
        final_time=FINAL_TIME,
        time_step=TIME_STEP,
        observation_std=NOISE_STD,
        process_std=process_std,
        contamination_probability=contamination,
        degrees_of_freedom=1.01,
        seed=SIMULATOR_SEED
    )
    vanilla_bpf_data, student_bpf_data, robust_bpf_data = [], [], []
    robust_predictive_data = []
    for _ in trange(runs):
        simulator, vanilla_bpf, student_bpf, robust_bpfs = experiment_step(simulator)
        vanilla_bpf_data.append(compute_mse_and_coverage(simulator, vanilla_bpf))
        student_bpf_data.append(compute_mse_and_coverage(simulator, student_bpf))
        robust_bpf_data.append([compute_mse_and_coverage(simulator, robust_bpf) for robust_bpf in robust_bpfs])

        robust_predictive_data.append([compute_predictive_score(simulator, robust_bpf) for robust_bpf in robust_bpfs])

    return (np.array(vanilla_bpf_data), np.array(student_bpf_data), np.array(robust_bpf_data)), \
           np.array(robust_predictive_data)


if __name__ == '__main__':
    for contamination in CONTAMINATION:
        results, predictive_results = run(NUM_RUNS, contamination)
        pickle_save(f'./results/tan/impulsive_noise_with_finite_mean/beta-sweep-contamination-{contamination}.pk', results)
        pickle_save(
            f'./results/tan/impulsive_noise_with_finite_mean/beta-predictive-sweep-contamination-{contamination}.pk',
            predictive_results
        )
            coverage = np.sum(upper * lower) / simulator.X.shape[0]
            scores.append([mse, coverage])
    return scores


def run(runs, contamination):
    observation_cov = NOISE_VAR * np.eye(2)
    simulator = ConstantVelocityModel(
        final_time=FINAL_TIME,
        time_step=TIME_STEP,
        observation_cov=observation_cov,
        explosion_scale=EXPLOSION_SCALE,
        contamination_probability=contamination,
        seed=SIMULATOR_SEED
    )
    vanilla_bpf_data, robust_bpf_data, kalman_data = [], [], []
    for _ in trange(runs):
        simulator, kalman, vanilla_bpf, robust_bpfs = experiment_step(simulator)
        kalman_data.append(compute_mse_and_coverage(simulator, kalman))
        vanilla_bpf_data.append(compute_mse_and_coverage(simulator, vanilla_bpf))
        robust_bpf_data.append([compute_mse_and_coverage(simulator, robust_bpf) for robust_bpf in robust_bpfs])

    return np.array(kalman_data), np.array(vanilla_bpf_data), np.array(robust_bpf_data)


if __name__ == '__main__':
    for contamination in CONTAMINATION:
        results = run(NUM_RUNS, contamination)
        pickle_save(f'./results/constant-velocity/impulsive_noise/beta-sweep-contamination-{contamination}.pk', results)

Example #4
0
    X, Y, test_series = get_data()

    kalman_data = kalman_results(X, Y, test_series)

    vanilla_bpf_data, robust_bpf_data = [], []
    robust_predictive_data = []
    for _ in trange(runs):
        vanilla_smoother, robust_smoothers, vanilla_bpf, robust_bpfs = experiment_step(
            X, Y)
        vanilla_bpf_data.append(
            compute_mse_and_coverage(test_series, vanilla_smoother))
        robust_bpf_data.append([
            compute_mse_and_coverage(test_series, robust_smoother)
            for robust_smoother in robust_smoothers
        ])

        robust_predictive_data.append([
            compute_predictive_score(Y, robust_bpf)
            for robust_bpf in robust_bpfs
        ])

    return (np.array(kalman_data), np.array(vanilla_bpf_data),
            np.array(robust_bpf_data)), np.array(robust_predictive_data)


if __name__ == '__main__':
    results, predictive_results = run(NUM_RUNS)
    pickle_save(f'./results/air_quality/beta-sweep.pk', results)
    pickle_save(f'./results/air_quality/beta-predictive-sweep.pk',
                predictive_results)