def plot_stacked_hist(self,
output_filename=None,
dpi=200,
kind="barh",
fontsize=10,
edgecolor="k",
lw=1,
width=1,
ytick_fontsize=10):
df = self.get_df()
df.T.plot(kind=kind,
stacked=True,
edgecolor=edgecolor,
lw=lw,
width=width)
ax = pylab.gca()
positions = pylab.yticks()
#ax.set_yticklabel(positions, labels, fontsize=ytick_fontsize)
pylab.xlabel("Percentage (%)", fontsize=fontsize)
pylab.ylabel("Sample index/name", fontsize=fontsize)
pylab.yticks(fontsize=ytick_fontsize)
pylab.legend(title="kingdom")
pylab.xlim([0, 100])
if output_filename:
pylab.savefig(output_filename, dpi=dpi)
def scatterplot(self, enrich, cutoff=0.05, nmax=10, gene_set_size=[]):
df = self._get_final_df(enrich.results, cutoff=cutoff, nmax=nmax)
pylab.clf()
pylab.scatter(-pylab.log10(df['Adjusted P-value']),
range(len(df)),
s=10 * df['size'],
c=df['size'])
pylab.xlabel("Odd ratio")
pylab.ylabel("Gene sets")
pylab.yticks(range(len(df)), df.name)
a, b = pylab.xlim()
pylab.xlim([0, b])
pylab.grid(True)
ax = pylab.gca()
M = max(df['size'])
if M > 100:
l1, l2, l3 = "10", "100", str(M)
else:
l1, l2, l3 = str(round(M / 3)), str(round(M * 2 / 3)), str(M)
handles = [
pylab.Line2D([0], [0], marker="o", markersize=5, label=l1, ls=""),
pylab.Line2D([0], [0], marker="o", markersize=10, label=l2, ls=""),
pylab.Line2D([0], [0], marker="o", markersize=15, label=l3, ls="")
]
ax.legend(handles=handles, loc="upper left", title="gene-set size")
pylab.axvline(1.3, lw=2, ls="--", color="r")
pylab.tight_layout()
ax = pylab.colorbar(pylab.gci())
return df
def barplot_per_sample(self, alpha=0.5, width=0.8, filename=None):
df = self.get_data_reads()
# this is ugly but will do the job for now
under = df.query("name=='Undetermined'")
others = df.query("name!='Undetermined'")
under = under.groupby("name").sum().reset_index()
others = others.groupby("name").sum().reset_index()
under = under[["name", "count"]].set_index("name")
others = others[["name", "count"]].set_index("name")
all_data = others.sort_index(ascending=False)
all_data.columns = ["samples"]
# appended at the end
all_data.loc['undetermined'] = 0
# revert back
all_data = all_data.loc[::-1]
# just for legend
under.columns = ['undetermined']
if all_data.sum().min() > 1e6:
all_data /= 1e6
under /= 1e6
M = True
else:
M = False
all_data.plot(kind="barh", alpha=alpha, zorder=1, width=width, ec='k')
under.plot(kind="barh",
alpha=alpha,
color="red",
ax=pylab.gca(),
zorder=1,
width=width,
ec='k')
pylab.ylim([-0.5, len(all_data) + 0.5])
if len(all_data) < 100:
pylab.yticks(range(len(all_data)), all_data.index)
pylab.legend()
pylab.grid(True, zorder=-1)
if M:
pylab.xlabel("Number of reads (M)")
else:
pylab.xlabel("Number of reads")
try:
pylab.tight_layout()
except:
pass
if filename:
pylab.savefig(filename, dpi=200)
def plot_corr(self):
lengths = self.SIRV_data.SIRV.get_lengths_as_dict()
spikes = self.spikes_found()
spikes["lengths"] = [lengths[k] for k in spikes.index]
corr = spikes.corr()
pylab.imshow(corr)
N = len(spikes.columns)
pylab.xticks(range(N), spikes.columns, rotation=90)
pylab.yticks(range(N), spikes.columns)
pylab.clim(0,1)
pylab.colorbar()
def plot_corr(self):
lengths = self.SIRV_data.SIRV.get_lengths_as_dict()
spikes = self.spikes_found()
spikes["lengths"] = [lengths[k] for k in spikes.index]
corr = spikes.corr()
pylab.imshow(corr)
N = len(spikes.columns)
pylab.xticks(range(N), spikes.columns, rotation=90)
pylab.yticks(range(N), spikes.columns)
pylab.clim(0, 1)
pylab.colorbar()
def barplot(self, enrich, cutoff=0.05, nmax=10):
df = self._get_final_df(enrich.results, cutoff=cutoff, nmax=nmax)
pylab.clf()
pylab.barh(range(len(df)), -pylab.log10(df['Adjusted P-value']))
pylab.yticks(range(len(df)), df.name)
pylab.axvline(1.3, lw=2, ls="--", color="r")
pylab.grid(True)
pylab.xlabel("Adjusted p-value (log10)")
pylab.ylabel("Gene sets")
a, b = pylab.xlim()
pylab.xlim([0, b])
pylab.tight_layout()
return df
def plot(self, interpolation='None', aspect='auto', cmap='hot', tight_layout=True,
colorbar=True, fontsize_x=None, fontsize_y=None, rotation_x=90,
xticks_on=True, yticks_on=True, **kargs):
"""wrapper around imshow to plot a dataframe
:param interpolation: set to None
:param aspect: set to 'auto'
:param cmap: colormap to be used.
:param tight_layout:
:param colorbar: add a colobar (default to True)
:param fontsize_x: fontsize on xlabels
:param fontsize_y: fontsize on ylabels
:param rotation_x: rotate labels on xaxis
:param xticks_on: switch off the xticks and labels
:param yticks_on: switch off the yticks and labels
"""
data = self.df
pylab.clf()
pylab.imshow(data, interpolation=interpolation, aspect=aspect, cmap=cmap, **kargs)
if fontsize_x == None:
fontsize_x = 16 #FIXME use default values
if fontsize_y == None:
fontsize_y = 16 #FIXME use default values
if yticks_on is True:
pylab.yticks(range(0, len(data.index)), data.index,
fontsize=fontsize_y)
else:
pylab.yticks([])
if xticks_on is True:
pylab.xticks(range(0, len(data.columns[:])), data.columns,
fontsize=fontsize_x, rotation=rotation_x)
else:
pylab.xticks([])
if colorbar is True:
pylab.colorbar()
if tight_layout:
pylab.tight_layout()
def plot_go_terms(self,
ontologies,
max_features=50,
log=False,
fontsize=8,
minimum_genes=0,
pvalue=0.05,
cmap="summer_r",
sort_by="fold_enrichment",
show_pvalues=False,
include_negative_enrichment=False,
fdr_threshold=0.05,
compute_levels=True,
progress=True):
assert sort_by in ['pValue', 'fold_enrichment', 'fdr']
# FIXME: pvalue and fold_enrichment not sorted in same order
pylab.clf()
df = self.get_data(
ontologies,
include_negative_enrichment=include_negative_enrichment,
fdr=fdr_threshold)
if len(df) == 0:
return df
df = df.query("pValue<=@pvalue")
logger.info("Filtering out pvalue>{}. Kept {} GO terms".format(
pvalue, len(df)))
df = df.reset_index(drop=True)
# Select a subset of the data to keep the best max_features in terms of
# pValue
subdf = df.query("number_in_list>@minimum_genes").copy()
logger.info(
"Filtering out GO terms with less than {} genes: Kept {} GO terms".
format(minimum_genes, len(subdf)))
logger.info("Filtering out the 3 parent terms")
subdf = subdf.query("id not in @self.ontologies")
# Keeping only a part of the data, sorting by pValue
if sort_by == "pValue":
subdf = subdf.sort_values(by="pValue",
ascending=False).iloc[-max_features:]
df = df.sort_values(by="pValue", ascending=False)
elif sort_by == "fold_enrichment":
subdf = subdf.sort_values(by="abs_log2_fold_enrichment",
ascending=True).iloc[-max_features:]
df = df.sort_values(by="abs_log2_fold_enrichment", ascending=False)
elif sort_by == "fdr":
subdf = subdf.sort_values(by="fdr",
ascending=False).iloc[-max_features:]
df = df.sort_values(by="fdr", ascending=False)
subdf = subdf.reset_index(drop=True)
# We get all levels for each go id.
# They are stored by MF, CC or BP
if compute_levels:
paths = self.get_graph(list(subdf['id'].values), progress=progress)
levels = []
keys = list(paths.keys())
goid_levels = paths[keys[0]]
if len(keys) > 1:
for k in keys[1:]:
goid_levels.update(paths[k])
levels = [goid_levels[ID] for ID in subdf['id'].values]
subdf["level"] = levels
else:
subdf['level'] = ""
N = len(subdf)
size_factor = 12000 / len(subdf)
max_size = subdf.number_in_list.max()
min_size = subdf.number_in_list.min()
sizes = [
max(max_size * 0.2, x) for x in size_factor *
subdf.number_in_list.values / subdf.number_in_list.max()
]
m1 = min(sizes)
m3 = max(sizes)
m2 = m1 + (m3 - m1) / 2
if log:
pylab.scatter(pylab.log2(subdf.fold_enrichment),
range(len(subdf)),
c=subdf.fdr,
s=sizes,
cmap=cmap,
alpha=0.8,
ec="k",
vmin=0,
vmax=fdr_threshold,
zorder=10)
#pylab.barh(range(N), pylab.log2(subdf.fold_enrichment), color="r",
# label="pvalue>0.05; FDR>0.05")
#pylab.axvline(1, color="gray", ls="--")
#pylab.axvline(-1, color="gray", ls="--")
else:
pylab.scatter(subdf.fold_enrichment,
range(len(subdf)),
c=subdf.fdr,
cmap=cmap,
s=sizes,
ec="k",
alpha=.8,
vmin=0,
vmax=fdr_threshold,
zorder=10)
# pylab.barh(range(N), subdf.fold_enrichment, color="r",
# label="not significant")
pylab.grid(zorder=-10)
ax2 = pylab.colorbar(shrink=0.5)
ax2.ax.set_ylabel('FDR')
labels = [
x if len(x) < 50 else x[0:47] + "..." for x in list(subdf.label)
]
ticks = [
"{} ({}) {}".format(ID, level, "; " + label.title())
for level, ID, label in zip(subdf['level'], subdf.id, labels)
]
pylab.yticks(range(N), ticks, fontsize=fontsize, ha='left')
yax = pylab.gca().get_yaxis()
try:
pad = [x.label.get_window_extent().width for x in yax.majorTicks]
yax.set_tick_params(pad=max(pad))
except:
yax.set_tick_params(pad=60 * fontsize * 0.7)
yax.set_tick_params(pad=60 * fontsize * 0.6)
fc_max = subdf.fold_enrichment.max(skipna=True)
fc_min = subdf.fold_enrichment.min(skipna=True)
# go into log2 space
fc_max = pylab.log2(fc_max)
fc_min = pylab.log2(fc_min)
abs_max = max(fc_max, abs(fc_min), 1)
if log:
fc_max = abs_max * 1.5
else:
fc_max = 2**abs_max * 1.2
pylab.axvline(0, color="k", lw=2)
if log:
pylab.xlabel("Fold Enrichment (log2)")
else:
pylab.xlabel("Fold Enrichment")
if include_negative_enrichment:
pylab.xlim([-fc_max, fc_max])
else:
pylab.xlim([0, fc_max])
pylab.tight_layout()
# The pvalue:
if show_pvalues:
ax = pylab.gca().twiny()
ax.set_xlim([0, max(-pylab.log10(subdf.pValue)) * 1.2])
ax.set_xlabel("p-values (log10)", fontsize=12)
ax.plot(-pylab.log10(subdf.pValue),
range(len(subdf)),
label="pvalue",
lw=2,
color="k")
ax.axvline(1.33, lw=1, ls="--", color="grey", label="pvalue=0.05")
pylab.tight_layout()
pylab.legend(loc="lower right")
s1 = pylab.scatter([], [], s=m1, marker='o', color='#555555', ec="k")
s2 = pylab.scatter([], [], s=m2, marker='o', color='#555555', ec="k")
s3 = pylab.scatter([], [], s=m3, marker='o', color='#555555', ec="k")
if len(subdf) < 10:
labelspacing = 1.5 * 4
borderpad = 4
handletextpad = 2
elif len(subdf) < 20:
labelspacing = 1.5 * 2
borderpad = 1
handletextpad = 2
else:
labelspacing = 1.5
borderpad = 2
handletextpad = 2
if len(subdf) >= 3:
leg = pylab.legend(
(s1, s2, s3),
(str(int(min_size)),
str(int(min_size +
(max_size - min_size) / 2)), str(int(max_size))),
scatterpoints=1,
loc='lower right',
ncol=1,
frameon=True,
title="gene-set size",
labelspacing=labelspacing,
borderpad=borderpad,
handletextpad=handletextpad,
fontsize=8)
else:
leg = pylab.legend((s1, ), (str(int(min_size)), ),
scatterpoints=1,
loc='lower right',
ncol=1,
frameon=True,
title="gene-set size",
labelspacing=labelspacing,
borderpad=borderpad,
handletextpad=handletextpad,
fontsize=8)
frame = leg.get_frame()
frame.set_facecolor('#b4aeae')
frame.set_edgecolor('black')
frame.set_alpha(1)
self.subdf = subdf
self.df = df
return df
