Source code for statsmodels.stats.weightstats

'''Ttests and descriptive statistics with weights


Created on 2010-09-18

Author: josef-pktd
License: BSD (3-clause)


References
----------
SPSS manual
SAS manual

This follows in large parts the SPSS manual, which is largely the same as
the SAS manual with different, simpler notation.

Freq, Weight in SAS seems redundant since they always show up as product, SPSS
has only weights.

Notes
-----

This has potential problems with ddof, I started to follow numpy with ddof=0
by default and users can change it, but this might still mess up the t-tests,
since the estimates for the standard deviation will be based on the ddof that
the user chooses.
- fixed ddof for the meandiff ttest, now matches scipy.stats.ttest_ind

Note: scipy has now a separate, pooled variance option in ttest, but I haven't
compared yet.

'''


import numpy as np
from scipy import stats

from statsmodels.tools.decorators import OneTimeProperty


[docs]class DescrStatsW(object): '''descriptive statistics and tests with weights for case weights Assumes that the data is 1d or 2d with (nobs, nvars) observations in rows, variables in columns, and that the same weight applies to each column. If degrees of freedom correction is used, then weights should add up to the number of observations. ttest also assumes that the sum of weights corresponds to the sample size. This is essentially the same as replicating each observations by its weight, if the weights are integers, often called case or frequency weights. Parameters ---------- data : array_like, 1-D or 2-D dataset weights : None or 1-D ndarray weights for each observation, with same length as zero axis of data ddof : int default ddof=0, degrees of freedom correction used for second moments, var, std, cov, corrcoef. However, statistical tests are independent of `ddof`, based on the standard formulas. Examples -------- >>> import numpy as np >>> np.random.seed(0) >>> x1_2d = 1.0 + np.random.randn(20, 3) >>> w1 = np.random.randint(1, 4, 20) >>> d1 = DescrStatsW(x1_2d, weights=w1) >>> d1.mean array([ 1.42739844, 1.23174284, 1.083753 ]) >>> d1.var array([ 0.94855633, 0.52074626, 1.12309325]) >>> d1.std_mean array([ 0.14682676, 0.10878944, 0.15976497]) >>> tstat, pval, df = d1.ttest_mean(0) >>> tstat; pval; df array([ 9.72165021, 11.32226471, 6.78342055]) array([ 1.58414212e-12, 1.26536887e-14, 2.37623126e-08]) 44.0 >>> tstat, pval, df = d1.ttest_mean([0, 1, 1]) >>> tstat; pval; df array([ 9.72165021, 2.13019609, 0.52422632]) array([ 1.58414212e-12, 3.87842808e-02, 6.02752170e-01]) 44.0 #if weiqhts are integers, then asrepeats can be used >>> x1r = d1.asrepeats() >>> x1r.shape ... >>> stats.ttest_1samp(x1r, [0, 1, 1]) ... ''' def __init__(self, data, weights=None, ddof=0): self.data = np.asarray(data) if weights is None: self.weights = np.ones(self.data.shape[0]) else: #why squeeze? self.weights = np.asarray(weights).squeeze().astype(float) self.ddof = ddof
[docs] @OneTimeProperty def sum_weights(self): return self.weights.sum(0)
[docs] @OneTimeProperty def nobs(self): '''alias for number of observations/cases, equal to sum of weights ''' return self.sum_weights
[docs] @OneTimeProperty def sum(self): '''weighted sum of data''' return np.dot(self.data.T, self.weights)
[docs] @OneTimeProperty def mean(self): '''weighted mean of data''' return self.sum / self.sum_weights
[docs] @OneTimeProperty def demeaned(self): '''data with weighted mean subtracted''' return self.data - self.mean
[docs] @OneTimeProperty def sumsquares(self): '''weighted sum of squares of demeaned data''' return np.dot((self.demeaned**2).T, self.weights)
#need memoize instead of cache decorator
[docs] def var_ddof(self, ddof=0): '''variance of data given ddof Parameters ---------- ddof : int, float degrees of freedom correction, independent of attribute ddof Returns ------- var : float, ndarray variance with denominator ``sum_weights - ddof`` ''' return self.sumsquares / (self.sum_weights - ddof)
[docs] def std_ddof(self, ddof=0): '''standard deviation of data with given ddof Parameters ---------- ddof : int, float degrees of freedom correction, independent of attribute ddof Returns ------- std : float, ndarray standard deviation with denominator ``sum_weights - ddof`` ''' return np.sqrt(self.var_ddof(ddof=ddof))
[docs] @OneTimeProperty def var(self): '''variance with default degrees of freedom correction ''' return self.sumsquares / (self.sum_weights - self.ddof)
@OneTimeProperty def _var(self): '''variance without degrees of freedom correction used for statistical tests with controlled ddof ''' return self.sumsquares / self.sum_weights
[docs] @OneTimeProperty def std(self): '''standard deviation with default degrees of freedom correction ''' return np.sqrt(self.var)
[docs] @OneTimeProperty def cov(self): '''weighted covariance of data if data is 2 dimensional assumes variables in columns and observations in rows uses default ddof ''' cov_ = np.dot(self.weights * self.demeaned.T, self.demeaned) cov_ /= (self.sum_weights - self.ddof) return cov_
[docs] @OneTimeProperty def corrcoef(self): '''weighted correlation with default ddof assumes variables in columns and observations in rows ''' return self.cov / self.std / self.std[:,None]
[docs] @OneTimeProperty def std_mean(self): '''standard deviation of weighted mean ''' std = self.std if self.ddof != 0: #ddof correction, (need copy of std) std = std * np.sqrt((self.sum_weights - self.ddof) / self.sum_weights) return std / np.sqrt(self.sum_weights - 1)
[docs] def quantile(self, probs, return_pandas=True): """ Compute quantiles for a weighted sample. Parameters ---------- probs : array-like A vector of probability points at which to calculate the quantiles. Each element of `probs` should fall in [0, 1]. return_pandas : bool If True, return value is a Pandas DataFrame or Series. Otherwise returns a ndarray. Returns ------- quantiles : Series, DataFrame, or ndarray If `return_pandas` = True, returns one of the following: * data are 1d, `return_pandas` = True: a Series indexed by the probability points. * data are 2d, `return_pandas` = True: a DataFrame with the probability points as row index and the variables as column index. If `return_pandas` = False, returns an ndarray containing the same values as the Series/DataFrame. Notes ----- To compute the quantiles, first, the weights are summed over exact ties yielding distinct data values y_1 < y_2 < ..., and corresponding weights w_1, w_2, .... Let s_j denote the sum of the first j weights, and let W denote the sum of all the weights. For a probability point p, if pW falls strictly between s_j and s_{j+1} then the estimated quantile is y_{j+1}. If pW = s_j then the estimated quantile is (y_j + y_{j+1})/2. If pW < p_1 then the estimated quantile is y_1. References ---------- SAS documentation for weighted quantiles: https://support.sas.com/documentation/cdl/en/procstat/63104/HTML/default/viewer.htm#procstat_univariate_sect028.htm """ import pandas as pd probs = np.asarray(probs) probs = np.atleast_1d(probs) if self.data.ndim == 1: rslt = self._quantile(self.data, probs) if return_pandas: rslt = pd.Series(rslt, index=probs) else: rslt = [] for vec in self.data.T: rslt.append(self._quantile(vec, probs)) rslt = np.column_stack(rslt) if return_pandas: columns = ["col%d" % (j+1) for j in range(rslt.shape[1])] rslt = pd.DataFrame(data=rslt, columns=columns, index=probs) if return_pandas: rslt.index.name = "p" return rslt
def _quantile(self, vec, probs): # Helper function to calculate weighted quantiles for one column. # Follows definition from SAS documentation. # Returns ndarray import pandas as pd # Aggregate over ties df = pd.DataFrame(index=np.arange(len(self.weights))) df["weights"] = self.weights df["vec"] = vec dfg = df.groupby("vec").agg(np.sum) weights = dfg.values[:, 0] values = np.asarray(dfg.index) cweights = np.cumsum(weights) totwt = cweights[-1] targets = probs * totwt ii = np.searchsorted(cweights, targets) rslt = values[ii] # Exact hits jj = np.flatnonzero(np.abs(targets - cweights[ii]) < 1e-10) jj = jj[ii[jj] < len(cweights) - 1] rslt[jj] = (values[ii[jj]] + values[ii[jj]+1]) / 2 return rslt
[docs] def tconfint_mean(self, alpha=0.05, alternative='two-sided'): '''two-sided confidence interval for weighted mean of data If the data is 2d, then these are separate confidence intervals for each column. Parameters ---------- alpha : float significance level for the confidence interval, coverage is ``1-alpha`` alternative : string This specifies the alternative hypothesis for the test that corresponds to the confidence interval. The alternative hypothesis, H1, has to be one of the following 'two-sided': H1: mean not equal to value (default) 'larger' : H1: mean larger than value 'smaller' : H1: mean smaller than value Returns ------- lower, upper : floats or ndarrays lower and upper bound of confidence interval Notes ----- In a previous version, statsmodels 0.4, alpha was the confidence level, e.g. 0.95 ''' #TODO: add asymmetric dof = self.sum_weights - 1 ci = _tconfint_generic(self.mean, self.std_mean, dof, alpha, alternative) return ci
[docs] def zconfint_mean(self, alpha=0.05, alternative='two-sided'): '''two-sided confidence interval for weighted mean of data Confidence interval is based on normal distribution. If the data is 2d, then these are separate confidence intervals for each column. Parameters ---------- alpha : float significance level for the confidence interval, coverage is ``1-alpha`` alternative : string This specifies the alternative hypothesis for the test that corresponds to the confidence interval. The alternative hypothesis, H1, has to be one of the following 'two-sided': H1: mean not equal to value (default) 'larger' : H1: mean larger than value 'smaller' : H1: mean smaller than value Returns ------- lower, upper : floats or ndarrays lower and upper bound of confidence interval Notes ----- In a previous version, statsmodels 0.4, alpha was the confidence level, e.g. 0.95 ''' return _zconfint_generic(self.mean, self.std_mean, alpha, alternative)
[docs] def ttest_mean(self, value=0, alternative='two-sided'): '''ttest of Null hypothesis that mean is equal to value. The alternative hypothesis H1 is defined by the following 'two-sided': H1: mean not equal to value 'larger' : H1: mean larger than value 'smaller' : H1: mean smaller than value Parameters ---------- value : float or array the hypothesized value for the mean alternative : string The alternative hypothesis, H1, has to be one of the following 'two-sided': H1: mean not equal to value (default) 'larger' : H1: mean larger than value 'smaller' : H1: mean smaller than value Returns ------- tstat : float test statisic pvalue : float pvalue of the t-test df : int or float ''' #TODO: check direction with R, smaller=less, larger=greater tstat = (self.mean - value) / self.std_mean dof = self.sum_weights - 1 #TODO: use outsourced if alternative == 'two-sided': pvalue = stats.t.sf(np.abs(tstat), dof)*2 elif alternative == 'larger': pvalue = stats.t.sf(tstat, dof) elif alternative == 'smaller': pvalue = stats.t.cdf(tstat, dof) return tstat, pvalue, dof
[docs] def ttost_mean(self, low, upp): '''test of (non-)equivalence of one sample TOST: two one-sided t tests null hypothesis: m < low or m > upp alternative hypothesis: low < m < upp where m is the expected value of the sample (mean of the population). If the pvalue is smaller than a threshold, say 0.05, then we reject the hypothesis that the expected value of the sample (mean of the population) is outside of the interval given by thresholds low and upp. Parameters ---------- low, upp : float equivalence interval low < mean < upp Returns ------- pvalue : float pvalue of the non-equivalence test t1, pv1, df1 : tuple test statistic, pvalue and degrees of freedom for lower threshold test t2, pv2, df2 : tuple test statistic, pvalue and degrees of freedom for upper threshold test ''' t1, pv1, df1 = self.ttest_mean(low, alternative='larger') t2, pv2, df2 = self.ttest_mean(upp, alternative='smaller') return np.maximum(pv1, pv2), (t1, pv1, df1), (t2, pv2, df2)
[docs] def ztest_mean(self, value=0, alternative='two-sided'): '''z-test of Null hypothesis that mean is equal to value. The alternative hypothesis H1 is defined by the following 'two-sided': H1: mean not equal to value 'larger' : H1: mean larger than value 'smaller' : H1: mean smaller than value Parameters ---------- value : float or array the hypothesized value for the mean alternative : string The alternative hypothesis, H1, has to be one of the following 'two-sided': H1: mean not equal to value (default) 'larger' : H1: mean larger than value 'smaller' : H1: mean smaller than value Returns ------- tstat : float test statisic pvalue : float pvalue of the t-test Notes ----- This uses the same degrees of freedom correction as the t-test in the calculation of the standard error of the mean, i.e it uses `(sum_weights - 1)` instead of `sum_weights` in the denominator. See Examples below for the difference. Examples -------- z-test on a proportion, with 20 observations, 15 of those are our event >>> import statsmodels.api as sm >>> x1 = [0, 1] >>> w1 = [5, 15] >>> d1 = sm.stats.DescrStatsW(x1, w1) >>> d1.ztest_mean(0.5) (2.5166114784235836, 0.011848940928347452) This differs from the proportions_ztest because of the degrees of freedom correction: >>> sm.stats.proportions_ztest(15, 20.0, value=0.5) (2.5819888974716112, 0.009823274507519247). We can replicate the results from ``proportions_ztest`` if we increase the weights to have artificially one more observation: >>> sm.stats.DescrStatsW(x1, np.array(w1)*21./20).ztest_mean(0.5) (2.5819888974716116, 0.0098232745075192366) ''' tstat = (self.mean - value) / self.std_mean #TODO: use outsourced if alternative == 'two-sided': pvalue = stats.norm.sf(np.abs(tstat))*2 elif alternative == 'larger': pvalue = stats.norm.sf(tstat) elif alternative == 'smaller': pvalue = stats.norm.cdf(tstat) return tstat, pvalue
[docs] def ztost_mean(self, low, upp): '''test of (non-)equivalence of one sample, based on z-test TOST: two one-sided z-tests null hypothesis: m < low or m > upp alternative hypothesis: low < m < upp where m is the expected value of the sample (mean of the population). If the pvalue is smaller than a threshold, say 0.05, then we reject the hypothesis that the expected value of the sample (mean of the population) is outside of the interval given by thresholds low and upp. Parameters ---------- low, upp : float equivalence interval low < mean < upp Returns ------- pvalue : float pvalue of the non-equivalence test t1, pv1 : tuple test statistic and p-value for lower threshold test t2, pv2 : tuple test statistic and p-value for upper threshold test ''' t1, pv1 = self.ztest_mean(low, alternative='larger') t2, pv2 = self.ztest_mean(upp, alternative='smaller') return np.maximum(pv1, pv2), (t1, pv1), (t2, pv2)
[docs] def get_compare(self, other, weights=None): '''return an instance of CompareMeans with self and other Parameters ---------- other : array_like or instance of DescrStatsW If array_like then this creates an instance of DescrStatsW with the given weights. weights : None or array weights are only used if other is not an instance of DescrStatsW Returns ------- cm : instance of CompareMeans the instance has self attached as d1 and other as d2. See Also -------- CompareMeans ''' if not isinstance(other, self.__class__): d2 = DescrStatsW(other, weights) else: d2 = other return CompareMeans(self, d2)
[docs] def asrepeats(self): '''get array that has repeats given by floor(weights) observations with weight=0 are dropped ''' w_int = np.floor(self.weights).astype(int) return np.repeat(self.data, w_int, axis=0)
[docs]def _tstat_generic(value1, value2, std_diff, dof, alternative, diff=0): '''generic ttest to save typing''' tstat = (value1 - value2 - diff) / std_diff if alternative in ['two-sided', '2-sided', '2s']: pvalue = stats.t.sf(np.abs(tstat), dof)*2 elif alternative in ['larger', 'l']: pvalue = stats.t.sf(tstat, dof) elif alternative in ['smaller', 's']: pvalue = stats.t.cdf(tstat, dof) else: raise ValueError('invalid alternative') return tstat, pvalue
[docs]def _tconfint_generic(mean, std_mean, dof, alpha, alternative): '''generic t-confint to save typing''' if alternative in ['two-sided', '2-sided', '2s']: tcrit = stats.t.ppf(1 - alpha / 2., dof) lower = mean - tcrit * std_mean upper = mean + tcrit * std_mean elif alternative in ['larger', 'l']: tcrit = stats.t.ppf(alpha, dof) lower = mean + tcrit * std_mean upper = np.inf elif alternative in ['smaller', 's']: tcrit = stats.t.ppf(1 - alpha, dof) lower = -np.inf upper = mean + tcrit * std_mean else: raise ValueError('invalid alternative') return lower, upper
[docs]def _zstat_generic(value1, value2, std_diff, alternative, diff=0): '''generic (normal) z-test to save typing can be used as ztest based on summary statistics ''' zstat = (value1 - value2 - diff) / std_diff if alternative in ['two-sided', '2-sided', '2s']: pvalue = stats.norm.sf(np.abs(zstat))*2 elif alternative in ['larger', 'l']: pvalue = stats.norm.sf(zstat) elif alternative in ['smaller', 's']: pvalue = stats.norm.cdf(zstat) else: raise ValueError('invalid alternative') return zstat, pvalue
[docs]def _zstat_generic2(value, std_diff, alternative): '''generic (normal) z-test to save typing can be used as ztest based on summary statistics ''' zstat = value / std_diff if alternative in ['two-sided', '2-sided', '2s']: pvalue = stats.norm.sf(np.abs(zstat))*2 elif alternative in ['larger', 'l']: pvalue = stats.norm.sf(zstat) elif alternative in ['smaller', 's']: pvalue = stats.norm.cdf(zstat) else: raise ValueError('invalid alternative') return zstat, pvalue
[docs]def _zconfint_generic(mean, std_mean, alpha, alternative): '''generic normal-confint to save typing''' if alternative in ['two-sided', '2-sided', '2s']: zcrit = stats.norm.ppf(1 - alpha / 2.) lower = mean - zcrit * std_mean upper = mean + zcrit * std_mean elif alternative in ['larger', 'l']: zcrit = stats.norm.ppf(alpha) lower = mean + zcrit * std_mean upper = np.inf elif alternative in ['smaller', 's']: zcrit = stats.norm.ppf(1 - alpha) lower = -np.inf upper = mean + zcrit * std_mean else: raise ValueError('invalid alternative') return lower, upper
[docs]class CompareMeans(object): '''class for two sample comparison The tests and the confidence interval work for multi-endpoint comparison: If d1 and d2 have the same number of rows, then each column of the data in d1 is compared with the corresponding column in d2. Parameters ---------- d1, d2 : instances of DescrStatsW Notes ----- The result for the statistical tests and the confidence interval are independent of the user specified ddof. TODO: Extend to any number of groups or write a version that works in that case, like in SAS and SPSS. ''' def __init__(self, d1, d2): '''assume d1, d2 hold the relevant attributes ''' self.d1 = d1 self.d2 = d2 #assume nobs is available # if not hasattr(self.d1, 'nobs'): # d1.nobs1 = d1.sum_weights.astype(float) #float just to make sure # self.nobs2 = d2.sum_weights.astype(float)
[docs] @classmethod def from_data(cls, data1, data2, weights1=None, weights2=None, ddof1=0, ddof2=0): '''construct a CompareMeans object from data Parameters ---------- data1, data2 : array-like, 1-D or 2-D compared datasets weights1, weights2 : None or 1-D ndarray weights for each observation of data1 and data2 respectively, with same length as zero axis of corresponding dataset. ddof1, ddof2 : int default ddof1=0, ddof2=0, degrees of freedom for data1, data2 respectively. Returns ------- A CompareMeans instance. ''' return cls(DescrStatsW(data1, weights=weights1, ddof=ddof1), DescrStatsW(data2, weights=weights2, ddof=ddof2))
[docs] def summary(self, use_t=True, alpha=0.05, usevar='pooled', value=0): '''summarize the results of the hypothesis test Parameters ---------- use_t : bool, optional if use_t is True, then t test results are returned if use_t is False, then z test results are returned alpha : float significance level for the confidence interval, coverage is ``1-alpha`` usevar : string, 'pooled' or 'unequal' If ``pooled``, then the standard deviation of the samples is assumed to be the same. If ``unequal``, then the variance of Welsh ttest will be used, and the degrees of freedom are those of Satterthwaite if ``use_t`` is True. value : float difference between the means under the Null hypothesis. Returns ------- smry : SimpleTable ''' d1 = self.d1 d2 = self.d2 confint_percents = 100 - alpha * 100 if use_t: tstat, pvalue, _ = self.ttest_ind(usevar=usevar, value=value) lower, upper = self.tconfint_diff(alpha=alpha, usevar=usevar) else: tstat, pvalue = self.ztest_ind(usevar=usevar, value=value) lower, upper = self.zconfint_diff(alpha=alpha, usevar=usevar) if usevar == 'pooled': std_err = self.std_meandiff_pooledvar else: std_err = self.std_meandiff_separatevar std_err = np.atleast_1d(std_err) tstat = np.atleast_1d(tstat) pvalue = np.atleast_1d(pvalue) lower = np.atleast_1d(lower) upper = np.atleast_1d(upper) conf_int = np.column_stack((lower, upper)) params = np.atleast_1d(d1.mean - d2.mean - value) title = 'Test for equality of means' yname = 'y' # not used in params_frame xname = ['subset #%d' % (ii + 1) for ii in range(tstat.shape[0])] from statsmodels.iolib.summary import summary_params return summary_params((None, params, std_err, tstat, pvalue, conf_int), alpha=alpha, use_t=use_t, yname=yname, xname=xname, title=title)
[docs] @OneTimeProperty def std_meandiff_separatevar(self): #this uses ``_var`` to use ddof=0 for formula d1 = self.d1 d2 = self.d2 return np.sqrt(d1._var / (d1.nobs-1) + d2._var / (d2.nobs-1))
[docs] @OneTimeProperty def std_meandiff_pooledvar(self): '''variance assuming equal variance in both data sets ''' #this uses ``_var`` to use ddof=0 for formula d1 = self.d1 d2 = self.d2 #could make var_pooled into attribute var_pooled = ((d1.sumsquares + d2.sumsquares) / #(d1.nobs - d1.ddof + d2.nobs - d2.ddof)) (d1.nobs - 1 + d2.nobs - 1)) return np.sqrt(var_pooled * (1. / d1.nobs + 1. /d2.nobs))
[docs] def dof_satt(self): '''degrees of freedom of Satterthwaite for unequal variance ''' d1 = self.d1 d2 = self.d2 #this follows blindly the SPSS manual #except I use ``_var`` which has ddof=0 sem1 = d1._var / (d1.nobs-1) sem2 = d2._var / (d2.nobs-1) semsum = sem1 + sem2 z1 = (sem1 / semsum)**2 / (d1.nobs - 1) z2 = (sem2 / semsum)**2 / (d2.nobs - 1) dof = 1. / (z1 + z2) return dof
[docs] def ttest_ind(self, alternative='two-sided', usevar='pooled', value=0): '''ttest for the null hypothesis of identical means this should also be the same as onewaygls, except for ddof differences Parameters ---------- x1, x2 : array_like, 1-D or 2-D two independent samples, see notes for 2-D case alternative : string The alternative hypothesis, H1, has to be one of the following 'two-sided': H1: difference in means not equal to value (default) 'larger' : H1: difference in means larger than value 'smaller' : H1: difference in means smaller than value usevar : string, 'pooled' or 'unequal' If ``pooled``, then the standard deviation of the samples is assumed to be the same. If ``unequal``, then Welsh ttest with Satterthwait degrees of freedom is used value : float difference between the means under the Null hypothesis. Returns ------- tstat : float test statisic pvalue : float pvalue of the t-test df : int or float degrees of freedom used in the t-test Notes ----- The result is independent of the user specified ddof. ''' d1 = self.d1 d2 = self.d2 if usevar == 'pooled': stdm = self.std_meandiff_pooledvar dof = (d1.nobs - 1 + d2.nobs - 1) elif usevar == 'unequal': stdm = self.std_meandiff_separatevar dof = self.dof_satt() else: raise ValueError('usevar can only be "pooled" or "unequal"') tstat, pval = _tstat_generic(d1.mean, d2.mean, stdm, dof, alternative, diff=value) return tstat, pval, dof
[docs] def ztest_ind(self, alternative='two-sided', usevar='pooled', value=0): '''z-test for the null hypothesis of identical means Parameters ---------- x1, x2 : array_like, 1-D or 2-D two independent samples, see notes for 2-D case alternative : string The alternative hypothesis, H1, has to be one of the following 'two-sided': H1: difference in means not equal to value (default) 'larger' : H1: difference in means larger than value 'smaller' : H1: difference in means smaller than value usevar : string, 'pooled' or 'unequal' If ``pooled``, then the standard deviation of the samples is assumed to be the same. If ``unequal``, then the standard deviations of the samples may be different. value : float difference between the means under the Null hypothesis. Returns ------- tstat : float test statisic pvalue : float pvalue of the z-test ''' d1 = self.d1 d2 = self.d2 if usevar == 'pooled': stdm = self.std_meandiff_pooledvar elif usevar == 'unequal': stdm = self.std_meandiff_separatevar else: raise ValueError('usevar can only be "pooled" or "unequal"') tstat, pval = _zstat_generic(d1.mean, d2.mean, stdm, alternative, diff=value) return tstat, pval
[docs] def tconfint_diff(self, alpha=0.05, alternative='two-sided', usevar='pooled'): '''confidence interval for the difference in means Parameters ---------- alpha : float significance level for the confidence interval, coverage is ``1-alpha`` alternative : string This specifies the alternative hypothesis for the test that corresponds to the confidence interval. The alternative hypothesis, H1, has to be one of the following : 'two-sided': H1: difference in means not equal to value (default) 'larger' : H1: difference in means larger than value 'smaller' : H1: difference in means smaller than value usevar : string, 'pooled' or 'unequal' If ``pooled``, then the standard deviation of the samples is assumed to be the same. If ``unequal``, then Welsh ttest with Satterthwait degrees of freedom is used Returns ------- lower, upper : floats lower and upper limits of the confidence interval Notes ----- The result is independent of the user specified ddof. ''' d1 = self.d1 d2 = self.d2 diff = d1.mean - d2.mean if usevar == 'pooled': std_diff = self.std_meandiff_pooledvar dof = (d1.nobs - 1 + d2.nobs - 1) elif usevar == 'unequal': std_diff = self.std_meandiff_separatevar dof = self.dof_satt() else: raise ValueError('usevar can only be "pooled" or "unequal"') res = _tconfint_generic(diff, std_diff, dof, alpha=alpha, alternative=alternative) return res
[docs] def zconfint_diff(self, alpha=0.05, alternative='two-sided', usevar='pooled'): '''confidence interval for the difference in means Parameters ---------- alpha : float significance level for the confidence interval, coverage is ``1-alpha`` alternative : string This specifies the alternative hypothesis for the test that corresponds to the confidence interval. The alternative hypothesis, H1, has to be one of the following : 'two-sided': H1: difference in means not equal to value (default) 'larger' : H1: difference in means larger than value 'smaller' : H1: difference in means smaller than value usevar : string, 'pooled' or 'unequal' If ``pooled``, then the standard deviation of the samples is assumed to be the same. If ``unequal``, then Welsh ttest with Satterthwait degrees of freedom is used Returns ------- lower, upper : floats lower and upper limits of the confidence interval Notes ----- The result is independent of the user specified ddof. ''' d1 = self.d1 d2 = self.d2 diff = d1.mean - d2.mean if usevar == 'pooled': std_diff = self.std_meandiff_pooledvar elif usevar == 'unequal': std_diff = self.std_meandiff_separatevar else: raise ValueError('usevar can only be "pooled" or "unequal"') res = _zconfint_generic(diff, std_diff, alpha=alpha, alternative=alternative) return res
[docs] def ttost_ind(self, low, upp, usevar='pooled'): ''' test of equivalence for two independent samples, base on t-test Parameters ---------- low, upp : float equivalence interval low < m1 - m2 < upp usevar : string, 'pooled' or 'unequal' If ``pooled``, then the standard deviation of the samples is assumed to be the same. If ``unequal``, then Welsh ttest with Satterthwait degrees of freedom is used Returns ------- pvalue : float pvalue of the non-equivalence test t1, pv1 : tuple of floats test statistic and pvalue for lower threshold test t2, pv2 : tuple of floats test statistic and pvalue for upper threshold test ''' tt1 = self.ttest_ind(alternative='larger', usevar=usevar, value=low) tt2 = self.ttest_ind(alternative='smaller', usevar=usevar, value=upp) #TODO: remove tuple return, use same as for function tost_ind return np.maximum(tt1[1], tt2[1]), (tt1, tt2)
[docs] def ztost_ind(self, low, upp, usevar='pooled'): ''' test of equivalence for two independent samples, based on z-test Parameters ---------- low, upp : float equivalence interval low < m1 - m2 < upp usevar : string, 'pooled' or 'unequal' If ``pooled``, then the standard deviation of the samples is assumed to be the same. If ``unequal``, then Welsh ttest with Satterthwait degrees of freedom is used Returns ------- pvalue : float pvalue of the non-equivalence test t1, pv1 : tuple of floats test statistic and pvalue for lower threshold test t2, pv2 : tuple of floats test statistic and pvalue for upper threshold test ''' tt1 = self.ztest_ind(alternative='larger', usevar=usevar, value=low) tt2 = self.ztest_ind(alternative='smaller', usevar=usevar, value=upp) #TODO: remove tuple return, use same as for function tost_ind return np.maximum(tt1[1], tt2[1]), tt1, tt2
#tost.__doc__ = tost_ind.__doc__ #doesn't work for 2d, doesn't take weights into account ## def test_equal_var(self): ## '''Levene test for independence ## ## ''' ## d1 = self.d1 ## d2 = self.d2 ## #rewrite this, for now just use scipy.stats ## return stats.levene(d1.data, d2.data)
[docs]def ttest_ind(x1, x2, alternative='two-sided', usevar='pooled', weights=(None, None), value=0): '''ttest independent sample convenience function that uses the classes and throws away the intermediate results, compared to scipy stats: drops axis option, adds alternative, usevar, and weights option Parameters ---------- x1, x2 : array_like, 1-D or 2-D two independent samples, see notes for 2-D case alternative : string The alternative hypothesis, H1, has to be one of the following 'two-sided': H1: difference in means not equal to value (default) 'larger' : H1: difference in means larger than value 'smaller' : H1: difference in means smaller than value usevar : string, 'pooled' or 'unequal' If ``pooled``, then the standard deviation of the samples is assumed to be the same. If ``unequal``, then Welsh ttest with Satterthwait degrees of freedom is used weights : tuple of None or ndarrays Case weights for the two samples. For details on weights see ``DescrStatsW`` value : float difference between the means under the Null hypothesis. Returns ------- tstat : float test statisic pvalue : float pvalue of the t-test df : int or float degrees of freedom used in the t-test ''' cm = CompareMeans(DescrStatsW(x1, weights=weights[0], ddof=0), DescrStatsW(x2, weights=weights[1], ddof=0)) tstat, pval, dof = cm.ttest_ind(alternative=alternative, usevar=usevar, value=value) return tstat, pval, dof
[docs]def ttost_ind(x1, x2, low, upp, usevar='pooled', weights=(None, None), transform=None): '''test of (non-)equivalence for two independent samples TOST: two one-sided t tests null hypothesis: m1 - m2 < low or m1 - m2 > upp alternative hypothesis: low < m1 - m2 < upp where m1, m2 are the means, expected values of the two samples. If the pvalue is smaller than a threshold, say 0.05, then we reject the hypothesis that the difference between the two samples is larger than the the thresholds given by low and upp. Parameters ---------- x1, x2 : array_like, 1-D or 2-D two independent samples, see notes for 2-D case low, upp : float equivalence interval low < m1 - m2 < upp usevar : string, 'pooled' or 'unequal' If ``pooled``, then the standard deviation of the samples is assumed to be the same. If ``unequal``, then Welsh ttest with Satterthwait degrees of freedom is used weights : tuple of None or ndarrays Case weights for the two samples. For details on weights see ``DescrStatsW`` transform : None or function If None (default), then the data is not transformed. Given a function, sample data and thresholds are transformed. If transform is log, then the equivalence interval is in ratio: low < m1 / m2 < upp Returns ------- pvalue : float pvalue of the non-equivalence test t1, pv1 : tuple of floats test statistic and pvalue for lower threshold test t2, pv2 : tuple of floats test statistic and pvalue for upper threshold test Notes ----- The test rejects if the 2*alpha confidence interval for the difference is contained in the ``(low, upp)`` interval. This test works also for multi-endpoint comparisons: If d1 and d2 have the same number of columns, then each column of the data in d1 is compared with the corresponding column in d2. This is the same as comparing each of the corresponding columns separately. Currently no multi-comparison correction is used. The raw p-values reported here can be correction with the functions in ``multitest``. ''' if transform: if transform is np.log: #avoid hstack in special case x1 = transform(x1) x2 = transform(x2) else: #for transforms like rankdata that will need both datasets #concatenate works for stacking 1d and 2d arrays xx = transform(np.concatenate((x1, x2), 0)) x1 = xx[:len(x1)] x2 = xx[len(x1):] low = transform(low) upp = transform(upp) cm = CompareMeans(DescrStatsW(x1, weights=weights[0], ddof=0), DescrStatsW(x2, weights=weights[1], ddof=0)) pval, res = cm.ttost_ind(low, upp, usevar=usevar) return pval, res[0], res[1]
[docs]def ttost_paired(x1, x2, low, upp, transform=None, weights=None): '''test of (non-)equivalence for two dependent, paired sample TOST: two one-sided t tests null hypothesis: md < low or md > upp alternative hypothesis: low < md < upp where md is the mean, expected value of the difference x1 - x2 If the pvalue is smaller than a threshold,say 0.05, then we reject the hypothesis that the difference between the two samples is larger than the the thresholds given by low and upp. Parameters ---------- x1, x2 : array_like two dependent samples low, upp : float equivalence interval low < mean of difference < upp weights : None or ndarray case weights for the two samples. For details on weights see ``DescrStatsW`` transform : None or function If None (default), then the data is not transformed. Given a function sample data and thresholds are transformed. If transform is log the the equivalence interval is in ratio: low < x1 / x2 < upp Returns ------- pvalue : float pvalue of the non-equivalence test t1, pv1, df1 : tuple test statistic, pvalue and degrees of freedom for lower threshold test t2, pv2, df2 : tuple test statistic, pvalue and degrees of freedom for upper threshold test ''' if transform: if transform is np.log: #avoid hstack in special case x1 = transform(x1) x2 = transform(x2) else: #for transforms like rankdata that will need both datasets #concatenate works for stacking 1d and 2d arrays xx = transform(np.concatenate((x1, x2), 0)) x1 = xx[:len(x1)] x2 = xx[len(x1):] low = transform(low) upp = transform(upp) dd = DescrStatsW(x1 - x2, weights=weights, ddof=0) t1, pv1, df1 = dd.ttest_mean(low, alternative='larger') t2, pv2, df2 = dd.ttest_mean(upp, alternative='smaller') return np.maximum(pv1, pv2), (t1, pv1, df1), (t2, pv2, df2)
[docs]def ztest(x1, x2=None, value=0, alternative='two-sided', usevar='pooled', ddof=1.): '''test for mean based on normal distribution, one or two samples In the case of two samples, the samples are assumed to be independent. Parameters ---------- x1, x2 : array_like, 1-D or 2-D two independent samples value : float In the one sample case, value is the mean of x1 under the Null hypothesis. In the two sample case, value is the difference between mean of x1 and mean of x2 under the Null hypothesis. The test statistic is `x1_mean - x2_mean - value`. alternative : string The alternative hypothesis, H1, has to be one of the following 'two-sided': H1: difference in means not equal to value (default) 'larger' : H1: difference in means larger than value 'smaller' : H1: difference in means smaller than value usevar : string, 'pooled' Currently, only 'pooled' is implemented. If ``pooled``, then the standard deviation of the samples is assumed to be the same. see CompareMeans.ztest_ind for different options. ddof : int Degrees of freedom use in the calculation of the variance of the mean estimate. In the case of comparing means this is one, however it can be adjusted for testing other statistics (proportion, correlation) Returns ------- tstat : float test statisic pvalue : float pvalue of the t-test Notes ----- usevar not implemented, is always pooled in two sample case use CompareMeans instead. ''' # TODO: this should delegate to CompareMeans like ttest_ind # However that does not implement ddof #usevar is not used, always pooled if usevar != 'pooled': raise NotImplementedError('only usevar="pooled" is implemented') x1 = np.asarray(x1) nobs1 = x1.shape[0] x1_mean = x1.mean(0) x1_var = x1.var(0) if x2 is not None: x2 = np.asarray(x2) nobs2 = x2.shape[0] x2_mean = x2.mean(0) x2_var = x2.var(0) var_pooled = (nobs1 * x1_var + nobs2 * x2_var) var_pooled /= (nobs1 + nobs2 - 2 * ddof) var_pooled *= (1. / nobs1 + 1. / nobs2) else: var_pooled = x1_var / (nobs1 - ddof) x2_mean = 0 std_diff = np.sqrt(var_pooled) #stat = x1_mean - x2_mean - value return _zstat_generic(x1_mean, x2_mean, std_diff, alternative, diff=value)
[docs]def zconfint(x1, x2=None, value=0, alpha=0.05, alternative='two-sided', usevar='pooled', ddof=1.): '''confidence interval based on normal distribution z-test Parameters ---------- x1, x2 : array_like, 1-D or 2-D two independent samples, see notes for 2-D case value : float In the one sample case, value is the mean of x1 under the Null hypothesis. In the two sample case, value is the difference between mean of x1 and mean of x2 under the Null hypothesis. The test statistic is `x1_mean - x2_mean - value`. usevar : string, 'pooled' Currently, only 'pooled' is implemented. If ``pooled``, then the standard deviation of the samples is assumed to be the same. see CompareMeans.ztest_ind for different options. ddof : int Degrees of freedom use in the calculation of the variance of the mean estimate. In the case of comparing means this is one, however it can be adjusted for testing other statistics (proportion, correlation) Notes ----- checked only for 1 sample case usevar not implemented, is always pooled in two sample case ``value`` shifts the confidence interval so it is centered at `x1_mean - x2_mean - value` See Also -------- ztest CompareMeans ''' #usevar is not used, always pooled # mostly duplicate code from ztest if usevar != 'pooled': raise NotImplementedError('only usevar="pooled" is implemented') x1 = np.asarray(x1) nobs1 = x1.shape[0] x1_mean = x1.mean(0) x1_var = x1.var(0) if x2 is not None: x2 = np.asarray(x2) nobs2 = x2.shape[0] x2_mean = x2.mean(0) x2_var = x2.var(0) var_pooled = (nobs1 * x1_var + nobs2 * x2_var) var_pooled /= (nobs1 + nobs2 - 2 * ddof) var_pooled *= (1. / nobs1 + 1. / nobs2) else: var_pooled = x1_var / (nobs1 - ddof) x2_mean = 0 std_diff = np.sqrt(var_pooled) ci = _zconfint_generic(x1_mean - x2_mean - value, std_diff, alpha, alternative) return ci
[docs]def ztost(x1, low, upp, x2=None, usevar='pooled', ddof=1.): '''Equivalence test based on normal distribution Parameters ---------- x1 : array_like one sample or first sample for 2 independent samples low, upp : float equivalence interval low < m1 - m2 < upp x1 : array_like or None second sample for 2 independent samples test. If None, then a one-sample test is performed. usevar : string, 'pooled' If `pooled`, then the standard deviation of the samples is assumed to be the same. Only `pooled` is currently implemented. Returns ------- pvalue : float pvalue of the non-equivalence test t1, pv1 : tuple of floats test statistic and pvalue for lower threshold test t2, pv2 : tuple of floats test statistic and pvalue for upper threshold test Notes ----- checked only for 1 sample case ''' tt1 = ztest(x1, x2, alternative='larger', usevar=usevar, value=low, ddof=ddof) tt2 = ztest(x1, x2, alternative='smaller', usevar=usevar, value=upp, ddof=ddof) return np.maximum(tt1[1], tt2[1]), tt1, tt2,