Пример #1
0
def test_results_access(data):
    mod = PooledOLS(data.y, data.x)
    res = mod.fit(debiased=False)
    d = dir(res)
    for key in d:
        if not key.startswith('_'):
            val = getattr(res, key)
            if callable(val):
                val()

    mod = PooledOLS(data.y, data.x)
    res = mod.fit(debiased=True)
    d = dir(res)
    for key in d:
        if not key.startswith('_'):
            val = getattr(res, key)
            if callable(val):
                val()

    if not isinstance(data.x, pd.Panel):
        return
    x = data.y.copy()
    x.iloc[:, :] = 1
    mod = PooledOLS(data.y, x)
    res = mod.fit(debiased=False)
    d = dir(res)
    for key in d:
        if not key.startswith('_'):
            val = getattr(res, key)
            if callable(val):
                val()
def test_alt_cov(data, cov_type):
    mod = PooledOLS(data.y, data.x)
    res = mod.fit(cov_type=cov_type)
    res_def = mod.fit()
    assert not np.all(np.isclose(res.cov, res_def.cov))
    if cov_type.startswith("a"):
        cov_name = "Autocorrelation Rob. Cov."
    else:
        cov_name = "Driscoll-Kraay"
    assert cov_name in str(res.summary)
Пример #3
0
def test_cov_equiv(data):
    mod = PooledOLS(data.y, data.x)
    res = mod.fit(cov_type='robust', debiased=False)
    y = mod.dependent.dataframe.copy()
    x = mod.exog.dataframe.copy()
    y.index = np.arange(len(y))
    x.index = y.index
    res2 = IV2SLS(y, x, None, None).fit(cov_type='robust')
    assert_results_equal(res, res2)

    res3 = mod.fit(cov_type='heteroskedastic', debiased=False)
    assert_results_equal(res, res3)
Пример #4
0
def test_pooled_ols(data):
    mod = PooledOLS(data.y, data.x)
    res = mod.fit(debiased=False)

    y = mod.dependent.dataframe.copy()
    x = mod.exog.dataframe.copy()
    y.index = np.arange(len(y))
    x.index = y.index

    res2 = IV2SLS(y, x, None, None).fit(cov_type="unadjusted")
    assert_results_equal(res, res2)

    res3 = mod.fit(cov_type="homoskedastic", debiased=False)
    assert_results_equal(res, res3)
Пример #5
0
def test_cov_equiv_weighted(data):
    mod = PooledOLS(data.y, data.x, weights=data.w)
    res = mod.fit(cov_type="robust", debiased=False)
    y = mod.dependent.dataframe.copy()
    x = mod.exog.dataframe.copy()
    w = mod.weights.dataframe.copy()
    y.index = np.arange(len(y))
    w.index = x.index = y.index

    res2 = IV2SLS(y, x, None, None, weights=w).fit(cov_type="robust")
    assert_results_equal(res, res2)

    res3 = mod.fit(cov_type="heteroskedastic", debiased=False)
    assert_results_equal(res, res3)
Пример #6
0
def test_results_access(data):
    mod = PooledOLS(data.y, data.x)
    res = mod.fit(debiased=False)
    access_attributes(res)

    mod = PooledOLS(data.y, data.x)
    res = mod.fit(debiased=True)
    access_attributes(res)

    if not isinstance(data.x, pd.DataFrame):
        return
    x = data.y.copy()
    x.iloc[:, :] = 1
    mod = PooledOLS(data.y, x)
    res = mod.fit(debiased=False)
    access_attributes(res)
Пример #7
0
def test_pooled_ols_weighted(data):
    mod = PooledOLS(data.y, data.x, weights=data.w)
    res = mod.fit(debiased=False)

    y = mod.dependent.dataframe
    x = mod.exog.dataframe
    w = mod.weights.dataframe
    y.index = np.arange(len(y))
    w.index = x.index = y.index

    res2 = IV2SLS(y, x, None, None, weights=w).fit(cov_type='unadjusted')
    assert_results_equal(res, res2)
Пример #8
0
def test_cov_equiv_cluster_weighted(data):
    mod = PooledOLS(data.y, data.x, weights=data.w)
    res = mod.fit(cov_type='clustered', clusters=data.vc1, debiased=False)

    y = mod.dependent.dataframe.copy()
    x = mod.exog.dataframe.copy()
    w = mod.weights.dataframe
    y.index = np.arange(len(y))
    w.index = x.index = y.index
    clusters = mod.reformat_clusters(data.vc1)
    ols_mod = IV2SLS(y, x, None, None, weights=w)
    res2 = ols_mod.fit(cov_type='clustered', clusters=clusters.dataframe)
    assert_results_equal(res, res2)
Пример #9
0
def test_cov_equiv_cluster(data):
    mod = PooledOLS(data.y, data.x)
    res = mod.fit(cov_type='clustered', cluster_entity=True, debiased=False)
    y = PanelData(data.y)
    clusters = pd.DataFrame(y.entity_ids, index=y.index)
    res2 = mod.fit(cov_type='clustered', clusters=clusters, debiased=False)
    assert_results_equal(res, res2)

    res = mod.fit(cov_type='clustered', cluster_time=True, debiased=False)
    clusters = pd.DataFrame(y.time_ids, index=y.index)
    res2 = mod.fit(cov_type='clustered', clusters=clusters, debiased=False)
    assert_results_equal(res, res2)

    res = mod.fit(cov_type='clustered', clusters=data.vc1, debiased=False)
    y = mod.dependent.dataframe.copy()
    x = mod.exog.dataframe.copy()
    y.index = np.arange(len(y))
    x.index = y.index
    clusters = mod.reformat_clusters(data.vc1)
    ols_mod = IV2SLS(y, x, None, None)
    res2 = ols_mod.fit(cov_type='clustered', clusters=clusters.dataframe, debiased=False)
    assert_results_equal(res, res2)
Пример #10
0
def test_f_pooled(data):
    mod = PanelOLS(data.y, data.x, entity_effects=True)
    res = mod.fit(debiased=False)

    if mod.has_constant:
        mod2 = PooledOLS(data.y, data.x)
    else:
        exog = mod.exog.dataframe.copy()
        exog['Intercept'] = 1.0
        mod2 = PooledOLS(mod.dependent.dataframe, exog)

    res2 = mod2.fit(debiased=False)

    eps = res.resids.values
    eps2 = res2.resids.values
    v1 = res.df_model - res2.df_model
    v2 = res.df_resid
    f_pool = (eps2.T @ eps2 - eps.T @ eps) / v1
    f_pool /= ((eps.T @ eps) / v2)
    f_pool = float(f_pool)
    assert_allclose(res.f_pooled.stat, f_pool)
    assert res.f_pooled.df == v1
    assert res.f_pooled.df_denom == v2

    mod = PanelOLS(data.y, data.x, time_effects=True)
    res = mod.fit(debiased=False)
    eps = res.resids.values
    eps2 = res2.resids.values
    v1 = res.df_model - res2.df_model
    v2 = res.df_resid
    f_pool = (eps2.T @ eps2 - eps.T @ eps) / v1
    f_pool /= ((eps.T @ eps) / v2)
    f_pool = float(f_pool)
    assert_allclose(res.f_pooled.stat, f_pool)
    assert res.f_pooled.df == v1
    assert res.f_pooled.df_denom == v2

    mod = PanelOLS(data.y, data.x, entity_effects=True, time_effects=True)
    res = mod.fit(debiased=False)
    eps = res.resids.values
    eps2 = res2.resids.values
    v1 = res.df_model - res2.df_model
    v2 = res.df_resid
    f_pool = (eps2.T @ eps2 - eps.T @ eps) / v1
    f_pool /= ((eps.T @ eps) / v2)
    f_pool = float(f_pool)
    assert_allclose(res.f_pooled.stat, f_pool)
    assert res.f_pooled.df == v1
    assert res.f_pooled.df_denom == v2
Пример #11
0
def test_fitted_effects_residuals(data):
    mod = PooledOLS(data.y, data.x)
    res = mod.fit()
    expected = pd.DataFrame(res.resids.copy())
    expected.columns = ['idiosyncratic']
    assert_allclose(res.idiosyncratic, expected)
    assert_frame_similar(res.idiosyncratic, expected)

    expected = mod.dependent.values2d - res.resids.values[:, None]
    expected = pd.DataFrame(expected, index=res.resids.index, columns=['fitted_values'])
    assert_allclose(res.fitted_values, expected)
    assert_frame_similar(res.fitted_values, expected)

    expected.iloc[:, 0] = np.nan
    expected.columns = ['estimated_effects']
    assert_allclose(res.estimated_effects, expected)
    assert_frame_similar(res.estimated_effects, expected)
Пример #12
0
def test_two_way_clustering(data):
    mod = PooledOLS(data.y, data.x)

    y = PanelData(data.y)
    entity_clusters = pd.DataFrame(y.entity_ids, index=y.index)
    vc1 = PanelData(data.vc1)
    clusters = vc1.copy()
    clusters.dataframe['var.cluster.entity'] = entity_clusters
    clusters._frame = clusters._frame.astype(np.int64)
    res = mod.fit(cov_type='clustered', clusters=clusters, debiased=False)

    y = mod.dependent.dataframe.copy()
    x = mod.exog.dataframe.copy()
    y.index = np.arange(len(y))
    x.index = y.index
    clusters = mod.reformat_clusters(clusters)

    ols_mod = IV2SLS(y, x, None, None)
    ols_res = ols_mod.fit(cov_type='clustered', clusters=clusters.dataframe)
    assert_results_equal(res, ols_res)
Пример #13
0
def test_alt_rsquared_weighted(data):
    mod = PooledOLS(data.y, data.x, weights=data.w)
    res = mod.fit(debiased=False)
    assert_allclose(res.rsquared, res.rsquared_overall)
def test_extra_df(data):
    mod = PooledOLS(data.y, data.x)
    res = mod.fit()
    res_extra = mod.fit(extra_df=10)
    assert np.all(np.diag(res_extra.cov) > np.diag(res.cov))