reconnect moved files to git repo
This commit is contained in:
root
@ -0,0 +1,634 @@
|
||||
"""
|
||||
Conditional logistic, Poisson, and multinomial logit regression
|
||||
"""
|
||||
|
||||
import numpy as np
|
||||
import statsmodels.base.model as base
|
||||
import statsmodels.regression.linear_model as lm
|
||||
import statsmodels.base.wrapper as wrap
|
||||
from statsmodels.discrete.discrete_model import (MultinomialResults,
|
||||
MultinomialResultsWrapper)
|
||||
import collections
|
||||
import warnings
|
||||
import itertools
|
||||
|
||||
|
||||
class _ConditionalModel(base.LikelihoodModel):
|
||||
|
||||
def __init__(self, endog, exog, missing='none', **kwargs):
|
||||
|
||||
if "groups" not in kwargs:
|
||||
raise ValueError("'groups' is a required argument")
|
||||
groups = kwargs["groups"]
|
||||
|
||||
if groups.size != endog.size:
|
||||
msg = "'endog' and 'groups' should have the same dimensions"
|
||||
raise ValueError(msg)
|
||||
|
||||
if exog.shape[0] != endog.size:
|
||||
msg = "The leading dimension of 'exog' should equal the length of 'endog'"
|
||||
raise ValueError(msg)
|
||||
|
||||
super().__init__(
|
||||
endog, exog, missing=missing, **kwargs)
|
||||
|
||||
if self.data.const_idx is not None:
|
||||
msg = ("Conditional models should not have an intercept in the " +
|
||||
"design matrix")
|
||||
raise ValueError(msg)
|
||||
|
||||
exog = self.exog
|
||||
self.k_params = exog.shape[1]
|
||||
|
||||
# Get the row indices for each group
|
||||
row_ix = {}
|
||||
for i, g in enumerate(groups):
|
||||
if g not in row_ix:
|
||||
row_ix[g] = []
|
||||
row_ix[g].append(i)
|
||||
|
||||
# Split the data into groups and remove groups with no variation
|
||||
endog, exog = np.asarray(endog), np.asarray(exog)
|
||||
offset = kwargs.get("offset")
|
||||
self._endog_grp = []
|
||||
self._exog_grp = []
|
||||
self._groupsize = []
|
||||
if offset is not None:
|
||||
offset = np.asarray(offset)
|
||||
self._offset_grp = []
|
||||
self._offset = []
|
||||
self._sumy = []
|
||||
self.nobs = 0
|
||||
drops = [0, 0]
|
||||
for g, ix in row_ix.items():
|
||||
y = endog[ix].flat
|
||||
if np.std(y) == 0:
|
||||
drops[0] += 1
|
||||
drops[1] += len(y)
|
||||
continue
|
||||
self.nobs += len(y)
|
||||
self._endog_grp.append(y)
|
||||
if offset is not None:
|
||||
self._offset_grp.append(offset[ix])
|
||||
self._groupsize.append(len(y))
|
||||
self._exog_grp.append(exog[ix, :])
|
||||
self._sumy.append(np.sum(y))
|
||||
|
||||
if drops[0] > 0:
|
||||
msg = ("Dropped %d groups and %d observations for having " +
|
||||
"no within-group variance") % tuple(drops)
|
||||
warnings.warn(msg)
|
||||
|
||||
# This can be pre-computed
|
||||
if offset is not None:
|
||||
self._endofs = []
|
||||
for k, ofs in enumerate(self._offset_grp):
|
||||
self._endofs.append(np.dot(self._endog_grp[k], ofs))
|
||||
|
||||
# Number of groups
|
||||
self._n_groups = len(self._endog_grp)
|
||||
|
||||
# These are the sufficient statistics
|
||||
self._xy = []
|
||||
self._n1 = []
|
||||
for g in range(self._n_groups):
|
||||
self._xy.append(np.dot(self._endog_grp[g], self._exog_grp[g]))
|
||||
self._n1.append(np.sum(self._endog_grp[g]))
|
||||
|
||||
def hessian(self, params):
|
||||
|
||||
from statsmodels.tools.numdiff import approx_fprime
|
||||
hess = approx_fprime(params, self.score)
|
||||
hess = np.atleast_2d(hess)
|
||||
return hess
|
||||
|
||||
def fit(self,
|
||||
start_params=None,
|
||||
method='BFGS',
|
||||
maxiter=100,
|
||||
full_output=True,
|
||||
disp=False,
|
||||
fargs=(),
|
||||
callback=None,
|
||||
retall=False,
|
||||
skip_hessian=False,
|
||||
**kwargs):
|
||||
|
||||
rslt = super().fit(
|
||||
start_params=start_params,
|
||||
method=method,
|
||||
maxiter=maxiter,
|
||||
full_output=full_output,
|
||||
disp=disp,
|
||||
skip_hessian=skip_hessian)
|
||||
|
||||
crslt = ConditionalResults(self, rslt.params, rslt.cov_params(), 1)
|
||||
crslt.method = method
|
||||
crslt.nobs = self.nobs
|
||||
crslt.n_groups = self._n_groups
|
||||
crslt._group_stats = [
|
||||
"%d" % min(self._groupsize),
|
||||
"%d" % max(self._groupsize),
|
||||
"%.1f" % np.mean(self._groupsize)
|
||||
]
|
||||
rslt = ConditionalResultsWrapper(crslt)
|
||||
return rslt
|
||||
|
||||
def fit_regularized(self,
|
||||
method="elastic_net",
|
||||
alpha=0.,
|
||||
start_params=None,
|
||||
refit=False,
|
||||
**kwargs):
|
||||
"""
|
||||
Return a regularized fit to a linear regression model.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
method : {'elastic_net'}
|
||||
Only the `elastic_net` approach is currently implemented.
|
||||
alpha : scalar or array_like
|
||||
The penalty weight. If a scalar, the same penalty weight
|
||||
applies to all variables in the model. If a vector, it
|
||||
must have the same length as `params`, and contains a
|
||||
penalty weight for each coefficient.
|
||||
start_params : array_like
|
||||
Starting values for `params`.
|
||||
refit : bool
|
||||
If True, the model is refit using only the variables that
|
||||
have non-zero coefficients in the regularized fit. The
|
||||
refitted model is not regularized.
|
||||
**kwargs
|
||||
Additional keyword argument that are used when fitting the model.
|
||||
|
||||
Returns
|
||||
-------
|
||||
Results
|
||||
A results instance.
|
||||
"""
|
||||
|
||||
from statsmodels.base.elastic_net import fit_elasticnet
|
||||
|
||||
if method != "elastic_net":
|
||||
raise ValueError("method for fit_regularized must be elastic_net")
|
||||
|
||||
defaults = {"maxiter": 50, "L1_wt": 1, "cnvrg_tol": 1e-10,
|
||||
"zero_tol": 1e-10}
|
||||
defaults.update(kwargs)
|
||||
|
||||
return fit_elasticnet(self, method=method,
|
||||
alpha=alpha,
|
||||
start_params=start_params,
|
||||
refit=refit,
|
||||
**defaults)
|
||||
|
||||
# Override to allow groups to be passed as a variable name.
|
||||
@classmethod
|
||||
def from_formula(cls,
|
||||
formula,
|
||||
data,
|
||||
subset=None,
|
||||
drop_cols=None,
|
||||
*args,
|
||||
**kwargs):
|
||||
|
||||
try:
|
||||
groups = kwargs["groups"]
|
||||
del kwargs["groups"]
|
||||
except KeyError:
|
||||
raise ValueError("'groups' is a required argument")
|
||||
|
||||
if isinstance(groups, str):
|
||||
groups = data[groups]
|
||||
|
||||
if "0+" not in formula.replace(" ", ""):
|
||||
warnings.warn("Conditional models should not include an intercept")
|
||||
|
||||
model = super().from_formula(
|
||||
formula, data=data, groups=groups, *args, **kwargs)
|
||||
|
||||
return model
|
||||
|
||||
|
||||
class ConditionalLogit(_ConditionalModel):
|
||||
"""
|
||||
Fit a conditional logistic regression model to grouped data.
|
||||
|
||||
Every group is implicitly given an intercept, but the model is fit using
|
||||
a conditional likelihood in which the intercepts are not present. Thus,
|
||||
intercept estimates are not given, but the other parameter estimates can
|
||||
be interpreted as being adjusted for any group-level confounders.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
endog : array_like
|
||||
The response variable, must contain only 0 and 1.
|
||||
exog : array_like
|
||||
The array of covariates. Do not include an intercept
|
||||
in this array.
|
||||
groups : array_like
|
||||
Codes defining the groups. This is a required keyword parameter.
|
||||
"""
|
||||
|
||||
def __init__(self, endog, exog, missing='none', **kwargs):
|
||||
|
||||
super().__init__(
|
||||
endog, exog, missing=missing, **kwargs)
|
||||
|
||||
if np.any(np.unique(self.endog) != np.r_[0, 1]):
|
||||
msg = "endog must be coded as 0, 1"
|
||||
raise ValueError(msg)
|
||||
|
||||
self.K = self.exog.shape[1]
|
||||
# i.e. self.k_params, for compatibility with MNLogit
|
||||
|
||||
def loglike(self, params):
|
||||
|
||||
ll = 0
|
||||
for g in range(len(self._endog_grp)):
|
||||
ll += self.loglike_grp(g, params)
|
||||
|
||||
return ll
|
||||
|
||||
def score(self, params):
|
||||
|
||||
score = 0
|
||||
for g in range(self._n_groups):
|
||||
score += self.score_grp(g, params)
|
||||
|
||||
return score
|
||||
|
||||
def _denom(self, grp, params, ofs=None):
|
||||
|
||||
if ofs is None:
|
||||
ofs = 0
|
||||
|
||||
exb = np.exp(np.dot(self._exog_grp[grp], params) + ofs)
|
||||
|
||||
# In the recursions, f may be called multiple times with the
|
||||
# same arguments, so we memoize the results.
|
||||
memo = {}
|
||||
|
||||
def f(t, k):
|
||||
if t < k:
|
||||
return 0
|
||||
if k == 0:
|
||||
return 1
|
||||
|
||||
try:
|
||||
return memo[(t, k)]
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
v = f(t - 1, k) + f(t - 1, k - 1) * exb[t - 1]
|
||||
memo[(t, k)] = v
|
||||
|
||||
return v
|
||||
|
||||
return f(self._groupsize[grp], self._n1[grp])
|
||||
|
||||
def _denom_grad(self, grp, params, ofs=None):
|
||||
|
||||
if ofs is None:
|
||||
ofs = 0
|
||||
|
||||
ex = self._exog_grp[grp]
|
||||
exb = np.exp(np.dot(ex, params) + ofs)
|
||||
|
||||
# s may be called multiple times in the recursions with the
|
||||
# same arguments, so memoize the results.
|
||||
memo = {}
|
||||
|
||||
def s(t, k):
|
||||
|
||||
if t < k:
|
||||
return 0, np.zeros(self.k_params)
|
||||
if k == 0:
|
||||
return 1, 0
|
||||
|
||||
try:
|
||||
return memo[(t, k)]
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
h = exb[t - 1]
|
||||
a, b = s(t - 1, k)
|
||||
c, e = s(t - 1, k - 1)
|
||||
d = c * h * ex[t - 1, :]
|
||||
|
||||
u, v = a + c * h, b + d + e * h
|
||||
memo[(t, k)] = (u, v)
|
||||
|
||||
return u, v
|
||||
|
||||
return s(self._groupsize[grp], self._n1[grp])
|
||||
|
||||
def loglike_grp(self, grp, params):
|
||||
|
||||
ofs = None
|
||||
if hasattr(self, 'offset'):
|
||||
ofs = self._offset_grp[grp]
|
||||
|
||||
llg = np.dot(self._xy[grp], params)
|
||||
|
||||
if ofs is not None:
|
||||
llg += self._endofs[grp]
|
||||
|
||||
llg -= np.log(self._denom(grp, params, ofs))
|
||||
|
||||
return llg
|
||||
|
||||
def score_grp(self, grp, params):
|
||||
|
||||
ofs = 0
|
||||
if hasattr(self, 'offset'):
|
||||
ofs = self._offset_grp[grp]
|
||||
|
||||
d, h = self._denom_grad(grp, params, ofs)
|
||||
return self._xy[grp] - h / d
|
||||
|
||||
|
||||
class ConditionalPoisson(_ConditionalModel):
|
||||
"""
|
||||
Fit a conditional Poisson regression model to grouped data.
|
||||
|
||||
Every group is implicitly given an intercept, but the model is fit using
|
||||
a conditional likelihood in which the intercepts are not present. Thus,
|
||||
intercept estimates are not given, but the other parameter estimates can
|
||||
be interpreted as being adjusted for any group-level confounders.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
endog : array_like
|
||||
The response variable
|
||||
exog : array_like
|
||||
The covariates
|
||||
groups : array_like
|
||||
Codes defining the groups. This is a required keyword parameter.
|
||||
"""
|
||||
|
||||
def loglike(self, params):
|
||||
|
||||
ofs = None
|
||||
if hasattr(self, 'offset'):
|
||||
ofs = self._offset_grp
|
||||
|
||||
ll = 0.0
|
||||
|
||||
for i in range(len(self._endog_grp)):
|
||||
|
||||
xb = np.dot(self._exog_grp[i], params)
|
||||
if ofs is not None:
|
||||
xb += ofs[i]
|
||||
exb = np.exp(xb)
|
||||
y = self._endog_grp[i]
|
||||
ll += np.dot(y, xb)
|
||||
s = exb.sum()
|
||||
ll -= self._sumy[i] * np.log(s)
|
||||
|
||||
return ll
|
||||
|
||||
def score(self, params):
|
||||
|
||||
ofs = None
|
||||
if hasattr(self, 'offset'):
|
||||
ofs = self._offset_grp
|
||||
|
||||
score = 0.0
|
||||
|
||||
for i in range(len(self._endog_grp)):
|
||||
|
||||
x = self._exog_grp[i]
|
||||
xb = np.dot(x, params)
|
||||
if ofs is not None:
|
||||
xb += ofs[i]
|
||||
exb = np.exp(xb)
|
||||
s = exb.sum()
|
||||
y = self._endog_grp[i]
|
||||
score += np.dot(y, x)
|
||||
score -= self._sumy[i] * np.dot(exb, x) / s
|
||||
|
||||
return score
|
||||
|
||||
|
||||
class ConditionalResults(base.LikelihoodModelResults):
|
||||
def __init__(self, model, params, normalized_cov_params, scale):
|
||||
|
||||
super().__init__(
|
||||
model,
|
||||
params,
|
||||
normalized_cov_params=normalized_cov_params,
|
||||
scale=scale)
|
||||
|
||||
def summary(self, yname=None, xname=None, title=None, alpha=.05):
|
||||
"""
|
||||
Summarize the fitted model.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
yname : str, optional
|
||||
Default is `y`
|
||||
xname : list[str], optional
|
||||
Names for the exogenous variables, default is "var_xx".
|
||||
Must match the number of parameters in the model
|
||||
title : str, optional
|
||||
Title for the top table. If not None, then this replaces the
|
||||
default title
|
||||
alpha : float
|
||||
Significance level for the confidence intervals
|
||||
|
||||
Returns
|
||||
-------
|
||||
smry : Summary instance
|
||||
This holds the summary tables and text, which can be printed or
|
||||
converted to various output formats.
|
||||
|
||||
See Also
|
||||
--------
|
||||
statsmodels.iolib.summary.Summary : class to hold summary
|
||||
results
|
||||
"""
|
||||
|
||||
top_left = [
|
||||
('Dep. Variable:', None),
|
||||
('Model:', None),
|
||||
('Log-Likelihood:', None),
|
||||
('Method:', [self.method]),
|
||||
('Date:', None),
|
||||
('Time:', None),
|
||||
]
|
||||
|
||||
top_right = [
|
||||
('No. Observations:', None),
|
||||
('No. groups:', [self.n_groups]),
|
||||
('Min group size:', [self._group_stats[0]]),
|
||||
('Max group size:', [self._group_stats[1]]),
|
||||
('Mean group size:', [self._group_stats[2]]),
|
||||
]
|
||||
|
||||
if title is None:
|
||||
title = "Conditional Logit Model Regression Results"
|
||||
|
||||
# create summary tables
|
||||
from statsmodels.iolib.summary import Summary
|
||||
smry = Summary()
|
||||
smry.add_table_2cols(
|
||||
self,
|
||||
gleft=top_left,
|
||||
gright=top_right, # [],
|
||||
yname=yname,
|
||||
xname=xname,
|
||||
title=title)
|
||||
smry.add_table_params(
|
||||
self, yname=yname, xname=xname, alpha=alpha, use_t=self.use_t)
|
||||
|
||||
return smry
|
||||
|
||||
class ConditionalMNLogit(_ConditionalModel):
|
||||
"""
|
||||
Fit a conditional multinomial logit model to grouped data.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
endog : array_like
|
||||
The dependent variable, must be integer-valued, coded
|
||||
0, 1, ..., c-1, where c is the number of response
|
||||
categories.
|
||||
exog : array_like
|
||||
The independent variables.
|
||||
groups : array_like
|
||||
Codes defining the groups. This is a required keyword parameter.
|
||||
|
||||
Notes
|
||||
-----
|
||||
Equivalent to femlogit in Stata.
|
||||
|
||||
References
|
||||
----------
|
||||
Gary Chamberlain (1980). Analysis of covariance with qualitative
|
||||
data. The Review of Economic Studies. Vol. 47, No. 1, pp. 225-238.
|
||||
"""
|
||||
|
||||
def __init__(self, endog, exog, missing='none', **kwargs):
|
||||
|
||||
super().__init__(
|
||||
endog, exog, missing=missing, **kwargs)
|
||||
|
||||
# endog must be integers
|
||||
self.endog = self.endog.astype(int)
|
||||
|
||||
self.k_cat = self.endog.max() + 1
|
||||
self.df_model = (self.k_cat - 1) * self.exog.shape[1]
|
||||
self.df_resid = self.nobs - self.df_model
|
||||
self._ynames_map = {j: str(j) for j in range(self.k_cat)}
|
||||
self.J = self.k_cat # Unfortunate name, needed for results
|
||||
self.K = self.exog.shape[1] # for compatibility with MNLogit
|
||||
|
||||
if self.endog.min() < 0:
|
||||
msg = "endog may not contain negative values"
|
||||
raise ValueError(msg)
|
||||
|
||||
grx = collections.defaultdict(list)
|
||||
for k, v in enumerate(self.groups):
|
||||
grx[v].append(k)
|
||||
self._group_labels = list(grx.keys())
|
||||
self._group_labels.sort()
|
||||
self._grp_ix = [grx[k] for k in self._group_labels]
|
||||
|
||||
def fit(self,
|
||||
start_params=None,
|
||||
method='BFGS',
|
||||
maxiter=100,
|
||||
full_output=True,
|
||||
disp=False,
|
||||
fargs=(),
|
||||
callback=None,
|
||||
retall=False,
|
||||
skip_hessian=False,
|
||||
**kwargs):
|
||||
|
||||
if start_params is None:
|
||||
q = self.exog.shape[1]
|
||||
c = self.k_cat - 1
|
||||
start_params = np.random.normal(size=q * c)
|
||||
|
||||
# Do not call super(...).fit because it cannot handle the 2d-params.
|
||||
rslt = base.LikelihoodModel.fit(
|
||||
self,
|
||||
start_params=start_params,
|
||||
method=method,
|
||||
maxiter=maxiter,
|
||||
full_output=full_output,
|
||||
disp=disp,
|
||||
skip_hessian=skip_hessian)
|
||||
|
||||
rslt.params = rslt.params.reshape((self.exog.shape[1], -1))
|
||||
rslt = MultinomialResults(self, rslt)
|
||||
|
||||
# Not clear what the null likelihood should be, there is no intercept
|
||||
# so the null model is not clearly defined. This is needed for summary
|
||||
# to work.
|
||||
rslt.set_null_options(llnull=np.nan)
|
||||
|
||||
return MultinomialResultsWrapper(rslt)
|
||||
|
||||
def loglike(self, params):
|
||||
|
||||
q = self.exog.shape[1]
|
||||
c = self.k_cat - 1
|
||||
|
||||
pmat = params.reshape((q, c))
|
||||
pmat = np.concatenate((np.zeros((q, 1)), pmat), axis=1)
|
||||
lpr = np.dot(self.exog, pmat)
|
||||
|
||||
ll = 0.0
|
||||
for ii in self._grp_ix:
|
||||
x = lpr[ii, :]
|
||||
jj = np.arange(x.shape[0], dtype=int)
|
||||
y = self.endog[ii]
|
||||
denom = 0.0
|
||||
for p in itertools.permutations(y):
|
||||
denom += np.exp(x[(jj, p)].sum())
|
||||
ll += x[(jj, y)].sum() - np.log(denom)
|
||||
|
||||
return ll
|
||||
|
||||
|
||||
def score(self, params):
|
||||
|
||||
q = self.exog.shape[1]
|
||||
c = self.k_cat - 1
|
||||
|
||||
pmat = params.reshape((q, c))
|
||||
pmat = np.concatenate((np.zeros((q, 1)), pmat), axis=1)
|
||||
lpr = np.dot(self.exog, pmat)
|
||||
|
||||
grad = np.zeros((q, c))
|
||||
for ii in self._grp_ix:
|
||||
x = lpr[ii, :]
|
||||
jj = np.arange(x.shape[0], dtype=int)
|
||||
y = self.endog[ii]
|
||||
denom = 0.0
|
||||
denomg = np.zeros((q, c))
|
||||
for p in itertools.permutations(y):
|
||||
v = np.exp(x[(jj, p)].sum())
|
||||
denom += v
|
||||
for i, r in enumerate(p):
|
||||
if r != 0:
|
||||
denomg[:, r - 1] += v * self.exog[ii[i], :]
|
||||
|
||||
for i, r in enumerate(y):
|
||||
if r != 0:
|
||||
grad[:, r - 1] += self.exog[ii[i], :]
|
||||
|
||||
grad -= denomg / denom
|
||||
|
||||
return grad.flatten()
|
||||
|
||||
|
||||
|
||||
class ConditionalResultsWrapper(lm.RegressionResultsWrapper):
|
||||
pass
|
||||
|
||||
|
||||
wrap.populate_wrapper(ConditionalResultsWrapper, ConditionalResults)
|
||||
Reference in New Issue
Block a user