Esempio n. 1
0
def ppm_experiment_1d(seed, sigma, L, b, Ncopy, use_signal_prior):
    np.random.seed(seed)

    n_iter = 1000
    tol = 1e-7
    # Generate MRA measurements
    y, s, n, x = make_data_1d(L, Ncopy, sigma, b)

    if use_signal_prior:
        b_prior = b
    else:
        b_prior = None
    t = time()
    y_s, s = synchronize_1d(y, method='ppm')
    x_init = np.expand_dims(np.mean(y_s, axis=1), axis=-1)

    t_ppm = time() - t
    err_ppm = relative_error_1d(x_init, x)

    results = pd.DataFrame()
    results = results.append(
        {
            'use_signal_prior': use_signal_prior,
            'L': L,
            'b': b,
            'sigma': sigma,
            'seed': seed,
            'N': Ncopy,
            'err': err_ppm,
            'num_iter': 0,
            't': t_ppm
        },
        ignore_index=True)

    return results
Esempio n. 2
0
def ppm_synch_em_experiment(seed, sigma, L, b, Ncopy, use_signal_prior):
    np.random.seed(seed)

    n_iter = 1000
    tol = 1e-7
    # Generate MRA measurements
    y, s, n, x = make_data_1d(L, Ncopy, sigma, b)

    if use_signal_prior:
        b_prior = b
    else:
        b_prior = None

    y_s, s_est = synchronize_1d(y, method='ppm')
    x_init = np.expand_dims(np.mean(y_s, axis=1), axis=-1)

    print('start em processing')
    t = time()
    x_est_em, rho_est_em, num_iter_em_uniform = em_1d(y_s,
                                                      sigma,
                                                      n_iter,
                                                      tol,
                                                      x_init,
                                                      b=b_prior,
                                                      rho_prior=None,
                                                      uniform=False)

    t_em_uniform = time() - t
    err_em_uniform = relative_error_1d(x_est_em, x)

    h, bin_edges = np.histogram((s_est - s) % L, bins=np.arange(-0.5, L + 0.5))
    measured_rho = h / np.sum(h)

    results = pd.DataFrame()
    results = results.append(
        {
            'use_signal_prior': use_signal_prior,
            'L': L,
            'b': b,
            'sigma': sigma,
            'seed': seed,
            'N': Ncopy,
            'err': err_em_uniform,
            'num_iter': num_iter_em_uniform,
            't': t_em_uniform
        },
        ignore_index=True)

    return results
Esempio n. 3
0
def synchronize_and_match_em_experiment(seed, sigma, L, b, Ncopy,
                                        use_signal_prior, P):
    np.random.seed(seed)

    n_iter = 1000
    tol = 1e-7
    # Generate MRA measurements
    y, s, n, x = make_data_1d(L, Ncopy, sigma, b)

    if use_signal_prior:
        b_prior = b
    else:
        b_prior = None

    y_s, s, _, _ = synchronize_and_match_1d(y, P)
    x_init = np.expand_dims(np.mean(y_s, axis=1), axis=-1)

    print('start em processing')
    t = time()
    x_est_em, rho_est_em, num_iter_em_uniform = em_1d(y_s,
                                                      sigma,
                                                      n_iter,
                                                      tol,
                                                      x_init,
                                                      b=b_prior,
                                                      rho_prior=None,
                                                      uniform=False)

    t_em_uniform = time() - t
    err_em_uniform = relative_error_1d(x_est_em, x)

    results = pd.DataFrame()
    results = results.append(
        {
            'use_signal_prior': use_signal_prior,
            'L': L,
            'b': b,
            'sigma': sigma,
            'seed': seed,
            'N': Ncopy,
            'err': err_em_uniform,
            'num_iter': num_iter_em_uniform,
            't': t_em_uniform
        },
        ignore_index=True)

    return results
Esempio n. 4
0
def synch_em_1d_experiment(seed, sigma, L, b, Ncopy, use_signal_prior, P,
                           gamma):
    np.random.seed(seed)

    n_iter = 1000
    tol = 1e-7
    # Generate MRA measurements
    y, s, n, x = make_data_1d(L, Ncopy, sigma, b)

    if use_signal_prior:
        b_prior = b
    else:
        b_prior = None
    t = time()
    y_s, s_est, _, _ = synchronize_and_match_1d(y, P)
    #y_s, s_est = synchronize_1d(y,method='ppm')
    t_synch = time() - t
    x_init = np.expand_dims(np.mean(y_s, axis=1), axis=-1)

    h, bin_edges = np.histogram((s_est - s) % L, bins=np.arange(-0.5, L + 0.5))
    measured_rho = h / np.sum(h)

    print('start synch em 1d processing')
    t = time()
    x_est_em, rho_est_em, num_iter_em_uniform = em_1d(y_s,
                                                      sigma,
                                                      n_iter,
                                                      tol,
                                                      x_init,
                                                      b=b_prior,
                                                      rho_prior=(measured_rho,
                                                                 gamma),
                                                      uniform=False)

    t_em_uniform = time() - t

    err_em_uniform = relative_error_1d(x_est_em, x)

    plt.plot(measured_rho)
    plt.xlabel('shift')
    plt.ylabel('Probability')
    plt.savefig(
        'est_dist/rho_est_L_%d_sigma_%.2f_N_%d_b_%d_seed_%d_SNR_%.2f.png' %
        (L, sigma, Ncopy, b, seed, 1 / sigma**2))
    plt.clf()

    results = pd.DataFrame()
    results = results.append(
        {
            'use_signal_prior': use_signal_prior,
            'L': L,
            'b': b,
            'sigma': sigma,
            'seed': seed,
            'N': Ncopy,
            'err': err_em_uniform,
            'num_iter': num_iter_em_uniform,
            't': t_synch + t_em_uniform
        },
        ignore_index=True)

    return results