Python scipy.stats.mannwhitneyu() Examples

The following are code examples for showing how to use scipy.stats.mannwhitneyu(). They are from open source Python projects. You can vote up the examples you like or vote down the ones you don't like.

Example 1
```def diff_expr(A, B, genes, permute_cutoff, verbose=True):

p_vals = []
for idx, gene in enumerate(genes):
if sum(A[:, idx]) == 0 and sum(B[:, idx]) == 0:
p_vals.append(1.)
continue
u, p = mannwhitneyu(A[:, idx], B[:, idx])
p_vals.append(p)

de_genes = []
for idx, gene in enumerate(genes):
if p_vals[idx] < permute_cutoff:
if verbose:
print('{}\t{}'.format(gene, p_vals[idx]))
de_genes.append(gene)
return de_genes ```
Example 2
 Project: GeoPy   Author: aerler   File: stats.py    GNU General Public License v3.0 6 votes
```def mannwhitneyu(sample1, sample2, ignoreNaN=True, lonesided=False, lstatistic=False,
use_continuity=True, **kwargs):
''' Apply the Mann-Whitney Rank Test, to test whether two samples are drawn from the same
underlying (continuous) distribution; a high p-value means, the two samples are likely
drawn from the same distribution.
The Mann-Whitney Test has very high efficiency for non-normal distributions and is almost as
reliable as the T-test for normal distributions. It is more sophisticated than the
Wilcoxon Ranksum Test and also handles ties between ranks.
One-sided p-values test the hypothesis that one distribution is larger than the other;
the two-sided test just tests, if the distributions are different. '''
if lstatistic: raise NotImplementedError("Return of test statistic is not yet implemented; only p-values are returned.")
testfct = functools.partial(mannwhitneyu_wrapper, ignoreNaN=ignoreNaN,
use_continuity=use_continuity)
pvar = apply_stat_test_2samp(sample1, sample2, fct=testfct, laax=True,
lpval=True, lrho=False, **kwargs)
if not lonesided: # transform to twosided (multiply p-value by 2)
if isinstance(pvar,Variable): pvar.data_array *= 2.
else : pvar *= 2.
# N.B.: for some reason Mann-Whitney returns the one-sided p-value... The one-sided p-value
#       is for the hypothesis that one sample is larger than the other.
#       It is better to correct here, so we can use vector multiplication.
return pvar ```
Example 3
 Project: GeoPy   Author: aerler   File: stats.py    GNU General Public License v3.0 6 votes
```def mannwhitneyu_wrapper(data, size1=None, ignoreNaN=True, use_continuity=True, loneside=False):
''' Apply the Mann-Whitney Rank Test, to test whether two samples are drawn from the same
underlying (continuous) distribution. This is a wrapper for the SciPy function that
removes NaN's, allows application over a field, and only returns the p-value. '''
if ignoreNaN:
data1 = data[:size1]; data2 = data[size1:]
nonans1 = np.invert(np.isnan(data1)) # test for NaN's
nonans2 = np.invert(np.isnan(data2))
if np.sum(nonans1) < 3 or np.sum(nonans2) < 3: return np.NaN # return, if less than 3 non-NaN's
data1 = data1[nonans1]; data2 = data2[nonans2] # remove NaN's
else:
data1 = data[:size1]; data2 = data[size1:]
# apply test
D, pval = ss.mannwhitneyu(data1, data2, use_continuity=use_continuity); del D
return pval

# Wilcoxon Ranksum Test on 2 samples ```
Example 4
```def test_mannwhitneyu_no_correct_one_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='less')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='greater')
u3, p3 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='greater')
u4, p4 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='less')

assert_equal(p1, p2)
assert_equal(p3, p4)
assert_(p1 != p3)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_equal(u3, 498)
assert_equal(u4, 102)
assert_approx_equal(p1, 0.999955905990004, significant=self.significant)
assert_approx_equal(p3, 4.40940099958089e-05, significant=self.significant) ```
Example 5
```def test_mannwhitneyu_default(self):
# The default value for alternative is None
with suppress_warnings() as sup:
sup.filter(DeprecationWarning,
"Calling `mannwhitneyu` without .*`alternative`")
u1, p1 = stats.mannwhitneyu(self.X, self.Y)
u2, p2 = stats.mannwhitneyu(self.Y, self.X)
u3, p3 = stats.mannwhitneyu(self.X, self.Y, alternative=None)

assert_equal(p1, p2)
assert_equal(p1, p3)
assert_equal(u1, 102)
assert_equal(u2, 102)
assert_equal(u3, 102)
assert_approx_equal(p1, 4.5941632666275e-05,
significant=self.significant) ```
Example 6
```def test_mannwhitneyu_no_correct_one_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='less')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='greater')
u3, p3 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='greater')
u4, p4 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='less')

assert_equal(p1, p2)
assert_equal(p3, p4)
assert_(p1 != p3)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_equal(u3, 498)
assert_equal(u4, 102)
assert_approx_equal(p1, 0.999955905990004, significant=self.significant)
assert_approx_equal(p3, 4.40940099958089e-05, significant=self.significant) ```
Example 7
 Project: FAE   Author: salan668   File: statistcs.py    GNU General Public License v3.0 6 votes
```def _statistic_continuous(array_0, array_1):

# 判断方差齐性
sta_value, p_value_h = levene(array_0, array_1)
# 判断正态性
w_train, p_value_train_n = kstest(array_0, 'norm')
w_test, p_value_test_n = kstest(array_1, 'norm')
# 如果方差齐性并且都满足正态分布，做U检验
if p_value_h >= 0.05 and p_value_train_n >= 0.05 and p_value_test_n >= 0.05:
stat_num, p_value = ttest_ind(array_0, array_1)
statistic_method = 'T-test'
else:
stat_num, p_value = mannwhitneyu(array_0, array_1)
statistic_method = 'U'

data_description = [str('%.2f' % np.mean(array_0)) + '±' + str('%.2f' % np.std(array_0)),
str('%.2f' % np.mean(array_1)) + '±' + str('%.2f' % np.std(array_1))]
return data_description, statistic_method,  p_value ```
Example 8
```def test_mannwhitneyu_no_correct_one_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='less')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='greater')
u3, p3 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='greater')
u4, p4 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='less')

assert_equal(p1, p2)
assert_equal(p3, p4)
assert_(p1 != p3)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_equal(u3, 498)
assert_equal(u4, 102)
assert_approx_equal(p1, 0.999955905990004, significant=self.significant)
assert_approx_equal(p3, 4.40940099958089e-05, significant=self.significant) ```
Example 9
```def test_mannwhitneyu_default(self):
# The default value for alternative is None
with suppress_warnings() as sup:
sup.filter(DeprecationWarning,
"Calling `mannwhitneyu` without .*`alternative`")
u1, p1 = stats.mannwhitneyu(self.X, self.Y)
u2, p2 = stats.mannwhitneyu(self.Y, self.X)
u3, p3 = stats.mannwhitneyu(self.X, self.Y, alternative=None)

assert_equal(p1, p2)
assert_equal(p1, p3)
assert_equal(u1, 102)
assert_equal(u2, 102)
assert_equal(u3, 102)
assert_approx_equal(p1, 4.5941632666275e-05,
significant=self.significant) ```
Example 10
```def test_mannwhitneyu_no_correct_one_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='less')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='greater')
u3, p3 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='greater')
u4, p4 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='less')

assert_equal(p1, p2)
assert_equal(p3, p4)
assert_(p1 != p3)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_equal(u3, 498)
assert_equal(u4, 102)
assert_approx_equal(p1, 0.999955905990004, significant=self.significant)
assert_approx_equal(p3, 4.40940099958089e-05, significant=self.significant) ```
Example 11
```def test_mannwhitneyu_default(self):
# The default value for alternative is None
with suppress_warnings() as sup:
sup.filter(DeprecationWarning,
"Calling `mannwhitneyu` without .*`alternative`")
u1, p1 = stats.mannwhitneyu(self.X, self.Y)
u2, p2 = stats.mannwhitneyu(self.Y, self.X)
u3, p3 = stats.mannwhitneyu(self.X, self.Y, alternative=None)

assert_equal(p1, p2)
assert_equal(p1, p3)
assert_equal(u1, 102)
assert_equal(u2, 102)
assert_equal(u3, 102)
assert_approx_equal(p1, 4.5941632666275e-05,
significant=self.significant) ```
Example 12
```def test_mannwhitneyu_no_correct_one_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='less')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='greater')
u3, p3 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='greater')
u4, p4 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='less')

assert_equal(p1, p2)
assert_equal(p3, p4)
assert_(p1 != p3)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_equal(u3, 498)
assert_equal(u4, 102)
assert_approx_equal(p1, 0.999955905990004, significant=self.significant)
assert_approx_equal(p3, 4.40940099958089e-05, significant=self.significant) ```
Example 13
```def test_mannwhitneyu_no_correct_one_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='less')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='greater')
u3, p3 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='greater')
u4, p4 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='less')

assert_equal(p1, p2)
assert_equal(p3, p4)
assert_(p1 != p3)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_equal(u3, 498)
assert_equal(u4, 102)
assert_approx_equal(p1, 0.999955905990004, significant=self.significant)
assert_approx_equal(p3, 4.40940099958089e-05, significant=self.significant) ```
Example 14
```def compute_test_accuracy(X_test, Y_test, model, prediction_type, cellgroup_map_array):

prediction = model.predict(X_test)
auc = []

if prediction_type=="cellgroup":

prediction = np.dot(prediction, cellgroup_map_array)
Y_test = np.dot(Y_test, cellgroup_map_array)

for y,pred in zip(Y_test.T,prediction.T):
try:
U = stats.mannwhitneyu(pred[pos], pred[neg])[0]
auc.append(1.-U/(np.count_nonzero(pos)*np.count_nonzero(neg)))
except ValueError:
auc.append(0.5)

return auc ```
Example 15
 Project: scprep   Author: KrishnaswamyLab   File: test_stats.py    GNU General Public License v3.0 6 votes
```def test_u_statistic():
X = data.generate_positive_sparse_matrix(shape=(500, 3), seed=42, poisson_mean=0.2)
Y = data.generate_positive_sparse_matrix(shape=(500, 3), seed=42, poisson_mean=0.3)
u_stat = [
stats.mannwhitneyu(X[:, i], Y[:, i], alternative="two-sided")[0]
for i in range(X.shape[1])
]

def test_fun(X):
return scprep.stats.rank_sum_statistic(
scprep.select.select_rows(X, idx=np.arange(500)),
scprep.select.select_rows(X, idx=np.arange(500, 1000)),
)

matrix.test_all_matrix_types(
np.vstack([X, Y]),
utils.assert_transform_equals,
Y=u_stat,
transform=test_fun,
check=utils.assert_all_close,
) ```
Example 16
 Project: gamtl   Author: shgo   File: graphics.py    GNU General Public License v3.0 6 votes
```def sig_test(self, metric='nmse', reference='GroupAMTL'):
"""
Computa Mann-Whitney rank test nas metricas gerais.
Args:
metric (str): metrica a ser utilizada na comparação
reference (str): nome do método que sera comparado contra outros.
"""
metrics = self.exp.resul['metrics']
met = metrics[metrics['metric'] == metric]
assert reference in met['method'].unique()
x = met[met['method'] == reference]['te']
methods = [met for met in met['method'].unique() if met != reference]
res = pd.DataFrame()
for method in methods:
y = met[met['method'] == method]['te']
from scipy.stats import mannwhitneyu
u, p = mannwhitneyu(x, y, alternative='less')
row = pd.Series([u, p, p < 0.05], index=['U', 'p-value', 'sig?'])
res[method] = row
return res.T ```
Example 17
```def test_test_num_feats(self):
p_vals = num_test(self.zipper, feat_subset=["feat1", "feat2"])

# check if p-value for feat1 is correct
feat1_p_val = mannwhitneyu(self.datacol[0]["feat1"].dropna(), self.datacol[1]["feat1"].dropna(),
alternative="two-sided")
self.assertEqual(p_vals["feat1"][(1, 2)], feat1_p_val.pvalue) ```
Example 18
```def test_mannwhitneyu_one_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, alternative='less')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, alternative='greater')
u3, p3 = stats.mannwhitneyu(self.X, self.Y, alternative='greater')
u4, p4 = stats.mannwhitneyu(self.Y, self.X, alternative='less')

assert_equal(p1, p2)
assert_equal(p3, p4)
assert_(p1 != p3)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_equal(u3, 498)
assert_equal(u4, 102)
assert_approx_equal(p1, 0.999957683256589, significant=self.significant)
assert_approx_equal(p3, 4.5941632666275e-05, significant=self.significant) ```
Example 19
```def test_mannwhitneyu_two_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, alternative='two-sided')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, alternative='two-sided')

assert_equal(p1, p2)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_approx_equal(p1, 9.188326533255e-05,
significant=self.significant) ```
Example 20
```def test_mannwhitneyu_default(self):
# The default value for alternative is None
with warnings.catch_warnings():
warnings.simplefilter("ignore", DeprecationWarning)
u1, p1 = stats.mannwhitneyu(self.X, self.Y)
u2, p2 = stats.mannwhitneyu(self.Y, self.X)
u3, p3 = stats.mannwhitneyu(self.X, self.Y, alternative=None)

assert_equal(p1, p2)
assert_equal(p1, p3)
assert_equal(u1, 102)
assert_equal(u2, 102)
assert_equal(u3, 102)
assert_approx_equal(p1, 4.5941632666275e-05,
significant=self.significant) ```
Example 21
```def test_mannwhitneyu_no_correct_two_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='two-sided')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='two-sided')

assert_equal(p1, p2)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_approx_equal(p1, 8.81880199916178e-05,
significant=self.significant) ```
Example 22
```def test_mannwhitneyu_ones(self):
x = np.array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 2., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 3., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1.])

y = np.array([1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1., 1., 1., 1.,
2., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2., 1., 1., 3.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1.,
1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2.,
2., 1., 1., 2., 1., 1., 2., 1., 2., 1., 1., 1., 1., 2.,
2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 2., 1., 1., 1., 1., 1., 2., 2., 2., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
2., 1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 2., 1., 1.,
1., 1., 1., 1.])

# p-value verified with matlab and R to 5 significant digits
assert_array_almost_equal(stats.stats.mannwhitneyu(x, y,
alternative='less'),
(16980.5, 2.8214327656317373e-005),
decimal=12) ```
Example 23
```def test_mannwhitneyu_result_attributes(self):
# test for namedtuple attribute results
attributes = ('statistic', 'pvalue')
res = stats.mannwhitneyu(self.X, self.Y)
check_named_results(res, attributes) ```
Example 24
```def test_mannwhitneyu_one_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, alternative='less')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, alternative='greater')
u3, p3 = stats.mannwhitneyu(self.X, self.Y, alternative='greater')
u4, p4 = stats.mannwhitneyu(self.Y, self.X, alternative='less')

assert_equal(p1, p2)
assert_equal(p3, p4)
assert_(p1 != p3)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_equal(u3, 498)
assert_equal(u4, 102)
assert_approx_equal(p1, 0.999957683256589, significant=self.significant)
assert_approx_equal(p3, 4.5941632666275e-05, significant=self.significant) ```
Example 25
```def test_mannwhitneyu_two_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, alternative='two-sided')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, alternative='two-sided')

assert_equal(p1, p2)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_approx_equal(p1, 9.188326533255e-05,
significant=self.significant) ```
Example 26
```def test_mannwhitneyu_no_correct_two_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='two-sided')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='two-sided')

assert_equal(p1, p2)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_approx_equal(p1, 8.81880199916178e-05,
significant=self.significant) ```
Example 27
```def test_mannwhitneyu_ones(self):
x = np.array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 2., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 3., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1.])

y = np.array([1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1., 1., 1., 1.,
2., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2., 1., 1., 3.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1.,
1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2.,
2., 1., 1., 2., 1., 1., 2., 1., 2., 1., 1., 1., 1., 2.,
2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 2., 1., 1., 1., 1., 1., 2., 2., 2., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
2., 1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 2., 1., 1.,
1., 1., 1., 1.])

# p-value verified with matlab and R to 5 significant digits
assert_array_almost_equal(stats.stats.mannwhitneyu(x, y,
alternative='less'),
(16980.5, 2.8214327656317373e-005),
decimal=12) ```
Example 28
```def test_mannwhitneyu_result_attributes(self):
# test for namedtuple attribute results
attributes = ('statistic', 'pvalue')
res = stats.mannwhitneyu(self.X, self.Y, alternative="less")
check_named_results(res, attributes) ```
Example 29
```def test_mannwhitneyu_one_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, alternative='less')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, alternative='greater')
u3, p3 = stats.mannwhitneyu(self.X, self.Y, alternative='greater')
u4, p4 = stats.mannwhitneyu(self.Y, self.X, alternative='less')

assert_equal(p1, p2)
assert_equal(p3, p4)
assert_(p1 != p3)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_equal(u3, 498)
assert_equal(u4, 102)
assert_approx_equal(p1, 0.999957683256589, significant=self.significant)
assert_approx_equal(p3, 4.5941632666275e-05, significant=self.significant) ```
Example 30
```def test_mannwhitneyu_two_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, alternative='two-sided')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, alternative='two-sided')

assert_equal(p1, p2)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_approx_equal(p1, 9.188326533255e-05,
significant=self.significant) ```
Example 31
```def test_mannwhitneyu_default(self):
# The default value for alternative is None
with warnings.catch_warnings():
warnings.simplefilter("ignore", DeprecationWarning)
u1, p1 = stats.mannwhitneyu(self.X, self.Y)
u2, p2 = stats.mannwhitneyu(self.Y, self.X)
u3, p3 = stats.mannwhitneyu(self.X, self.Y, alternative=None)

assert_equal(p1, p2)
assert_equal(p1, p3)
assert_equal(u1, 102)
assert_equal(u2, 102)
assert_equal(u3, 102)
assert_approx_equal(p1, 4.5941632666275e-05,
significant=self.significant) ```
Example 32
```def test_mannwhitneyu_no_correct_two_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='two-sided')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='two-sided')

assert_equal(p1, p2)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_approx_equal(p1, 8.81880199916178e-05,
significant=self.significant) ```
Example 33
```def test_mannwhitneyu_ones(self):
x = np.array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 2., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 3., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1.])

y = np.array([1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1., 1., 1., 1.,
2., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2., 1., 1., 3.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1.,
1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2.,
2., 1., 1., 2., 1., 1., 2., 1., 2., 1., 1., 1., 1., 2.,
2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 2., 1., 1., 1., 1., 1., 2., 2., 2., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
2., 1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 2., 1., 1.,
1., 1., 1., 1.])

# p-value verified with matlab and R to 5 significant digits
assert_array_almost_equal(stats.stats.mannwhitneyu(x, y,
alternative='less'),
(16980.5, 2.8214327656317373e-005),
decimal=12) ```
Example 34
```def test_mannwhitneyu_result_attributes(self):
# test for namedtuple attribute results
attributes = ('statistic', 'pvalue')
res = stats.mannwhitneyu(self.X, self.Y)
check_named_results(res, attributes) ```
Example 35
```def test_mannwhitneyu_one_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, alternative='less')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, alternative='greater')
u3, p3 = stats.mannwhitneyu(self.X, self.Y, alternative='greater')
u4, p4 = stats.mannwhitneyu(self.Y, self.X, alternative='less')

assert_equal(p1, p2)
assert_equal(p3, p4)
assert_(p1 != p3)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_equal(u3, 498)
assert_equal(u4, 102)
assert_approx_equal(p1, 0.999957683256589, significant=self.significant)
assert_approx_equal(p3, 4.5941632666275e-05, significant=self.significant) ```
Example 36
```def test_mannwhitneyu_two_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, alternative='two-sided')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, alternative='two-sided')

assert_equal(p1, p2)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_approx_equal(p1, 9.188326533255e-05,
significant=self.significant) ```
Example 37
```def test_mannwhitneyu_no_correct_two_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='two-sided')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='two-sided')

assert_equal(p1, p2)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_approx_equal(p1, 8.81880199916178e-05,
significant=self.significant) ```
Example 38
```def test_mannwhitneyu_ones(self):
x = np.array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 2., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 3., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1.])

y = np.array([1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1., 1., 1., 1.,
2., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2., 1., 1., 3.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1.,
1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2.,
2., 1., 1., 2., 1., 1., 2., 1., 2., 1., 1., 1., 1., 2.,
2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 2., 1., 1., 1., 1., 1., 2., 2., 2., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
2., 1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 2., 1., 1.,
1., 1., 1., 1.])

# p-value verified with matlab and R to 5 significant digits
assert_array_almost_equal(stats.stats.mannwhitneyu(x, y,
alternative='less'),
(16980.5, 2.8214327656317373e-005),
decimal=12) ```
Example 39
```def test_mannwhitneyu_result_attributes(self):
# test for namedtuple attribute results
attributes = ('statistic', 'pvalue')
res = stats.mannwhitneyu(self.X, self.Y, alternative="less")
check_named_results(res, attributes) ```
Example 40
```def compute_skew_stats(intra, inter):
"""Returns two dictionaries reporting (skew, skew_pval) for all groups"""
# Intra (within a group) stats
intra_skew = {}
for k, v in intra.items():
skew = st.skew(v)
try:
skew_zstat, skew_pval = st.skewtest(v)
except ValueError:  # if sample size too small
skew_zstat, skew_pval = (0, 1)
intra_skew[k] = (skew, skew_zstat, skew_pval)

# Inter (between groups) stats
inter_skew = {}
for k, v in inter.items():
# Inter skew stats
skew_sep = st.skew(v.flatten())
try:
skew_sep_zstat, skew_sep_pval = st.skewtest(v.flatten())
except ValueError:
skew_sep_zstat, skew_sep_pval = (0, 1)
inter_skew['-'.join(k)] = (skew_sep, skew_sep_zstat, skew_sep_pval)

# Significance of difference between intra and inter distributions
for intra_key in k:
try:
separation_zstat, separation_pval = mannwhitneyu(intra[intra_key],
v.flatten(),
alternative='less')
except ValueError:  # All numbers are identical in mannwhitneyu
separation_zstat, separation_pval = (0, 1)
inter_skew['{}<{}'.format(intra_key, '-'.join(k))] = (separation_zstat, separation_pval)

return intra_skew, inter_skew ```
Example 41
```def test_mannwhitneyu_one_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, alternative='less')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, alternative='greater')
u3, p3 = stats.mannwhitneyu(self.X, self.Y, alternative='greater')
u4, p4 = stats.mannwhitneyu(self.Y, self.X, alternative='less')

assert_equal(p1, p2)
assert_equal(p3, p4)
assert_(p1 != p3)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_equal(u3, 498)
assert_equal(u4, 102)
assert_approx_equal(p1, 0.999957683256589, significant=self.significant)
assert_approx_equal(p3, 4.5941632666275e-05, significant=self.significant) ```
Example 42
```def test_mannwhitneyu_two_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, alternative='two-sided')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, alternative='two-sided')

assert_equal(p1, p2)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_approx_equal(p1, 9.188326533255e-05,
significant=self.significant) ```
Example 43
```def test_mannwhitneyu_no_correct_two_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='two-sided')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='two-sided')

assert_equal(p1, p2)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_approx_equal(p1, 8.81880199916178e-05,
significant=self.significant) ```
Example 44
```def test_mannwhitneyu_ones(self):
x = np.array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 2., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 3., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1.])

y = np.array([1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1., 1., 1., 1.,
2., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2., 1., 1., 3.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1.,
1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2.,
2., 1., 1., 2., 1., 1., 2., 1., 2., 1., 1., 1., 1., 2.,
2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 2., 1., 1., 1., 1., 1., 2., 2., 2., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
2., 1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 2., 1., 1.,
1., 1., 1., 1.])

# p-value verified with matlab and R to 5 significant digits
assert_array_almost_equal(stats.stats.mannwhitneyu(x, y,
alternative='less'),
(16980.5, 2.8214327656317373e-005),
decimal=12) ```
Example 45
```def test_mannwhitneyu_result_attributes(self):
# test for namedtuple attribute results
attributes = ('statistic', 'pvalue')
res = stats.mannwhitneyu(self.X, self.Y, alternative="less")
check_named_results(res, attributes) ```
Example 46
```def mann_whitney_u_similar_distribution(self, column,
pvalue_threshold=0.05,
num_rounds=3):
p_value = permutation_test(
self.new_data[column],
self.historical_data[column],
method="approximate",
num_rounds=num_rounds,
func=lambda x, y: stats.mannwhitneyu(x, y).statistic,
seed=0)

if p_value < pvalue_threshold:
return False
return True ```
Example 47
 Project: ribotish   Author: zhpn1024   File: ribo.py    GNU General Public License v3.0 5 votes
```def rstest_mw(x, y):
'''rank sum test p value of x > y, Not used because of some bug in mannwhitneyu
'''
from scipy.stats import ranksums, mannwhitneyu
#n1, n2 = len(x), len(y)
#mu = n1 * n2 / 2.
st1, p1 = ranksums(x, y)
try : st, p = mannwhitneyu(x, y)
except : return 0.5
if st1 > 0 : return p
else: return 1 - p ### ```
Example 48
 Project: SCNIC   Author: shafferm   File: calculate_permutation_stats.py    BSD 3-Clause "New" or "Revised" License 5 votes
```def perm_mannwhitneyu(x, y, dist, alternative):
stat, _ = mannwhitneyu(x, y, alternative=alternative)
pvalue = np.sum(stat > dist) / len(dist)
return stat, pvalue ```
Example 49
```def test_mannwhitneyu_one_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, alternative='less')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, alternative='greater')
u3, p3 = stats.mannwhitneyu(self.X, self.Y, alternative='greater')
u4, p4 = stats.mannwhitneyu(self.Y, self.X, alternative='less')

assert_equal(p1, p2)
assert_equal(p3, p4)
assert_(p1 != p3)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_equal(u3, 498)
assert_equal(u4, 102)
assert_approx_equal(p1, 0.999957683256589, significant=self.significant)
assert_approx_equal(p3, 4.5941632666275e-05, significant=self.significant) ```
Example 50
```def test_mannwhitneyu_two_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, alternative='two-sided')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, alternative='two-sided')

assert_equal(p1, p2)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_approx_equal(p1, 9.188326533255e-05,
significant=self.significant) ```
Example 51
```def test_mannwhitneyu_default(self):
# The default value for alternative is None
with warnings.catch_warnings():
warnings.simplefilter("ignore", DeprecationWarning)
u1, p1 = stats.mannwhitneyu(self.X, self.Y)
u2, p2 = stats.mannwhitneyu(self.Y, self.X)
u3, p3 = stats.mannwhitneyu(self.X, self.Y, alternative=None)

assert_equal(p1, p2)
assert_equal(p1, p3)
assert_equal(u1, 102)
assert_equal(u2, 102)
assert_equal(u3, 102)
assert_approx_equal(p1, 4.5941632666275e-05,
significant=self.significant) ```
Example 52
```def test_mannwhitneyu_no_correct_two_sided(self):
u1, p1 = stats.mannwhitneyu(self.X, self.Y, False,
alternative='two-sided')
u2, p2 = stats.mannwhitneyu(self.Y, self.X, False,
alternative='two-sided')

assert_equal(p1, p2)
assert_equal(u1, 498)
assert_equal(u2, 102)
assert_approx_equal(p1, 8.81880199916178e-05,
significant=self.significant) ```
Example 53
```def test_mannwhitneyu_ones(self):
x = np.array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 2., 1., 1., 2.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 3., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1.])

y = np.array([1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1., 1., 1., 1.,
2., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2., 1., 1., 3.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 2., 1., 2., 1.,
1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1., 2.,
2., 1., 1., 2., 1., 1., 2., 1., 2., 1., 1., 1., 1., 2.,
2., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 2., 1., 1., 1., 1., 1., 2., 2., 2., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
2., 1., 1., 2., 1., 1., 1., 1., 2., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 2., 1., 1., 1., 2., 1., 1.,
1., 1., 1., 1.])

# p-value verified with matlab and R to 5 significant digits
assert_array_almost_equal(stats.stats.mannwhitneyu(x, y,
alternative='less'),
(16980.5, 2.8214327656317373e-005),
decimal=12) ```
Example 54
```def test_mannwhitneyu_result_attributes(self):
# test for namedtuple attribute results
attributes = ('statistic', 'pvalue')
res = stats.mannwhitneyu(self.X, self.Y)
check_named_results(res, attributes) ```
Example 55
```def mann_whitney_test(train_examples, test_examples, num1, num2):
if len(train_examples) > 1 and len(test_examples) > 1:
if test_examples[-1] != 0 and train_examples[-1] != 0:
result = mannwhitneyu(train_examples, test_examples)[1]
return result
return 0 ```
Example 56
```def mann_whitney_u_test(train_examples, test_examples, num1, num2):
try:
if len(train_examples) > 1 and len(test_examples) > 1:
result = mannwhitneyu(train_examples, test_examples)[1]
return balance_result(num1, num2, True, result)
return 0
except ValueError as e:
logging.warn("IGNORE EXCEPTION: %s", str(e))
return 0 ```
Example 57
```def _compare_distributions(dist1, dist2):
'''Method to compare samples from two general distributions to determine if they are likely to be drawn from the
same distribution.
Return true if the two list of samples are likely to be drawn from the same distribution'''

_, pvalue = mannwhitneyu(dist1, dist2)

if (pvalue > 0.05):
# Likely to be drawn from same distribution
return True

else:
return False ```
Example 58
```def on_epoch_end(self, epoch, logs={}):

values = []
prediction = self.model.predict(self.model.validation_data[0])
Y = self.model.validation_data[1][0]

if self.prediction_type=="cellgroup":

prediction = np.dot(prediction, self.map_array)
Y = np.dot(Y, self.map_array)

for y,pred in zip(Y.T,prediction.T):
try:
U = stats.mannwhitneyu(pred[pos], pred[neg])[0]
values.append(1.-U/(np.count_nonzero(pos)*np.count_nonzero(neg)))
except ValueError:
values.append(0.5)

self.values.append(values)
epoch_time = time.time()-self.current_time
self.logger.log_this("epoch_%d_auroc: %s (%ds)"%(epoch, ' '.join(['%.4f'%v for v in self.values[-1]]), int(epoch_time)))
self.current_time = time.time() ```
Example 59
```def calc_mwu(clust_label, labels, conds, cond_order, gene_names, data, indices, indptr, shape):
csc_mat = csc_matrix((data, indices, indptr), shape = shape)
ngene = shape[1]
log_fc = np.zeros(ngene)
U_stats = np.zeros(ngene)
pvals = np.zeros(ngene)

idx = labels == clust_label
exprs = np.zeros(idx.sum())

idx_x = conds[idx] == cond_order[0]
idx_y = conds[idx] == cond_order[1]

local_mat = csc_mat[idx, :]

for j in range(ngene):
vec = local_mat[:, j]
if vec.size > 0:
exprs[vec.indices] = vec.data
log_fc[j] = np.mean(exprs[idx_x]) - np.mean(exprs[idx_y])
U_stats[j], pvals[j] = ss.mannwhitneyu(exprs[idx_x], exprs[idx_y], alternative = 'two-sided')
else:
log_fc[j] = 0.0
U_stats[j] = 0.0
pvals[j] = 1.0
exprs[:] = 0.0

passed, qvals = fdr(pvals)

df = pd.DataFrame({"log_fc": log_fc,
"mwu_U": U_stats,
"mwu_pval": pvals,
"mwu_qval": qvals},
index = gene_names)

print("Cluster {0} is processed.".format(clust_label))

return df ```
Example 60
```def calc_mwu(clust_label, labels, gene_names, data, indices, indptr, shape):
csc_mat = csc_matrix((data, indices, indptr), shape = shape)
nsample = shape[0]
ngene = shape[1]

idx_x = labels == clust_label
idx_y = ~idx_x

exprs = np.zeros(nsample)
U_stats = np.zeros(ngene)
pvals = np.zeros(ngene)

for j in range(ngene):
exprs[:] = 0.0
vec = csc_mat[:, j]
if vec.size > 0:
exprs[vec.indices] = vec.data
U_stats[j], pvals[j] = ss.mannwhitneyu(exprs[idx_x], exprs[idx_y], alternative = 'two-sided')
else:
U_stats[j] = 0.0
pvals[j] = 1.0
passed, qvals = fdr(pvals)

df = pd.DataFrame({"mwu_U_{0}".format(clust_label): U_stats,
"mwu_pval_{0}".format(clust_label): pvals,
"mwu_qval_{0}".format(clust_label): qvals},
index = gene_names)

print("Cluster {0} is processed.".format(clust_label))

return df ```
Example 61
```def str_mann_whitney(data1, data2):
s = "# datapoints {}, {} ; ".format(len(data1), len(data2))
U, p = mannwhitneyu(data1, data2, alternative='two-sided')
s += "U = {:0.2f} ; p = {:0.2E}".format(U, p)
return s ```
Example 62
 Project: diffxpy   Author: theislab   File: test_single_external_libs.py    BSD 3-Clause "New" or "Revised" License 5 votes
```def test_rank_ref(self, n_cells: int = 2000, n_genes: int = 100):
"""
Test if de.test.rank_test() generates the same p-value distribution as scipy t-test.

:param n_cells: Number of cells to simulate (number of observations per test).
:param n_genes: Number of genes to simulate (number of tests).
"""
logging.getLogger("tensorflow").setLevel(logging.ERROR)
logging.getLogger("batchglm").setLevel(logging.WARNING)
logging.getLogger("diffxpy").setLevel(logging.INFO)

np.random.seed(1)
sim = self._prepare_data(n_cells=n_cells, n_genes=n_genes)
test = de.test.rank_test(
data=sim.input_data,
grouping="condition",
sample_description=sim.sample_description
)

# Run scipy t-tests as a reference.
conds = np.unique(sim.sample_description["condition"].values)
ind_a = np.where(sim.sample_description["condition"] == conds[0])[0]
ind_b = np.where(sim.sample_description["condition"] == conds[1])[0]
scipy_pvals = np.array([
stats.mannwhitneyu(
x=sim.x[ind_a, i],
y=sim.x[ind_b, i],
use_continuity=True,
alternative="two-sided"
).pvalue
for i in range(sim.x.shape[1])
])
self._eval(test=test, ref_pvals=scipy_pvals)
return True ```
Example 63
```def main():
mutation_dir, clinical_dir, outdir = get_options()
mutation_files = os.listdir(mutation_dir)
mutation_files = util.remove_extraneous_files(mutation_files)

results = pd.DataFrame()
for mut in mutation_files:
if '_' in mut:
continue
cancer_type = util.get_cancer_type(mut)
print cancer_type
clinical = glob.glob(os.path.join(clinical_dir, '*' + cancer_type + '*'))[0]

mutation = mutation_base.prep_mutation_data(os.path.join(mutation_dir, mut), clinical_data)
data = mutation[['\'TP53']].join(clinical_data, how='inner')
print data

wt_as = data[data['\'TP53'] == 0]['breaks']
mut_as = data[data['\'TP53'] != 0]['breaks']

wt_q = wt_as.quantile([0.10, 0.25, 0.50, 0.75, 0.90])
mut_q = mut_as.quantile([0.10, 0.25, 0.50, 0.75, 0.90])

statistic, p = stats.mannwhitneyu(wt_as, mut_as)

wt_q['cancer_type'] = cancer_type
wt_q['mut?'] = 'wt'
mut_q['cancer_type'] = cancer_type
mut_q['mut?'] = 'mut'
wt_q['mann-whitney-p'] = p

results = results.append(wt_q)
results = results.append(mut_q)

results = results.set_index(['cancer_type', 'mut?'])
results.to_csv(os.path.join(outdir, 'breaks_and_p53_quantiles.csv')) ```
Example 64
```def test_num_feats(zipper, feat_subset=None, method=None):
"""
Performs a hypothesis test to check if the value distributions of numerical features deviate signifcantly between
the datasets. Currently t-test as a parametric and U-test as a non-parametric test are supported.

:param zipper: Dictionary storing the feature values of the datasets in a list. Feature name is used as the key.
:param feat_subset: A list containing feature names. If given, analysis will only be performed for the contained \
features. If not given all features will be considered.
:param method: Specify which statistical test should be used. "u" for Mann-Whitney-U-test, "t" for t-test and \
"wilcoxon" for a Wilcoxon signed rank test.
:return: dictionary storing the p_values of the analysis. Feature names are used as keys.
"""

# if no method is specified used Mann-Whitney-U-test as standard
if method is None:
method = "u"

# initialize dictionary which stores the p_values
p_values = dict()

if feat_subset is None:
feat_subset = zipper.keys()

for feat in feat_subset:  # run through all variables

# initiate dict in dict for d1 vs d2, d2 vs d3 etc. per feature
p_values[feat] = dict()

for i in range(len(zipper[feat]) - 1):  # select dataset1
for j in range(i + 1, len(zipper[feat])):  # select dataset2

# handle the case that all values of current feature are equal across current datasets
if _test_if_all_vals_equal(zipper[feat][i], zipper[feat][j]):
warnings.warn(
"Values of \"{}\" are the identical across the two datasets. It will be skipped.".format(feat),
UserWarning)
# delete already created dict for i, j in p_values and continue with next feature
del p_values[feat]
continue

# only calculate score if there are values in each dataset
if zipper[feat][i] and zipper[feat][j]:
# calculate u-test and return p-value
if method == "u":
stat_test_result = mannwhitneyu(zipper[feat][i], zipper[feat][j], alternative="two-sided")
# calculate t-test and return p-value
elif method == "t":
stat_test_result = ttest_ind(zipper[feat][i], zipper[feat][j])
elif method == "wilcoxon":
stat_test_result = wilcoxon(zipper[feat][i], zipper[feat][j])

p_values[feat][i + 1, j + 1] = stat_test_result.pvalue

# if one or both sets are empty
else:
p_values[feat][i + 1, j + 1] = np.nan

return p_values ```
Example 65
```def get_score_df(self, correction_method=None):
'''
Computes Mann Whitney corrected p, z-values.  Falls back to normal approximation when numerical limits are reached.

:param correction_method: str or None, correction method from statsmodels.stats.multitest.multipletests
'fdr_bh' is recommended.
:return: pd.DataFrame
'''
X = self._get_X().astype(np.float64)
X = X / X.sum(axis=1)
cat_X, ncat_X = self._get_cat_and_ncat(X)

def normal_apx(u, x, y):
# from https://stats.stackexchange.com/questions/116315/problem-with-mann-whitney-u-test-in-scipy
m_u = len(x) * len(y) / 2
sigma_u = np.sqrt(len(x) * len(y) * (len(x) + len(y) + 1) / 12)
z = (u - m_u) / sigma_u
return 2*norm.cdf(z)
scores = []
for i in range(cat_X.shape[1]):
cat_list = cat_X.T[i].A1
ncat_list = ncat_X.T[i].A1
try:
if cat_list.mean() > ncat_list.mean():
mw = mannwhitneyu(cat_list, ncat_list, alternative='greater')
if mw.pvalue in (0, 1):
mw.pvalue = normal_apx(mw.staistic, cat_list, ncat_list)

scores.append({'mwu': mw.statistic, 'mwu_p': mw.pvalue, 'mwu_z': norm.isf(float(mw.pvalue)), 'valid':True})

else:
mw = mannwhitneyu(ncat_list, cat_list, alternative='greater')
if mw.pvalue in (0, 1):
mw.pvalue = normal_apx(mw.staistic, ncat_list, cat_list)

scores.append({'mwu': -mw.statistic, 'mwu_p': 1 - mw.pvalue, 'mwu_z': 1. - norm.isf(float(mw.pvalue)), 'valid':True})
except:
scores.append({'mwu': 0, 'mwu_p': 0, 'mwu_z': 0, 'valid':False})

score_df = pd.DataFrame(scores, index=self.corpus_.get_terms()).fillna(0)
if correction_method is not None:
from statsmodels.stats.multitest import multipletests
for method in ['mwu']:
valid_pvals = score_df[score_df.valid].mwu_p
valid_pvals_abs = np.min([valid_pvals, 1-valid_pvals], axis=0)
valid_pvals_abs_corr = multipletests(valid_pvals_abs, method=correction_method)[1]
score_df[method + '_p_corr'] = 0.5
valid_pvals_abs_corr[valid_pvals > 0.5] = 1. - valid_pvals_abs_corr[valid_pvals > 0.5]
valid_pvals_abs_corr[valid_pvals < 0.5] = valid_pvals_abs_corr[valid_pvals < 0.5]
score_df.loc[score_df.valid, method + '_p_corr'] = valid_pvals_abs_corr
score_df[method + '_z'] = -norm.ppf(score_df[method + '_p_corr'])
return score_df ```
Example 66
 Project: DIVE-backend   Author: MacroConnections   File: numerical_comparison.py    GNU General Public License v3.0 4 votes
```def get_valid_tests(equal_var, independent, normal, num_samples):
'''
Get valid tests given number of samples and statistical characterization of
samples:

Equal variance
Indepenence
Normality
'''
if num_samples == 1:
valid_tests = {
'chisquare': stats.chisquare,
'power_divergence': stats.power_divergence,
'kstest': stats.kstest
}
if normal:
valid_tests['input']['one_sample_ttest'] = stats.ttest_1samp

elif num_samples == 2:
if independent:
valid_tests = {
'mannwhitneyu': stats.mannwhitneyu,
'kruskal': stats.kruskal,
'ks_2samp': stats.ks_2samp
}
if normal:
valid_tests['two_sample_ttest'] = stats.ttest_ind
if equal_var:
valid_tests['f_oneway'] = stats.f_oneway
else:
valid_tests = {
'two_sample_ks': stats.ks_2samp,
'wilcoxon': stats.wilcoxon
}
if normal:
valid_tests['two_sample_related_ttest'] = stats.ttest_rel

elif num_samples >= 3:
if independent:
valid_tests = {
'kruskal': stats.kruskal
}
if normal and equal_var:
valid_tests['f_oneway'] = stats.f_oneway

else:
valid_tests['friedmanchisquare'] = stats.friedmanchisquare

return valid_tests ```
Example 67
```def run_mannwhitneyu(df, condition_col, conditions, value_col='acc_diff',
min_n_obs=10, plot=False):
"""Run Mann-Whitney rank-sum test.

Args:
df (pd.DataFrame): dataframe where each row is a paper.
condition_col (str): name of column to use as condition.
conditions (list): list of two strings containing the values of the
condition to compare.

Keyword Args:
value_col (str): name of column to use as the numerical value to run the
test on.
min_n_obs (int): minimum number of observations in each sample in order
to run the test.

Returns:
(float): U statistic
(float): p-value
"""
assert len(conditions) == 2, '`conditions` must be of length 2, got {}'.format(
len(conditions))
data1 = df[df[condition_col] == conditions[0]][value_col]
data2 = df[df[condition_col] == conditions[1]][value_col]

if len(data1) >= min_n_obs and len(data2) >= min_n_obs:
stat, p = mannwhitneyu(data1, data2)
else:
stat, p = np.nan, np.nan
print('Not enough observations in each sample ({} and {}).'.format(
len(data1), len(data2)))

if plot:
fig, ax = plt.subplots()
sns.violinplot(
data=df[df[condition_col].isin(conditions)], x=condition_col,
y=value_col, ax=ax)
ax.set_title('Mann-Whitney for {} vs. {}\n(pvalue={:0.4f})'.format(
condition_col, value_col, p))
else:
fig = None

return {'test': 'mannwhitneyu', 'pvalue': p, 'stat': stat, 'fig': fig} ```
Example 68
 Project: mousestyles   Author: berkeley-stat222   File: mww.py    BSD 2-Clause "Simplified" License 4 votes
```def get_pvalues(m):
"""
This function takes a bunch of sampled distributions and compute the
p-values of the two sided Mann Whitney U test for each couple of samples.

The Mann-Whitney U test is a test for assessing whether two independent
samples come from the same distribution. The null hypothesis for this test
is that the two groups have the same distribution, while the alternative
hypothesis is that one group has larger (or smaller) values than the other.

Null hypothesis \$H_0\$: \$P(X>Y)=P(Y>X)\$.
Alternative \$H_1\$: not \$H_0\$.

The Mann-Whitney U test is similar to the Wilcoxon test, but can be used to
compare multiple samples that aren't necessarily paired.

Parameters
----------
m: list of numpy arrays
Sampled distributions.

Returns
-------
cor: 2 dimensional array of pvalues.
cor[i,j] is the p-value of the MWW test between the samples i and j.

Notes:
------
A p-value < 0.05 means that there is strong evidence to reject the null
hypothesis.

References:
-----------
1. Mann-Whitney U test:
http://tqmp.org/RegularArticles/vol04-1/p013/p013.pdf
2. Non parametric tests
http://www.mit.edu/~6.s085/notes/lecture5.pdf

Examples:
---------
>>> cor = get_pvalues([np.array([1, 2, 3]), np.array([1, 1, 2])])
"""
n = len(m)
indices = list(itertools.product(*[range(n), range(n)]))
cor = np.empty([n, n])
for (a, b) in indices:
cor[a, b] = 2 * mannwhitneyu(m[a], m[b])[1]
return cor ```