def test_noconstant():
exog = exog_st[:, :-1] # with const removed at end
mod = gmm.IV2SLS(endog, exog, instrument)
res = mod.fit()
assert_equal(res.fvalue, np.nan)
# smoke test
res.summary()
def test_input_dimensions(self):
rs = np.random.RandomState(1234)
x = rs.randn(200, 2)
z = rs.randn(200)
x[:, 0] = np.sqrt(0.5) * x[:, 0] + np.sqrt(0.5) * z
z = np.column_stack((x[:, [1]], z[:, None]))
e = np.sqrt(0.5) * rs.randn(200) + np.sqrt(0.5) * x[:, 0]
y_1d = y = x[:, 0] + x[:, 1] + e
y_2d = y[:, None]
y_series = pd.Series(y)
y_df = pd.DataFrame(y_series)
x_1d = x[:, 0]
x_2d = x
x_df = pd.DataFrame(x)
x_df_single = x_df.iloc[:, [0]]
x_series = x_df.iloc[:, 0]
z_2d = z
z_series = pd.Series(z[:, 1])
z_1d = z_series.values
z_df = pd.DataFrame(z)
ys = (y_df, y_series, y_2d, y_1d)
xs = (x_2d, x_1d, x_df_single, x_df, x_series)
zs = (z_1d, z_2d, z_series, z_df)
res2 = gmm.IV2SLS(y_1d, x_2d, z_2d).fit()
res1 = gmm.IV2SLS(y_1d, x_1d, z_1d).fit()
res1_2sintr = gmm.IV2SLS(y_1d, x_1d, z_2d).fit()
for _y in ys:
for _x in xs:
for _z in zs:
x_1d = np.size(_x) == _x.shape[0]
z_1d = np.size(_z) == _z.shape[0]
if z_1d and not x_1d:
continue
res = gmm.IV2SLS(_y, _x, _z).fit()
if z_1d:
assert_allclose(res.params, res1.params)
elif x_1d and not z_1d:
assert_allclose(res.params, res1_2sintr.params)
else:
assert_allclose(res.params, res2.params)
def setup_class(cls):
exog = exog_st # with const at end
start = OLS(endog, exog).fit().params
nobs, k_instr = instrument.shape
mod = gmm.IV2SLS(endog, exog, instrument)
res = mod.fit()
cls.res1 = res
from .results_ivreg2_griliches import results_small as results
cls.res2 = results
def test_iv2sls_r():
mod = gmm.IV2SLS(endog, exog, instrument)
res = mod.fit()
# print(res.params)
# print(res.params - params)
n, k = exog.shape
assert_allclose(res.params, params, rtol=1e-7, atol=1e-9)
# TODO: check df correction
#assert_allclose(res.bse * np.sqrt((n - k) / (n - k - 1.)), bse,
assert_allclose(res.bse, bse, rtol=0, atol=3e-7)
elif exampledata == 'ivfake':
endog, exog, instrument = sample_ivfake(X)
#using GMM and IV2SLS classes
#----------------------------
mod = gmm.IVGMM(endog, exog, instrument, nmoms=instrument.shape[1])
res = mod.fit()
modgmmols = gmm.IVGMM(endog, exog, exog, nmoms=exog.shape[1])
resgmmols = modgmmols.fit()
#the next is the same as IV2SLS, (Z'Z)^{-1} as weighting matrix
modgmmiv = gmm.IVGMM(endog, exog, instrument, nmoms=instrument.shape[1]) #same as mod
resgmmiv = modgmmiv.fitgmm(np.ones(exog.shape[1], float),
weights=np.linalg.inv(np.dot(instrument.T, instrument)))
modls = gmm.IV2SLS(endog, exog, instrument)
resls = modls.fit()
modols = OLS(endog, exog)
resols = modols.fit()
print('\nIV case')
print('params')
print('IV2SLS', resls.params)
print('GMMIV ', resgmmiv) # .params
print('GMM ', res.params)
print('diff ', res.params - resls.params)
print('OLS ', resols.params)
print('GMMOLS', resgmmols.params)
print('\nbse')
print('IV2SLS', resls.bse)
Sigma = [[1.0, 0.8], [0.8, 1.0]]
mu = [0, 0]
errors = np.random.multivariate_normal(mu, Sigma, 1000)
eta = errors[:, 0]
xi = errors[:, 1]
# Create Z, x, y
Z = np.random.multivariate_normal([0] * 20, np.identity(20), 1000)
x = 0.1 * Z[:, 0] + xi
y = x + eta
x = sm.add_constant(x)
Z = sm.add_constant(x)
ols = sm.OLS(y, x).fit().params[1]
# tsls = np.linalg.inv(np.transpose(Z).dot(x)).dot(np.transpose(Z).dot(y))[1]
tsls = gmm.IV2SLS(y, x, Z).fit().params[1]
def LIML(exogenous, endogenous, instruments):
y = exogenous
x = endogenous
Z = instruments
I = np.eye(y.shape[0])
Mz = I - Z.dot(np.linalg.inv(np.transpose(Z).dot(Z))).dot(np.transpose(Z))
Mx = I - x.dot(np.linalg.inv(np.transpose(x).dot(x))).dot(np.transpose(x))
A = np.transpose(np.hstack((y, x[:,
1]))).dot(Mz).dot(np.hstack((y, x[:, 1])))
k = 1
beta = np.linalg.inv(np.transpose(Z).dot(I - k * M).dot(Z)).dot(
np.transpose(Z).dot(I - k * M)).dot(y)
return
