def main():
option_parser, opts, args = parse_command_line_parameters(**script_info)
if opts.num_permutations < 10:
option_parser.error('Number of permuations must be greater than or '
'equal to 10.')
rarefaction_lines = open(opts.alpha_diversity_fp, 'U')
mapping_lines = open(opts.mapping_fp, 'U')
category = opts.category
depth = opts.depth
ttest_result, alphadiv_avgs = compare_alpha_diversities(
rarefaction_lines, mapping_lines, category, depth, opts.test_type,
opts.num_permutations)
rarefaction_lines.close()
mapping_lines.close()
corrected_result = _correct_compare_alpha_results(ttest_result,
opts.correction_method)
# write results
outfile = open(opts.output_fp, 'w')
header = ('Group1\tGroup2\tGroup1 mean\tGroup1 std\tGroup2 mean\t'
'Group2 std\tt stat\tp-value')
lines = [header]
for (t0, t1), v in corrected_result.items():
lines.append('\t'.join(
map(str, [
t0, t1, alphadiv_avgs[t0][0], alphadiv_avgs[t0][1],
alphadiv_avgs[t1][0], alphadiv_avgs[t1][1], v[0], v[1]
])))
outfile.write('\n'.join(lines) + '\n')
outfile.close()
def main():
option_parser, opts, args = parse_command_line_parameters(**script_info)
if opts.num_permutations < 10:
option_parser.error('Number of permuations must be greater than or '
'equal to 10.')
rarefaction_lines = open(opts.alpha_diversity_fp, 'U')
mapping_lines = open(opts.mapping_fp, 'U')
category = opts.category
depth = int(opts.depth)
output_path = opts.output_fp
result = compare_alpha_diversities(rarefaction_lines, mapping_lines,
category, depth, opts.test_type, opts.num_permutations)
rarefaction_lines.close()
mapping_lines.close()
corrected_result = _correct_compare_alpha_results(result,
opts.correction_method)
# write results
outfile = open(output_path, 'w')
header = 'Comparison\ttval\tpval'
lines = [header]
for k,v in corrected_result.items():
lines.append('\t'.join(map(str,[k,v[0],v[1]])))
outfile.write('\n'.join(lines))
outfile.close()
def main():
option_parser, opts, args = parse_command_line_parameters(**script_info)
if opts.num_permutations < 10:
option_parser.error('Number of permuations must be greater than or '
'equal to 10.')
rarefaction_lines = open(opts.alpha_diversity_fp, 'U')
mapping_lines = open(opts.mapping_fp, 'U')
category = opts.category
depth = opts.depth
ttest_result, alphadiv_avgs = compare_alpha_diversities(rarefaction_lines,
mapping_lines, category, depth, opts.test_type, opts.num_permutations)
rarefaction_lines.close()
mapping_lines.close()
corrected_result = _correct_compare_alpha_results(ttest_result,
opts.correction_method)
# write results
outfile = open(opts.output_fp, 'w')
header = ('Group1\tGroup2\tGroup1 mean\tGroup1 std\tGroup2 mean\t'
'Group2 std\tt stat\tp-value')
lines = [header]
for (t0, t1), v in corrected_result.items():
lines.append('\t'.join(map(str,[t0,t1,alphadiv_avgs[t0][0],
alphadiv_avgs[t0][1], alphadiv_avgs[t1][0],
alphadiv_avgs[t1][1],v[0],v[1]])))
outfile.write('\n'.join(lines) + '\n')
outfile.close()
def main():
option_parser, opts, args = parse_command_line_parameters(**script_info)
mapping_fp = opts.mapping_fp
alpha_diversity_fp = opts.alpha_diversity_fp
categories = opts.categories.split(',')
depth = opts.depth
output_dir = opts.output_dir
correction_method = opts.correction_method
test_type = opts.test_type
num_permutations = opts.num_permutations
if num_permutations < 10:
option_parser.error('Number of permuations must be greater than or '
'equal to 10.')
create_dir(output_dir)
for category in categories:
stat_output_fp = join(output_dir, '%s_stats.txt' % category)
boxplot_output_fp = join(output_dir, '%s_boxplots.pdf' % category)
alpha_diversity_f = open(alpha_diversity_fp, 'U')
mapping_f = open(mapping_fp, 'U')
ttest_result, alphadiv_avgs = \
compare_alpha_diversities(alpha_diversity_f,
mapping_f,
category,
depth,
test_type,
num_permutations)
alpha_diversity_f.close()
mapping_f.close()
corrected_result = _correct_compare_alpha_results(
ttest_result, correction_method)
# write stats results
stat_output_f = open(stat_output_fp, 'w')
header = ('Group1\tGroup2\tGroup1 mean\tGroup1 std\tGroup2 mean\t'
'Group2 std\tt stat\tp-value')
lines = [header]
for (t0, t1), v in corrected_result.items():
lines.append('\t'.join(
map(str, [
t0, t1, alphadiv_avgs[t0][0], alphadiv_avgs[t0][1],
alphadiv_avgs[t1][0], alphadiv_avgs[t1][1], v[0], v[1]
])))
stat_output_f.write('\n'.join(lines) + '\n')
stat_output_f.close()
# write box plots
alpha_diversity_f = open(alpha_diversity_fp, 'U')
mapping_f = open(mapping_fp, 'U')
boxplot = generate_alpha_diversity_boxplots(alpha_diversity_f,
mapping_f, category, depth)
alpha_diversity_f.close()
mapping_f.close()
boxplot.savefig(boxplot_output_fp)
def test_correct_compare_alpha_results(self):
"""Test that FDR and Bonferroni are applied correctly."""
input_results = \
{'1xDose,2xDose': (-1.8939787722170394, 0.14),
'Control,1xDose': (3.365078231689424, 0.34),
'Control,2xDose': (0.43262479194397335, 1.0)}
method = 'fdr'
expected_results = \
{'1xDose,2xDose': (-1.8939787722170394, 0.42),
'Control,1xDose': (3.365078231689424, 0.51),
'Control,2xDose': (0.43262479194397335, 1.0)}
observed_results = _correct_compare_alpha_results(
input_results, method)
# test each key in expected results -- this won't catch if
# observed_results has extra entries, but test that via the next call
for k in expected_results:
for val0, val1 in zip(expected_results[k], observed_results[k]):
self.assertAlmostEqual(val0, val1)
self.assertEqual(set(expected_results.keys()),
set(observed_results.keys()))
method = 'bonferroni'
expected_results = \
{'1xDose,2xDose': (-1.8939787722170394, 0.14 * 3),
'Control,1xDose': (3.365078231689424, 1.0), # because maxes at 1
'Control,2xDose': (0.43262479194397335, 1.0)} # becuase maxes at 1
observed_results = _correct_compare_alpha_results(
input_results, method)
# test each key in expected results -- this won't catch if
# observed_results has extra entries, but test that via the next call
for k in expected_results:
for val0, val1 in zip(expected_results[k], observed_results[k]):
self.assertAlmostEqual(val0, val1)
self.assertEqual(set(expected_results.keys()),
set(observed_results.keys()))
method = 'none'
expected_results = \
{'1xDose,2xDose': (-1.8939787722170394, 0.14),
'Control,1xDose': (3.365078231689424, 0.34),
'Control,2xDose': (0.43262479194397335, 1.0)}
observed_results = _correct_compare_alpha_results(
input_results, method)
# test each key in expected results -- this won't catch if
# observed_results has extra entries, but test that via the next call
for k in expected_results:
for val0, val1 in zip(expected_results[k], observed_results[k]):
self.assertAlmostEqual(val0, val1)
self.assertEqual(set(expected_results.keys()),
set(observed_results.keys()))
# check errors if wrong method
self.assertRaises(ValueError, _correct_compare_alpha_results,
input_results, 'DNE')
# check that the methods work correctly when Nones are included
input_results = \
{'1xDose,2xDose': (None, None),
'A,B': (3, 0.004),
'A,C': (3, 0.0022),
'A,D': (3, 0.05),
'A,E': (3, 0.06),
'A,F': (None, None),
'Control,1xDose': (None, None),
'Control,2xDose': (-0.6366887333996324, 0.639061687134877)}
# Bonferroni
expected_bonferroni_results = \
{'1xDose,2xDose': (None, None),
'A,B': (3, 0.02),
'A,C': (3, 0.011000000000000001),
'A,D': (3, 0.25),
'A,E': (3, 0.3),
'A,F': (None, None),
'Control,1xDose': (None, None),
'Control,2xDose': (-0.6366887333996324, 1.0)}
self.assertEqual(
expected_bonferroni_results,
_correct_compare_alpha_results(input_results, 'bonferroni'))
# FDR
expected_fdr_results = \
{'1xDose,2xDose': (None, None),
'A,B': (3, 0.01),
'A,C': (3, 0.011000000000000001),
'A,D': (3, 0.08333333333333334),
'A,E': (3, 0.075),
'A,F': (None, None),
'Control,1xDose': (None, None),
'Control,2xDose': (-0.6366887333996324, 0.639061687134877)}
for k, v in _correct_compare_alpha_results(input_results,
'fdr').items():
if v[0] is not None:
assert_almost_equal(v, expected_fdr_results[k])
else:
self.assertEqual(v, expected_fdr_results[k])
def test_correct_compare_alpha_results(self):
"""Test that FDR and Bonferroni are applied correctly."""
input_results = \
{'1xDose,2xDose': (-1.8939787722170394, 0.14),
'Control,1xDose': (3.365078231689424, 0.34),
'Control,2xDose': (0.43262479194397335, 1.0)}
method = 'fdr'
expected_results = \
{'1xDose,2xDose': (-1.8939787722170394, 0.42),
'Control,1xDose': (3.365078231689424, 0.51),
'Control,2xDose': (0.43262479194397335, 1.0)}
observed_results = _correct_compare_alpha_results(input_results, method)
# test each key in expected results -- this won't catch if
# observed_results has extra entries, but test that via the next call
for k in expected_results:
for val0, val1 in zip(expected_results[k],observed_results[k]):
self.assertAlmostEqual(val0,val1)
self.assertEqual(set(expected_results.keys()),set(observed_results.keys()))
method = 'bonferroni'
expected_results = \
{'1xDose,2xDose': (-1.8939787722170394, 0.14*3),
'Control,1xDose': (3.365078231689424, 1.0), #because maxes at 1
'Control,2xDose': (0.43262479194397335, 1.0)} #becuase maxes at 1
observed_results = _correct_compare_alpha_results(input_results, method)
# test each key in expected results -- this won't catch if
# observed_results has extra entries, but test that via the next call
for k in expected_results:
for val0, val1 in zip(expected_results[k],observed_results[k]):
self.assertAlmostEqual(val0,val1)
self.assertEqual(set(expected_results.keys()),set(observed_results.keys()))
method = 'none'
expected_results = \
{'1xDose,2xDose': (-1.8939787722170394, 0.14),
'Control,1xDose': (3.365078231689424, 0.34),
'Control,2xDose': (0.43262479194397335, 1.0)}
observed_results = _correct_compare_alpha_results(input_results, method)
# test each key in expected results -- this won't catch if
# observed_results has extra entries, but test that via the next call
for k in expected_results:
for val0, val1 in zip(expected_results[k],observed_results[k]):
self.assertAlmostEqual(val0,val1)
self.assertEqual(set(expected_results.keys()),set(observed_results.keys()))
# check errors if wrong method
self.assertRaises(ValueError, _correct_compare_alpha_results,
input_results, 'DNE')
# check that the methods work correctly when Nones are included
input_results = \
{'1xDose,2xDose': (None, None),
'A,B': (3, 0.004),
'A,C': (3, 0.0022),
'A,D': (3, 0.05),
'A,E': (3, 0.06),
'A,F': (None, None),
'Control,1xDose': (None, None),
'Control,2xDose': (-0.6366887333996324, 0.639061687134877)}
# Bonferroni
expected_bonferroni_results = \
{'1xDose,2xDose': (None, None),
'A,B': (3, 0.02),
'A,C': (3, 0.011000000000000001),
'A,D': (3, 0.25),
'A,E': (3, 0.3),
'A,F': (None, None),
'Control,1xDose': (None, None),
'Control,2xDose': (-0.6366887333996324, 1.0)}
self.assertEqual(expected_bonferroni_results,
_correct_compare_alpha_results(input_results,'bonferroni'))
#FDR
expected_fdr_results = \
{'1xDose,2xDose': (None, None),
'A,B': (3, 0.01),
'A,C': (3, 0.011000000000000001),
'A,D': (3, 0.08333333333333334),
'A,E': (3, 0.075),
'A,F': (None, None),
'Control,1xDose': (None, None),
'Control,2xDose': (-0.6366887333996324, 0.639061687134877)}
self.assertEqual(expected_fdr_results,
_correct_compare_alpha_results(input_results,'fdr'))
def main():
option_parser, opts, args = parse_command_line_parameters(**script_info)
mapping_fp = opts.mapping_fp
alpha_diversity_fp = opts.alpha_diversity_fp
categories = opts.categories.split(",")
depth = opts.depth
output_dir = opts.output_dir
correction_method = opts.correction_method
test_type = opts.test_type
num_permutations = opts.num_permutations
if num_permutations < 10:
option_parser.error("Number of permuations must be greater than or " "equal to 10.")
create_dir(output_dir)
for category in categories:
stat_output_fp = join(output_dir, "%s_stats.txt" % category)
boxplot_output_fp = join(output_dir, "%s_boxplots.pdf" % category)
alpha_diversity_f = open(alpha_diversity_fp, "U")
mapping_f = open(mapping_fp, "U")
ttest_result, alphadiv_avgs = compare_alpha_diversities(
alpha_diversity_f, mapping_f, category, depth, test_type, num_permutations
)
alpha_diversity_f.close()
mapping_f.close()
corrected_result = _correct_compare_alpha_results(ttest_result, correction_method)
# write stats results
stat_output_f = open(stat_output_fp, "w")
header = "Group1\tGroup2\tGroup1 mean\tGroup1 std\tGroup2 mean\t" "Group2 std\tt stat\tp-value"
lines = [header]
for (t0, t1), v in corrected_result.items():
lines.append(
"\t".join(
map(
str,
[
t0,
t1,
alphadiv_avgs[t0][0],
alphadiv_avgs[t0][1],
alphadiv_avgs[t1][0],
alphadiv_avgs[t1][1],
v[0],
v[1],
],
)
)
)
stat_output_f.write("\n".join(lines) + "\n")
stat_output_f.close()
# write box plots
alpha_diversity_f = open(alpha_diversity_fp, "U")
mapping_f = open(mapping_fp, "U")
boxplot = generate_alpha_diversity_boxplots(alpha_diversity_f, mapping_f, category, depth)
alpha_diversity_f.close()
mapping_f.close()
boxplot.savefig(boxplot_output_fp)
