def scatter_length_cov_gc(self, min_length=200, min_cov=10):
pylab.clf()
pylab.scatter(self.df.length, self.df['cov'], c=self.df.GC)
pylab.loglog()
pylab.axvline(min_length, lw=2, c="r", ls='--')
pylab.axhline(min_cov, lw=2, c="r", ls='--')
pylab.xlabel("contig length")
pylab.ylabel("contig coverage")
pylab.colorbar(label="GC")
pylab.grid(True)
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 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 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_scatter_contig_length_nread_cov(self,
fontsize=16,
vmin=0,
vmax=50,
min_nreads=20,
min_length=50000):
if self._df is None:
_ = self.get_df()
pylab.clf()
df = self._df
m1 = df.length.min()
M1 = df.length.max()
# least square
X = df.query("nread>@min_nreads and length>@min_length")['length']
Y = df.query("nread>@min_nreads and length>@min_length")['nread']
Z = df.query("nread>@min_nreads and length>@min_length")['covStat']
print(X)
print(Y)
print(Z)
A = np.vstack([X, np.ones(len(X))]).T
m, c = np.linalg.lstsq(A, Y.as_matrix())[0]
x = np.array([m1, M1])
X = df['length']
Y = df['nread']
Z = df['covStat']
pylab.scatter(X, Y, c=Z, vmin=vmin, vmax=vmax)
pylab.colorbar()
pylab.xlabel("Contig length", fontsize=fontsize)
pylab.ylabel("Contig reads", fontsize=fontsize)
pylab.title("coverage function of contig length and reads used")
pylab.grid()
pylab.plot(x, m * x + c, "o-r")
pylab.loglog()
pylab.tight_layout()
def plot(self,
bins=100,
cmap="hot_r",
fontsize=10,
Nlevels=4,
xlabel=None,
ylabel=None,
norm=None,
range=None,
normed=False,
colorbar=True,
contour=True,
grid=True,
**kargs):
"""plots histogram of mean across replicates versus coefficient variation
:param int bins: binning for the 2D histogram (either a float or list
of 2 binning values).
:param cmap: a valid colormap (defaults to hot_r)
:param fontsize: fontsize for the labels
:param int Nlevels: must be more than 2
:param str xlabel: set the xlabel (overwrites content of the dataframe)
:param str ylabel: set the ylabel (overwrites content of the dataframe)
:param norm: set to 'log' to show the log10 of the values.
:param normed: normalise the data
:param range: as in pylab.Hist2D : a 2x2 shape [[-3,3],[-4,4]]
:param contour: show some contours (default to True)
:param bool grid: Show unerlying grid (defaults to True)
If the input is a dataframe, the xlabel and ylabel will be populated
with the column names of the dataframe.
"""
X = self.df[self.df.columns[0]].values
Y = self.df[self.df.columns[1]].values
if len(X) > 10000:
logger.info("Computing 2D histogram. Please wait")
pylab.clf()
if norm == 'log':
from matplotlib import colors
res = pylab.hist2d(X,
Y,
bins=bins,
density=normed,
cmap=cmap,
norm=colors.LogNorm())
else:
res = pylab.hist2d(X,
Y,
bins=bins,
cmap=cmap,
density=normed,
range=range)
if colorbar is True:
pylab.colorbar()
if contour:
try:
bins1 = bins[0]
bins2 = bins[1]
except:
bins1 = bins
bins2 = bins
X, Y = pylab.meshgrid(res[1][0:bins1], res[2][0:bins2])
if contour:
if res[0].max().max() < 10 and norm == 'log':
pylab.contour(X, Y, res[0].transpose())
else:
levels = [
round(x) for x in pylab.logspace(
0, pylab.log10(res[0].max().max()), Nlevels)
]
pylab.contour(X, Y, res[0].transpose(), levels[2:])
#pylab.clabel(C, fontsize=fontsize, inline=1)
if ylabel is None:
ylabel = self.df.columns[1]
if xlabel is None:
xlabel = self.df.columns[0]
pylab.xlabel(xlabel, fontsize=fontsize)
pylab.ylabel(ylabel, fontsize=fontsize)
if grid is True:
pylab.grid(True)
return res
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
