def get_llh(model, exog, full_model, name, values, beta_seq):
"""
Parameters
---------
model: bambi.Model
exog: pandas.DataFrame
name: str
Name of the term for which we want to compute the llh
values: np.array
Values of the term for which we want to compute the llh
beta_seq: np.array
Sequence of values from to beta_mle.
"""
# True if there are other predictors appart from `predictor_name`
if name not in exog.columns:
raise ValueError("get_llh failed. Term name not in exog.")
multiple_predictors = exog.shape[1] > 1
sm_family = model.family.smfamily(model.family.smlink)
if multiple_predictors:
# Use statsmodels to _optimize_ the LL. Model is fitted 'points' times.
glm_model = GLM(endog=model.response.data, exog=exog, family=sm_family)
null_models = [glm_model.fit_constrained(f"{name}={beta}") for beta in beta_seq[:-1]]
null_models = np.append(null_models, full_model)
log_likelihood = np.array([x.llf for x in null_models])
else:
# Use statsmodels to _evaluate_ the LL. Model is fitted 'points' times.
log_likelihood = [
sm_family.loglike(np.squeeze(model.response.data), beta * values)
for beta in beta_seq[:-1]
]
log_likelihood = np.append(log_likelihood, full_model.llf)
return log_likelihood
def setup_class(cls):
cls.idx = slice(None) # params sequence same as Stata
#res1ul = Logit(data.endog, data.exog).fit(method="newton", disp=0)
cls.res2 = reslogit.results_constraint2_robust
mod1 = GLM(spector_data.endog,
spector_data.exog,
family=families.Binomial())
# not used to match Stata for HC
# nobs, k_params = mod1.exog.shape
# k_params -= 1 # one constraint
cov_type = 'HC0'
cov_kwds = {'scaling_factor': 32 / 31}
# looks like nobs / (nobs - 1) and not (nobs - 1.) / (nobs - k_params)}
constr = 'x1 - x3 = 0'
cls.res1m = mod1.fit_constrained(constr,
cov_type=cov_type,
cov_kwds=cov_kwds,
atol=1e-10)
R, q = cls.res1m.constraints.coefs, cls.res1m.constraints.constants
cls.res1 = fit_constrained(mod1,
R,
q,
fit_kwds={
'atol': 1e-10,
'cov_type': cov_type,
'cov_kwds': cov_kwds
})
cls.constraints_rq = (R, q)
def setup_class(cls):
cls.idx = slice(None) # params sequence same as Stata
#res1ul = Logit(data.endog, data.exog).fit(method="newton", disp=0)
cls.res2 = reslogit.results_constraint2
mod1 = GLM(spector_data.endog, spector_data.exog,
family=families.Binomial())
constr = 'x1 - x3 = 0'
cls.res1m = mod1.fit_constrained(constr, atol=1e-10)
R, q = cls.res1m.constraints.coefs, cls.res1m.constraints.constants
cls.res1 = fit_constrained(mod1, R, q, fit_kwds={'atol': 1e-10})
cls.constraints_rq = (R, q)
def setup_class(cls):
cls.idx = slice(None) # params sequence same as Stata
#res1ul = Logit(data.endog, data.exog).fit(method="newton", disp=0)
cls.res2 = reslogit.results_constraint2
mod1 = GLM(spector_data.endog, spector_data.exog,
family=families.Binomial())
constr = 'x1 - x3 = 0'
cls.res1m = mod1.fit_constrained(constr, atol=1e-10)
R, q = cls.res1m.constraints.coefs, cls.res1m.constraints.constants
cls.res1 = fit_constrained(mod1, R, q, fit_kwds={'atol': 1e-10})
cls.constraints_rq = (R, q)
def setup_class(cls):
cls.idx = slice(None) # params sequence same as Stata
cls.res2 = reslogit.results_constraint2
mod1 = GLM(spector_data.endog, spector_data.exog,
family=families.Binomial())
constr = 'x1 - x3 = 0'
cls.res1m = mod1.fit_constrained(constr, atol=1e-10)
# patsy compatible constraints
R, q = cls.res1m.constraints.coefs, cls.res1m.constraints.constants
cls.res1 = fit_constrained(mod1, R, q, fit_kwds={'atol': 1e-10})
cls.constraints_rq = (R, q)
def _compute_concentrated_states(self, params, *args, **kwargs):
# Apply the usual filter, but keep forecasts
kwargs['conserve_memory'] = MEMORY_CONSERVE & ~MEMORY_NO_FORECAST
super().loglike(params, *args, **kwargs)
# Compute the initial state vector
y_tilde = np.array(self.ssm._kalman_filter.forecast_error[0],
copy=True)
# Need to modify our state space system matrices slightly to get them
# back into the form of the innovations framework of
# De Livera et al. (2011)
T = self['transition', 1:, 1:]
R = self['selection', 1:]
Z = self['design', :, 1:].copy()
i = 1
if self.trend:
Z[0, i] = 1.
i += 1
if self.seasonal:
Z[0, i] = 0.
Z[0, -1] = 1.
# Now compute the regression components as described in
# De Livera et al. (2011), equation (10).
D = T - R.dot(Z)
w = np.zeros((self.nobs, self.k_states - 1), dtype=D.dtype)
w[0] = Z
for i in range(self.nobs - 1):
w[i + 1] = w[i].dot(D)
mod_ols = GLM(y_tilde, w)
# If we have seasonal parameters, constrain them to sum to zero
# (otherwise the initial level gets confounded with the sum of the
# seasonals).
if self.seasonal:
R = np.zeros_like(Z)
R[0, -self.seasonal_periods:] = 1.
q = np.zeros((1, 1))
res_ols = mod_ols.fit_constrained((R, q))
else:
res_ols = mod_ols.fit()
# Separate into individual components
initial_level = res_ols.params[0]
initial_trend = res_ols.params[1] if self.trend else None
initial_seasonal = (
res_ols.params[-self.seasonal_periods:] if self.seasonal else None)
return initial_level, initial_trend, initial_seasonal
def setup_class(cls):
cls.idx = slice(None)
# params sequence same as Stata, but Stata reports param = nan
# and we have param = value = 0
cls.res2 = reslogit.results_constraint1
mod1 = GLM(spector_data.endog, spector_data.exog,
family=families.Binomial())
constr = 'x1 = 2.8'
cls.res1m = mod1.fit_constrained(constr)
R, q = cls.res1m.constraints
cls.res1 = fit_constrained(mod1, R, q)
def setup_class(cls):
cls.idx = slice(None)
# params sequence same as Stata, but Stata reports param = nan
# and we have param = value = 0
#res1ul = Logit(data.endog, data.exog).fit(method="newton", disp=0)
cls.res2 = reslogit.results_constraint1
mod1 = GLM(spector_data.endog, spector_data.exog,
family=families.Binomial())
constr = 'x1 = 2.8'
cls.res1m = mod1.fit_constrained(constr)
R, q = cls.res1m.constraints.coefs, cls.res1m.constraints.constants
cls.res1 = fit_constrained(mod1, R, q)
def setup_class(cls):
cls.idx = slice(None) # params sequence same as Stata
#res1ul = Logit(data.endog, data.exog).fit(method="newton", disp=0)
cls.res2 = reslogit.results_constraint2_robust
mod1 = GLM(spector_data.endog, spector_data.exog,
family=families.Binomial())
# not used to match Stata for HC
# nobs, k_params = mod1.exog.shape
# k_params -= 1 # one constraint
cov_type = 'HC0'
cov_kwds = {'scaling_factor': 32/31}
# looks like nobs / (nobs - 1) and not (nobs - 1.) / (nobs - k_params)}
constr = 'x1 - x3 = 0'
cls.res1m = mod1.fit_constrained(constr, cov_type=cov_type,
cov_kwds=cov_kwds, atol=1e-10)
R, q = cls.res1m.constraints.coefs, cls.res1m.constraints.constants
cls.res1 = fit_constrained(mod1, R, q, fit_kwds={'atol': 1e-10,
'cov_type': cov_type,
'cov_kwds': cov_kwds})
cls.constraints_rq = (R, q)
def init(cls):
cov_type = 'HC0'
cls.res2 = cls.mod2.fit(cov_type=cov_type)
mod = GLM(cls.endog, cls.exog, var_weights=cls.aweights)
mod.exog_names[:] = ['const', 'x1', 'x2', 'x3', 'x4']
cls.res1 = mod.fit_constrained('x1=0.5', cov_type=cov_type)
def init(cls):
cls.res2 = cls.mod2.fit()
mod = GLM(cls.endog, cls.exog)
mod.exog_names[:] = ['const', 'x1', 'x2', 'x3', 'x4']
cls.res1 = mod.fit_constrained('x1=0.5')
def init(cls):
cov_type = 'HC0'
cls.res2 = cls.mod2.fit(cov_type=cov_type)
mod = GLM(cls.endog, cls.exog, var_weights=cls.aweights)
mod.exog_names[:] = ['const', 'x1', 'x2', 'x3', 'x4']
cls.res1 = mod.fit_constrained('x1=0.5', cov_type=cov_type)
def init(cls):
cls.res2 = cls.mod2.fit()
mod = GLM(cls.endog, cls.exog)
mod.exog_names[:] = ['const', 'x1', 'x2', 'x3', 'x4']
cls.res1 = mod.fit_constrained('x1=0.5')
