def test_SUR_iter(
self
): #2 equations, same K in each, iterated estimation, spatial test
y_var0 = ['HR80', 'HR90']
x_var0 = [['PS80', 'UE80'], ['PS90', 'UE90']]
bigy0, bigX0, bigyvars0, bigXvars0 = sur_dictxy(
self.db, y_var0, x_var0)
reg = SUR(bigy0,bigX0,w=self.w,nonspat_diag=True,spat_diag=True,iter=True,verbose=False,\
name_bigy=bigyvars0,name_bigX=bigXvars0)
print reg
dict_compare(reg.bOLS,{0: np.array([[ 5.39719146],[ 0.6973813 ],\
[ 0.22566378]]), 1: np.array([[ 1.80829725],[ 1.03504143],[ 0.6582483 ]])},RTOL)
dict_compare(reg.bSUR,{0: np.array([[ 5.18423225],[ 0.67757925],\
[ 0.25706498]]), 1: np.array([[ 3.79731807],[ 1.02411196],[ 0.35895674]])},RTOL)
dict_compare(reg.sur_inf,{0: np.array([[ 2.59392406e-01, 1.99860602e+01, 7.28237551e-89],\
[ 1.21911330e-01, 5.55796781e+00, 2.72933704e-08],\
[ 3.38051365e-02, 7.60431727e+00, 2.86411830e-14]]),\
1: np.array([[ 2.53108919e-01, 1.50027035e+01, 7.04886598e-51],\
[ 1.13329850e-01, 9.03655976e+00, 1.61679985e-19],\
[ 3.40440433e-02, 1.05438928e+01, 5.42075621e-26]])},RTOL)
np.testing.assert_allclose(
reg.corr, np.array([[1., 0.5079133], [0.5079133, 1.]]), RTOL)
np.testing.assert_allclose(reg.surchow,[(23.457203761752844, 1, 1.2772356421778157e-06),\
(8.6998292497532859, 1, 0.0031823985960753743),\
(6.8426866249389589, 1, 0.0089004881389025351)],RTOL)
np.testing.assert_allclose(reg.llik, -19860.067987395596)
np.testing.assert_allclose(
reg.lmtest, (680.16759754291365, 1, 6.144389240997126e-150))
np.testing.assert_allclose(
reg.lrtest, (854.18095147295708, 1, 8.966465468792485e-188))
np.testing.assert_allclose(reg.lmEtest,
(1270.87724, 2, 1.07773778e-276))
def test_error_gm(self): #2 equations
y_var0 = ['HR80', 'HR90']
x_var0 = [['PS80', 'UE80'], ['PS90', 'UE90']]
bigy0, bigX0, bigyvars0, bigXvars0 = sur_dictxy(
self.db, y_var0, x_var0)
reg = SURerrorGM(bigy0,bigX0,self.w,\
name_bigy=bigyvars0,name_bigX=bigXvars0,spat_diag=False,\
name_w="natqueen",name_ds="natregimes",nonspat_diag=True)
dict_compare(reg.bSUR,{0: np.array([[ 3.9774686 ],[ 0.8902122 ],[ 0.43050364]]),\
1: np.array([[ 2.93679118],
[ 1.11002827],
[ 0.48761542]])},RTOL)
dict_compare(reg.sur_inf,{0: np.array([[ 3.72514769e-01, 1.06773447e+01, 1.29935073e-26],
[ 1.42242969e-01, 6.25839157e+00, 3.88968202e-10],
[ 4.32238809e-02, 9.95985619e+00, 2.28392844e-23]]),\
1: np.array([[ 3.36949019e-01, 8.71583239e+00, 2.88630055e-18],
[ 1.34136264e-01, 8.27537784e+00, 1.28048921e-16],
[ 4.03310502e-02, 1.20903229e+01, 1.18818750e-33]])},rtol=RTOL, atol=ATOL)
np.testing.assert_allclose(reg.lamsur,
np.array([[0.55099267], [0.52364925]]),
RTOL)
np.testing.assert_allclose(
reg.corr, np.array([[1., 0.29038532], [0.29038532, 1.]]), RTOL)
np.testing.assert_allclose(
reg.surchow,
[[5.5135078, 1., 0.01887016], [1.77544155, 1., 0.18271008],
[1.14089432, 1., 0.28546343]],
rtol=RTOL,
atol=ATOL)
def test_3SLS(self): # two equations, one endog, one instrument, same k
y_var1 = ['HR80', 'HR90']
x_var1 = [['PS80', 'UE80'], ['PS90', 'UE90']]
yend_var1 = [['RD80'], ['RD90']]
q_var1 = [['FP79'], ['FP89']]
bigy1, bigX1, bigyvars1, bigXvars1 = sur_dictxy(
self.db, y_var1, x_var1)
bigyend1, bigyendvars1 = sur_dictZ(self.db, yend_var1)
bigq1, bigqvars1 = sur_dictZ(self.db, q_var1)
reg = ThreeSLS(bigy1, bigX1, bigyend1, bigq1)
print 'test_3SLS'
print reg.summary
dict_compare(reg.b3SLS,{0: np.array([[ 6.92426353e+00],[ 1.42921826e+00],[ 4.94348442e-04],\
[ 3.58292750e+00]]), 1: np.array([[ 7.62385875],[ 1.65031181],[-0.21682974],[ 3.91250428]])},RTOL)
dict_compare(reg.tsls_inf,{0: np.array([[ 2.32208525e-001, 2.98191616e+001, 2.20522747e-195],\
[ 1.03734166e-001, 1.37777004e+001, 3.47155373e-043],\
[ 3.08619277e-002, 1.60180675e-002, 9.87219978e-001],\
[ 1.11319989e-001, 3.21858412e+001, 2.78527634e-227]]),\
1: np.array([[ 2.87394149e-001, 2.65275364e+001, 4.66554915e-155],\
[ 9.59703138e-002, 1.71960655e+001, 2.84185085e-066],\
[ 4.08954707e-002, -5.30204786e+000, 1.14510807e-007],\
[ 1.35867887e-001, 2.87963872e+001, 2.38043782e-182]])},RTOL)
np.testing.assert_allclose(
reg.corr, np.array([[1., 0.26404959], [0.26404959, 1.]]), RTOL)
np.testing.assert_allclose(reg.surchow,[(4.398001850528483, 1, 0.035981064325265613),\
(3.3042403886525147, 1, 0.069101286634542139),\
(21.712902666281863, 1, 3.1665430446850281e-06),\
(4.4286185200127388, 1, 0.035341101907069621)],RTOL)
def test_3SLS_3eq(self): #Three equations, no endogenous
y_var1 = ['HR60','HR70','HR80']
x_var1 = [['RD60','PS60'],['RD70','PS70','UE70'],['RD80','PS80']]
bigy1,bigX1,bigyvars1,bigXvars1 = sur_dictxy(self.db,y_var1,x_var1)
reg = SURlagIV(bigy1,bigX1,w=self.w,name_bigy=bigyvars1,name_bigX=bigXvars1,\
name_ds="NAT",name_w="nat_queen")
print reg.summary
dict_compare(reg.b2SLS,{0: np.array([[ 2.42754085],[ 1.48928052],[ 0.33812558],\
[ 0.45567848]]), 1: np.array([[ 4.83887747],[ 2.86272903],[ 0.96950417],\
[-0.12928124],[ 0.33328525]]), 2: np.array([[ 6.69407561],[ 3.81449588],\
[ 1.44603996],[ 0.03355501]])},RTOL)
dict_compare(reg.b3SLS,{0: np.array([[ 2.1646724 ],[ 1.31916307],[ 0.3398716 ],
[ 0.51336281]]), 1: np.array([[ 4.87587006],[ 2.68927603],
[ 0.94945336],[-0.145607 ],[ 0.33901794]]), 2: np.array([[ 6.48848271],
[ 3.53936913],[ 1.34731149],[ 0.06309451]])},RTOL)
dict_compare(reg.tsls_inf,{0: np.array([[ 3.51568531e-01, 6.15718476e+00, 7.40494437e-10],\
[ 1.86875349e-01, 7.05905340e+00, 1.67640650e-12],\
[ 9.04557549e-02, 3.75732426e+00, 1.71739894e-04],\
[ 7.48661202e-02, 6.85707782e+00, 7.02833502e-12]]),\
1: np.array([[ 4.72342840e-01, 1.03227352e+01, 5.56158073e-25],\
[ 2.12539934e-01, 1.26530388e+01, 1.07629786e-36],\
[ 1.21325632e-01, 7.82566179e+00, 5.04993280e-15],\
[ 4.61662438e-02, -3.15397123e+00, 1.61064963e-03],\
[ 5.41804741e-02, 6.25719766e+00, 3.91956530e-10]]),\
2: np.array([[ 3.36526688e-001, 1.92807374e+001, 7.79572152e-083],\
[ 1.59012676e-001, 2.22584087e+001, 9.35079396e-110],\
[ 1.08370073e-001, 1.24325052e+001, 1.74091603e-035],\
[ 4.61776859e-002, 1.36634202e+000, 1.71831639e-001]])},RTOL)
reg = SURlagIV(bigy1,bigX1,w=self.w,w_lags=2,name_bigy=bigyvars1,name_bigX=bigXvars1,\
name_ds="NAT",name_w="nat_queen")
dict_compare(reg.b3SLS,{0: np.array([[ 1.77468937],[ 1.14510457],[ 0.30768813],\
[ 0.5989414 ]]), 1: np.array([[ 4.26823484],[ 2.43651351],[ 0.8683601 ],[-0.12672555],\
[ 0.4208373 ]]), 2: np.array([[ 6.02334209],[ 3.38056146],[ 1.30003556],[ 0.12992573]])},RTOL)
dict_compare(reg.tsls_inf,{0: np.array([[ 3.27608281e-01, 5.41710779e+00, 6.05708284e-08],\
[ 1.76245578e-01, 6.49721025e+00, 8.18230736e-11],\
[ 8.95068772e-02, 3.43759205e+00, 5.86911195e-04],\
[ 6.94610221e-02, 8.62269771e+00, 6.53949186e-18]]),\
1: np.array([[ 4.52225005e-01, 9.43829906e+00, 3.78879655e-21],\
[ 2.03807701e-01, 1.19549629e+01, 6.11608551e-33],\
[ 1.19004906e-01, 7.29684281e+00, 2.94598624e-13],\
[ 4.57552474e-02, -2.76963964e+00, 5.61183429e-03],\
[ 5.13101239e-02, 8.20183745e+00, 2.36740266e-16]]),\
2: np.array([[ 3.27580342e-001, 1.83873735e+001, 1.65820984e-075],\
[ 1.55771577e-001, 2.17020429e+001, 1.96247435e-104],\
[ 1.06817752e-001, 1.21705946e+001, 4.45822889e-034],\
[ 4.48871540e-002, 2.89449691e+000, 3.79766647e-003]])},RTOL)
def test_error_vm(self): #Asymptotic variance matrix
y_var0 = ['HR80', 'HR90']
x_var0 = [['PS80', 'UE80'], ['PS90', 'UE90']]
bigy0, bigX0, bigyvars0, bigXvars0 = sur_dictxy(
self.db, y_var0, x_var0)
reg = SURerrorML(bigy0,bigX0,self.w,spat_diag=True,vm=True,\
name_bigy=bigyvars0,name_bigX=bigXvars0,\
name_w="natqueen",name_ds="natregimes")
dict_compare(reg.bSUR,{0: np.array([[ 4.0222855 ],[ 0.88489646],[ 0.42402853]]),\
1: np.array([[ 3.04923009],[ 1.10972634],[ 0.47075682]])},RTOL)
dict_compare(reg.sur_inf,{0: np.array([[ 3.669218e-01, 1.096224e+01, 5.804195e-28],\
[ 1.412908e-01, 6.262946e+00, 3.777726e-10],\
[ 4.267954e-02, 9.935169e+00, 2.926783e-23]]),\
1: np.array([[ 3.31399691e-01, 9.20106497e+00, 3.54419478e-20],\
[ 1.33525912e-01, 8.31094371e+00, 9.49439563e-17],\
[ 4.00409716e-02, 1.17568780e+01, 6.50970965e-32]])},rtol=RTOL, atol=ATOL)
np.testing.assert_allclose(reg.vm, np.array([[ 4.14625293e-04, 2.38494923e-05, -3.48748935e-03,\
-5.55994101e-04, -1.63239040e-04],[ 2.38494923e-05, 4.53642714e-04, -2.00602452e-04,\
-5.46893937e-04, -3.10498019e-03],[ -3.48748935e-03, -2.00602452e-04, 7.09989591e-01,\
2.11105214e-01, 6.39785285e-02],[ -5.55994101e-04, -5.46893937e-04, 2.11105214e-01,\
3.42890248e-01, 1.91931389e-01],[ -1.63239040e-04, -3.10498019e-03, 6.39785285e-02,\
1.91931389e-01, 5.86933821e-01]]),RTOL)
np.testing.assert_allclose(reg.lamsetp,(np.array([[ 0.02036235],\
[ 0.02129889]]), np.array([[ 26.69730489],[ 23.68454458]]), np.array([[ 5.059048e-157],\
[ 5.202838e-124]])),rtol=RTOL, atol=ATOL)
np.testing.assert_allclose(reg.joinlam, (1207.81269, 2, 5.330924e-263),
rtol=RTOL,
atol=ATOL)
np.testing.assert_allclose(
reg.surchow, [(5.1073696860799931, 1, 0.023824413482255974),
(1.9524745281321374, 1, 0.16232044613203933),
(0.79663667463065702, 1, 0.37210085476281407)],
rtol=RTOL,
atol=ATOL)
np.testing.assert_allclose(
reg.likrlambda, (1014.0319285186415, 2, 6.3938800607190098e-221),
rtol=RTOL,
atol=ATOL)
np.testing.assert_allclose(
reg.lrtest, (287.95821154104488, 1, 1.3849971230596533e-64),
rtol=RTOL,
atol=ATOL)
np.testing.assert_allclose(
reg.lamtest, (1.8693306894921564, 1, 0.17155175615429052),
rtol=RTOL,
atol=ATOL)
def test_3SLS_uneqK(
self
): # Three equations, unequal K, two endog variables, three instruments
y_var2 = ['HR60', 'HR70', 'HR80']
x_var2 = [['RD60', 'PS60'], ['RD70', 'PS70', 'MA70'], ['RD80', 'PS80']]
yend_var2 = [['UE60', 'DV60'], ['UE70', 'DV70'], ['UE80', 'DV80']]
q_var2 = [['FH60', 'FP59', 'GI59'], ['FH70', 'FP69', 'GI69'],
['FH80', 'FP79', 'GI79']]
bigy2, bigX2, bigyvars2, bigXvars2 = sur_dictxy(
self.db, y_var2, x_var2)
bigyend2, bigyendvars2 = sur_dictZ(self.db, yend_var2)
bigq2, bigqvars2 = sur_dictZ(self.db, q_var2)
reg = ThreeSLS(bigy2,bigX2,bigyend2,bigq2,name_bigy=bigyvars2,\
name_bigX=bigXvars2,name_bigyend=bigyendvars2,\
name_bigq=bigqvars2,name_ds="natregimes")
print 'test_3SLS_uneqK'
print reg.summary
dict_compare(reg.b2SLS,{0: np.array([[-2.04160355],[ 4.5438992 ],[ 1.65007567],[-0.73163458],\
[ 5.43071683]]), 1: np.array([[ 17.26252005],[ 5.17297895],[ 1.2893243 ],[ -0.38349609],\
[ -2.17689289],[ 4.31713382]]), 2: np.array([[-7.6809159 ],[ 3.88957396],[ 0.49973258],\
[ 0.36476446],[ 2.63375234]])},RTOL)
dict_compare(reg.b3SLS,{0: np.array([[-1.56830297],[ 4.07805179],[ 1.49694849],[-0.5376807 ],\
[ 4.65487154]]), 1: np.array([[ 16.13792395],[ 4.97265632],[ 1.31962844],[ -0.32122485],\
[ -2.12407425],[ 3.91227737]]), 2: np.array([[-6.7283657 ],[ 3.79206731],[ 0.52278922],\
[ 0.33447996],[ 2.47158609]])},RTOL)
dict_compare(reg.tsls_inf,{0: np.array([[ 9.95215966e-01, -1.57584185e+00, 1.15062254e-01],\
[ 2.26574971e-01, 1.79986861e+01, 1.99495587e-72],\
[ 1.60939740e-01, 9.30129807e+00, 1.38741353e-20],\
[ 1.19040839e-01, -4.51677511e+00, 6.27885257e-06],\
[ 5.32942876e-01, 8.73427857e+00, 2.45216107e-18]]),\
1: np.array([[ 1.59523920e+000, 1.01163035e+001, 4.67748637e-024],\
[ 1.87013008e-001, 2.65898954e+001, 8.88419907e-156],\
[ 1.44410869e-001, 9.13801331e+000, 6.36101069e-020],\
[ 3.46429228e-002, -9.27245233e+000, 1.81914372e-020],\
[ 2.49627824e-001, -8.50896434e+000, 1.75493796e-017],\
[ 4.19425249e-001, 9.32771068e+000, 1.08182251e-020]]),\
2: np.array([[ 1.09143600e+000, -6.16469102e+000, 7.06208998e-010],\
[ 1.27908896e-001, 2.96466268e+001, 3.74870055e-193],\
[ 1.32436222e-001, 3.94747912e+000, 7.89784041e-005],\
[ 8.81489692e-002, 3.79448524e+000, 1.47950082e-004],\
[ 1.95538678e-001, 1.26398834e+001, 1.27242486e-036]])},RTOL)
np.testing.assert_allclose(reg.corr,np.array([[ 1. , 0.31819323, 0.20428789],\
[ 0.31819323, 1. , 0.12492191],[ 0.20428789, 0.12492191, 1. ]]),RTOL)
def test_3SLS_3eq_end(self): #Three equations, two endogenous, three instruments
y_var2 = ['HR60','HR70','HR80']
x_var2 = [['RD60','PS60'],['RD70','PS70','MA70'],['RD80','PS80']]
yend_var2 = [['UE60','DV60'],['UE70','DV70'],['UE80','DV80']]
q_var2 = [['FH60','FP59','GI59'],['FH70','FP69','GI69'],['FH80','FP79','GI79']]
bigy2,bigX2,bigyvars2,bigXvars2 = sur_dictxy(self.db,y_var2,x_var2)
bigyend2,bigyendvars2 = sur_dictZ(self.db,yend_var2)
bigq2,bigqvars2 = sur_dictZ(self.db,q_var2)
reg = SURlagIV(bigy2,bigX2,bigyend2,bigq2,w=self.w,name_bigy=bigyvars2,name_bigX=bigXvars2,\
name_bigyend=bigyendvars2,name_bigq=bigqvars2,spat_diag=True,name_ds="NAT",name_w="nat_queen")
dict_compare(reg.b2SLS,{0: np.array([[-2.36265226],[ 1.69785946],[ 0.65777251],[-0.07519173],[ 2.15755822],\
[ 0.69200015]]), 1: np.array([[ 8.13716008],[ 3.28583832],[ 0.90311859],[-0.21702098],[-1.04365606],\
[ 2.8597322 ],[ 0.39935589]]), 2: np.array([[-5.8117312 ],[ 3.49934818],[ 0.56523782],[ 0.09653315],\
[ 2.31166815],[ 0.20602185]])},RTOL)
dict_compare(reg.b3SLS,{0: np.array([[-2.33115839],[ 1.43097732],[ 0.57312948],[ 0.03474891],[ 1.78825098],\
[ 0.7145636 ]]), 1: np.array([[ 8.34932294],[ 3.28396774],[ 0.95119978],[-0.19323687],[-1.1750583 ],\
[ 2.75925141],[ 0.38544424]]), 2: np.array([[-5.2395274 ],[ 3.38941755],[ 0.55897901],[ 0.08212108],\
[ 2.19387428],[ 0.21582944]])},RTOL)
dict_compare(reg.tsls_inf,{0: np.array([[ 7.31246733e-01, -3.18792315e+00, 1.43298614e-03],\
[ 2.07089585e-01, 6.90994348e+00, 4.84846854e-12],\
[ 1.15296751e-01, 4.97090750e+00, 6.66402399e-07],\
[ 8.75272616e-02, 3.97006755e-01, 6.91362479e-01],\
[ 3.10638495e-01, 5.75669472e+00, 8.57768262e-09],\
[ 5.40333500e-02, 1.32244919e+01, 6.33639937e-40]]),\
1: np.array([[ 1.71703190e+00, 4.86264870e+00, 1.15825305e-06],\
[ 2.79253520e-01, 1.17598079e+01, 6.28772226e-32],\
[ 1.27575632e-01, 7.45596763e+00, 8.92106480e-14],\
[ 3.31742265e-02, -5.82490950e+00, 5.71435564e-09],\
[ 2.19785746e-01, -5.34638083e+00, 8.97303096e-08],\
[ 3.29882178e-01, 8.36435430e+00, 6.04450321e-17],\
[ 5.54968909e-02, 6.94533032e+00, 3.77575814e-12]]),\
2: np.array([[ 9.77398092e-01, -5.36068920e+00, 8.29050465e-08],\
[ 1.67632600e-01, 2.02193222e+01, 6.61862485e-91],\
[ 1.24321379e-01, 4.49624202e+00, 6.91650078e-06],\
[ 6.94834624e-02, 1.18187957e+00, 2.37253491e-01],\
[ 1.68013780e-01, 1.30577045e+01, 5.74336064e-39],\
[ 4.16751208e-02, 5.17885587e+00, 2.23250870e-07]])},RTOL)
np.testing.assert_allclose(reg.joinrho,(215.897034, 3, 1.54744730e-46))
def test_SUR(self): #2 equations, same K in each, two-step estimation
y_var0 = ['HR80', 'HR90']
x_var0 = [['PS80', 'UE80'], ['PS90', 'UE90']]
bigy0, bigX0, bigyvars0, bigXvars0 = sur_dictxy(
self.db, y_var0, x_var0)
reg = SUR(bigy0, bigX0, name_bigy=bigyvars0, name_bigX=bigXvars0)
dict_compare(reg.bOLS,{0: np.array([[ 5.39719146],[ 0.6973813 ],\
[ 0.22566378]]), 1: np.array([[ 1.80829725],[ 1.03504143],[ 0.6582483 ]])},RTOL)
dict_compare(reg.bSUR,{0: np.array([[ 5.13907179],[ 0.67764814],\
[ 0.26372397]]), 1: np.array([[ 3.61394031],[ 1.02607147],[ 0.38654993]])},RTOL)
dict_compare(reg.sur_inf,{0: np.array([[ 2.62467257e-01, 1.95798587e+01, 2.29656805e-85],\
[ 1.21957836e-01, 5.55641325e+00, 2.75374482e-08],\
[ 3.43183797e-02, 7.68462769e+00, 1.53442563e-14]]),\
1: np.array([[ 2.53499643e-01, 1.42561949e+01, 4.10220329e-46],\
[ 1.12166227e-01, 9.14777552e+00, 5.81179115e-20],\
[ 3.41995564e-02, 1.13027760e+01, 1.27134462e-29]])},RTOL)
np.testing.assert_allclose(reg.corr,np.array([[ 1. , 0.46954842],\
[ 0.46954842, 1. ]]),RTOL)
np.testing.assert_allclose(reg.surchow,[(26.72917022127309, 1, 2.3406126054510838e-07),\
(8.2409218385398244, 1, 0.0040956326095295649),\
(9.3837654127686712, 1, 0.002189154327032255)],RTOL)
def test_error(self): #2 equations
y_var0 = ['HR80', 'HR90']
x_var0 = [['PS80', 'UE80'], ['PS90', 'UE90']]
bigy0, bigX0, bigyvars0, bigXvars0 = sur_dictxy(
self.db, y_var0, x_var0)
reg = SURerrorML(bigy0,bigX0,self.w,\
name_bigy=bigyvars0,name_bigX=bigXvars0,spat_diag=True,\
name_w="natqueen",name_ds="natregimes",nonspat_diag=False)
dict_compare(
reg.bSUR0, {
0: np.array([[5.18423225], [0.67757925], [0.25706498]]),
1: np.array([[3.79731807], [1.02411196], [0.35895674]])
}, RTOL)
dict_compare(reg.bSUR,{0: np.array([[ 4.0222855 ],[ 0.88489646],[ 0.42402853]]),\
1: np.array([[ 3.04923009],[ 1.10972634],[ 0.47075682]])},RTOL)
dict_compare(reg.sur_inf,{0: np.array([[ 3.669218e-01, 1.096224e+01, 5.804195e-28],\
[ 1.412908e-01, 6.262946e+00, 3.777726e-10],\
[ 4.267954e-02, 9.935169e+00, 2.926783e-23]]),\
1: np.array([[ 3.31399691e-01, 9.20106497e+00, 3.54419478e-20],\
[ 1.33525912e-01, 8.31094371e+00, 9.49439563e-17],\
[ 4.00409716e-02, 1.17568780e+01, 6.50970965e-32]])},rtol=RTOL, atol=ATOL)
np.testing.assert_allclose(reg.lamols,
np.array([[0.60205035], [0.56056348]]),
RTOL)
np.testing.assert_allclose(reg.lamsur,
np.array([[0.54361986], [0.50445451]]),
RTOL)
np.testing.assert_allclose(reg.corr,np.array([[ 1. , 0.31763719],\
[ 0.31763719, 1. ]]),RTOL)
np.testing.assert_allclose(reg.surchow,[(5.1073696860799931, 1, 0.023824413482255974),\
(1.9524745281321374, 1, 0.16232044613203933),\
(0.79663667463065702, 1, 0.37210085476281407)],rtol=RTOL, atol=ATOL)
np.testing.assert_allclose(reg.llik, -19860.067987395596)
np.testing.assert_allclose(reg.errllik, -19497.031128906794)
np.testing.assert_allclose(reg.surerrllik, -19353.052023136348)
np.testing.assert_allclose(
reg.likrlambda, (1014.0319285186415, 2, 6.3938800607190098e-221))
def test_error_3eq(self): #Three equation example, unequal K
y_var1 = ['HR60', 'HR70', 'HR80']
x_var1 = [['RD60', 'PS60'], ['RD70', 'PS70', 'UE70'], ['RD80', 'PS80']]
bigy1, bigX1, bigyvars1, bigXvars1 = sur_dictxy(
self.db, y_var1, x_var1)
reg = SURerrorML(bigy1,bigX1,self.w,name_bigy=bigyvars1,name_bigX=bigXvars1,\
name_w="natqueen",name_ds="natregimes")
print reg.summary
dict_compare(reg.bSUR0,{0: np.array([[ 4.50407527],[ 2.39199682],[ 0.52723694]]), 1: np.array([[ 7.44509818],\
[ 3.74968571],[ 1.28811685],[-0.23526451]]), 2: np.array([[ 6.92761614],[ 3.65423052],\
[ 1.38247611]])},RTOL)
dict_compare(reg.bSUR,{0: np.array([[ 4.474891 ],[ 2.19004379],[ 0.59110509]]), 1: np.array([[ 7.15676612],\
[ 3.49581077],[ 1.12846288],[-0.17133968]]), 2: np.array([[ 6.91550936],[ 3.69351192],\
[ 1.40395543]])},RTOL)
dict_compare(reg.sur_inf,{0: np.array([[ 1.345557e-001, 3.325679e+001, 1.628656e-242],\
[ 1.205317e-001, 1.816985e+001, 8.943986e-074],\
[ 1.092657e-001, 5.409796e+000, 6.309653e-008]]),\
1: np.array([[ 2.957692e-001, 2.419713e+001, 2.384951e-129],\
[ 1.482144e-001, 2.358618e+001, 5.343318e-123],\
[ 1.344687e-001, 8.392014e+000, 4.778835e-017],\
[ 5.378335e-002, -3.185738e+000, 1.443854e-003]]),\
2: np.array([[ 1.500528e-001, 4.608718e+001, 0.000000e+000],\
[ 1.236340e-001, 2.987457e+001, 4.210941e-196],\
[ 1.194989e-001, 1.174869e+001, 7.172248e-032]])},rtol=RTOL, atol=ATOL)
np.testing.assert_allclose(
reg.lamols, np.array([[0.4248829], [0.46428101], [0.42823999]]),
RTOL)
np.testing.assert_allclose(
reg.lamsur, np.array([[0.36137603], [0.38321666], [0.37183716]]),
RTOL)
np.testing.assert_allclose(reg.corr,np.array([[ 1., 0.24563253, 0.14986527],\
[ 0.24563253, 1., 0.25945021],[ 0.14986527, 0.25945021, 1. ]]),RTOL)
np.testing.assert_allclose(reg.llik, -28695.767676078722)
np.testing.assert_allclose(reg.errllik, -28593.569427945633)
np.testing.assert_allclose(reg.surerrllik, -28393.703607018397)
np.testing.assert_allclose(
reg.lrtest, (399.7316418544724, 3, 2.5309501580053097e-86))
def test_error_3eq_gm(self): #Three equation example, unequal K
y_var1 = ['HR60', 'HR70', 'HR80']
x_var1 = [['RD60', 'PS60'], ['RD70', 'PS70', 'UE70'], ['RD80', 'PS80']]
bigy1, bigX1, bigyvars1, bigXvars1 = sur_dictxy(
self.db, y_var1, x_var1)
reg = SURerrorGM(bigy1,bigX1,self.w,name_bigy=bigyvars1,name_bigX=bigXvars1,\
name_w="natqueen",name_ds="natregimes")
print reg.summary
dict_compare(
reg.bSUR, {
0:
np.array([[4.46897583], [2.15287009], [0.5979781]]),
1:
np.array([[7.10380031], [3.44965826], [1.10254808],
[-0.15962263]]),
2:
np.array([[6.91299706], [3.70234954], [1.40532701]])
}, RTOL)
dict_compare(reg.sur_inf,{0: np.array([[ 1.44081634e-001, 3.10169709e+001, 3.18308523e-211],
[ 1.25725320e-001, 1.71236000e+001, 9.89616102e-066],
[ 1.11848242e-001, 5.34633439e+000, 8.97533244e-008]]),\
1: np.array([[ 3.08054448e-001, 2.30602101e+001, 1.16187890e-117],
[ 1.54010409e-001, 2.23988643e+001, 4.03738963e-111],
[ 1.37435180e-001, 8.02231335e+000, 1.03772013e-015],
[ 5.51073953e-002, -2.89657361e+000, 3.77262126e-003]]),\
2: np.array([[ 1.60807064e-001, 4.29893867e+001, 0.00000000e+000],
[ 1.27136514e-001, 2.91210559e+001, 1.94342017e-186],
[ 1.21987743e-001, 1.15202312e+001, 1.04330705e-030]])},rtol=RTOL, atol=ATOL)
np.testing.assert_allclose(
reg.lamsur, np.array([[0.40589647], [0.42900222], [0.41682256]]),
RTOL)
np.testing.assert_allclose(
reg.corr,
np.array([[1., 0.22987815,
0.13516187], [0.22987815, 1., 0.2492023],
[0.13516187, 0.2492023, 1.]]), RTOL)
def test_3SLS_3eq_2or(self): # Second order spatial lags, no instrument lags
y_var2 = ['HR60','HR70','HR80']
x_var2 = [['RD60','PS60'],['RD70','PS70','MA70'],['RD80','PS80']]
yend_var2 = [['UE60','DV60'],['UE70','DV70'],['UE80','DV80']]
q_var2 = [['FH60','FP59','GI59'],['FH70','FP69','GI69'],['FH80','FP79','GI79']]
bigy2,bigX2,bigyvars2,bigXvars2 = sur_dictxy(self.db,y_var2,x_var2)
bigyend2,bigyendvars2 = sur_dictZ(self.db,yend_var2)
bigq2,bigqvars2 = sur_dictZ(self.db,q_var2)
reg = SURlagIV(bigy2,bigX2,bigyend2,bigq2,w=self.w,w_lags=2,lag_q=False,\
name_bigy=bigyvars2,name_bigX=bigXvars2,\
name_bigyend=bigyendvars2,name_bigq=bigqvars2,\
name_ds="NAT",name_w="nat_queen")
dict_compare(reg.b3SLS,{0: np.array([[-2.40071969],[ 1.2933015 ],[ 0.53165876],[ 0.04883189],[ 1.6663233 ],\
[ 0.76473297]]), 1: np.array([[ 7.24987963],[ 2.96110365],[ 0.86322179],[-0.17847268],[-1.1332928 ],\
[ 2.69573919],[ 0.48295237]]), 2: np.array([[-7.55692635],[ 3.17561152],[ 0.37487877],[ 0.1816544 ],\
[ 2.45768258],[ 0.27716717]])},RTOL)
dict_compare(reg.tsls_inf,{0: np.array([[ 7.28635609e-01, -3.29481522e+00, 9.84864177e-04],\
[ 2.44756930e-01, 5.28402406e+00, 1.26376643e-07],\
[ 1.26021571e-01, 4.21879172e+00, 2.45615028e-05],\
[ 1.03323393e-01, 4.72612122e-01, 6.36489932e-01],\
[ 3.48694501e-01, 4.77874843e+00, 1.76389726e-06],\
[ 6.10435763e-02, 1.25276568e+01, 5.26966810e-36]]),\
1: np.array([[ 1.76286536e+00, 4.11255436e+00, 3.91305295e-05],\
[ 2.78649343e-01, 1.06266306e+01, 2.24061686e-26],\
[ 1.28607242e-01, 6.71207766e+00, 1.91872523e-11],\
[ 3.21721548e-02, -5.54742685e+00, 2.89904383e-08],\
[ 2.09773378e-01, -5.40246249e+00, 6.57322045e-08],\
[ 3.06806758e-01, 8.78644007e+00, 1.54373978e-18],\
[ 5.88231798e-02, 8.21023915e+00, 2.20748374e-16]]),\
2: np.array([[ 1.10429601e+00, -6.84320712e+00, 7.74395589e-12],\
[ 1.81002635e-01, 1.75445597e+01, 6.54581911e-69],\
[ 1.33983129e-01, 2.79795505e+00, 5.14272697e-03],\
[ 7.56814009e-02, 2.40025154e+00, 1.63838090e-02],\
[ 1.83365858e-01, 1.34031635e+01, 5.79398038e-41],\
[ 4.61324726e-02, 6.00807101e+00, 1.87743612e-09]])},RTOL)
def test_3SLS(self): #2 equations, same K in each
y_var0 = ['HR80','HR90']
x_var0 = [['PS80','UE80'],['PS90','UE90']]
bigy0,bigX0,bigyvars0,bigXvars0 = sur_dictxy(self.db,y_var0,x_var0)
reg = SURlagIV(bigy0,bigX0,w=self.w,name_bigy=bigyvars0,name_bigX=bigXvars0,\
name_ds="NAT",name_w="nat_queen")
dict_compare(reg.b3SLS,{0: np.array([[ 4.79766641],[ 0.66900706],[ 0.45430715],\
[-0.13665465]]), 1: np.array([[ 2.27972563],[ 0.99252289],[ 0.52280565],[ 0.06909469]])},RTOL)
dict_compare(reg.tsls_inf,{0: np.array([[ 4.55824001e+00, 1.05252606e+00, 2.92558259e-01],\
[ 3.54744447e-01, 1.88588453e+00, 5.93105171e-02],\
[ 7.79071951e-02, 5.83138887e+00, 5.49679157e-09],\
[ 6.74318852e-01, -2.02655838e-01, 8.39404043e-01]]),\
1: np.array([[ 3.90351092e-01, 5.84019280e+00, 5.21404469e-09],\
[ 1.21674079e-01, 8.15722547e+00, 3.42808098e-16],\
[ 4.47686969e-02, 1.16779288e+01, 1.65273681e-31],\
[ 7.99640809e-02, 8.64071585e-01, 3.87548567e-01]])},RTOL)
np.testing.assert_allclose(reg.corr,np.array([[ 1. , 0.525751],
[ 0.525751, 1. ]]),RTOL)
np.testing.assert_allclose(reg.surchow,[(0.3178787640240518, 1, 0.57288522734425285),\
(1.0261877219299562, 1, 0.31105574708021311),\
(0.76852435750330428, 1, 0.38067394159083323),\
(0.099802260814129934, 1, 0.75206705793155604)],RTOL)
def test_SUR_3eq(
self
): #3 equations, different K, iterated estimation, spatial test
y_var1 = ['HR60', 'HR70', 'HR80']
x_var1 = [['RD60', 'PS60'], ['RD70', 'PS70', 'UE70'], ['RD80', 'PS80']]
bigy1, bigX1, bigyvars1, bigXvars1 = sur_dictxy(
self.db, y_var1, x_var1)
reg = SUR(bigy1,bigX1,w=self.w,spat_diag=True,iter=True,verbose=False,\
name_bigy=bigyvars1,name_bigX=bigXvars1)
dict_compare(reg.bOLS,{0: np.array([[ 4.50407527],[ 2.50426531],\
[ 0.50130802]]), 1: np.array([[ 7.41171812],[ 4.0021532 ],[ 1.32168167],\
[-0.22786048]]), 2: np.array([[ 6.92761614],[ 3.90531039],[ 1.47413939]])},RTOL)
dict_compare(reg.bSUR,{0: np.array([[ 4.50407527],[ 2.39199682],\
[ 0.52723694]]), 1: np.array([[ 7.44509818],
[ 3.74968571],[ 1.28811685],[-0.23526451]]), 2: np.array([[ 6.92761614],\
[ 3.65423052],[ 1.38247611]])},RTOL)
dict_compare(reg.sur_inf,{0: np.array([[ 9.16019177e-002, 4.91700980e+001, 0.00000000e+000],\
[ 9.18832357e-002, 2.60330060e+001, 2.09562528e-149],\
[ 9.31668754e-002, 5.65906002e+000, 1.52204326e-008]]),\
1: np.array([[ 2.31085029e-001, 3.22180031e+001, 9.87752395e-228],\
[ 1.14421850e-001, 3.27707138e+001, 1.53941252e-235],\
[ 1.14799399e-001, 1.12205888e+001, 3.23111806e-029],\
[ 4.47806286e-002, -5.25371170e+000, 1.49064159e-007]]),\
2: np.array([[ 1.00643767e-001, 6.88330371e+001, 0.00000000e+000],\
[ 1.00599909e-001, 3.63243917e+001, 6.66811571e-289],\
[ 1.02053898e-001, 1.35465291e+001, 8.30659234e-042]])},RTOL)
np.testing.assert_allclose(reg.corr,np.array([[ 1. , 0.34470181, 0.25096458],\
[ 0.34470181, 1. , 0.33527277],[ 0.25096458, 0.33527277, 1. ]]),RTOL)
np.testing.assert_allclose(reg.llik, -28695.767676078722)
np.testing.assert_allclose(
reg.lmtest, (882.43543942655947, 3, 5.7128374010751484e-191))
np.testing.assert_allclose(
reg.lrtest, (818.30409875688747, 3, 4.6392724270549021e-177))
np.testing.assert_allclose(reg.lmEtest,
(696.541197, 3, 1.18041989e-150))
def test_sur_regi(self):
y_var0 = ['HR80', 'HR90']
x_var0 = [['PS80', 'UE80'], ['PS90', 'UE90']]
bigy0, bigX0, bigyvars0, bigXvars0 = sur_dictxy(
self.db, y_var0, x_var0)
regi1 = int(bigy0[0].shape[0] / 2)
regi = [0] * (regi1) + [1] * (bigy0[0].shape[0] - regi1)
bigysub, bigXsub = {}, {}
for r in bigy0.keys():
bigysub[r] = bigy0[r][0:regi1]
bigXsub[r] = bigX0[r][0:regi1]
reg = SUR(bigy0,
bigX0,
regimes=regi,
name_bigy=bigyvars0,
name_bigX=bigXvars0)
reg_sub = SUR(bigysub,
bigXsub,
name_bigy=bigyvars0,
name_bigX=bigXvars0)
dict_compare(
reg.bOLS, {
0:
np.array([[1.87615878], [0.18966296], [0.34814587],
[9.16595183], [0.82165993], [0.06343039]]),
1:
np.array([[0.74758463], [0.72948358], [0.45993437],
[4.81814289], [0.96819747], [0.55080463]])
}, RTOL)
dict_compare(
reg_sub.bOLS, {
0: np.array([[1.87615878], [0.18966296], [0.34814587]]),
1: np.array([[0.74758463], [0.72948358], [0.45993437]])
}, RTOL)
dict_compare(
reg.bSUR, {
0:
np.array([[2.01116476], [0.20092017], [0.32804397],
[8.73384797], [0.78145176], [0.12659106]]),
1:
np.array([[1.74977074], [0.74734938], [0.29345176],
[6.31032557], [0.91171898], [0.34665252]])
}, RTOL)
dict_compare(
reg_sub.bSUR, {
0: np.array([[1.92667554], [0.19603381], [0.34065072]]),
1: np.array([[1.48997568], [0.74311959], [0.33661536]])
}, RTOL)
dict_compare(
reg.sur_inf, {
0:
np.array([[3.41101914e-001, 5.89608171e+000, 3.72234709e-009],
[1.46263739e-001, 1.37368406e+000, 1.69539787e-001],
[4.50557935e-002, 7.28083871e+000, 3.31751122e-013],
[3.54394907e-001, 2.46443947e+001, 4.22629982e-134],
[1.75344503e-001, 4.45666528e+000, 8.32444268e-006],
[4.61236608e-002, 2.74460137e+000, 6.05844400e-003]
]),
1:
np.array([[3.17850453e-01, 5.50501258e+00, 3.69141910e-08],
[1.36607810e-01, 5.47076618e+00, 4.48094161e-08],
[4.66138382e-02, 6.29537851e+00, 3.06650646e-10],
[3.81183966e-01, 1.65545409e+01, 1.48469542e-61],
[1.65046297e-01, 5.52401961e+00, 3.31330455e-08],
[4.80006322e-02, 7.22183237e+00, 5.12916752e-13]])
}, RTOL)
dict_compare(
reg_sub.sur_inf, {
0:
np.array([[3.09065537e-01, 6.23387375e+00, 4.55039845e-10],
[1.31344830e-01, 1.49251259e+00, 1.35564820e-01],
[4.09281853e-02, 8.32313281e+00, 8.56683667e-17]]),
1:
np.array([[2.55486625e-01, 5.83191264e+00, 5.47956072e-09],
[1.08792884e-01, 6.83059002e+00, 8.45660945e-12],
[3.75656548e-02, 8.96072109e+00, 3.22561992e-19]])
}, RTOL)
np.testing.assert_allclose(
reg.corr, np.array([[1., 0.39876159], [0.39876159, 1.]]), RTOL)
np.testing.assert_allclose(
reg_sub.corr, np.array([[1., 0.34082746], [0.34082746, 1.]]), RTOL)
np.testing.assert_allclose(
reg.surchow, [(0.45990603232321264, 1, 0.49766789236262199),
(12.272945563489683, 1, 0.00045957230926145726),
(0.40387355647401846, 1, 0.52509554089354726),
(29.703322949663928, 1, 5.0348441543660547e-08),
(0.48278663488874679, 1, 0.48716278953324077),
(14.458361295874431, 1, 0.00014329232472224597)],
RTOL)
np.testing.assert_allclose(
reg_sub.surchow, [(1.6159328442921959, 1, 0.2036598282347839),
(15.367000078470731, 1, 8.8520850179747918e-05),
(0.0070481637293965593, 1, 0.93309352797583178)],
RTOL)
def run(self, path=None, predy_resid=None):
""" Runs the Model """
print self.verify()
if not self.verify()[0]:
return False
data = self.data
print data
if self.data['config']['other_missingValueCheck']:
pysal.MISSINGVALUE = self.data['config']['other_missingValue']
else:
pysal.MISSINGVALUE = None
# Build up args for dispatcher
# weights
w_names = [w.name for w in data['mWeights'] if w.enabled]
w_list = [w.w for w in data['mWeights'] if w.enabled]
for w, name in zip(w_list, w_names):
w.name = name
wk_names = [w.name for w in data['kWeights'] if w.enabled]
wk_list = [w.w for w in data['kWeights'] if w.enabled]
for w, name in zip(wk_list, wk_names):
w.name = name
if 'fname' in self.data:
fileType = self.data['fname'].rsplit('.')[-1].lower()
self.fileType = fileType
if fileType == 'csv':
db = pysal.open(data['fname'], 'rU')
else:
db = pysal.open(data['fname'], 'r')
else:
return None
# y
y_names = data['spec']['y']
name_y = ','.join(y_names)
y = np.array([self.get_col(db, name) for name in y_names]).T
# x
x = []
x_names = data['spec']['X']
for x_name in x_names:
if x_name.find(',') >= 0:
x = None # get data using sur_dictxy
#x.append([self.get_col(db, name) for name in x_name.split(',')])
else:
x.append(self.get_col(db, x_name))
if x != None:
x = np.array(x).T
# YE
ye = []
ye_names = data['spec']['YE']
for ye_name in ye_names:
if ye_name.find(',') >= 0:
ye.append(
[self.get_col(db, name) for name in ye_name.split(',')])
else:
ye.append(self.get_col(db, ye_name))
ye = np.array(ye).T
# H
h = []
h_names = data['spec']['H']
for h_name in h_names:
if h_name.find(',') >= 0:
h.append(
[self.get_col(db, name) for name in h_name.split(',')])
else:
h.append(self.get_col(db, h_name))
h = np.array(h).T
mtypes = {
0: 'Standard',
1: 'Spatial Lag',
2: 'Spatial Error',
3: 'Spatial Lag+Error'
}
model_type = mtypes[data['modelType']['mType']]
print model_type
# estimation methods
# method_types = {0: 'gm', 1: 'ml'}
method_types = {0: 'ols', 1: 'gm', 2: 'ml'}
method = method_types[data['modelType']['method']]
print method
# R
if data['spec']['R']:
name_r = data['spec']['R']
r = self.get_col(db, name_r)
else:
name_r = None
r = None
# T
if data['spec']['T']:
name_t = data['spec']['T']
t = self.get_col(db, name_t)
else:
name_t = None
t = None
# S
if data['spec']['S']:
name_s = data['spec']['S']
s = self.get_col(db, name_s)
else:
s = None
name_s = None
# SUR: get data (1) HR60,HR70 (2) using Time, Space
if name_y.find(',') >= 0:
y_var0 = name_y.split(',')
x_var0 = [x_name.split(',') for x_name in x_names]
y, x, name_y, x_names = sur_dictxy(db, y_var0, x_var0)
yend_var1 = [name.split(',') for name in ye_names]
ye, ye_names = sur_dictZ(db, yend_var1)
q_var1 = [name.split(',') for name in h_names]
h, h_names = sur_dictZ(db, q_var1)
# regimes shrinks to n
#r = r[ : len(r) / len(y)]
elif name_s and name_t and len(name_s) > 0 and len(name_t) > 0:
y, x, name_y, x_names = sur_dictxy(db, [name_y], [x_names],
space_id=[name_s],
time_id=[name_t])
if len(ye_names) > 0:
yend_var1 = [name.split(',') for name in ye_names]
ye, ye_names = sur_dictZ(db,
yend_var1,
form="plm",
space_id=[name_s],
time_id=[name_t])
if len(h_names) > 0:
q_var1 = [name.split(',') for name in h_names]
h, h_names = sur_dictZ(db,
q_var1,
form="plm",
space_id=[name_s],
time_id=[name_t])
# regimes shrinks to n
if r:
r = r[:len(r) / len(y)]
config = data['config']
if self.getMWeightsEnabled() and model_type in \
['Standard', 'Spatial Lag']:
LM_TEST = True
else:
LM_TEST = False
print w_list, wk_list
fname = os.path.basename(data['fname'])
results = Spmodel(
name_ds=fname,
w_list=w_list,
wk_list=wk_list,
y=y,
name_y=name_y,
x=x,
name_x=x_names,
ye=ye,
name_ye=ye_names,
h=h,
name_h=h_names,
r=r,
name_r=name_r,
s=s,
name_s=name_s,
t=t,
name_t=name_t,
model_type=model_type, # data['modelType']['endogenous'],
# data['modelType']['spatial_tests']['lm'],
spat_diag=LM_TEST,
white=data['modelType']['error']['white'],
hac=data['modelType']['error']['hac'],
kp_het=data['modelType']['error']['het'],
# config.....
sig2n_k_ols=config['sig2n_k_ols'],
sig2n_k_tsls=config['sig2n_k_2sls'],
sig2n_k_gmlag=config['sig2n_k_gmlag'],
max_iter=config['gmm_max_iter'],
stop_crit=config['gmm_epsilon'],
inf_lambda=config['gmm_inferenceOnLambda'],
comp_inverse=config['gmm_inv_method'],
step1c=config['gmm_step1c'],
instrument_lags=config['instruments_w_lags'],
lag_user_inst=config['instruments_lag_q'],
vc_matrix=config['output_vm_summary'],
predy_resid=predy_resid,
ols_diag=config['other_ols_diagnostics'],
moran=config['other_residualMoran'],
white_test=config['white_test'],
regime_err_sep=config['regimes_regime_error'],
regime_lag_sep=config['regimes_regime_lag'],
cores=config['other_numcores'],
ml_epsilon=config['ml_epsilon'],
ml_method=config['ml_method'],
ml_diag=config['ml_diagnostics'],
SUR_Spatdiagnostics=config['SURSpatdiagnostics'],
SUR_NonSpatdiagnostics=config['SURNonSpatdiagnostics'],
SUR_UseIterEst=config['SURUseIterEst'],
method=method).output
print results
for r in results:
path.write(r.summary)
path.write('\n\n\n')
return [r.summary for r in results]
"""
