def accPlot(accsByNFeats):
plotdata = []
for s in accsByNFeats:
plotdata.append(
pd.concat([
pd.DataFrame({
"p": p,
"acc": accsByNFeats[s][p],
"set": s
},
index=[str(p)]) for p in accsByNFeats[s]
],
axis=0))
ggd = pd.concat(plotdata)
ggd['acc'] = ggd['acc'].astype(float)
ggo = gg.ggplot(ggd, gg.aes(x='p', y='acc', color='set'))
ggo += gg.geom_line(alpha=0.5)
ggo += gg.geom_point()
ggo += gg.theme_bw()
ggo += gg.scale_x_log10(breaks=[10, 100, 1000, 10000])
ggo += gg.scale_color_manual(
values=['darkgray', 'black', 'red', 'dodgerblue'])
ggo += gg.ylab('Accuracy (5-fold CV)')
print(ggo)
return ggd
def test_annotation_logticks_coord_flip():
p = (ggplot(df, aes('x', 'x')) + annotation_logticks(sides='b', size=.75) +
geom_point() + scale_x_log10() + scale_y_log10() + coord_flip() +
theme(panel_grid_minor=element_line(color='green'),
panel_grid_major=element_line(color='red')))
assert p == 'annotation_logticks_coord_flip'
def plot_ci_eval(df):
molten = pd.melt(df,
id_vars=['sample_size'],
value_vars=['bootstrap', 'ztest', 'ttest'])
return (ggplot(molten, aes(x='sample_size', y='value', color='variable')) +
geom_line() + scale_x_log10() + ylim(0, 1))
def scatter_plot(df,
xcol,
ycol,
domain,
xname=None,
yname=None,
log=False,
width=6,
height=6,
clamp=True,
tickCount=5):
assert len(domain) == 2
POINT_SIZE = 0.5
DASH_PATTERN = (0, (3, 1))
if xname == None:
xname = xcol
if yname == None:
yname = ycol
# formater for axes' labels
ax_formatter = mizani.custom_format('{:n}')
if clamp: # clamp overflowing values if required
df = df.copy(deep=True)
df.loc[df[xcol] > domain[1], xcol] = domain[1]
df.loc[df[ycol] > domain[1], ycol] = domain[1]
# generate scatter plot
scatter = p9.ggplot(df)
scatter += p9.aes(x=xcol, y=ycol)
scatter += p9.geom_point(size=POINT_SIZE, na_rm=True)
scatter += p9.labs(x=xname, y=yname)
if log: # log scale
scatter += p9.scale_x_log10(limits=domain, labels=ax_formatter)
scatter += p9.scale_y_log10(limits=domain, labels=ax_formatter)
else:
scatter += p9.scale_x_continuous(limits=domain, labels=ax_formatter)
scatter += p9.scale_y_continuous(limits=domain, labels=ax_formatter)
#scatter += p9.theme_xkcd()
scatter += p9.theme_bw()
scatter += p9.theme(
panel_grid_major=p9.element_line(color='#666666', alpha=0.5))
scatter += p9.theme(figure_size=(width, height))
# generate additional lines
scatter += p9.geom_abline(intercept=0, slope=1,
linetype=DASH_PATTERN) # diagonal
scatter += p9.geom_vline(xintercept=domain[1],
linetype=DASH_PATTERN) # vertical rule
scatter += p9.geom_hline(yintercept=domain[1],
linetype=DASH_PATTERN) # horizontal rule
res = scatter
return res
def test_annotation_logticks():
# The grid should align with the logticks
p = (ggplot(df, aes('x', 'x')) + annotation_logticks(sides='b', size=.75) +
geom_point() + scale_x_log10() + scale_y_log10() +
theme(panel_grid_minor=element_line(color='green'),
panel_grid_major=element_line(color='red')))
assert p == 'annotation_logticks'
def test_scale_transformed_breaks():
df = pd.DataFrame({'x': [1, 10, 100, 1000], 'y': range(4)})
p = (ggplot(df, aes('x', 'y')) +
geom_bin2d(breaks=([5, 50, 500], [0.5, 1.5, 2.5])))
out1 = layer_data(p)
out2 = layer_data(p + scale_x_log10())
np.testing.assert_allclose(out1.xmax, [50, 500])
np.testing.assert_allclose(out2.xmax, np.log10([50, 500]))
def test_annotation_logticks_coord_flip_discrete_bottom():
df2 = df.assign(discrete=pd.Categorical(['A' + str(a) for a in df['x']]))
p = (ggplot(df2, aes('x', 'discrete')) +
annotation_logticks(sides='b', size=.75) + geom_point() +
scale_x_log10() + coord_flip() +
theme(panel_grid_minor=element_line(color='green'),
panel_grid_major=element_line(color='red')))
assert p == 'annotation_logticks_coord_flip_discrete_bottom'
def scatter_plot2(df1, df2, xcol, ycol, domain, color1='black', color2='red', xname=None, yname=None, log=False, width=6, height=6, clamp=True, tickCount=5):
assert len(domain) == 2
POINT_SIZE = 1.5
DASH_PATTERN = (0, (6, 2))
if xname is None:
xname = xcol
if yname is None:
yname = ycol
# formatter for axes' labels
ax_formatter = mizani.custom_format('{:n}')
if clamp: # clamp overflowing values if required
df1 = df1.copy(deep=True)
df1.loc[df1[xcol] > domain[1], xcol] = domain[1]
df1.loc[df1[ycol] > domain[1], ycol] = domain[1]
df2 = df2.copy(deep=True)
df2.loc[df2[xcol] > domain[1], xcol] = domain[1]
df2.loc[df2[ycol] > domain[1], ycol] = domain[1]
# generate scatter plot
scatter = p9.ggplot(df1)
scatter += p9.aes(x=xcol, y=ycol)
scatter += p9.geom_point(size=POINT_SIZE, na_rm=True, color=color1, alpha=0.5)
scatter += p9.geom_point(size=POINT_SIZE, na_rm=True, data=df2, color=color2, alpha=0.5)
scatter += p9.labs(x=xname, y=yname)
# rug plots
scatter += p9.geom_rug(na_rm=True, sides="tr", color=color1, alpha=0.05)
scatter += p9.geom_rug(na_rm=True, sides="tr", data=df2, color=color2, alpha=0.05)
if log: # log scale
scatter += p9.scale_x_log10(limits=domain, labels=ax_formatter)
scatter += p9.scale_y_log10(limits=domain, labels=ax_formatter)
else:
scatter += p9.scale_x_continuous(limits=domain, labels=ax_formatter)
scatter += p9.scale_y_continuous(limits=domain, labels=ax_formatter)
# scatter += p9.theme_xkcd()
scatter += p9.theme_bw()
scatter += p9.theme(panel_grid_major=p9.element_line(color='#666666', alpha=0.5))
scatter += p9.theme(panel_grid_minor=p9.element_blank())
scatter += p9.theme(figure_size=(width, height))
scatter += p9.theme(text=p9.element_text(size=24, color="black"))
# generate additional lines
scatter += p9.geom_abline(intercept=0, slope=1, linetype=DASH_PATTERN) # diagonal
scatter += p9.geom_vline(xintercept=domain[1], linetype=DASH_PATTERN) # vertical rule
scatter += p9.geom_hline(yintercept=domain[1], linetype=DASH_PATTERN) # horizontal rule
res = scatter
return res
def plot_scaling_log(plt_df: pd.DataFrame,
sweep_vars: Optional[Sequence[str]] = None,
with_baseline=True) -> gg.ggplot:
"""Plot scaling of learning time against exponential baseline."""
p = _base_scaling(plt_df, sweep_vars, with_baseline)
p += gg.scale_x_log10(breaks=[5, 10, 20, 50])
p += gg.scale_y_log10(breaks=[100, 300, 1000, 3000, 10000, 30000])
p += gg.xlab('deep sea problem size (log scale)')
p += gg.ylab('#episodes until < 90% bad episodes (log scale)')
return plotting.facet_sweep_plot(p, sweep_vars)
def plot_compare(stats,
variant,
variant_baseline,
metric,
mode="identity",
jitter=0.01):
assert mode in ["identity", "ratio", "difference"]
plotdata = compare_stats(stats, variant, variant_baseline)
bsw = bsw_table2(plotdata, metric=metric, reltol=1.0)
display(bsw)
baseline_name = f"{metric}_baseline"
plotdata = plotdata[[metric, baseline_name, "dataset"]].assign(
ratio=plotdata[metric] / plotdata[baseline_name],
difference=plotdata[metric] - plotdata[baseline_name],
)
if mode == "identity":
return (ggplot(data=plotdata) + geom_jitter(
aes(x=f"{metric}_baseline", y=metric, fill="dataset"),
width=jitter,
height=jitter,
) + scale_x_log10() + scale_y_log10() +
geom_abline(aes(slope=1, intercept=0)))
elif mode == "ratio":
return (
ggplot(data=plotdata) + geom_jitter(
aes(x=f"{metric}_baseline", y="ratio", fill="dataset"),
width=jitter,
height=jitter,
) + scale_x_log10() + scale_y_log10()
## ablines are drawn wrt the already log-transformed axes. hence 0 = log(1) in scale
+ geom_abline(aes(slope=0, intercept=0.0)) +
geom_abline(aes(slope=-1, intercept=0.0)) # max
)
elif mode == "difference":
return (ggplot(data=plotdata) + geom_jitter(
aes(x=f"{metric}_baseline", y="difference", fill="dataset"),
width=jitter,
height=jitter,
) + scale_x_log10() + scale_y_log10() +
geom_abline(aes(slope=0, intercept=0)))
else:
assert False, "unknown mode"
def test_scale_transformed_breaks():
df = pd.DataFrame({
'x': [1, 10, 100, 1000],
'y': range(4)
})
p = (ggplot(df, aes('x', 'y'))
+ geom_bin2d(breaks=([5, 50, 500], [0.5, 1.5, 2.5]))
)
out1 = layer_data(p)
out2 = layer_data(p + scale_x_log10())
np.testing.assert_allclose(out1.xmax, [50, 500])
np.testing.assert_allclose(out2.xmax, np.log10([50, 500]))
def test_annotation_logticks_faceting():
n = len(df)
df2 = pd.DataFrame({
'x': np.hstack([df['x'], df['x']]),
'g': list('a' * n + 'b' * n)
})
p = (ggplot(df2) + annotation_logticks(sides='b', size=.75) +
geom_point(aes('x', 'x')) + scale_x_log10() + scale_y_log10() +
facet_wrap('g') + theme(panel_grid_minor=element_line(color='green'),
panel_grid_major=element_line(color='red')))
assert p == 'annotation_logticks_faceting'
def plot_replicates_log_axes(self):
"""
Plots replicate traces from a single run on logarithmic axes to determine the baseline metabolic charge production
or other stabilization.
"""
from plotnine import ggplot, ylab, xlab, geom_line, aes, scale_y_log10, scale_x_log10
plot = ((ggplot(self.data, aes('Time', 'Current', color='Channel')) +
ylab(u'Current (μA)') + xlab('Time (seconds)') + geom_line() +
scale_y_log10() + scale_x_log10()))
print(plot)
return plot
def make_plot(name):
df = pd.read_csv(f'small_n/results/{name}.csv')
molten = pd.melt(
df,
id_vars=['sample_size'],
value_vars=['bootstrap', 'ztest', 'ttest'],
var_name='method',
value_name='success',
)
(ggplot(molten, aes(x='sample_size', y='success', color='method')) +
geom_line(size=1) + scale_x_log10() + ylim(0, 1) + geom_hline(
yintercept=0.95, linetype='dotted', color='#FF5500', size=3)).save(
f'slides/static/plots/{name}.png',
height=7.0,
width=10,
units='in')
def plot_regret_ave_scaling(df_in: pd.DataFrame,
group_col: str,
episode: int,
regret_thresh: float,
sweep_vars: Sequence[str] = None,
regret_col: str = 'total_regret') -> gg.ggplot:
"""Point plot of average regret investigating scaling to threshold."""
df = _preprocess_ave_regret(df_in, group_col, episode, sweep_vars, regret_col)
group_name = group_col.replace('_', ' ')
p = (gg.ggplot(df)
+ gg.aes(x=group_name, y='average_regret',
colour='average_regret < {}'.format(regret_thresh))
+ gg.geom_point(size=5, alpha=0.8)
+ gg.scale_x_log10(breaks=[1, 3, 10, 30, 100])
+ gg.scale_colour_manual(values=['#d73027', '#313695'])
+ gg.ylab('average regret at {} episodes'.format(episode))
+ gg.geom_hline(gg.aes(yintercept=0.0), alpha=0) # axis hack
)
return facet_sweep_plot(p, sweep_vars)
def accPlot(accsByNFeats):
plotdata = []
for s in accsByNFeats:
plotdata.append(pd.concat([DataFrame({"p" : p,
"acc" : accsByNFeats[s][p],
"set" : s},
index = [str(p)])
for p in accsByNFeats[s]],
axis = 0))
ggd = pd.concat(plotdata)
ggd['acc'] = ggd['acc'].astype(float)
ggo = gg.ggplot(ggd, gg.aes(x='p', y='acc', color='set'))
ggo += gg.geom_line(alpha=0.5)
ggo += gg.geom_point()
ggo += gg.theme_bw()
ggo += gg.scale_x_log10(breaks=[10, 100, 1000, 10000])
ggo += gg.scale_color_manual(values=['darkgray', 'black',
'red', 'dodgerblue'])
ggo += gg.ylab('Accuracy (5-fold CV)')
print(ggo)
def kernel_stats(inFile, log_scale=True):
par = get_params(inFile)
n_kernel = 0
for var in sorted(par["means"]):
n_kernel += "mus_f" in var
tf = pm.distributions.transforms.StickBreaking()
dfs = list()
for tissue_type in ["t", "f"]:
weights = tf.backward(
par["means"][f"w_{tissue_type}_stickbreaking__"]).eval()
n_dim = par["means"][f"x_{tissue_type}"].shape[1]
volumes = list()
for kernel in range(n_kernel):
# get covariance elipse parameters
packed_cov = par["means"][
f"packed_L_{tissue_type}_{kernel}_cholesky-cov-packed__"]
lower = pm.expand_packed_triangular(n_dim, packed_cov,
lower=True).eval()
cov = np.dot(lower, lower.T)
volume = np.linalg.det(cov)
volumes.append(volume)
type_df = pd.DataFrame(
{
"tissue": "tumor" if tissue_type == "t" else "non-tumor",
"weight": weights,
"volume": volumes,
},
index=[f"kernel {i}" for i in range(n_kernel)],
)
dfs.append(type_df)
df = pd.concat(dfs)
pl = (pn.ggplot(pn.aes("volume", "weight", color="tissue"), df) +
pn.geom_point())
if log_scale:
pl += pn.scale_y_log10()
pl += pn.scale_x_log10()
pl += pn.theme_minimal()
return pl, df
def plot(self,
plotDat,
tag=None,
log=True,
by='cell_type',
data_set=None,
title=None,
alpha=.4):
pDat = plotDat.copy()
gcorr = pearsonr(pDat.measured, pDat.prediction)[0]
corrs = pDat.groupby(
pDat[by]).apply(lambda x: pearsonr(x.measured, x.prediction)[0])
pDat['corr'] = corrs[pDat[by]].values
by_str = '{}_pearson'.format(by)
pDat[by_str] = pDat.apply(
lambda x: '{} {:.2f}'.format(x[by], corrs[x[by]]), axis=1)
if data_set:
pDat = pDat.loc[pDat['dataset_name'] == data_set]
pl = (pn.ggplot(pn.aes('measured', 'prediction', color=by_str), pDat) +
pn.geom_point(alpha=alpha) + pn.stat_smooth(mapping=pn.aes(
'measured', 'prediction', color=by_str),
method='lm',
geom='line',
alpha=0.5,
se=False,
inherit_aes=False))
if len(pDat['sample'].unique()) < 10:
pl = pl + pn.aes(shape='sample')
else:
pl = pl + pn.aes(shape='dataset_name')
if log is True:
pl = pl + pn.scale_x_log10() + pn.scale_y_log10()
if title is not None:
pl = pl + pn.ggtitle(title)
elif tag is not None:
pl = pl + pn.ggtitle('{} pearson={}'.format(tag, gcorr))
else:
pl = pl + pn.ggtitle('pearson={}'.format(gcorr))
return pl
def _scale_x(self):
return scale_x_log10()
x['k'],
x['resubAccuracy'],
x['testAccuracy'])
for x in repeatedKnnResults],
columns = ['p',
'k',
'resubAccuracy',
'testAccuracy'])
ggdata = pd.concat(
[DataFrame({'p' : knnResultsSimplified.p,
'k' : knnResultsSimplified.k.apply(int),
'type' : 'resub',
'Accuracy' : knnResultsSimplified.resubAccuracy}),
DataFrame({'p' : knnResultsSimplified.p,
'k' : knnResultsSimplified.k.apply(int),
'type' : 'test',
'Accuracy' : knnResultsSimplified.testAccuracy})],
axis = 0
)
plt.close()
ggo = gg.ggplot(ggdata, gg.aes(x='p', y='Accuracy',
color='type', group='type', linetype='type'))
ggo += gg.facet_wrap('~ k')
ggo += gg.scale_x_log10()
ggo += gg.geom_point(alpha=0.6)
ggo += gg.stat_smooth()
ggo += gg.theme_bw()
print(ggo)
def plot_violinbox_plots_per_category(
dataframe: pandas.DataFrame,
plot_type: str,
target_feature: str,
label_column: str,
colors: List[str],
coloring_style: str,
value_skip_list: List = [],
jitter_alpha: float = 0.7,
plot_alpha: float = 0.5,
log_10_scale: bool = False,
theme: str = 'gray',
save_to_file: str = None,
dpi: int = 150,
show: bool = True
) -> p9.ggplot:
"""
The :func:`plot_violinbox_plots_per_category` helps with providing the user with nicely plotted violin and
box plots of the distribution of data points.
Parameters
----------
dataframe: `pandas.DataFrame`, required
This is the main parameter that this method is supposed to work with, which is a dataframe that has
a label column in which we have integer values starting from 0, and a float feature column the distribution
of which we tend to monitor.
plot_type: `str`, required
This value, either `box` or `violin`, determines the type of plot.
target_feature: `str`, required
This parameter is the column name of the features that we want to monitor.
label_column: `str`, required
The input dataframe must have a label_column (preferably integer starting from 0), the name of that
column should be input here.
colors: `List[str]`, required
Depending on whether or not our `coloring_style` is manual or automatic, this can either be a list of colors
or a list of two colors indicating a range of color values.
coloring_style: `str`, optional (default='manual')
Either `manual` or `gradient` which helps assigning colors to clusters.
value_skip_list: `List`, optional (default=[])
If some values in the feature column are to be skipped, they should be put in here so that they
are ignored in the plots. For example, if for some reason some values are -10000000, they can be taken care
of in here.
jitter_alpha: `float`, optional (default=0.7)
The jitter value transparency is set in this parameter.
plot_alpha: `float`, optional (default=0.5)
The transparency intensity can be determined by setting this parameter.
log_10_scale: `bool`, optional (default=False)
If the user wants to take the logarithm in the basis of 10, this parameter should be set to 1.
theme: `str`, optional (default='gray')
This is the `theme` types, the acceped values are: ``['gray', 'dark', 'seaborn', 'light']``, the values
are consistent with `plotnine` package's format.
save_to_file: `str`, optional (default=None)
If the user intends to save the plot in a file, this parameter should have a value. The value must be a filepath.
dpi: `int`, optional (default=150)
The dpi for saving the plots indicating the image quality.
show: `bool`, optional (default=True)
Whether or not the plot is to be shown is set in this parameter.
Returns
----------
The output of this method is of `p9.ggplot` type.
"""
if len(value_skip_list) > 0:
df = dataframe[~dataframe[target_feature].isin(value_skip_list)]
if coloring_style == 'gradient':
assert len(colors) == 2, "you have chosen gradient style coloring, for colors you have to provide a list with the \
First element being the color for low and the second the color for high."
pplot = p9.ggplot(data=dataframe, mapping=p9.aes(x='factor(' + label_column + ')', y=target_feature, color=label_column))
pplot += p9.scale_color_gradient(low=colors[0], high=colors[1])
elif coloring_style == 'manual':
assert len(colors) == len(df[label_column].unique()), "You have chosen per category manual coloring, therefore you have to provide the same number of colors"
pplot = p9.ggplot(data=dataframe, mapping=p9.aes(x='factor(' + label_column + ')', y=target_feature, color='factor(' + label_column + ')'))
pplot += p9.scale_alpha_manual(colors)
pplot += p9.geom_jitter(alpha=jitter_alpha)
if plot_type == 'box':
pplot += p9.geom_boxplot(alpha=plot_alpha)
elif plot_type == 'violin':
pplot += p9.geom_violin(alpha=plot_alpha)
else:
raise Exception('unknown plot type, it must be violin or box.')
if theme == 'gray':
pplot += p9.theme_gray()
elif theme == 'dark':
pplot += p9.theme_dark()
elif theme == 'seaborn':
pplot += p9.theme_seaborn()
elif theme == 'light':
pplot += p9.theme_light()
else:
raise Exception('Theme type not supported, please add.')
if log_10_scale:
pplot += p9.scale_x_log10()
if save_to_file is not None:
save_directory, filename = separate_path_and_file(filepath=save_to_file)
pplot.save(filename=filename, path=save_directory, dpi=dpi)
if show:
pplot.draw()
return pplot
df['feature_set'] = model
cv_results_df = cv_results_df.append(df)
cv_results_summary = (cv_results_df
.groupby(['classify__alpha', 'feature_set'])['mean_test_score']
.max()
.reset_index())
# In[17]:
(gg.ggplot(cv_results_summary, gg.aes(x='classify__alpha',
y='mean_test_score',
color='feature_set'))
+ gg.geom_jitter(size=4, alpha=0.8, height=0, width=0.05)
+ gg.scale_x_log10()
+ gg.labs(x='Regularization strength multiplier (log alpha)',
y='CV AUROC')
+ gg.guides(fill=gg.guide_legend(title="Feature Set"))
+ gg.aes(ymin=min([0.5, cv_results_summary['mean_test_score'].min()]), ymax=1)
+ theme_cognoma()
)
# ## Use optimal hyperparameters to output ROC curve
# In[18]:
y_pred_dict = {
model: {
'train': pipeline.decision_function(X_train),
def _scale_x(self, xmin: float = None, xmax: float = None):
return scale_x_log10(limits=(xmin, xmax))
pd.DataFrame(pipeline.cv_results_),
pd.DataFrame.from_records(pipeline.cv_results_['params'])
],
axis='columns')
df['feature_set'] = model
cv_results_df = cv_results_df.append(df)
cv_results_summary = (cv_results_df.groupby(
['classify__alpha', 'feature_set'])['mean_test_score'].max().reset_index())
# In[17]:
(gg.ggplot(
cv_results_summary,
gg.aes(x='classify__alpha', y='mean_test_score', color='feature_set')) +
gg.geom_jitter(size=4, alpha=0.8, height=0, width=0.05) + gg.scale_x_log10() +
gg.labs(x='Regularization strength multiplier (log alpha)', y='CV AUROC') +
gg.guides(fill=gg.guide_legend(title="Feature Set")) +
gg.aes(ymin=min([0.5, cv_results_summary['mean_test_score'].min()]), ymax=1) +
theme_cognoma())
# ## Use optimal hyperparameters to output ROC curve
# In[18]:
y_pred_dict = {
model: {
'train': pipeline.decision_function(X_train),
'test': pipeline.decision_function(X_test)
}
for model, pipeline in cv_pipelines.items()
g = 'T'
ens = adata.var[adata.var.SYMBOL == "T"].ENSEMBL[0]
adata.obs['T_counts'] = adata[:, ens].X.toarray()[:, 0]
adata.obs['T_logcounts'] = adata[:, ens].layers.get("logcounts").toarray()[:,
0]
adata.obs['T_smoothed'] = adata[:,
ens].layers.get("scvi_normalised").toarray()[:,
0]
adata.obs['T_smoothed_lc'] = np.log2(adata.obs['T_smoothed'] + 1)
count_hist = adata.obs[f'{g}_counts'].value_counts().reset_index().rename(
columns={'index': 'counts'})
p.options.figure_size = 6, 2
plot_ = (p.ggplot(p.aes(x='counts', y=f'{g}_counts'),
count_hist.query('0 < counts < 25')) +
p.geom_bar(stat='identity') + p.scale_x_log10() + p.theme_minimal() +
p.labs(x=f'{g} UMI counts', y='Number cells'))
plot_.save('mgast_T_counts.pdf', verbose=False)
count_hist = adata.obs[f'{g}_logcounts'].value_counts().reset_index().rename(
columns={'index': 'logcounts'})
p.options.figure_size = 6, 2
plot_ = (
p.ggplot(p.aes(x='logcounts'), count_hist.query('0 < logcounts < 25')) +
p.geom_histogram(bins=128, color="k", fill="w") + p.scale_x_log10() +
p.theme_minimal() + p.labs(x=f'{g} UMI logcounts', y='Number cells'))
plot_.save('mgast_T_logcounts.pdf', verbose=False)
count_hist = adata.obs[f'{g}_smoothed_lc'].value_counts().reset_index().rename(
columns={'index': 'smoothed_lc'})
p.options.figure_size = 6, 2
def plot_2d_distribution_per_category(
dataframe: pandas.DataFrame,
label_column: str,
coordinates: Tuple[str],
colors: List[str],
coloring_style: str = 'manual',
log_10_scale: bool = False,
theme: str = 'gray',
alpha: float = 0.5,
save_to_file: str = None,
dpi: int = 150
) -> p9.ggplot:
"""
The :func:`plot_2d_distribution_per_category` helps with providing the user with a 2-dimensional plot of the
whole distribution.
Parameters
----------
dataframe: `pandas.DataFrame`, required
This is the main parameter that this method is supposed to work with, which is a dataframe with a label column
(which is to help us determine the column) and coordinates for x and y axes.
label_column: `str`, required
The input dataframe must have a label_column (preferably integer starting from 0), the name of that
column should be input here.
coordinates: `Tuple[str]`, required
This is a tuple of column names, the first one being the column in which the `x` values for our 2d plot
are stored, and the other one corresponds to the `y` axis.
colors: `List[str]`, required
Depending on whether or not our `coloring_style` is manual or automatic, this can either be a list of colors
or a list of two colors indicating a range of color values.
coloring_style: `str`, optional (default='manual')
Either `manual` or `gradient` which helps assigning colors to clusters.
log_10_scale: `bool`, optional (default=False)
If the user wants to take the logarithm in the basis of 10, this parameter should be set to 1.
theme: `str`, optional (default='gray')
This is the `theme` types, the acceped values are: ``['gray', 'dark', 'seaborn', 'light']``, the values
are consistent with `plotnine` package's format.
alpha: `float`, optional (default=0.5)
The transparency intensity can be determined by setting this parameter.
save_to_file: `str`, optional (default=None)
If the user intends to save the plot in a file, this parameter should have a value. The value must be a filepath.
dpi: `int`, optional (default=150)
The dpi for saving the plots indicating the image quality.
Returns
----------
The output of this method is of `p9.ggplot` type.
"""
assert coloring_style in ['manual', 'gradient'], "invalid coloring style"
if coloring_style == 'gradient':
assert len(colors) == 2, "you have chosen gradient style coloring, for colors you have to provide a list with the \
First element being the color for low and the second the color for high."
pplot = p9.ggplot(data=dataframe, mapping=p9.aes(x=coordinates[0], y=coordinates[1], color=label_column))
pplot += p9.scale_color_gradient(low=colors[0], high=colors[1])
elif coloring_style == 'manual':
assert len(colors) == len(dataframe[label_column].unique()), "You have chosen per category manual coloring, therefore you have to provide the same number of colors"
pplot = p9.ggplot(data=dataframe, mapping=p9.aes(x=coordinates[0], y=coordinates[1], color='factor(' + label_column + ')'))
pplot += p9.scale_alpha_manual(colors)
pplot += p9.geom_point(alpha=alpha)
pplot += p9.xlab(coordinates[0]) + p9.ylab(coordinates[1])
if log_10_scale:
pplot += p9.scale_x_log10()
if theme == 'gray':
pplot += p9.theme_gray()
elif theme == 'dark':
pplot += p9.theme_dark()
elif theme == 'seaborn':
pplot += p9.theme_seaborn()
elif theme == 'light':
pplot += p9.theme_light()
else:
raise Exception('Theme type not supported, please add.')
pplot += p9.theme(text=p9.element_text(size=8))
if save_to_file is not None:
save_directory, filename = separate_path_and_file(filepath=save_to_file)
pplot.save(filename=filename, path=save_directory, dpi=dpi)
else:
pplot.draw()
return pplot
def rel_plot(sbs, variant, jitter=0.01):
plotdata = sbs[sbs.variant == variant]
xcol = "base"
ycol = "ratio"
plotdata = plotdata.assign(x=plotdata[xcol], y=plotdata[ycol])
plotdata = plotdata.assign(sbs_index=plotdata.index.values)
session_text = (plotdata[["session_index", "base_session_index"]].apply(
tuple, axis=1).map(lambda tup: f"{tup[0]} vs. {tup[1]}"))
plotdata = plotdata.assign(session_text=session_text)
x = np.geomspace(0.02, 1, num=5)
y = 1 / x
diag_df = pd.DataFrame({"x": x, "y": y})
scatterplot = (
ggplot(plotdata) + geom_jitter(
aes(x="x", y="y", fill="dataset", color="dataset"),
width=jitter,
height=jitter,
alpha=0.6,
size=1.0,
)
# shape=plotdata.dataset.map(lambda x : '.' if x in ['lvis','objectnet'] else 'o'),
# size=plotdata.dataset.map(lambda x : 1. if x in ['lvis','objectnet'] else 2.))
# + geom_text(aes(x='base', y='delta', label='category', color='dataset'), va='bottom',
# data=plotdata1[plotdata1.ratio < .6],
# position=position_jitter(.05, .05), show_legend=False)
+ geom_line(aes(x="x", y="y"), data=diag_df)
# + geom_text(aes(x='x', y='y', label='session_text'), va='top', data=plotdata[(plotdata.y < .4) | (plotdata.y > 3)])
+ ylab(ycol)
# + geom_area(aes(y2=1.1, y=.9), linetype='dashed', alpha=.7)
+ geom_hline(aes(yintercept=1.1), linetype="dashed", alpha=0.7) +
geom_hline(aes(yintercept=0.9), linetype="dashed", alpha=0.7) +
geom_vline(
aes(xintercept=0.1, ),
linetype="dashed",
alpha=0.7,
) + geom_vline(
aes(xintercept=0.3, ),
linetype="dashed",
alpha=0.7,
)
# + geom_abline()
# + geom_point(aes(x='recall', y='precision', color='variant'), size=1.)
# + facet_wrap(facets=['cat'], ncol=6, scales='free_x')
+ xlab(xcol)
# +scale_color_discrete()
+ theme(
figure_size=(8, 5),
legend_position="top",
subplots_adjust={"hspace": 0.5},
legend_title=element_blank(),
legend_box_margin=-1,
legend_margin=0.0,
axis_text=element_text(size=12, margin={
"t": 0.2,
"l": -0.3
}),
legend_text=element_text(size=11),
axis_title=element_text(size=12,
margin={
"r": -0.2,
"b": 0.0,
"l": 0,
"t": 0.0
}),
) + scale_x_log10(labels=make_labeler(brief_format),
breaks=[0.01, 0.1, 0.3, 1.0]) +
scale_y_log10(labels=make_labeler(brief_format),
breaks=[0.5, 0.9, 1.1, 2.0, 3.0, 6, 12]))
return scatterplot
package_reader = PackageReader()
package_features = package_reader.read_features()
print("packages loaded!")
class_reader = ClassReader()
class_features = class_reader.read_features()
print("classes loaded!")
(
ggplot(project_features, aes('loc_sum'))
+ geom_histogram(bins=100)
+ facet_grid('is_pattern_project ~ .')
+ scale_x_log10(breaks=[1, 10, 100, 1000, 10000, 100000, 1000000, 10000000])
+ scale_y_continuous(labels=lambda l: ["%.2f%%" % (v * 100 / len(project_features)) for v in l])
+ xlab("Lines of Code")
+ ylab("Percent of Projects")
).save('projects_histogram.png')
print("projects drawn!")
(
ggplot(package_features, aes('loc_sum'))
+ geom_histogram(bins=100)
+ facet_grid('is_pattern_pakkage ~ .')
+ scale_x_log10(breaks=[1, 10, 100, 1000, 10000, 100000, 1000000, 10000000])
+ scale_y_continuous(labels=lambda l: ["%.2f%%" % (v * 100 / len(package_features)) for v in l])
+ xlab("Lines of Code")
+ ylab("Percent of Packages")
# Save
res.to_csv(FIGURE_DIRECTORY + "crm_res.tsv", sep='\t')
peakstats.to_csv(FIGURE_DIRECTORY + "peakstats.tsv", sep='\t')
"""
# To reload :
res = pd.read_csv(FIGURE_DIRECTORY+"crm_res.tsv", sep = '\t')
peakstats = pd.read_csv(FIGURE_DIRECTORY+"peakstats.tsv", sep = '\t')
"""
## --------- For the figures
p = (ggplot(data=res[0:10000],
mapping=aes(x='nb_peaks_2020', y='nb_peaks_2018')) +
geom_point(mapping=aes(color='average_atypeak_score')) +
scale_x_log10() + scale_y_log10() +
labs(x="Nb. peaks Remap 2020",
y="Nb. peaks Remap 2018",
color="Mean atyPeak score per CRM") +
scale_color_gradient(low="red", high="blue"))
p.save(FIGURE_DIRECTORY + "crm_nb_peaks_update.pdf", verbose=False)
p = (ggplot(data=res[10000:13000],
mapping=aes(x='nb_peaks_2018', y='update_ratio')) +
geom_point(mapping=aes(color='average_atypeak_score')) +
scale_x_log10() + scale_y_log10() +
labs(x="Nb. peaks Remap 2018",
y="Nb peaks ReMap 2020/2018",
color="Mean atyPeak score per CRM") +
scale_color_gradient(low="red", high="blue"))
p.save(FIGURE_DIRECTORY + "crm_update_ratio.pdf", verbose=False)
