def _work(y, x, w, regi_ids, r, yend, q, robust, sig2n_k, name_ds, name_y, name_x, name_yend, name_q, name_w, name_regimes): y_r = y[regi_ids[r]] x_r = x[regi_ids[r]] yend_r = yend[regi_ids[r]] q_r = q[regi_ids[r]] x_constant = USER.check_constant(x_r) if robust == 'hac' or robust == 'ogmm': robust2 = None else: robust2 = robust model = BaseTSLS(y_r, x_constant, yend_r, q_r, robust=robust2, sig2n_k=sig2n_k) model.title = "TWO STAGE LEAST SQUARES ESTIMATION - REGIME %s" % r if robust == 'ogmm': _optimal_weight(model, sig2n_k, warn=False) model.robust = USER.set_robust(robust) model.name_ds = name_ds model.name_y = '%s_%s' % (str(r), name_y) model.name_x = ['%s_%s' % (str(r), i) for i in name_x] model.name_yend = ['%s_%s' % (str(r), i) for i in name_yend] model.name_z = model.name_x + model.name_yend model.name_q = ['%s_%s' % (str(r), i) for i in name_q] model.name_h = model.name_x + model.name_q model.name_w = name_w model.name_regimes = name_regimes if w: w_r, warn = REGI.w_regime(w, regi_ids[r], r, transform=True) set_warn(model, warn) model.w = w_r return model
def __init__(self, y, x, yend=None, q=None,\ w=None, w_lags=1, lag_q=True,\ vm=False, name_y=None, name_x=None,\ name_yend=None, name_q=None,\ name_w=None, name_ds=None): n = USER.check_arrays(y, x, yend, q) USER.check_y(y, n) USER.check_weights(w, y, w_required=True) yend2, q2 = set_endog(y, x, w, yend, q, w_lags, lag_q) x_constant = USER.check_constant(x) BaseGM_Combo.__init__(self, y=y, x=x_constant, w=w.sparse, yend=yend2, q=q2,\ w_lags=w_lags, lag_q=lag_q) self.predy_e, self.e_pred, warn = sp_att(w,self.y,\ self.predy,yend2[:,-1].reshape(self.n,1),self.betas[-2]) set_warn(self, warn) self.title = "SPATIALLY WEIGHTED TWO STAGE LEAST SQUARES" self.name_ds = USER.set_name_ds(name_ds) self.name_y = USER.set_name_y(name_y) self.name_x = USER.set_name_x(name_x, x) self.name_yend = USER.set_name_yend(name_yend, yend) self.name_yend.append(USER.set_name_yend_sp(self.name_y)) self.name_z = self.name_x + self.name_yend self.name_z.append('lambda') self.name_q = USER.set_name_q(name_q, q) self.name_q.extend( USER.set_name_q_sp(self.name_x, w_lags, self.name_q, lag_q)) self.name_h = USER.set_name_h(self.name_x, self.name_q) self.name_w = USER.set_name_w(name_w, w) SUMMARY.GM_Combo(reg=self, w=w, vm=vm)
def __init__(self, y, x, yend=None, q=None,\ w=None, w_lags=1, lag_q=True,\ robust=None, gwk=None, sig2n_k=False,\ spat_diag=False,\ vm=False, name_y=None, name_x=None,\ name_yend=None, name_q=None,\ name_w=None, name_gwk=None, name_ds=None): n = USER.check_arrays(x, yend, q) USER.check_y(y, n) USER.check_weights(w, y, w_required=True) USER.check_robust(robust, gwk) yend2, q2 = set_endog(y, x, w, yend, q, w_lags, lag_q) x_constant = USER.check_constant(x) BaseGM_Lag.__init__(self, y=y, x=x_constant, w=w.sparse, yend=yend2, q=q2,\ w_lags=w_lags, robust=robust, gwk=gwk,\ lag_q=lag_q, sig2n_k=sig2n_k) self.predy_e, self.e_pred, warn = sp_att(w,self.y,self.predy,\ yend2[:,-1].reshape(self.n,1),self.betas[-1]) set_warn(self, warn) self.title = "SPATIAL TWO STAGE LEAST SQUARES" self.name_ds = USER.set_name_ds(name_ds) self.name_y = USER.set_name_y(name_y) self.name_x = USER.set_name_x(name_x, x) self.name_yend = USER.set_name_yend(name_yend, yend) self.name_yend.append(USER.set_name_yend_sp(self.name_y)) self.name_z = self.name_x + self.name_yend self.name_q = USER.set_name_q(name_q, q) self.name_q.extend( USER.set_name_q_sp(self.name_x, w_lags, self.name_q, lag_q)) self.name_h = USER.set_name_h(self.name_x, self.name_q) self.robust = USER.set_robust(robust) self.name_w = USER.set_name_w(name_w, w) self.name_gwk = USER.set_name_w(name_gwk, gwk) SUMMARY.GM_Lag(reg=self, w=w, vm=vm, spat_diag=spat_diag)
def _optimal_weight(reg, sig2n_k, warn=True): try: Hu = reg.h.toarray() * reg.u ** 2 except: Hu = reg.h * reg.u ** 2 if sig2n_k: S = spdot(reg.h.T, Hu, array_out=True) / (reg.n - reg.k) else: S = spdot(reg.h.T, Hu, array_out=True) / reg.n Si = np.linalg.inv(S) ZtH = spdot(reg.z.T, reg.h) ZtHSi = spdot(ZtH, Si) fac2 = np.linalg.inv(spdot(ZtHSi, ZtH.T, array_out=True)) fac3 = spdot(ZtHSi, spdot(reg.h.T, reg.y), array_out=True) betas = np.dot(fac2, fac3) if sig2n_k: vm = fac2 * (reg.n - reg.k) else: vm = fac2 * reg.n RegressionProps_basic(reg, betas=betas, vm=vm, sig2=False) reg.title += " (Optimal-Weighted GMM)" if warn: set_warn( reg, "Residuals treated as homoskedastic for the purpose of diagnostics.") return
def __init__(self, y, x, regimes, w=None, robust=None, gwk=None, sig2n_k=True, nonspat_diag=True, spat_diag=False, moran=False, white_test=False, vm=False, constant_regi='many', cols2regi='all', regime_err_sep=True, cores=None, name_y=None, name_x=None, name_regimes=None, name_w=None, name_gwk=None, name_ds=None): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y) USER.check_robust(robust, gwk) USER.check_spat_diag(spat_diag, w) self.name_x_r = USER.set_name_x(name_x, x) self.constant_regi = constant_regi self.cols2regi = cols2regi self.name_w = USER.set_name_w(name_w, w) self.name_gwk = USER.set_name_w(name_gwk, gwk) self.name_ds = USER.set_name_ds(name_ds) self.name_y = USER.set_name_y(name_y) self.name_regimes = USER.set_name_ds(name_regimes) self.n = n cols2regi = REGI.check_cols2regi( constant_regi, cols2regi, x, add_cons=False) self.regimes_set = REGI._get_regimes_set(regimes) self.regimes = regimes USER.check_regimes(self.regimes_set, self.n, x.shape[1]) if regime_err_sep == True and robust == 'hac': set_warn( self, "Error by regimes is incompatible with HAC estimation. Hence, error by regimes has been disabled for this model.") regime_err_sep = False self.regime_err_sep = regime_err_sep if regime_err_sep == True and set(cols2regi) == set([True]) and constant_regi == 'many': self.y = y name_x = USER.set_name_x(name_x, x) regi_ids = dict((r, list(np.where(np.array(regimes) == r)[0])) for r in self.regimes_set) self._ols_regimes_multi(x, w, regi_ids, cores, gwk, sig2n_k, robust, nonspat_diag, spat_diag, vm, name_x, moran, white_test) else: name_x = USER.set_name_x(name_x, x, constant=True) x, self.name_x = REGI.Regimes_Frame.__init__(self, x, regimes, constant_regi, cols2regi, name_x) BaseOLS.__init__(self, y=y, x=x, robust=robust, gwk=gwk, sig2n_k=sig2n_k) if regime_err_sep == True and robust == None: y2, x2 = REGI._get_weighted_var( regimes, self.regimes_set, sig2n_k, self.u, y, x) ols2 = BaseOLS(y=y2, x=x2, sig2n_k=sig2n_k) RegressionProps_basic(self, betas=ols2.betas, vm=ols2.vm) self.title = "ORDINARY LEAST SQUARES - REGIMES (Group-wise heteroskedasticity)" nonspat_diag = None set_warn( self, "Residuals treated as homoskedastic for the purpose of diagnostics.") else: self.title = "ORDINARY LEAST SQUARES - REGIMES" self.robust = USER.set_robust(robust) self.chow = REGI.Chow(self) SUMMARY.OLS(reg=self, vm=vm, w=w, nonspat_diag=nonspat_diag, spat_diag=spat_diag, moran=moran, white_test=white_test, regimes=True)
def _optimal_weight(reg, sig2n_k, warn=True): try: Hu = reg.h.toarray() * reg.u**2 except: Hu = reg.h * reg.u**2 if sig2n_k: S = spdot(reg.h.T, Hu, array_out=True) / (reg.n - reg.k) else: S = spdot(reg.h.T, Hu, array_out=True) / reg.n Si = np.linalg.inv(S) ZtH = spdot(reg.z.T, reg.h) ZtHSi = spdot(ZtH, Si) fac2 = np.linalg.inv(spdot(ZtHSi, ZtH.T, array_out=True)) fac3 = spdot(ZtHSi, spdot(reg.h.T, reg.y), array_out=True) betas = np.dot(fac2, fac3) if sig2n_k: vm = fac2 * (reg.n - reg.k) else: vm = fac2 * reg.n RegressionProps_basic(reg, betas=betas, vm=vm, sig2=False) reg.title += " (Optimal-Weighted GMM)" if warn: set_warn( reg, "Residuals treated as homoskedastic for the purpose of diagnostics." ) return
def __init__(self, y, x, regimes, w=None, robust=None, gwk=None, sig2n_k=True, nonspat_diag=True, spat_diag=False, moran=False, white_test=False, vm=False, constant_regi='many', cols2regi='all', regime_err_sep=True, cores=False, name_y=None, name_x=None, name_regimes=None, name_w=None, name_gwk=None, name_ds=None): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y) USER.check_robust(robust, gwk) USER.check_spat_diag(spat_diag, w) self.name_x_r = USER.set_name_x(name_x, x) self.constant_regi = constant_regi self.cols2regi = cols2regi self.name_w = USER.set_name_w(name_w, w) self.name_gwk = USER.set_name_w(name_gwk, gwk) self.name_ds = USER.set_name_ds(name_ds) self.name_y = USER.set_name_y(name_y) self.name_regimes = USER.set_name_ds(name_regimes) self.n = n cols2regi = REGI.check_cols2regi( constant_regi, cols2regi, x, add_cons=False) self.regimes_set = REGI._get_regimes_set(regimes) self.regimes = regimes USER.check_regimes(self.regimes_set, self.n, x.shape[1]) if regime_err_sep == True and robust == 'hac': set_warn( self, "Error by regimes is incompatible with HAC estimation. Hence, error by regimes has been disabled for this model.") regime_err_sep = False self.regime_err_sep = regime_err_sep if regime_err_sep == True and set(cols2regi) == set([True]) and constant_regi == 'many': self.y = y name_x = USER.set_name_x(name_x, x) regi_ids = dict( (r, list(np.where(np.array(regimes) == r)[0])) for r in self.regimes_set) self._ols_regimes_multi(x, w, regi_ids, cores, gwk, sig2n_k, robust, nonspat_diag, spat_diag, vm, name_x, moran, white_test) else: name_x = USER.set_name_x(name_x, x, constant=True) x, self.name_x = REGI.Regimes_Frame.__init__(self, x, regimes, constant_regi, cols2regi, name_x) BaseOLS.__init__( self, y=y, x=x, robust=robust, gwk=gwk, sig2n_k=sig2n_k) if regime_err_sep == True and robust == None: y2, x2 = REGI._get_weighted_var( regimes, self.regimes_set, sig2n_k, self.u, y, x) ols2 = BaseOLS(y=y2, x=x2, sig2n_k=sig2n_k) RegressionProps_basic(self, betas=ols2.betas, vm=ols2.vm) self.title = "ORDINARY LEAST SQUARES - REGIMES (Group-wise heteroskedasticity)" nonspat_diag = None set_warn( self, "Residuals treated as homoskedastic for the purpose of diagnostics.") else: self.title = "ORDINARY LEAST SQUARES - REGIMES" self.robust = USER.set_robust(robust) self.chow = REGI.Chow(self) SUMMARY.OLS(reg=self, vm=vm, w=w, nonspat_diag=nonspat_diag, spat_diag=spat_diag, moran=moran, white_test=white_test, regimes=True)
def __init__(self, y, x, yend=None, q=None,\ w=None, w_lags=1, lag_q=True,\ robust=None, gwk=None, sig2n_k=False,\ spat_diag=False,\ vm=False, name_y=None, name_x=None,\ name_yend=None, name_q=None,\ name_w=None, name_gwk=None, name_ds=None): n = USER.check_arrays(x, yend, q) USER.check_y(y, n) USER.check_weights(w, y, w_required=True) USER.check_robust(robust, gwk) yend2, q2 = set_endog(y, x, w, yend, q, w_lags, lag_q) x_constant = USER.check_constant(x) BaseGM_Lag.__init__(self, y=y, x=x_constant, w=w.sparse, yend=yend2, q=q2,\ w_lags=w_lags, robust=robust, gwk=gwk,\ lag_q=lag_q, sig2n_k=sig2n_k) self.predy_e, self.e_pred, warn = sp_att(w,self.y,self.predy,\ yend2[:,-1].reshape(self.n,1),self.betas[-1]) set_warn(self,warn) self.title = "SPATIAL TWO STAGE LEAST SQUARES" self.name_ds = USER.set_name_ds(name_ds) self.name_y = USER.set_name_y(name_y) self.name_x = USER.set_name_x(name_x, x) self.name_yend = USER.set_name_yend(name_yend, yend) self.name_yend.append(USER.set_name_yend_sp(self.name_y)) self.name_z = self.name_x + self.name_yend self.name_q = USER.set_name_q(name_q, q) self.name_q.extend(USER.set_name_q_sp(self.name_x, w_lags, self.name_q, lag_q)) self.name_h = USER.set_name_h(self.name_x, self.name_q) self.robust = USER.set_robust(robust) self.name_w = USER.set_name_w(name_w, w) self.name_gwk = USER.set_name_w(name_gwk, gwk) SUMMARY.GM_Lag(reg=self, w=w, vm=vm, spat_diag=spat_diag)
def __init__(self, y, x, yend=None, q=None,\ w=None, w_lags=1, lag_q=True,\ vm=False, name_y=None, name_x=None,\ name_yend=None, name_q=None,\ name_w=None, name_ds=None): n = USER.check_arrays(y, x, yend, q) USER.check_y(y, n) USER.check_weights(w, y, w_required=True) yend2, q2 = set_endog(y, x, w, yend, q, w_lags, lag_q) x_constant = USER.check_constant(x) BaseGM_Combo.__init__(self, y=y, x=x_constant, w=w.sparse, yend=yend2, q=q2,\ w_lags=w_lags, lag_q=lag_q) self.rho = self.betas[-2] self.predy_e, self.e_pred, warn = sp_att(w,self.y,\ self.predy,yend2[:,-1].reshape(self.n,1),self.rho) set_warn(self, warn) self.title = "SPATIALLY WEIGHTED TWO STAGE LEAST SQUARES" self.name_ds = USER.set_name_ds(name_ds) self.name_y = USER.set_name_y(name_y) self.name_x = USER.set_name_x(name_x, x) self.name_yend = USER.set_name_yend(name_yend, yend) self.name_yend.append(USER.set_name_yend_sp(self.name_y)) self.name_z = self.name_x + self.name_yend self.name_z.append('lambda') self.name_q = USER.set_name_q(name_q, q) self.name_q.extend(USER.set_name_q_sp(self.name_x, w_lags, self.name_q, lag_q)) self.name_h = USER.set_name_h(self.name_x, self.name_q) self.name_w = USER.set_name_w(name_w, w) SUMMARY.GM_Combo(reg=self, w=w, vm=vm)
def __init__(self, y, x, equationID, yend=None, q=None, w=None,\ cores=None, sig2n_k=False, name_y=None, name_x=None, name_yend=None,\ name_q=None, name_equationID=None, name_ds=None, name_w=None, vm=False,\ w_lags=1, lag_q=True): ThreeSLS.__init__(self, y=y, x=x, equationID=equationID, yend=yend, q=q, w=w, cores=cores,\ sig2n_k=sig2n_k, name_y=name_y, name_x=name_x, name_yend=name_yend, name_q=name_q,\ name_equationID=name_equationID, name_ds=name_ds, name_w=name_w, vm=vm,\ w_lags=w_lags, lag_q=lag_q) for r in self.eq_set: self.multi[r].predy_e, self.multi[r].e_pred, warn = sp_att(w,self.multi[r].y,self.multi[r].predy,\ self.multi[r].yend[:,-1].reshape(self.n,1),self.multi[r].betas[-1]) set_warn(self.multi[r], warn) title = "SPATIAL THREE-STAGE LEAST SQUARES - EQUATION " self.multi = USER.set_name_multi(self.multi, self.eq_set, name_equationID, y, x, name_y, name_x, name_ds, title, name_w, robust=None, endog=(yend, q, name_yend, name_q), sp_lag=(w_lags, lag_q)) SUMMARY.GM_Lag_multi(reg=self, multireg=self.multi, vm=vm, spat_diag=False, sur=True)
def __init__(self, y, x, yend, q, regimes,\ w=None, robust=None, gwk=None, sig2n_k=True,\ spat_diag=False, vm=False, constant_regi='many',\ cols2regi='all', regime_err_sep=False, name_y=None, name_x=None,\ cores=None, name_yend=None, name_q=None, name_regimes=None,\ name_w=None, name_gwk=None, name_ds=None, summ=True): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y) USER.check_robust(robust, gwk) USER.check_spat_diag(spat_diag, w) self.constant_regi = constant_regi self.cols2regi = cols2regi self.name_ds = USER.set_name_ds(name_ds) self.name_regimes = USER.set_name_ds(name_regimes) self.name_w = USER.set_name_w(name_w, w) self.name_gwk = USER.set_name_w(name_gwk, gwk) self.name_y = USER.set_name_y(name_y) name_yend = USER.set_name_yend(name_yend, yend) name_q = USER.set_name_q(name_q, q) self.name_x_r = USER.set_name_x(name_x, x) + name_yend self.n = n if regime_err_sep == True: name_x = USER.set_name_x(name_x, x) self.y = y if cols2regi == 'all': cols2regi = [True] * (x.shape[1]+yend.shape[1]) self.regimes_set = list(set(regimes)) self.regimes_set.sort() if w: w_i,regi_ids,warn = REGI.w_regimes(w, regimes, self.regimes_set, transform=True, get_ids=True, min_n=len(self.cols2regi)+1) set_warn(self,warn) else: regi_ids = dict((r, list(np.where(np.array(regimes) == r)[0])) for r in self.regimes_set) w_i = None if set(cols2regi) == set([True]): self._tsls_regimes_multi(x, yend, q, w_i, regi_ids, cores,\ gwk, sig2n_k, robust, spat_diag, vm, name_x, name_yend, name_q) else: raise Exception, "All coefficients must vary accross regimes if regime_err_sep = True." else: name_x = USER.set_name_x(name_x, x,constant=True) q, self.name_q = REGI.Regimes_Frame.__init__(self, q, \ regimes, constant_regi=None, cols2regi='all', names=name_q) x, self.name_x = REGI.Regimes_Frame.__init__(self, x, \ regimes, constant_regi, cols2regi=cols2regi, names=name_x) yend, self.name_yend = REGI.Regimes_Frame.__init__(self, yend, \ regimes, constant_regi=None, \ cols2regi=cols2regi, yend=True, names=name_yend) BaseTSLS.__init__(self, y=y, x=x, yend=yend, q=q, \ robust=robust, gwk=gwk, sig2n_k=sig2n_k) self.name_z = self.name_x + self.name_yend self.name_h = USER.set_name_h(self.name_x, self.name_q) self.chow = REGI.Chow(self) self.robust = USER.set_robust(robust) if summ: self.title = "TWO STAGE LEAST SQUARES - REGIMES" SUMMARY.TSLS(reg=self, vm=vm, w=w, spat_diag=spat_diag, regimes=True)
def __init__(self, y, x, regimes, w=None, constant_regi='many',\ cols2regi='all', method='full', epsilon=0.0000001,\ regime_lag_sep=False, cores=None, spat_diag=False,\ vm=False, name_y=None, name_x=None,\ name_w=None, name_ds=None, name_regimes=None): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y, w_required=True) USER.check_spat_diag(spat_diag, w) name_y = USER.set_name_y(name_y) self.name_y = name_y self.name_x_r = USER.set_name_x(name_x, x) + [USER.set_name_yend_sp(name_y)] self.method = method self.epsilon = epsilon self.name_regimes = USER.set_name_ds(name_regimes) self.constant_regi=constant_regi self.n = n cols2regi = REGI.check_cols2regi(constant_regi, cols2regi, x, add_cons=False) self.cols2regi = cols2regi self.regimes_set = REGI._get_regimes_set(regimes) self.regimes = regimes self.regime_lag_sep = regime_lag_sep self._cache = {} self.name_ds = USER.set_name_ds(name_ds) self.name_w = USER.set_name_w(name_w, w) USER.check_regimes(self.regimes_set,self.n,x.shape[1]) if regime_lag_sep == True: if not (set(cols2regi) == set([True]) and constant_regi == 'many'): raise Exception, "All variables must vary by regimes if regime_lag_sep = True." cols2regi += [True] w_i,regi_ids,warn = REGI.w_regimes(w, regimes, self.regimes_set, transform=True, get_ids=True, min_n=len(cols2regi)+1) set_warn(self,warn) else: cols2regi += [False] if set(cols2regi) == set([True]) and constant_regi == 'many': self.y = y self.ML_Lag_Regimes_Multi(y, x, w_i, w, regi_ids,\ cores=cores, cols2regi=cols2regi, method=method, epsilon=epsilon,\ spat_diag=spat_diag, vm=vm, name_y=name_y, name_x=name_x,\ name_regimes=self.name_regimes,\ name_w=name_w, name_ds=name_ds) else: #if regime_lag_sep == True: # w = REGI.w_regimes_union(w, w_i, self.regimes_set) name_x = USER.set_name_x(name_x, x,constant=True) x, self.name_x = REGI.Regimes_Frame.__init__(self, x, \ regimes, constant_regi, cols2regi=cols2regi[:-1], names=name_x) self.name_x.append("_Global_"+USER.set_name_yend_sp(name_y)) BaseML_Lag.__init__(self, y=y, x=x, w=w, method=method, epsilon=epsilon) self.kf += 1 #Adding a fixed k to account for spatial lag. self.chow = REGI.Chow(self) self.aic = DIAG.akaike(reg=self) self.schwarz = DIAG.schwarz(reg=self) self.regime_lag_sep=regime_lag_sep self.title = "MAXIMUM LIKELIHOOD SPATIAL LAG - REGIMES" + " (METHOD = " + method + ")" SUMMARY.ML_Lag(reg=self, w=w, vm=vm, spat_diag=spat_diag, regimes=True)
def __init__(self, y, x, regimes,\ w=None, robust=None, gwk=None, sig2n_k=True,\ nonspat_diag=True, spat_diag=False, moran=False,\ vm=False, constant_regi='many', cols2regi='all',\ regime_err_sep=False, cores=None,\ name_y=None, name_x=None, name_regimes=None,\ name_w=None, name_gwk=None, name_ds=None): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y) USER.check_robust(robust, gwk) USER.check_spat_diag(spat_diag, w) self.name_x_r = USER.set_name_x(name_x, x) self.constant_regi = constant_regi self.cols2regi = cols2regi self.name_w = USER.set_name_w(name_w, w) self.name_gwk = USER.set_name_w(name_gwk, gwk) self.name_ds = USER.set_name_ds(name_ds) self.name_y = USER.set_name_y(name_y) self.name_regimes = USER.set_name_ds(name_regimes) self.n = n if regime_err_sep == True: name_x = USER.set_name_x(name_x, x) self.y = y if cols2regi == 'all': cols2regi = [True] * (x.shape[1]) self.regimes_set = list(set(regimes)) self.regimes_set.sort() if w: w_i,regi_ids,warn = REGI.w_regimes(w, regimes, self.regimes_set, transform=True, get_ids=True, min_n=len(self.cols2regi)+1) set_warn(self,warn) else: regi_ids = dict((r, list(np.where(np.array(regimes) == r)[0])) for r in self.regimes_set) w_i = None if set(cols2regi) == set([True]): self._ols_regimes_multi(x, w_i, regi_ids, cores,\ gwk, sig2n_k, robust, nonspat_diag, spat_diag, vm, name_x, moran) else: raise Exception, "All coefficients must vary accross regimes if regime_err_sep = True." else: name_x = USER.set_name_x(name_x, x,constant=True) x, self.name_x = REGI.Regimes_Frame.__init__(self, x,\ regimes, constant_regi, cols2regi, name_x) BaseOLS.__init__(self, y=y, x=x, robust=robust, gwk=gwk, \ sig2n_k=sig2n_k) self.title = "ORDINARY LEAST SQUARES - REGIMES" self.robust = USER.set_robust(robust) self.chow = REGI.Chow(self) SUMMARY.OLS(reg=self, vm=vm, w=w, nonspat_diag=nonspat_diag,\ spat_diag=spat_diag, moran=moran, regimes=True)
def _work_error(y,x,regi_ids,r,w,method,epsilon,name_ds,name_y,name_x,name_w,name_regimes): w_r,warn = REGI.w_regime(w, regi_ids[r], r, transform=True) y_r = y[regi_ids[r]] x_r = x[regi_ids[r]] x_constant = USER.check_constant(x_r) model = BaseML_Error(y=y_r,x=x_constant,w=w_r,method=method,epsilon=epsilon) set_warn(model, warn) model.w = w_r model.title = "MAXIMUM LIKELIHOOD SPATIAL ERROR - REGIME "+str(r)+" (METHOD = "+method+")" model.name_ds = name_ds model.name_y = '%s_%s'%(str(r), name_y) model.name_x = ['%s_%s'%(str(r), i) for i in name_x] model.name_w = name_w model.name_regimes = name_regimes model.aic = DIAG.akaike(reg=model) model.schwarz = DIAG.schwarz(reg=model) return model
def __init__(self, y, x, equationID, yend=None, q=None, w=None,\ cores=None, sig2n_k=False, name_y=None, name_x=None, name_yend=None,\ name_q=None, name_equationID=None, name_ds=None, name_w=None, vm=False,\ w_lags=1, lag_q=True): ThreeSLS.__init__(self, y=y, x=x, equationID=equationID, yend=yend, q=q, w=w, cores=cores,\ sig2n_k=sig2n_k, name_y=name_y, name_x=name_x, name_yend=name_yend, name_q=name_q,\ name_equationID=name_equationID, name_ds=name_ds, name_w=name_w, vm=vm,\ w_lags=w_lags, lag_q=lag_q) for r in self.eq_set: self.multi[r].predy_e, self.multi[r].e_pred, warn = sp_att(w,self.multi[r].y,self.multi[r].predy,\ self.multi[r].yend[:,-1].reshape(self.n,1),self.multi[r].betas[-1]) set_warn(self.multi[r], warn) title = "SPATIAL THREE-STAGE LEAST SQUARES - EQUATION " self.multi = USER.set_name_multi(self.multi,self.eq_set,name_equationID,y,x,name_y,name_x,name_ds,title,name_w,robust=None,endog=(yend,q,name_yend,name_q),sp_lag=(w_lags, lag_q)) SUMMARY.GM_Lag_multi(reg=self, multireg=self.multi, vm=vm, spat_diag=False, sur=True)
def _work(y,x,w,regi_ids,r,robust,sig2n_k,name_ds,name_y,name_x,name_w,name_regimes): y_r = y[regi_ids[r]] x_r = x[regi_ids[r]] x_constant = USER.check_constant(x_r) if robust == 'hac': robust = None model = BaseOLS(y_r, x_constant, robust=robust, sig2n_k=sig2n_k) model.title = "ORDINARY LEAST SQUARES ESTIMATION - REGIME %s" %r model.robust = USER.set_robust(robust) model.name_ds = name_ds model.name_y = '%s_%s'%(str(r), name_y) model.name_x = ['%s_%s'%(str(r), i) for i in name_x] model.name_w = name_w model.name_regimes = name_regimes if w: w_r,warn = REGI.w_regime(w, regi_ids[r], r, transform=True) set_warn(model, warn) model.w = w_r return model
def _work(y, x, w, regi_ids, r, robust, sig2n_k, name_ds, name_y, name_x, name_w, name_regimes): y_r = y[regi_ids[r]] x_r = x[regi_ids[r]] x_constant = USER.check_constant(x_r) if robust == 'hac': robust = None model = BaseOLS(y_r, x_constant, robust=robust, sig2n_k=sig2n_k) model.title = "ORDINARY LEAST SQUARES ESTIMATION - REGIME %s" % r model.robust = USER.set_robust(robust) model.name_ds = name_ds model.name_y = '%s_%s' % (str(r), name_y) model.name_x = ['%s_%s' % (str(r), i) for i in name_x] model.name_w = name_w model.name_regimes = name_regimes if w: w_r, warn = REGI.w_regime(w, regi_ids[r], r, transform=True) set_warn(model, warn) model.w = w_r return model
def _work_error(y, x, regi_ids, r, w, method, epsilon, name_ds, name_y, name_x, name_w, name_regimes): w_r, warn = REGI.w_regime(w, regi_ids[r], r, transform=True) y_r = y[regi_ids[r]] x_r = x[regi_ids[r]] x_constant = USER.check_constant(x_r) model = BaseML_Error( y=y_r, x=x_constant, w=w_r, method=method, epsilon=epsilon) set_warn(model, warn) model.w = w_r model.title = "MAXIMUM LIKELIHOOD SPATIAL ERROR - REGIME " + \ str(r) + " (METHOD = " + method + ")" model.name_ds = name_ds model.name_y = '%s_%s' % (str(r), name_y) model.name_x = ['%s_%s' % (str(r), i) for i in name_x] model.name_w = name_w model.name_regimes = name_regimes model.aic = DIAG.akaike(reg=model) model.schwarz = DIAG.schwarz(reg=model) return model
def __init__( self, y, x, regimes, yend=None, q=None, w=None, w_lags=1, lag_q=True, robust=None, gwk=None, sig2n_k=False, spat_diag=False, constant_regi="many", cols2regi="all", regime_lag_sep=False, regime_err_sep=True, cores=False, vm=False, name_y=None, name_x=None, name_yend=None, name_q=None, name_regimes=None, name_w=None, name_gwk=None, name_ds=None, ): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y, w_required=True) USER.check_robust(robust, gwk) USER.check_spat_diag(spat_diag, w) name_x = USER.set_name_x(name_x, x, constant=True) name_y = USER.set_name_y(name_y) name_yend = USER.set_name_yend(name_yend, yend) name_q = USER.set_name_q(name_q, q) name_q.extend(USER.set_name_q_sp(name_x, w_lags, name_q, lag_q, force_all=True)) self.name_regimes = USER.set_name_ds(name_regimes) self.constant_regi = constant_regi self.n = n cols2regi = REGI.check_cols2regi(constant_regi, cols2regi, x, yend=yend, add_cons=False) self.cols2regi = cols2regi self.regimes_set = REGI._get_regimes_set(regimes) self.regimes = regimes USER.check_regimes(self.regimes_set, self.n, x.shape[1]) if regime_err_sep == True and robust == "hac": set_warn( self, "Error by regimes is incompatible with HAC estimation for Spatial Lag models. Hence, error and lag by regimes have been disabled for this model.", ) regime_err_sep = False regime_lag_sep = False self.regime_err_sep = regime_err_sep self.regime_lag_sep = regime_lag_sep if regime_lag_sep == True: if not regime_err_sep: raise Exception, "regime_err_sep must be True when regime_lag_sep=True." cols2regi += [True] w_i, regi_ids, warn = REGI.w_regimes( w, regimes, self.regimes_set, transform=True, get_ids=True, min_n=len(cols2regi) + 1 ) set_warn(self, warn) else: cols2regi += [False] if regime_err_sep == True and set(cols2regi) == set([True]) and constant_regi == "many": self.y = y self.GM_Lag_Regimes_Multi( y, x, w_i, w, regi_ids, yend=yend, q=q, w_lags=w_lags, lag_q=lag_q, cores=cores, robust=robust, gwk=gwk, sig2n_k=sig2n_k, cols2regi=cols2regi, spat_diag=spat_diag, vm=vm, name_y=name_y, name_x=name_x, name_yend=name_yend, name_q=name_q, name_regimes=self.name_regimes, name_w=name_w, name_gwk=name_gwk, name_ds=name_ds, ) else: if regime_lag_sep == True: w = REGI.w_regimes_union(w, w_i, self.regimes_set) yend2, q2 = set_endog(y, x, w, yend, q, w_lags, lag_q) name_yend.append(USER.set_name_yend_sp(name_y)) TSLS_Regimes.__init__( self, y=y, x=x, yend=yend2, q=q2, regimes=regimes, w=w, robust=robust, gwk=gwk, sig2n_k=sig2n_k, spat_diag=spat_diag, vm=vm, constant_regi=constant_regi, cols2regi=cols2regi, regime_err_sep=regime_err_sep, name_y=name_y, name_x=name_x, name_yend=name_yend, name_q=name_q, name_regimes=name_regimes, name_w=name_w, name_gwk=name_gwk, name_ds=name_ds, summ=False, ) if regime_lag_sep: self.sp_att_reg(w_i, regi_ids, yend2[:, -1].reshape(self.n, 1)) else: self.rho = self.betas[-1] self.predy_e, self.e_pred, warn = sp_att( w, self.y, self.predy, yend2[:, -1].reshape(self.n, 1), self.rho ) set_warn(self, warn) self.regime_lag_sep = regime_lag_sep self.title = "SPATIAL " + self.title SUMMARY.GM_Lag(reg=self, w=w, vm=vm, spat_diag=spat_diag, regimes=True)
def __init__(self, y, x, yend, q, regimes, w=None, robust=None, gwk=None, sig2n_k=True, spat_diag=False, vm=False, constant_regi='many', cols2regi='all', regime_err_sep=True, name_y=None, name_x=None, cores=False, name_yend=None, name_q=None, name_regimes=None, name_w=None, name_gwk=None, name_ds=None, summ=True): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y) USER.check_robust(robust, gwk) USER.check_spat_diag(spat_diag, w) self.constant_regi = constant_regi self.cols2regi = cols2regi self.name_ds = USER.set_name_ds(name_ds) self.name_regimes = USER.set_name_ds(name_regimes) self.name_w = USER.set_name_w(name_w, w) self.name_gwk = USER.set_name_w(name_gwk, gwk) self.name_y = USER.set_name_y(name_y) name_yend = USER.set_name_yend(name_yend, yend) name_q = USER.set_name_q(name_q, q) self.name_x_r = USER.set_name_x(name_x, x) + name_yend self.n = n cols2regi = REGI.check_cols2regi(constant_regi, cols2regi, x, yend=yend, add_cons=False) self.regimes_set = REGI._get_regimes_set(regimes) self.regimes = regimes USER.check_regimes(self.regimes_set, self.n, x.shape[1]) if regime_err_sep == True and robust == 'hac': set_warn( self, "Error by regimes is incompatible with HAC estimation for 2SLS models. Hence, the error by regimes has been disabled for this model." ) regime_err_sep = False self.regime_err_sep = regime_err_sep if regime_err_sep == True and set(cols2regi) == set( [True]) and constant_regi == 'many': name_x = USER.set_name_x(name_x, x) self.y = y regi_ids = dict((r, list(np.where(np.array(regimes) == r)[0])) for r in self.regimes_set) self._tsls_regimes_multi(x, yend, q, w, regi_ids, cores, gwk, sig2n_k, robust, spat_diag, vm, name_x, name_yend, name_q) else: name_x = USER.set_name_x(name_x, x, constant=True) q, self.name_q = REGI.Regimes_Frame.__init__(self, q, regimes, constant_regi=None, cols2regi='all', names=name_q) x, self.name_x = REGI.Regimes_Frame.__init__(self, x, regimes, constant_regi, cols2regi=cols2regi, names=name_x) yend, self.name_yend = REGI.Regimes_Frame.__init__( self, yend, regimes, constant_regi=None, cols2regi=cols2regi, yend=True, names=name_yend) if regime_err_sep == True and robust == None: robust = 'white' BaseTSLS.__init__(self, y=y, x=x, yend=yend, q=q, robust=robust, gwk=gwk, sig2n_k=sig2n_k) self.title = "TWO STAGE LEAST SQUARES - REGIMES" if robust == 'ogmm': _optimal_weight(self, sig2n_k) self.name_z = self.name_x + self.name_yend self.name_h = USER.set_name_h(self.name_x, self.name_q) self.chow = REGI.Chow(self) self.robust = USER.set_robust(robust) if summ: SUMMARY.TSLS(reg=self, vm=vm, w=w, spat_diag=spat_diag, regimes=True)
def __init__(self, y, x, regimes, yend=None, q=None,\ w=None, w_lags=1, lag_q=True,\ robust=None, gwk=None, sig2n_k=False,\ spat_diag=False, constant_regi='many',\ cols2regi='all', regime_lag_sep=True, regime_err_sep=True,\ cores=None, vm=False, name_y=None, name_x=None,\ name_yend=None, name_q=None, name_regimes=None,\ name_w=None, name_gwk=None, name_ds=None): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y) USER.check_robust(robust, gwk) USER.check_spat_diag(spat_diag, w) name_x = USER.set_name_x(name_x, x,constant=True) name_y = USER.set_name_y(name_y) name_yend = USER.set_name_yend(name_yend, yend) name_q = USER.set_name_q(name_q, q) name_q.extend(USER.set_name_q_sp(name_x, w_lags, name_q, lag_q, force_all=True)) self.name_regimes = USER.set_name_ds(name_regimes) self.constant_regi=constant_regi self.n = n if cols2regi == 'all': if yend!=None: cols2regi = [True] * (x.shape[1]+yend.shape[1]) else: cols2regi = [True] * (x.shape[1]) if regime_lag_sep == True: cols2regi += [True] self.regimes_set = list(set(regimes)) self.regimes_set.sort() w_i,regi_ids,warn = REGI.w_regimes(w, regimes, self.regimes_set, transform=True, get_ids=True, min_n=len(cols2regi)+1) set_warn(self,warn) if not regime_err_sep: w = REGI.w_regimes_union(w, w_i, self.regimes_set) else: cols2regi += [False] if regime_err_sep == True: raise Exception, "All coefficients must vary accross regimes if regime_err_sep = True." self.cols2regi = cols2regi if regime_lag_sep == True and regime_err_sep == True: if set(cols2regi) == set([True]): self.GM_Lag_Regimes_Multi(y, x, w_i, regi_ids,\ yend=yend, q=q, w_lags=w_lags, lag_q=lag_q, cores=cores,\ robust=robust, gwk=gwk, sig2n_k=sig2n_k, cols2regi=cols2regi,\ spat_diag=spat_diag, vm=vm, name_y=name_y, name_x=name_x,\ name_yend=name_yend, name_q=name_q, name_regimes=self.name_regimes,\ name_w=name_w, name_gwk=name_gwk, name_ds=name_ds) else: raise Exception, "All coefficients must vary accross regimes if regime_err_sep = True." else: yend2, q2 = set_endog(y, x, w, yend, q, w_lags, lag_q) name_yend.append(USER.set_name_yend_sp(name_y)) TSLS_Regimes.__init__(self, y=y, x=x, yend=yend2, q=q2,\ regimes=regimes, w=w, robust=robust, gwk=gwk,\ sig2n_k=sig2n_k, spat_diag=spat_diag, vm=vm,\ constant_regi=constant_regi, cols2regi=cols2regi, name_y=name_y,\ name_x=name_x, name_yend=name_yend, name_q=name_q,\ name_regimes=name_regimes, name_w=name_w, name_gwk=name_gwk,\ name_ds=name_ds,summ=False) if regime_lag_sep: self.sp_att_reg(w_i, regi_ids, yend2[:,-1].reshape(self.n,1)) else: self.predy_e, self.e_pred = sp_att(w,self.y,self.predy,\ yend2[:,-1].reshape(self.n,1),self.betas[-1]) self.regime_lag_sep=regime_lag_sep self.title = "SPATIAL TWO STAGE LEAST SQUARES - REGIMES" SUMMARY.GM_Lag(reg=self, w=w, vm=vm, spat_diag=spat_diag, regimes=True)
def GM_Lag_Regimes_Multi(self, y, x, w_i, w, regi_ids, cores=False, yend=None, q=None, w_lags=1, lag_q=True, robust=None, gwk=None, sig2n_k=False, cols2regi='all', spat_diag=False, vm=False, name_y=None, name_x=None, name_yend=None, name_q=None, name_regimes=None, name_w=None, name_gwk=None, name_ds=None): # pool = mp.Pool(cores) self.name_ds = USER.set_name_ds(name_ds) name_x = USER.set_name_x(name_x, x) name_yend.append(USER.set_name_yend_sp(name_y)) self.name_w = USER.set_name_w(name_w, w_i) self.name_gwk = USER.set_name_w(name_gwk, gwk) results_p = {} """ for r in self.regimes_set: w_r = w_i[r].sparse if system() == 'Windows': is_win = True results_p[r] = _work(*(y,x,regi_ids,r,yend,q,w_r,w_lags,lag_q,robust,sig2n_k,self.name_ds,name_y,name_x,name_yend,name_q,self.name_w,name_regimes)) else: results_p[r] = pool.apply_async(_work,args=(y,x,regi_ids,r,yend,q,w_r,w_lags,lag_q,robust,sig2n_k,self.name_ds,name_y,name_x,name_yend,name_q,self.name_w,name_regimes, )) is_win = False """ for r in self.regimes_set: w_r = w_i[r].sparse if cores: pool = mp.Pool(None) results_p[r] = pool.apply_async(_work, args=( y, x, regi_ids, r, yend, q, w_r, w_lags, lag_q, robust, sig2n_k, self.name_ds, name_y, name_x, name_yend, name_q, self.name_w, name_regimes, )) else: results_p[r] = _work(*(y, x, regi_ids, r, yend, q, w_r, w_lags, lag_q, robust, sig2n_k, self.name_ds, name_y, name_x, name_yend, name_q, self.name_w, name_regimes)) self.kryd = 0 self.kr = len(cols2regi) + 1 self.kf = 0 self.nr = len(self.regimes_set) self.name_x_r = name_x + name_yend self.name_regimes = name_regimes self.vm = np.zeros((self.nr * self.kr, self.nr * self.kr), float) self.betas = np.zeros((self.nr * self.kr, 1), float) self.u = np.zeros((self.n, 1), float) self.predy = np.zeros((self.n, 1), float) self.predy_e = np.zeros((self.n, 1), float) self.e_pred = np.zeros((self.n, 1), float) """ if not is_win: pool.close() pool.join() """ if cores: pool.close() pool.join() results = {} self.name_y, self.name_x, self.name_yend, self.name_q, self.name_z, self.name_h = [ ], [], [], [], [], [] counter = 0 for r in self.regimes_set: """ if is_win: results[r] = results_p[r] else: results[r] = results_p[r].get() """ if not cores: results[r] = results_p[r] else: results[r] = results_p[r].get() results[r].predy_e, results[r].e_pred, warn = sp_att( w_i[r], results[r].y, results[r].predy, results[r].yend[:, -1].reshape(results[r].n, 1), results[r].rho) set_warn(results[r], warn) results[r].w = w_i[r] self.vm[(counter * self.kr):((counter + 1) * self.kr), (counter * self.kr):((counter + 1) * self.kr)] = results[r].vm self.betas[(counter * self.kr):((counter + 1) * self.kr), ] = results[r].betas self.u[regi_ids[r], ] = results[r].u self.predy[regi_ids[r], ] = results[r].predy self.predy_e[regi_ids[r], ] = results[r].predy_e self.e_pred[regi_ids[r], ] = results[r].e_pred self.name_y += results[r].name_y self.name_x += results[r].name_x self.name_yend += results[r].name_yend self.name_q += results[r].name_q self.name_z += results[r].name_z self.name_h += results[r].name_h if r == self.regimes_set[0]: self.hac_var = np.zeros((self.n, results[r].h.shape[1]), float) self.hac_var[regi_ids[r], ] = results[r].h counter += 1 self.multi = results if robust == 'hac': hac_multi(self, gwk, constant=True) if robust == 'ogmm': set_warn( self, "Residuals treated as homoskedastic for the purpose of diagnostics." ) self.chow = REGI.Chow(self) if spat_diag: pass #self._get_spat_diag_props(y, x, w, yend, q, w_lags, lag_q) SUMMARY.GM_Lag_multi(reg=self, multireg=self.multi, vm=vm, spat_diag=spat_diag, regimes=True, w=w)
def __init__(self, y, x, regimes, yend=None, q=None, w=None, w_lags=1, lag_q=True, robust=None, gwk=None, sig2n_k=False, spat_diag=False, constant_regi='many', cols2regi='all', regime_lag_sep=False, regime_err_sep=True, cores=False, vm=False, name_y=None, name_x=None, name_yend=None, name_q=None, name_regimes=None, name_w=None, name_gwk=None, name_ds=None): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y, w_required=True) USER.check_robust(robust, gwk) USER.check_spat_diag(spat_diag, w) name_x = USER.set_name_x(name_x, x, constant=True) name_y = USER.set_name_y(name_y) name_yend = USER.set_name_yend(name_yend, yend) name_q = USER.set_name_q(name_q, q) name_q.extend( USER.set_name_q_sp(name_x, w_lags, name_q, lag_q, force_all=True)) self.name_regimes = USER.set_name_ds(name_regimes) self.constant_regi = constant_regi self.n = n cols2regi = REGI.check_cols2regi(constant_regi, cols2regi, x, yend=yend, add_cons=False) self.cols2regi = cols2regi self.regimes_set = REGI._get_regimes_set(regimes) self.regimes = regimes USER.check_regimes(self.regimes_set, self.n, x.shape[1]) if regime_err_sep == True and robust == 'hac': set_warn( self, "Error by regimes is incompatible with HAC estimation for Spatial Lag models. Hence, error and lag by regimes have been disabled for this model." ) regime_err_sep = False regime_lag_sep = False self.regime_err_sep = regime_err_sep self.regime_lag_sep = regime_lag_sep if regime_lag_sep == True: if not regime_err_sep: raise Exception, "regime_err_sep must be True when regime_lag_sep=True." cols2regi += [True] w_i, regi_ids, warn = REGI.w_regimes(w, regimes, self.regimes_set, transform=True, get_ids=True, min_n=len(cols2regi) + 1) set_warn(self, warn) else: cols2regi += [False] if regime_err_sep == True and set(cols2regi) == set( [True]) and constant_regi == 'many': self.y = y self.GM_Lag_Regimes_Multi(y, x, w_i, w, regi_ids, yend=yend, q=q, w_lags=w_lags, lag_q=lag_q, cores=cores, robust=robust, gwk=gwk, sig2n_k=sig2n_k, cols2regi=cols2regi, spat_diag=spat_diag, vm=vm, name_y=name_y, name_x=name_x, name_yend=name_yend, name_q=name_q, name_regimes=self.name_regimes, name_w=name_w, name_gwk=name_gwk, name_ds=name_ds) else: if regime_lag_sep == True: w = REGI.w_regimes_union(w, w_i, self.regimes_set) yend2, q2 = set_endog(y, x, w, yend, q, w_lags, lag_q) name_yend.append(USER.set_name_yend_sp(name_y)) TSLS_Regimes.__init__(self, y=y, x=x, yend=yend2, q=q2, regimes=regimes, w=w, robust=robust, gwk=gwk, sig2n_k=sig2n_k, spat_diag=spat_diag, vm=vm, constant_regi=constant_regi, cols2regi=cols2regi, regime_err_sep=regime_err_sep, name_y=name_y, name_x=name_x, name_yend=name_yend, name_q=name_q, name_regimes=name_regimes, name_w=name_w, name_gwk=name_gwk, name_ds=name_ds, summ=False) if regime_lag_sep: self.sp_att_reg(w_i, regi_ids, yend2[:, -1].reshape(self.n, 1)) else: self.rho = self.betas[-1] self.predy_e, self.e_pred, warn = sp_att( w, self.y, self.predy, yend2[:, -1].reshape(self.n, 1), self.rho) set_warn(self, warn) self.regime_lag_sep = regime_lag_sep self.title = "SPATIAL " + self.title SUMMARY.GM_Lag(reg=self, w=w, vm=vm, spat_diag=spat_diag, regimes=True)
def __init__(self, y, x, regimes, yend=None, q=None,\ w=None, w_lags=1, lag_q=True,\ robust=None, gwk=None, sig2n_k=False,\ spat_diag=False, constant_regi='many',\ cols2regi='all', regime_lag_sep=False, regime_err_sep=True,\ cores=None, vm=False, name_y=None, name_x=None,\ name_yend=None, name_q=None, name_regimes=None,\ name_w=None, name_gwk=None, name_ds=None): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y, w_required=True) USER.check_robust(robust, gwk) USER.check_spat_diag(spat_diag, w) name_x = USER.set_name_x(name_x, x, constant=True) name_y = USER.set_name_y(name_y) name_yend = USER.set_name_yend(name_yend, yend) name_q = USER.set_name_q(name_q, q) name_q.extend( USER.set_name_q_sp(name_x, w_lags, name_q, lag_q, force_all=True)) self.name_regimes = USER.set_name_ds(name_regimes) self.constant_regi = constant_regi self.n = n cols2regi = REGI.check_cols2regi(constant_regi, cols2regi, x, yend=yend, add_cons=False) self.cols2regi = cols2regi self.regimes_set = REGI._get_regimes_set(regimes) self.regimes = regimes USER.check_regimes(self.regimes_set) self.regime_err_sep = regime_err_sep self.regime_lag_sep = regime_lag_sep if regime_lag_sep == True: if not regime_err_sep: raise Exception, "regime_err_sep must be True when regime_lag_sep=True." cols2regi += [True] w_i, regi_ids, warn = REGI.w_regimes(w, regimes, self.regimes_set, transform=True, get_ids=True, min_n=len(cols2regi) + 1) set_warn(self, warn) else: cols2regi += [False] if regime_err_sep == True and set(cols2regi) == set( [True]) and constant_regi == 'many': self.y = y self.GM_Lag_Regimes_Multi(y, x, w_i, regi_ids,\ yend=yend, q=q, w_lags=w_lags, lag_q=lag_q, cores=cores,\ robust=robust, gwk=gwk, sig2n_k=sig2n_k, cols2regi=cols2regi,\ spat_diag=spat_diag, vm=vm, name_y=name_y, name_x=name_x,\ name_yend=name_yend, name_q=name_q, name_regimes=self.name_regimes,\ name_w=name_w, name_gwk=name_gwk, name_ds=name_ds) else: if regime_lag_sep == True: w = REGI.w_regimes_union(w, w_i, self.regimes_set) yend2, q2 = set_endog(y, x, w, yend, q, w_lags, lag_q) name_yend.append(USER.set_name_yend_sp(name_y)) TSLS_Regimes.__init__(self, y=y, x=x, yend=yend2, q=q2,\ regimes=regimes, w=w, robust=robust, gwk=gwk,\ sig2n_k=sig2n_k, spat_diag=spat_diag, vm=vm,\ constant_regi=constant_regi, cols2regi=cols2regi, regime_err_sep=regime_err_sep,\ name_y=name_y, name_x=name_x, name_yend=name_yend, name_q=name_q,\ name_regimes=name_regimes, name_w=name_w, name_gwk=name_gwk,\ name_ds=name_ds,summ=False) if regime_lag_sep: self.sp_att_reg(w_i, regi_ids, yend2[:, -1].reshape(self.n, 1)) else: self.predy_e, self.e_pred, warn = sp_att(w,self.y,self.predy,\ yend2[:,-1].reshape(self.n,1),self.betas[-1]) set_warn(self, warn) self.regime_lag_sep = regime_lag_sep if regime_err_sep == True: self.title = "SPATIAL TWO STAGE LEAST SQUARES - REGIMES (Group-wise heteroskedasticity)" else: self.title = "SPATIAL TWO STAGE LEAST SQUARES - REGIMES" SUMMARY.GM_Lag(reg=self, w=w, vm=vm, spat_diag=spat_diag, regimes=True)
def __init__(self, y, x, regimes, w=None, constant_regi='many', cols2regi='all', method='full', epsilon=0.0000001, regime_lag_sep=False, regime_err_sep=False, cores=False, spat_diag=False, vm=False, name_y=None, name_x=None, name_w=None, name_ds=None, name_regimes=None): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y, w_required=True) USER.check_spat_diag(spat_diag, w) name_y = USER.set_name_y(name_y) self.name_y = name_y self.name_x_r = USER.set_name_x( name_x, x) + [USER.set_name_yend_sp(name_y)] self.method = method self.epsilon = epsilon self.name_regimes = USER.set_name_ds(name_regimes) self.constant_regi = constant_regi self.n = n cols2regi = REGI.check_cols2regi( constant_regi, cols2regi, x, add_cons=False) self.cols2regi = cols2regi self.regimes_set = REGI._get_regimes_set(regimes) self.regimes = regimes self.regime_lag_sep = regime_lag_sep self._cache = {} self.name_ds = USER.set_name_ds(name_ds) self.name_w = USER.set_name_w(name_w, w) USER.check_regimes(self.regimes_set, self.n, x.shape[1]) # regime_err_sep is ignored, always False if regime_lag_sep == True: if not (set(cols2regi) == set([True]) and constant_regi == 'many'): raise Exception, "All variables must vary by regimes if regime_lag_sep = True." cols2regi += [True] w_i, regi_ids, warn = REGI.w_regimes( w, regimes, self.regimes_set, transform=True, get_ids=True, min_n=len(cols2regi) + 1) set_warn(self, warn) else: cols2regi += [False] if set(cols2regi) == set([True]) and constant_regi == 'many': self.y = y self.ML_Lag_Regimes_Multi(y, x, w_i, w, regi_ids, cores=cores, cols2regi=cols2regi, method=method, epsilon=epsilon, spat_diag=spat_diag, vm=vm, name_y=name_y, name_x=name_x, name_regimes=self.name_regimes, name_w=name_w, name_ds=name_ds) else: # if regime_lag_sep == True: # w = REGI.w_regimes_union(w, w_i, self.regimes_set) name_x = USER.set_name_x(name_x, x, constant=True) x, self.name_x = REGI.Regimes_Frame.__init__(self, x, regimes, constant_regi, cols2regi=cols2regi[:-1], names=name_x) self.name_x.append("_Global_" + USER.set_name_yend_sp(name_y)) BaseML_Lag.__init__( self, y=y, x=x, w=w, method=method, epsilon=epsilon) self.kf += 1 # Adding a fixed k to account for spatial lag in Chow # adding a fixed k to account for spatial lag in aic, sc self.k += 1 self.chow = REGI.Chow(self) self.aic = DIAG.akaike(reg=self) self.schwarz = DIAG.schwarz(reg=self) self.regime_lag_sep = regime_lag_sep self.title = "MAXIMUM LIKELIHOOD SPATIAL LAG - REGIMES" + \ " (METHOD = " + method + ")" SUMMARY.ML_Lag( reg=self, w=w, vm=vm, spat_diag=spat_diag, regimes=True)
def __init__(self, y, x, yend, q, regimes,\ w=None, robust=None, gwk=None, sig2n_k=True,\ spat_diag=False, vm=False, constant_regi='many',\ cols2regi='all', regime_err_sep=True, name_y=None, name_x=None,\ cores=None, name_yend=None, name_q=None, name_regimes=None,\ name_w=None, name_gwk=None, name_ds=None, summ=True): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y) USER.check_robust(robust, gwk) USER.check_spat_diag(spat_diag, w) self.constant_regi = constant_regi self.cols2regi = cols2regi self.name_ds = USER.set_name_ds(name_ds) self.name_regimes = USER.set_name_ds(name_regimes) self.name_w = USER.set_name_w(name_w, w) self.name_gwk = USER.set_name_w(name_gwk, gwk) self.name_y = USER.set_name_y(name_y) name_yend = USER.set_name_yend(name_yend, yend) name_q = USER.set_name_q(name_q, q) self.name_x_r = USER.set_name_x(name_x, x) + name_yend self.n = n cols2regi = REGI.check_cols2regi(constant_regi, cols2regi, x, yend=yend, add_cons=False) self.regimes_set = REGI._get_regimes_set(regimes) self.regimes = regimes USER.check_regimes(self.regimes_set) self.regime_err_sep = regime_err_sep if regime_err_sep == True and set(cols2regi) == set([True]) and constant_regi == 'many': name_x = USER.set_name_x(name_x, x) self.y = y if w: w_i,regi_ids,warn = REGI.w_regimes(w, regimes, self.regimes_set, transform=True, get_ids=True, min_n=len(self.cols2regi)+1) set_warn(self,warn) else: regi_ids = dict((r, list(np.where(np.array(regimes) == r)[0])) for r in self.regimes_set) w_i = None self._tsls_regimes_multi(x, yend, q, w_i, regi_ids, cores,\ gwk, sig2n_k, robust, spat_diag, vm, name_x, name_yend, name_q) else: name_x = USER.set_name_x(name_x, x,constant=True) q, self.name_q = REGI.Regimes_Frame.__init__(self, q, \ regimes, constant_regi=None, cols2regi='all', names=name_q) x, self.name_x = REGI.Regimes_Frame.__init__(self, x, \ regimes, constant_regi, cols2regi=cols2regi, names=name_x) yend, self.name_yend = REGI.Regimes_Frame.__init__(self, yend, \ regimes, constant_regi=None, \ cols2regi=cols2regi, yend=True, names=name_yend) BaseTSLS.__init__(self, y=y, x=x, yend=yend, q=q, \ robust=robust, gwk=gwk, sig2n_k=sig2n_k) if regime_err_sep == True and robust == None: """ # Weighted x, y, yend and q approach: y2,x2,yend2,q2 = REGI._get_weighted_var(regimes,self.regimes_set,sig2n_k,self.u,y,x,yend,q) tsls2 = BaseTSLS(y=y2, x=x2, yend=yend2, q=q2, sig2n_k=sig2n_k) # Updating S_hat to S_tilde approach: betas2, predy2, resid2, vm2 = self._optimal_weight(sig2n_k) RegressionProps_basic(self,betas=betas2,predy=predy2,u=resid2,vm=vm2,sig2=False) """ betas2, vm2 = self._optimal_weight(sig2n_k) RegressionProps_basic(self,betas=betas2,vm=vm2,sig2=False) self.title = "TWO STAGE LEAST SQUARES - REGIMES (Optimal-Weighted GMM)" robust = None set_warn(self,"Residuals treated as homoskedastic for the purpose of diagnostics.") else: self.title = "TWO STAGE LEAST SQUARES - REGIMES" self.name_z = self.name_x + self.name_yend self.name_h = USER.set_name_h(self.name_x, self.name_q) self.chow = REGI.Chow(self) self.robust = USER.set_robust(robust) if summ: SUMMARY.TSLS(reg=self, vm=vm, w=w, spat_diag=spat_diag, regimes=True)
def __init__(self, y, x, regimes, yend=None, q=None,\ w=None, w_lags=1, lag_q=True,\ robust=None, gwk=None, sig2n_k=False,\ spat_diag=False, constant_regi='many',\ cols2regi='all', regime_lag_sep=False, regime_err_sep=True,\ cores=None, vm=False, name_y=None, name_x=None,\ name_yend=None, name_q=None, name_regimes=None,\ name_w=None, name_gwk=None, name_ds=None): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y, w_required=True) USER.check_robust(robust, gwk) USER.check_spat_diag(spat_diag, w) name_x = USER.set_name_x(name_x, x,constant=True) name_y = USER.set_name_y(name_y) name_yend = USER.set_name_yend(name_yend, yend) name_q = USER.set_name_q(name_q, q) name_q.extend(USER.set_name_q_sp(name_x, w_lags, name_q, lag_q, force_all=True)) self.name_regimes = USER.set_name_ds(name_regimes) self.constant_regi=constant_regi self.n = n cols2regi = REGI.check_cols2regi(constant_regi, cols2regi, x, yend=yend, add_cons=False) self.cols2regi = cols2regi self.regimes_set = REGI._get_regimes_set(regimes) self.regimes = regimes USER.check_regimes(self.regimes_set) self.regime_err_sep = regime_err_sep self.regime_lag_sep = regime_lag_sep if regime_lag_sep == True: if not regime_err_sep: raise Exception, "regime_err_sep must be True when regime_lag_sep=True." cols2regi += [True] w_i,regi_ids,warn = REGI.w_regimes(w, regimes, self.regimes_set, transform=True, get_ids=True, min_n=len(cols2regi)+1) set_warn(self,warn) else: cols2regi += [False] if regime_err_sep == True and set(cols2regi) == set([True]) and constant_regi == 'many': self.y = y self.GM_Lag_Regimes_Multi(y, x, w_i, regi_ids,\ yend=yend, q=q, w_lags=w_lags, lag_q=lag_q, cores=cores,\ robust=robust, gwk=gwk, sig2n_k=sig2n_k, cols2regi=cols2regi,\ spat_diag=spat_diag, vm=vm, name_y=name_y, name_x=name_x,\ name_yend=name_yend, name_q=name_q, name_regimes=self.name_regimes,\ name_w=name_w, name_gwk=name_gwk, name_ds=name_ds) else: if regime_lag_sep == True: w = REGI.w_regimes_union(w, w_i, self.regimes_set) yend2, q2 = set_endog(y, x, w, yend, q, w_lags, lag_q) name_yend.append(USER.set_name_yend_sp(name_y)) TSLS_Regimes.__init__(self, y=y, x=x, yend=yend2, q=q2,\ regimes=regimes, w=w, robust=robust, gwk=gwk,\ sig2n_k=sig2n_k, spat_diag=spat_diag, vm=vm,\ constant_regi=constant_regi, cols2regi=cols2regi, regime_err_sep=regime_err_sep,\ name_y=name_y, name_x=name_x, name_yend=name_yend, name_q=name_q,\ name_regimes=name_regimes, name_w=name_w, name_gwk=name_gwk,\ name_ds=name_ds,summ=False) if regime_lag_sep: self.sp_att_reg(w_i, regi_ids, yend2[:,-1].reshape(self.n,1)) else: self.predy_e, self.e_pred, warn = sp_att(w,self.y,self.predy,\ yend2[:,-1].reshape(self.n,1),self.betas[-1]) set_warn(self,warn) self.regime_lag_sep=regime_lag_sep if regime_err_sep == True: self.title = "SPATIAL TWO STAGE LEAST SQUARES - REGIMES (Group-wise heteroskedasticity)" else: self.title = "SPATIAL TWO STAGE LEAST SQUARES - REGIMES" SUMMARY.GM_Lag(reg=self, w=w, vm=vm, spat_diag=spat_diag, regimes=True)
def GM_Lag_Regimes_Multi( self, y, x, w_i, w, regi_ids, cores=False, yend=None, q=None, w_lags=1, lag_q=True, robust=None, gwk=None, sig2n_k=False, cols2regi="all", spat_diag=False, vm=False, name_y=None, name_x=None, name_yend=None, name_q=None, name_regimes=None, name_w=None, name_gwk=None, name_ds=None, ): # pool = mp.Pool(cores) self.name_ds = USER.set_name_ds(name_ds) name_x = USER.set_name_x(name_x, x) name_yend.append(USER.set_name_yend_sp(name_y)) self.name_w = USER.set_name_w(name_w, w_i) self.name_gwk = USER.set_name_w(name_gwk, gwk) results_p = {} """ for r in self.regimes_set: w_r = w_i[r].sparse if system() == 'Windows': is_win = True results_p[r] = _work(*(y,x,regi_ids,r,yend,q,w_r,w_lags,lag_q,robust,sig2n_k,self.name_ds,name_y,name_x,name_yend,name_q,self.name_w,name_regimes)) else: results_p[r] = pool.apply_async(_work,args=(y,x,regi_ids,r,yend,q,w_r,w_lags,lag_q,robust,sig2n_k,self.name_ds,name_y,name_x,name_yend,name_q,self.name_w,name_regimes, )) is_win = False """ for r in self.regimes_set: w_r = w_i[r].sparse if cores: pool = mp.Pool(None) results_p[r] = pool.apply_async( _work, args=( y, x, regi_ids, r, yend, q, w_r, w_lags, lag_q, robust, sig2n_k, self.name_ds, name_y, name_x, name_yend, name_q, self.name_w, name_regimes, ), ) else: results_p[r] = _work( *( y, x, regi_ids, r, yend, q, w_r, w_lags, lag_q, robust, sig2n_k, self.name_ds, name_y, name_x, name_yend, name_q, self.name_w, name_regimes, ) ) self.kryd = 0 self.kr = len(cols2regi) + 1 self.kf = 0 self.nr = len(self.regimes_set) self.name_x_r = name_x + name_yend self.name_regimes = name_regimes self.vm = np.zeros((self.nr * self.kr, self.nr * self.kr), float) self.betas = np.zeros((self.nr * self.kr, 1), float) self.u = np.zeros((self.n, 1), float) self.predy = np.zeros((self.n, 1), float) self.predy_e = np.zeros((self.n, 1), float) self.e_pred = np.zeros((self.n, 1), float) """ if not is_win: pool.close() pool.join() """ if cores: pool.close() pool.join() results = {} self.name_y, self.name_x, self.name_yend, self.name_q, self.name_z, self.name_h = [], [], [], [], [], [] counter = 0 for r in self.regimes_set: """ if is_win: results[r] = results_p[r] else: results[r] = results_p[r].get() """ if not cores: results[r] = results_p[r] else: results[r] = results_p[r].get() results[r].predy_e, results[r].e_pred, warn = sp_att( w_i[r], results[r].y, results[r].predy, results[r].yend[:, -1].reshape(results[r].n, 1), results[r].rho ) set_warn(results[r], warn) results[r].w = w_i[r] self.vm[ (counter * self.kr) : ((counter + 1) * self.kr), (counter * self.kr) : ((counter + 1) * self.kr) ] = results[r].vm self.betas[(counter * self.kr) : ((counter + 1) * self.kr),] = results[r].betas self.u[regi_ids[r],] = results[r].u self.predy[regi_ids[r],] = results[r].predy self.predy_e[regi_ids[r],] = results[r].predy_e self.e_pred[regi_ids[r],] = results[r].e_pred self.name_y += results[r].name_y self.name_x += results[r].name_x self.name_yend += results[r].name_yend self.name_q += results[r].name_q self.name_z += results[r].name_z self.name_h += results[r].name_h if r == self.regimes_set[0]: self.hac_var = np.zeros((self.n, results[r].h.shape[1]), float) self.hac_var[regi_ids[r],] = results[r].h counter += 1 self.multi = results if robust == "hac": hac_multi(self, gwk, constant=True) if robust == "ogmm": set_warn(self, "Residuals treated as homoskedastic for the purpose of diagnostics.") self.chow = REGI.Chow(self) if spat_diag: pass # self._get_spat_diag_props(y, x, w, yend, q, w_lags, lag_q) SUMMARY.GM_Lag_multi(reg=self, multireg=self.multi, vm=vm, spat_diag=spat_diag, regimes=True, w=w)
def _tsls_regimes_multi(self, x, yend, q, w, regi_ids, cores, gwk, sig2n_k, robust, spat_diag, vm, name_x, name_yend, name_q): results_p = {} """ for r in self.regimes_set: if system() != 'Windows': is_win = True results_p[r] = _work(*(self.y,x,w,regi_ids,r,yend,q,robust,sig2n_k,self.name_ds,self.name_y,name_x,name_yend,name_q,self.name_w,self.name_regimes)) else: pool = mp.Pool(cores) results_p[r] = pool.apply_async(_work,args=(self.y,x,w,regi_ids,r,yend,q,robust,sig2n_k,self.name_ds,self.name_y,name_x,name_yend,name_q,self.name_w,self.name_regimes)) is_win = False """ for r in self.regimes_set: if cores: pool = mp.Pool(None) results_p[r] = pool.apply_async( _work, args=(self.y, x, w, regi_ids, r, yend, q, robust, sig2n_k, self.name_ds, self.name_y, name_x, name_yend, name_q, self.name_w, self.name_regimes)) else: results_p[r] = _work(*(self.y, x, w, regi_ids, r, yend, q, robust, sig2n_k, self.name_ds, self.name_y, name_x, name_yend, name_q, self.name_w, self.name_regimes)) self.kryd = 0 self.kr = x.shape[1] + yend.shape[1] + 1 self.kf = 0 self.nr = len(self.regimes_set) self.vm = np.zeros((self.nr * self.kr, self.nr * self.kr), float) self.betas = np.zeros((self.nr * self.kr, 1), float) self.u = np.zeros((self.n, 1), float) self.predy = np.zeros((self.n, 1), float) """ if not is_win: pool.close() pool.join() """ if cores: pool.close() pool.join() results = {} self.name_y, self.name_x, self.name_yend, self.name_q, self.name_z, self.name_h = [ ], [], [], [], [], [] counter = 0 for r in self.regimes_set: """ if is_win: results[r] = results_p[r] else: results[r] = results_p[r].get() """ if not cores: results[r] = results_p[r] else: results[r] = results_p[r].get() self.vm[(counter * self.kr):((counter + 1) * self.kr), (counter * self.kr):((counter + 1) * self.kr)] = results[r].vm self.betas[(counter * self.kr):((counter + 1) * self.kr), ] = results[r].betas self.u[regi_ids[r], ] = results[r].u self.predy[regi_ids[r], ] = results[r].predy self.name_y += results[r].name_y self.name_x += results[r].name_x self.name_yend += results[r].name_yend self.name_q += results[r].name_q self.name_z += results[r].name_z self.name_h += results[r].name_h counter += 1 self.multi = results self.hac_var = sphstack(x, q) if robust == 'hac': hac_multi(self, gwk) if robust == 'ogmm': set_warn( self, "Residuals treated as homoskedastic for the purpose of diagnostics." ) self.chow = REGI.Chow(self) if spat_diag: self._get_spat_diag_props(results, regi_ids, x, yend, q) SUMMARY.TSLS_multi(reg=self, multireg=self.multi, vm=vm, spat_diag=spat_diag, regimes=True, w=w)
def _tsls_regimes_multi(self, x, yend, q, w, regi_ids, cores, gwk, sig2n_k, robust, spat_diag, vm, name_x, name_yend, name_q): results_p = {} for r in self.regimes_set: if system() != 'Windows': is_win = True results_p[r] = _work( *(self.y, x, w, regi_ids, r, yend, q, robust, sig2n_k, self.name_ds, self.name_y, name_x, name_yend, name_q, self.name_w, self.name_regimes)) else: pool = mp.Pool(cores) results_p[r] = pool.apply_async( _work, args=( self.y, x, w, regi_ids, r, yend, q, robust, sig2n_k, self.name_ds, self.name_y, name_x, name_yend, name_q, self.name_w, self.name_regimes)) is_win = False self.kryd = 0 self.kr = x.shape[1] + yend.shape[1] + 1 self.kf = 0 self.nr = len(self.regimes_set) self.vm = np.zeros((self.nr * self.kr, self.nr * self.kr), float) self.betas = np.zeros((self.nr * self.kr, 1), float) self.u = np.zeros((self.n, 1), float) self.predy = np.zeros((self.n, 1), float) if not is_win: pool.close() pool.join() results = {} self.name_y, self.name_x, self.name_yend, self.name_q, self.name_z, self.name_h = [ ], [], [], [], [], [] counter = 0 for r in self.regimes_set: if is_win: results[r] = results_p[r] else: results[r] = results_p[r].get() self.vm[(counter * self.kr):((counter + 1) * self.kr), (counter * self.kr):((counter + 1) * self.kr)] = results[r].vm self.betas[(counter * self.kr):((counter + 1) * self.kr), ] = results[r].betas self.u[regi_ids[r], ] = results[r].u self.predy[regi_ids[r], ] = results[r].predy self.name_y += results[r].name_y self.name_x += results[r].name_x self.name_yend += results[r].name_yend self.name_q += results[r].name_q self.name_z += results[r].name_z self.name_h += results[r].name_h counter += 1 self.multi = results self.hac_var = sphstack(x, q) if robust == 'hac': hac_multi(self, gwk) if robust == 'ogmm': set_warn( self, "Residuals treated as homoskedastic for the purpose of diagnostics.") self.chow = REGI.Chow(self) if spat_diag: self._get_spat_diag_props(results, regi_ids, x, yend, q) SUMMARY.TSLS_multi(reg=self, multireg=self.multi, vm=vm, spat_diag=spat_diag, regimes=True, w=w)
def __init__(self, y, x, yend, q, regimes, w=None, robust=None, gwk=None, sig2n_k=True, spat_diag=False, vm=False, constant_regi='many', cols2regi='all', regime_err_sep=True, name_y=None, name_x=None, cores=None, name_yend=None, name_q=None, name_regimes=None, name_w=None, name_gwk=None, name_ds=None, summ=True): n = USER.check_arrays(y, x) USER.check_y(y, n) USER.check_weights(w, y) USER.check_robust(robust, gwk) USER.check_spat_diag(spat_diag, w) self.constant_regi = constant_regi self.cols2regi = cols2regi self.name_ds = USER.set_name_ds(name_ds) self.name_regimes = USER.set_name_ds(name_regimes) self.name_w = USER.set_name_w(name_w, w) self.name_gwk = USER.set_name_w(name_gwk, gwk) self.name_y = USER.set_name_y(name_y) name_yend = USER.set_name_yend(name_yend, yend) name_q = USER.set_name_q(name_q, q) self.name_x_r = USER.set_name_x(name_x, x) + name_yend self.n = n cols2regi = REGI.check_cols2regi( constant_regi, cols2regi, x, yend=yend, add_cons=False) self.regimes_set = REGI._get_regimes_set(regimes) self.regimes = regimes USER.check_regimes(self.regimes_set, self.n, x.shape[1]) if regime_err_sep == True and robust == 'hac': set_warn( self, "Error by regimes is incompatible with HAC estimation for 2SLS models. Hence, the error by regimes has been disabled for this model.") regime_err_sep = False self.regime_err_sep = regime_err_sep if regime_err_sep == True and set(cols2regi) == set([True]) and constant_regi == 'many': name_x = USER.set_name_x(name_x, x) self.y = y regi_ids = dict((r, list(np.where(np.array(regimes) == r)[0])) for r in self.regimes_set) self._tsls_regimes_multi(x, yend, q, w, regi_ids, cores, gwk, sig2n_k, robust, spat_diag, vm, name_x, name_yend, name_q) else: name_x = USER.set_name_x(name_x, x, constant=True) q, self.name_q = REGI.Regimes_Frame.__init__(self, q, regimes, constant_regi=None, cols2regi='all', names=name_q) x, self.name_x = REGI.Regimes_Frame.__init__(self, x, regimes, constant_regi, cols2regi=cols2regi, names=name_x) yend, self.name_yend = REGI.Regimes_Frame.__init__(self, yend, regimes, constant_regi=None, cols2regi=cols2regi, yend=True, names=name_yend) if regime_err_sep == True and robust == None: robust = 'white' BaseTSLS.__init__(self, y=y, x=x, yend=yend, q=q, robust=robust, gwk=gwk, sig2n_k=sig2n_k) self.title = "TWO STAGE LEAST SQUARES - REGIMES" if robust == 'ogmm': _optimal_weight(self, sig2n_k) self.name_z = self.name_x + self.name_yend self.name_h = USER.set_name_h(self.name_x, self.name_q) self.chow = REGI.Chow(self) self.robust = USER.set_robust(robust) if summ: SUMMARY.TSLS(reg=self, vm=vm, w=w, spat_diag=spat_diag, regimes=True)