コード例 #1
0
def test5():
    """The tests checks if the simulation process works even if the covariance between
    U1 and V and U0 and V is equal. Further the test ensures that the mte_information
    function returns the same value for each quantile.
    """
    for _ in range(10):
        generate_random_dict()
        init_dict = read("test.grmpy.yml")

        # We impose that the covariance between the random components of the potential
        # outcomes and the random component determining choice is identical.
        init_dict["DIST"]["params"][2] = init_dict["DIST"]["params"][4]

        # Distribute information
        coeffs_untreated = init_dict["UNTREATED"]["params"]
        coeffs_treated = init_dict["TREATED"]["params"]

        # Construct auxiliary information
        cov = construct_covariance_matrix(init_dict)

        df = simulate("test.grmpy.yml")

        x = df[list(
            set(init_dict["TREATED"]["order"] +
                init_dict["UNTREATED"]["order"]))]

        q = [0.01] + list(np.arange(0.05, 1, 0.05)) + [0.99]
        mte = mte_information(coeffs_treated, coeffs_untreated, cov, q, x,
                              init_dict)

        # We simply test that there is a single unique value for the marginal treatment
        #  effect.
        np.testing.assert_equal(len(set(mte)), 1)
コード例 #2
0
def test5():
    """The tests checks if the simulation process works even if the covariance between U1 and V
    and U0 and V is equal. Further the test ensures that the mte_information function returns
    the same value for each quantile.
    """
    for _ in range(10):
        generate_random_dict()
        init_dict = read('test.grmpy.ini')

        # We impose that the covariance between the random components of the potential
        # outcomes and the random component determining choice is identical.
        init_dict['DIST']['all'][2] = init_dict['DIST']['all'][4]

        # Distribute information
        coeffs_untreated = init_dict['UNTREATED']['all']
        coeffs_treated = init_dict['TREATED']['all']

        # Construct auxiliary information
        cov = construct_covariance_matrix(init_dict)

        df = simulate('test.grmpy.ini')
        x = df.filter(regex=r'^X\_', axis=1)
        q = [0.01] + list(np.arange(0.05, 1, 0.05)) + [0.99]
        mte = mte_information(coeffs_treated, coeffs_untreated, cov, q, x)

        # We simply test that there is a single unique value for the marginal treatment effect.
        np.testing.assert_equal(len(set(mte)), 1)
コード例 #3
0
def is_pos_def(dict_):
    """The function tests if the specified covariance matrix is positive semi definite."""
    cov = construct_covariance_matrix(dict_)
    try:
        np.linalg.cholesky(cov)
        return True
    except LinAlgError:
        return False
コード例 #4
0
def test6():
    """The test ensures that the cholesky decomposition and recomposition works appropriately.
    For this purpose the test creates a positive smi definite matrix fom a wishart distribution,
    decomposes this matrix with, reconstruct it and compares the matrix with the one that was
    specified as the input for the decomposition process.
    """
    pseudo_dict = {'DIST': {'all': []}, 'AUX': {'init_values': []}}
    for _ in range(20):
        b = wishart.rvs(df=10, scale=np.identity(3), size=1)
        parameter = b[np.triu_indices(3)]
        for i in [0, 3, 5]:
            parameter[i] **= 0.5
        pseudo_dict['DIST']['all'] = parameter
        pseudo_dict['AUX']['init_values'] = parameter
        cov_1 = construct_covariance_matrix(pseudo_dict)
        x0, _ = provide_cholesky_decom(pseudo_dict, [], 'init')
        output = backward_cholesky_transformation(x0, test=True)
        output = adjust_output_cholesky(output)
        pseudo_dict['DIST']['all'] = output
        cov_2 = construct_covariance_matrix(pseudo_dict)
        np.testing.assert_array_almost_equal(cov_1, cov_2)
    cleanup()
コード例 #5
0
def weights_treatment_parameters(init_dict, GRID):
    """This function calculates the weights for the special case in
    Heckman & Vytlacil (2005) Figure 1B.

    """
    GRID = np.linspace(0.01, 0.99, num=99, endpoint=True)

    coeffs_untreated = init_dict['UNTREATED']['all']
    coeffs_treated = init_dict['TREATED']['all']
    cov = construct_covariance_matrix(init_dict)

    x = simulate_covariates(init_dict)
    x = x[:, :2]

    # We take the specified distribution for the cost shifters from the paper.
    cost_mean, cost_sd = -0.0026, np.sqrt(0.270)
    v_mean, v_sd = 0.00, np.sqrt(cov[2, 2])

    eval_points = norm.ppf(GRID, loc=v_mean, scale=v_sd)

    ate_weights = np.tile(1.0, 99)
    tut_weights = norm.cdf(eval_points, loc=cost_mean, scale=cost_sd)

    tt_weights = 1 - tut_weights

    def tut_integrand(point):
        eval_point = norm.ppf(point, loc=v_mean, scale=v_sd)
        return norm.cdf(eval_point, loc=cost_mean, scale=cost_sd)

    def tt_integrand(point):
        eval_point = norm.ppf(point, loc=v_mean, scale=v_sd)
        return norm.cdf(eval_point, loc=cost_mean, scale=cost_sd)

    # Scaling so that the weights integrate to one.
    tut_scaling = quad(tut_integrand, 0.01, 0.99)[0]
    tut_weights /= tut_scaling

    tt_scaling = quad(tt_integrand, 0.01, 0.99)[0]
    tt_weights /= tt_scaling

    mte = mte_information(coeffs_treated, coeffs_untreated, cov, GRID, x,
                          init_dict)

    return ate_weights, tt_weights, tut_weights, mte
コード例 #6
0
def provide_cholesky_decom(init_dict, x0, option, sd_=None):
    """The function transforms the start covariance matrix into its cholesky decomposition."""
    if option == 'init':
        cov = construct_covariance_matrix(init_dict)
        L = np.linalg.cholesky(cov)
        L = L[np.tril_indices(3)]
        distribution_characteristics = init_dict['AUX']['init_values'][-6:]
        x0 = np.concatenate((x0, L))

    elif option == 'auto':
        distribution_characteristics = [sd_[0], init_dict['DIST']['all'][1], 0, sd_[1], 0,
                                        init_dict['DIST']['all'][5]]
        cov = np.zeros((3, 3))
        cov[np.triu_indices(3)] = [distribution_characteristics]
        cov[np.tril_indices(3, k=-1)] = cov[np.triu_indices(3, k=1)]
        cov[np.diag_indices(3)] **= 2
        L = np.linalg.cholesky(cov)
        L = L[np.tril_indices(3)]
        x0 = np.concatenate((x0, L))
    init_dict['AUX']['cholesky_decomposition'] = L.tolist()
    start = [i for i in x0] + distribution_characteristics

    return x0, start
コード例 #7
0
        index = GRID.index(round(xtick, 2))
        height = mte[index]
        ax.text(x=xtick - 0.002, y=height - 0.1, s='[', fontsize=30)
    for xtick in [0.39, 0.79]:
        index = GRID.index(round(xtick, 2))
        height = mte[index]
        ax.text(x=xtick - 0.01, y=height - 0.1, s=']', fontsize=30)

    ax.set_xlabel('$u_S$')
    ax.set_ylabel(r'$B^{MTE}$')

    ax.set_xticks([0, 0.2, 0.4, 0.6, 0.8, 1])
    ax.set_xticklabels([0, '$p_1$', '$p_2$', '$p_3$', '$p_4$', 1])
    ax.tick_params(axis='x', which='major')
    ax.set_ylim([1.5, 4.5])

    plt.tight_layout()
    plt.savefig(ppj("OUT_FIGURES", 'fig-local-average-treatment.png'))


if __name__ == '__main__':

    coeffs_untreated = init_dict['UNTREATED']['all']
    coeffs_treated = init_dict['TREATED']['all']
    cov = construct_covariance_matrix(init_dict)
    x = np.loadtxt(ppj("OUT_DATA", "X.csv"), delimiter=",")
    x = x.reshape(165, 2)

    mte = mte_information(coeffs_treated, coeffs_untreated, cov, GRID, x)

    plot_local_average_treatment(mte)
コード例 #8
0
ファイル: auxiliary.py プロジェクト: fagan2888/grmpy
def is_pos_def(dict_):
    """The function tests if the specified covariance matrix is positive semi
    definite.
    """
    return np.all(np.linalg.eigvals(construct_covariance_matrix(dict_)) >= 0)