Source code for statsmodels.stats.contrast

from statsmodels.compat.python import range
import numpy as np
from scipy.stats import f as fdist
from scipy.stats import t as student_t
from scipy import stats
from import clean0, fullrank
from statsmodels.compat.numpy import np_matrix_rank
from statsmodels.stats.multitest import multipletests

#TODO: should this be public if it's just a container?
[docs]class ContrastResults(object): """ Class for results of tests of linear restrictions on coefficients in a model. This class functions mainly as a container for `t_test`, `f_test` and `wald_test` for the parameters of a model. The attributes depend on the statistical test and are either based on the normal, the t, the F or the chisquare distribution. """ def __init__(self, t=None, F=None, sd=None, effect=None, df_denom=None, df_num=None, alpha=0.05, **kwds): self.effect = effect # Let it be None for F if F is not None: self.distribution = 'F' self.fvalue = F self.statistic = self.fvalue self.df_denom = df_denom self.df_num = df_num self.dist = fdist self.dist_args = (df_num, df_denom) self.pvalue = fdist.sf(F, df_num, df_denom) elif t is not None: self.distribution = 't' self.tvalue = t self.statistic = t # generic alias = sd self.df_denom = df_denom self.dist = student_t self.dist_args = (df_denom,) self.pvalue = self.dist.sf(np.abs(t), df_denom) * 2 elif 'statistic' in kwds: # TODO: currently targeted to normal distribution, and chi2 self.distribution = kwds['distribution'] self.statistic = kwds['statistic'] self.tvalue = value = kwds['statistic'] # keep alias # TODO: for results instance we decided to use tvalues also for normal = sd self.dist = getattr(stats, self.distribution) self.dist_args = kwds.get('dist_args', ()) if self.distribution is 'chi2': self.pvalue = self.dist.sf(self.statistic, df_denom) self.df_denom = df_denom else: "normal" self.pvalue = np.full_like(value, np.nan) not_nan = ~np.isnan(value) self.pvalue[not_nan] = self.dist.sf(np.abs(value[not_nan])) * 2 # cleanup # should we return python scalar? self.pvalue = np.squeeze(self.pvalue)
[docs] def conf_int(self, alpha=0.05): """ Returns the confidence interval of the value, `effect` of the constraint. This is currently only available for t and z tests. Parameters ---------- alpha : float, optional The significance level for the confidence interval. ie., The default `alpha` = .05 returns a 95% confidence interval. Returns ------- ci : ndarray, (k_constraints, 2) The array has the lower and the upper limit of the confidence interval in the columns. """ if self.effect is not None: # confidence intervals q = self.dist.ppf(1 - alpha / 2., *self.dist_args) lower = self.effect - q * upper = self.effect + q * return np.column_stack((lower, upper)) else: raise NotImplementedError('Confidence Interval not available')
def __array__(self): if hasattr(self, "fvalue"): return self.fvalue else: return self.tvalue def __str__(self): return self.summary().__str__() def __repr__(self): return str(self.__class__) + '\n' + self.__str__()
[docs] def summary(self, xname=None, alpha=0.05, title=None): """Summarize the Results of the hypothesis test Parameters ----------- xname : list of strings, optional Default is `c_##` for ## in p the number of regressors alpha : float significance level for the confidence intervals. Default is alpha = 0.05 which implies a confidence level of 95%. title : string, optional Title for the params table. If not None, then this replaces the default title Returns ------- smry : string or Summary instance This contains a parameter results table in the case of t or z test in the same form as the parameter results table in the model results summary. For F or Wald test, the return is a string. """ if self.effect is not None: # TODO: should also add some extra information, e.g. robust cov ? # TODO: can we infer names for constraints, xname in __init__ ? if title is None: title = 'Test for Constraints' elif title == '': # don't add any title, # I think SimpleTable skips on None - check title = None # we have everything for a params table use_t = (self.distribution == 't') yname='constraints' # Not used in params_frame if xname is None: xname = ['c%d' % ii for ii in range(len(self.effect))] from statsmodels.iolib.summary import summary_params pvalues = np.atleast_1d(self.pvalue) summ = summary_params((self, self.effect,, self.statistic, pvalues, self.conf_int(alpha)), yname=yname, xname=xname, use_t=use_t, title=title, alpha=alpha) return summ elif hasattr(self, 'fvalue'): # TODO: create something nicer for these casee return '<F test: F=%s, p=%s, df_denom=%d, df_num=%d>' % \ (repr(self.fvalue), self.pvalue, self.df_denom, self.df_num) elif self.distribution == 'chi2': return '<Wald test (%s): statistic=%s, p-value=%s, df_denom=%d>' % \ (self.distribution, self.statistic, self.pvalue, self.df_denom) else: # generic return '<Wald test: statistic=%s, p-value=%s>' % \ (self.statistic, self.pvalue)
[docs] def summary_frame(self, xname=None, alpha=0.05): """Return the parameter table as a pandas DataFrame This is only available for t and normal tests """ if self.effect is not None: # we have everything for a params table use_t = (self.distribution == 't') yname='constraints' # Not used in params_frame if xname is None: xname = ['c%d' % ii for ii in range(len(self.effect))] from statsmodels.iolib.summary import summary_params_frame summ = summary_params_frame((self, self.effect,, self.statistic,self.pvalue, self.conf_int(alpha)), yname=yname, xname=xname, use_t=use_t, alpha=alpha) return summ else: # TODO: create something nicer raise NotImplementedError('only available for t and z')
class Contrast(object): """ This class is used to construct contrast matrices in regression models. They are specified by a (term, design) pair. The term, T, is a linear combination of columns of the design matrix. The matrix attribute of Contrast is a contrast matrix C so that colspan(dot(D, C)) = colspan(dot(D, dot(pinv(D), T))) where pinv(D) is the generalized inverse of D. Further, the matrix Tnew = dot(C, D) is full rank. The rank attribute is the rank of dot(D, dot(pinv(D), T)) In a regression model, the contrast tests that E(dot(Tnew, Y)) = 0 for each column of Tnew. Parameters ---------- term : array-like design : array-like Attributes ---------- contrast_matrix Examples -------- >>> import statsmodels.api as sm >>> from statsmodels.stats.contrast import Contrast >>> import numpy as np >>> np.random.seed(54321) >>> X = np.random.standard_normal((40,10)) # Get a contrast >>> new_term = np.column_stack((X[:,0], X[:,2])) >>> c = Contrast(new_term, X) >>> test = [[1] + [0]*9, [0]*2 + [1] + [0]*7] >>> np.allclose(c.contrast_matrix, test) True Get another contrast >>> P =, np.linalg.pinv(X)) >>> resid = np.identity(40) - P >>> noise =,np.random.standard_normal((40,5))) >>> new_term2 = np.column_stack((noise,X[:,2])) >>> c2 = Contrast(new_term2, X) >>> print(c2.contrast_matrix) [ -1.26424750e-16 8.59467391e-17 1.56384718e-01 -2.60875560e-17 -7.77260726e-17 -8.41929574e-18 -7.36359622e-17 -1.39760860e-16 1.82976904e-16 -3.75277947e-18] Get another contrast >>> zero = np.zeros((40,)) >>> new_term3 = np.column_stack((zero,X[:,2])) >>> c3 = Contrast(new_term3, X) >>> test2 = [0]*2 + [1] + [0]*7 >>> np.allclose(c3.contrast_matrix, test2) True """ def _get_matrix(self): """ Gets the contrast_matrix property """ if not hasattr(self, "_contrast_matrix"): self.compute_matrix() return self._contrast_matrix contrast_matrix = property(_get_matrix) def __init__(self, term, design): self.term = np.asarray(term) = np.asarray(design) def compute_matrix(self): """ Construct a contrast matrix C so that colspan(dot(D, C)) = colspan(dot(D, dot(pinv(D), T))) where pinv(D) is the generalized inverse of D=design. """ T = self.term if T.ndim == 1: T = T[:,None] self.T = clean0(T) self.D = self._contrast_matrix = contrastfromcols(self.T, self.D) try: self.rank = self.matrix.shape[1] except: self.rank = 1 #TODO: fix docstring after usage is settled def contrastfromcols(L, D, pseudo=None): """ From an n x p design matrix D and a matrix L, tries to determine a p x q contrast matrix C which determines a contrast of full rank, i.e. the n x q matrix dot(transpose(C), pinv(D)) is full rank. L must satisfy either L.shape[0] == n or L.shape[1] == p. If L.shape[0] == n, then L is thought of as representing columns in the column space of D. If L.shape[1] == p, then L is thought of as what is known as a contrast matrix. In this case, this function returns an estimable contrast corresponding to the dot(D, L.T) Note that this always produces a meaningful contrast, not always with the intended properties because q is always non-zero unless L is identically 0. That is, it produces a contrast that spans the column space of L (after projection onto the column space of D). Parameters ---------- L : array-like D : array-like """ L = np.asarray(L) D = np.asarray(D) n, p = D.shape if L.shape[0] != n and L.shape[1] != p: raise ValueError("shape of L and D mismatched") if pseudo is None: pseudo = np.linalg.pinv(D) # D^+ \approx= ((dot(D.T,D))^(-1),D.T) if L.shape[0] == n: C =, L).T else: C = L C =,, C.T)).T Lp =, C.T) if len(Lp.shape) == 1: Lp.shape = (n, 1) if np_matrix_rank(Lp) != Lp.shape[1]: Lp = fullrank(Lp) C =, Lp).T return np.squeeze(C) # TODO: this is currently a minimal version, stub class WaldTestResults(object): # for F and chi2 tests of joint hypothesis, mainly for vectorized def __init__(self, statistic, distribution, dist_args, table=None, pvalues=None): self.table = table self.distribution = distribution self.statistic = statistic = sd self.dist_args = dist_args # The following is because I don't know which we want if table is not None: self.statistic = table['statistic'].values self.pvalues = table['pvalue'].values self.df_constraints = table['df_constraint'].values if self.distribution == 'F': self.df_denom = table['df_denom'].values else: if self.distribution is 'chi2': self.dist = stats.chi2 self.df_constraints = self.dist_args[0] # assumes tuple # using dist_args[0] is a bit dangerous, elif self.distribution is 'F': self.dist = stats.f self.df_constraints, self.df_denom = self.dist_args else: raise ValueError('only F and chi2 are possible distribution') if pvalues is None: self.pvalues = self.dist.sf(np.abs(statistic), *dist_args) else: self.pvalues = pvalues @property def col_names(self): """column names for summary table """ pr_test = "P>%s" % self.distribution col_names = [self.distribution, pr_test, 'df constraint'] if self.distribution == 'F': col_names.append('df denom') return col_names def summary_frame(self): # needs to be a method for consistency if hasattr(self, '_dframe'): return self._dframe # rename the column nambes, but don't copy data renaming = dict(zip(self.table.columns, self.col_names)) self.dframe = self.table.rename(columns=renaming) return self.dframe def __str__(self): return self.summary_frame().to_string() def __repr__(self): return str(self.__class__) + '\n' + self.__str__() # t_test for pairwise comparison and automatic contrast/restrictions def _get_pairs_labels(k_level, level_names): """helper function for labels for pairwise comparisons """ idx_pairs_all = np.triu_indices(k_level, 1) labels = ['%s-%s' % (level_names[name[1]], level_names[name[0]]) for name in zip(*idx_pairs_all)] return labels def _contrast_pairs(k_params, k_level, idx_start): """create pairwise contrast for reference coding currently not used, using encoding contrast matrix is more general, but requires requires factor information from patsy design_info. Parameters ---------- k_params : int number of parameters k_level : int number of levels or categories (including reference case) idx_start : int Index of the first parameter of this factor. The restrictions on the factor are inserted as a block in the full restriction matrix starting at column with index `idx_start`. Returns ------- contrasts : ndarray restriction matrix with k_params columns and number of rows equal to the number of restrictions. """ k_level_m1 = k_level - 1 idx_pairs = np.triu_indices(k_level_m1, 1) k = len(idx_pairs[0]) c_pairs = np.zeros((k, k_level_m1)) c_pairs[np.arange(k), idx_pairs[0]] = -1 c_pairs[np.arange(k), idx_pairs[1]] = 1 c_reference = np.eye(k_level_m1) c = np.concatenate((c_reference, c_pairs), axis=0) k_all = c.shape[0] contrasts = np.zeros((k_all, k_params)) contrasts[:, idx_start : idx_start + k_level_m1] = c return contrasts def t_test_multi(result, contrasts, method='hs', alpha=0.05, ci_method=None, contrast_names=None): """perform t_test and add multiplicity correction to results dataframe Parameters ---------- result results instance results of an estimated model contrasts : ndarray restriction matrix for t_test method : string or list of strings method for multiple testing p-value correction, default is'hs'. alpha : float significance level for multiple testing reject decision. ci_method : None not used yet, will be for multiplicity corrected confidence intervals contrast_names : list of strings or None If contrast_names are provided, then they are used in the index of the returned dataframe, otherwise some generic default names are created. Returns ------- res_df : pandas DataFrame The dataframe contains the results of the t_test and additional columns for multiplicity corrected p-values and boolean indicator for whether the Null hypothesis is rejected. """ tt = result.t_test(contrasts) res_df = tt.summary_frame(xname=contrast_names) if type(method) is not list: method = [method] for meth in method: mt = multipletests(tt.pvalue, method=meth, alpha=alpha) res_df['pvalue-%s' % meth] = mt[1] res_df['reject-%s' % meth] = mt[0] return res_df class MultiCompResult(object): """class to hold return of t_test_pairwise currently just a minimal class to hold attributes. """ def __init__(self, **kwargs): self.__dict__.update(kwargs) def _embed_constraints(contrasts, k_params, idx_start, index=None): """helper function to expand constraints to a full restriction matrix Parameters ---------- contrasts : ndarray restriction matrix for t_test k_params : int number of parameters idx_start : int Index of the first parameter of this factor. The restrictions on the factor are inserted as a block in the full restriction matrix starting at column with index `idx_start`. index : slice or ndarray Column index if constraints do not form a block in the full restriction matrix, i.e. if parameters that are subject to restrictions are not consecutive in the list of parameters. If index is not None, then idx_start is ignored. Returns ------- contrasts : ndarray restriction matrix with k_params columns and number of rows equal to the number of restrictions. """ k_c, k_p = contrasts.shape c = np.zeros((k_c, k_params)) if index is None: c[:, idx_start : idx_start + k_p] = contrasts else: c[:, index] = contrasts return c def _constraints_factor(encoding_matrix, comparison='pairwise', k_params=None, idx_start=None): """helper function to create constraints based on encoding matrix Parameters ---------- encoding_matrix : ndarray contrast matrix for the encoding of a factor as defined by patsy. The number of rows should be equal to the number of levels or categories of the factor, the number of columns should be equal to the number of parameters for this factor. comparison : str Currently only 'pairwise' is implemented. The restriction matrix can be used for testing the hypothesis that all pairwise differences are zero. k_params : int number of parameters idx_start : int Index of the first parameter of this factor. The restrictions on the factor are inserted as a block in the full restriction matrix starting at column with index `idx_start`. Returns ------- contrast : ndarray Contrast or restriction matrix that can be used in hypothesis test of model results. The number of columns is k_params. """ cm = encoding_matrix k_level, k_p = cm.shape import statsmodels.sandbox.stats.multicomp as mc if comparison in ['pairwise', 'pw', 'pairs']: c_all = -mc.contrast_allpairs(k_level) else: raise NotImplementedError('currentlyonly pairwise comparison') contrasts = if k_params is not None: if idx_start is None: raise ValueError("if k_params is not None, then idx_start is " "required") contrasts = _embed_constraints(contrasts, k_params, idx_start) return contrasts def t_test_pairwise(result, term_name, method='hs', alpha=0.05, factor_labels=None, ignore=False): """perform pairwise t_test with multiple testing corrected p-values This uses the formula design_info encoding contrast matrix and should work for all encodings of a main effect. Parameters ---------- result : result instance The results of an estimated model with a categorical main effect. term_name : str name of the term for which pairwise comparisons are computed. Term names for categorical effects are created by patsy and correspond to the main part of the exog names. method : str or list of strings multiple testing p-value correction, default is 'hs', see stats.multipletesting alpha : float significance level for multiple testing reject decision. factor_labels : None, list of str Labels for the factor levels used for pairwise labels. If not provided, then the labels from the formula design_info are used. ignore : boolean Turn off some of the exceptions raised by input checks. Returns ------- results : instance of a simple Results class The results are stored as attributes, the main attributes are the following two. Other attributes are added for debugging purposes or as background information. - result_frame : pandas DataFrame with t_test results and multiple testing corrected p-values. - contrasts : matrix of constraints of the null hypothesis in the t_test. Notes ----- Status: experimental. Currently only checked for treatment coding with and without specified reference level. Currently there are no multiple testing corrected confidence intervals available. """ desinfo = term_idx = desinfo.term_names.index(term_name) term = desinfo.terms[term_idx] idx_start = desinfo.term_slices[term].start if not ignore and len(term.factors) > 1: raise ValueError('interaction effects not yet supported') factor = term.factors[0] cat = desinfo.factor_infos[factor].categories if factor_labels is not None: if len(factor_labels) == len(cat): cat = factor_labels else: raise ValueError("factor_labels has the wrong length, should be %d" % len(cat)) k_level = len(cat) cm = desinfo.term_codings[term][0].contrast_matrices[factor].matrix k_params = len(result.params) labels = _get_pairs_labels(k_level, cat) import statsmodels.sandbox.stats.multicomp as mc c_all_pairs = -mc.contrast_allpairs(k_level) contrasts_sub = contrasts = _embed_constraints(contrasts_sub, k_params, idx_start) res_df = t_test_multi(result, contrasts, method=method, ci_method=None, alpha=alpha, contrast_names=labels) res = MultiCompResult(result_frame=res_df, contrasts=contrasts, term=term, contrast_labels=labels, term_encoding_matrix=cm) return res