def scatter_soundstats(results, legend=False, manual_lims=False):
# HACK to get separate markers for batch 263 noisy vs clean dsounds
voc_in_noise = False
for k in results:
if '0dB' in k:
voc_in_noise = True
break
if voc_in_noise:
clean_means = []
clean_sds = []
noisy_means = []
noisy_sds = []
for k, (mean, sd) in results.items():
if '0dB' in k:
noisy_means.append(mean)
noisy_sds.append(sd)
else:
clean_means.append(mean)
clean_sds.append(sd)
fig = plt.figure(figsize=small_fig)
plt.scatter(clean_sds, clean_means, color='black',
s=big_scatter, label='clean')
plt.scatter(noisy_sds, noisy_means, color=model_colors['combined'],
s=small_scatter, label='noisy')
if legend:
plt.legend()
if manual_lims:
plt.xlim(0,32)
plt.ylim(0,65)
else:
means = []
sds = []
for k, (mean, sd) in results.items():
means.append(mean)
sds.append(sd)
fig = plt.figure(figsize=small_fig)
plt.scatter(sds, means, color='black', s=big_scatter)
if manual_lims:
plt.xlim(0,32)
plt.ylim(0,65)
plt.tight_layout()
ax_remove_box()
return fig
def scatter_bar(batches, modelnames, stest=SIG_TEST_MODELS, axes=None):
if axes is None:
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(3.5, 6))
else:
ax1, ax2 = axes
cellids = [
get_significant_cells(batch, stest, as_list=True) for batch in batches
]
r_values = [
nd.batch_comp(batch, modelnames, cellids=cells, stat=PLOT_STAT)
for batch, cells in zip(batches, cellids)
]
all_r_values = pd.concat(r_values)
# NOTE: if ALL_FAMILY_MODELS changes, the 3, 2 indices will need to be updated
# Scatter Plot -- LN vs c1dx2+d
ax1.scatter(all_r_values[modelnames[3]],
all_r_values[modelnames[2]],
s=2,
c='black')
ax1.plot([[0, 0], [1, 1]], c='black', linestyle='dashed', linewidth=1)
ax_remove_box(ax1)
#set_equal_axes(ax1)
ax1.set_ylim(0, 1)
ax1.set_xlim(0, 1)
ax1.set_xlabel('LN_pop prediction accuracy')
ax1.set_ylabel('conv1Dx2 prediction accuracy')
# Bar Plot -- Median for each model
# NOTE: ordering of names is assuming ALL_FAMILY_MODELS is being used and has not changed.
short_names = ['conv2d', 'conv1d', 'conv1dx2+d', 'LN_pop', 'dnn1_single']
bar_colors = [DOT_COLORS[k] for k in short_names]
ax2.bar(np.arange(0, len(modelnames)),
all_r_values.median(axis=0).values,
color=bar_colors,
tick_label=short_names)
ax_remove_box(ax2)
ax2.set_ylabel('Median Prediction Accuracy')
ax2.set_xticklabels(ax2.get_xticklabels(), rotation='45', ha='right')
fig = plt.gcf()
fig.tight_layout()
return ax1, ax2
def _stacked_hists(var1, var2, m1, m2, c1, c2, bin_count=30, hist_kwargs={}):
#c1: LN, c2: max
fig, (a1, a2) = plt.subplots(2, 1, sharex=True, sharey=True)
w1 = [np.ones(len(var1)) / len(var1)]
w2 = [np.ones(len(var2)) / len(var2)]
upper = max(var1.max(), var2.max())
lower = min(var1.min(), var2.min())
bins = np.linspace(lower, upper, bin_count + 1)
a1.hist(var1,
weights=w1,
fc=faded_LN,
bins=bins,
edgecolor=dark_LN,
**hist_kwargs)
a2.hist(var2,
weights=w2,
fc=faded_max,
bins=bins,
edgecolor=dark_max,
**hist_kwargs)
a1.axes.axvline(m1,
color=dark_LN,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
a1.axes.axvline(m2,
color=dark_max,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
a2.axes.axvline(m1,
color=dark_LN,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
a2.axes.axvline(m2,
color=dark_max,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
ax_remove_box(a1)
ax_remove_box(a2)
return fig
def plot_self_equivalence(batch,
stp1,
stp2,
gc1,
gc2,
LN1,
LN2,
stp_load,
gc_load,
axes=None):
eqs1 = self_equivalence_data(batch,
stp1,
stp2,
LN1,
LN2,
load_path=stp_load)
eqs2 = self_equivalence_data(batch, gc1, gc2, LN1, LN2, load_path=gc_load)
eqs = np.hstack([eqs1, eqs2])
weights1 = [np.ones(len(eqs)) / len(eqs)]
if axes is not None:
a1 = axes
else:
_, a1 = plt.subplots(1, 1)
a1.hist(eqs,
bins=30,
range=[-0.5, 1],
weights=weights1,
fc='gray',
edgecolor='black',
linewidth=1,
alpha=0.6)
a1.axes.axvline(np.median(eqs),
color='black',
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
if axes is None:
ax_remove_box(a1)
plt.tight_layout()
return a1
def compare_sims(start=0, end=None):
# TODO: set up to compare on synthetic stimuli
xfspec, ctx = xhelp.load_model_xform(_DEFAULT_CELL, _DEFAULT_BATCH,
_DEFAULT_MODEL)
val = ctx['val']
gc_sim = build_toy_gc_cell(0, 0, 0, -0.5) #base, amp, shift, kappa
gc_sim[-2]['fn_kwargs']['compute_contrast'] = True
stp_sim = build_toy_stp_cell([0, 0.1], [0.08, 0.08]) #u, tau
LN_sim = build_toy_LN_cell()
stim = val['stim'].as_continuous()
gc_val = gc_sim.evaluate(val)
gc_sim.recording = gc_val
gc_psth = gc_val['pred'].as_continuous().flatten()
stp_val = stp_sim.evaluate(val)
stp_sim.recording = stp_val
stp_psth = stp_val['pred'].as_continuous().flatten()
LN_val = LN_sim.evaluate(val)
LN_sim.recording = LN_val
LN_psth = LN_val['pred'].as_continuous().flatten()
fig = plt.figure(figsize=wide_fig)
if end is None:
end = stim.shape[-1]
plt.imshow(stim, aspect='auto', cmap=spectrogram_cmap,
origin='lower', extent=(0, stim.shape[-1], 2.1, 3.4))
lw = 0.75
plt.plot(LN_psth, color=model_colors['LN'], linewidth=lw)
plt.plot(gc_psth, color=model_colors['gc'], linewidth=lw*1.25)
plt.plot(stp_psth, color=model_colors['stp'], alpha=0.75,
linewidth=lw*1.25)
plt.ylim(-0.1, 3.4)
plt.xlim(start, end)
ax = plt.gca()
ax_remove_box(ax)
return fig
def equivalence_effect_size(batch,
gc,
stp,
LN,
combined,
se_filter=True,
LN_filter=False,
save_path=None,
load_path=None,
test_limit=None,
only_improvements=False,
legend=False,
effect_key='performance_effect',
equiv_key='partial_corr',
enable_hover=False,
plot_stat='r_ceiling',
highlight_cells=None):
e, a, g, s, c = improved_cells_to_list(batch,
gc,
stp,
LN,
combined,
se_filter=se_filter,
LN_filter=LN_filter)
_, cellids, _, _, _ = improved_cells_to_list(batch,
gc,
stp,
LN,
combined,
se_filter=se_filter,
LN_filter=LN_filter,
as_lists=False)
if load_path is None:
equivs = []
partials = []
gcs = []
stps = []
effects = []
for cell in a[:test_limit]:
xf1, ctx1 = xhelp.load_model_xform(cell, batch, gc)
xf2, ctx2 = xhelp.load_model_xform(cell, batch, stp)
xf3, ctx3 = xhelp.load_model_xform(cell, batch, LN)
gc_pred = ctx1['val'].apply_mask()['pred'].as_continuous()
stp_pred = ctx2['val'].apply_mask()['pred'].as_continuous()
ln_pred = ctx3['val'].apply_mask()['pred'].as_continuous()
ff = np.isfinite(gc_pred) & np.isfinite(stp_pred) & np.isfinite(
ln_pred)
gcff = gc_pred[ff]
stpff = stp_pred[ff]
lnff = ln_pred[ff]
C = np.hstack((np.expand_dims(gcff, 0).transpose(),
np.expand_dims(stpff, 0).transpose(),
np.expand_dims(lnff, 0).transpose()))
partials.append(partial_corr(C)[0, 1])
equivs.append(np.corrcoef(gcff - lnff, stpff - lnff)[0, 1])
this_gc = np.corrcoef(gcff, lnff)[0, 1]
this_stp = np.corrcoef(stpff, lnff)[0, 1]
gcs.append(this_gc)
stps.append(this_stp)
effects.append(1 - 0.5 * (this_gc + this_stp))
df_r, df_c, df_e = get_dataframes(batch, gc, stp, LN, combined)
if plot_stat == 'r_ceiling':
plot_df = df_c
else:
plot_df = df_r
models = [gc, stp, LN]
gc_rel_all, stp_rel_all = _relative_score(plot_df, models, a)
results = {
'cellid':
a[:test_limit],
'equivalence':
equivs,
'effect_size':
effects,
'corr_gc_LN':
gcs,
'corr_stp_LN':
stps,
'partial_corr':
partials,
'performance_effect':
0.5 * (gc_rel_all[:test_limit] + stp_rel_all[:test_limit])
}
df = pd.DataFrame.from_dict(results)
df.set_index('cellid', inplace=True)
if save_path is not None:
df.to_pickle(save_path)
else:
df = pd.read_pickle(load_path)
df = df[cellids]
equivalence = df[equiv_key].values
effect_size = df[effect_key].values
r, p = st.pearsonr(effect_size, equivalence)
improved = c
not_improved = list(set(a) - set(c))
fig1, ax = plt.subplots(1, 1)
ax.axes.axhline(0,
color='black',
linewidth=1,
linestyle='dashed',
dashes=dash_spacing)
ax_remove_box(ax)
extra_title_lines = []
if only_improvements:
equivalence_imp = df[equiv_key][improved].values
equivalence_not = df[equiv_key][not_improved].values
effectsize_imp = df[effect_key][improved].values
effectsize_not = df[effect_key][not_improved].values
r_imp, p_imp = st.pearsonr(effectsize_imp, equivalence_imp)
r_not, p_not = st.pearsonr(effectsize_not, equivalence_not)
n_imp = len(improved)
n_not = len(not_improved)
lines = [
"improved cells, r: %.4f, p: %.4E" % (r_imp, p_imp),
"not improved, r: %.4f, p: %.4E" % (r_not, p_not)
]
extra_title_lines.extend(lines)
# plt.scatter(effectsize_not, equivalence_not, s=small_scatter,
# color=model_colors['LN'], label='no imp')
plt.scatter(effectsize_imp,
equivalence_imp,
s=big_scatter,
color=model_colors['max'],
label='sig. imp.')
if enable_hover:
mplcursors.cursor(ax, hover=True).connect(
"add", lambda sel: sel.annotation.set_text(improved[sel.target.
index]))
if legend:
plt.legend()
else:
plt.scatter(effect_size, equivalence, s=big_scatter, color='black')
if enable_hover:
mplcursors.cursor(ax, hover=True).connect(
"add",
lambda sel: sel.annotation.set_text(a[sel.target.index]))
if highlight_cells is not None:
highlights = [df[df.index == h] for h in highlight_cells]
equiv_highlights = [df[equiv_key].values for df in highlights]
effect_highlights = [df[effect_key].values for df in highlights]
for eq, eff in zip(equiv_highlights, effect_highlights):
plt.scatter(eff,
eq,
s=big_scatter * 10,
facecolors='none',
edgecolors='black',
linewidths=1)
#plt.ylabel('Equivalence: CC(GC-LN, STP-LN)')
#plt.xlabel('Effect size: 1 - 0.5*(CC(GC,LN) + CC(STP,LN))')
if equiv_key == 'equivalence':
y_text = 'equivalence, CC(GC-LN, STP-LN)\n'
elif equiv_key == 'partial_corr':
y_text = 'equivalence, partial correlation\n'
else:
y_text = 'unknown equivalence key'
if effect_key == 'effect_size':
x_text = 'effect size: 1 - 0.5*(CC(GC,LN) + CC(STP,LN))'
elif effect_key == 'performance_effect':
x_text = 'effect size: 0.5*(rGC-rLN + rSTP-rLN)'
else:
x_text = 'unknown effect key'
text = ("scatter: Equivalence of Change to Predicted PSTH\n"
"batch: %d\n"
"vs Effect Size\n"
"all cells, r: %.4f, p: %.4E\n"
"y: %s"
"x: %s" % (batch, r, p, y_text, x_text))
for ln in extra_title_lines:
text += "\n%s" % ln
plt.tight_layout()
# fig2 = plt.figure()
# md = np.nanmedian(equivalence)
# n_cells = equivalence.shape[0]
# plt.hist(equivalence, bins=30, range=[-0.5, 1], histtype='bar',
# color=model_colors['combined'], edgecolor='black', linewidth=1)
# plt.plot(np.array([0,0]), np.array(fig2.axes[0].get_ylim()), 'k--',
# linewidth=2, dashes=dash_spacing)
# plt.text(0.05, 0.95, 'n = %d\nmd = %.2f' % (n_cells, md),
# ha='left', va='top', transform=fig2.axes[0].transAxes)
#plt.xlabel('CC, GC-LN vs STP-LN')
#plt.title('Equivalence of Change in Prediction Relative to LN Model')
fig3 = plt.figure()
plt.text(0.1, 0.75, text, va='top')
#plt.text(0.1, 0.25, text2, va='top')
return fig1, fig3
def equivalence_histogram(batch,
gc,
stp,
LN,
combined,
se_filter=True,
LN_filter=False,
test_limit=None,
alpha=0.05,
save_path=None,
load_path=None,
equiv_key='partial_corr',
effect_key='performance_effect',
self_equiv=False,
self_kwargs={},
eq_models=[],
cross_kwargs={},
cross_models=[],
use_median=True,
exclude_low_snr=False,
snr_path=None,
adjust_scores=True,
use_log_ratios=False):
'''
model1: GC
model2: STP
model3: LN
'''
e, a, g, s, c = improved_cells_to_list(batch, gc, stp, LN, combined)
_, cellids, _, _, _ = improved_cells_to_list(batch,
gc,
stp,
LN,
combined,
as_lists=False)
improved = c
not_improved = list(set(a) - set(c))
if load_path is None:
df_r, df_c, df_e = get_dataframes(batch, gc, stp, LN, combined)
rs = []
for c in a[:test_limit]:
xf1, ctx1 = xhelp.load_model_xform(c, batch, gc)
xf2, ctx2 = xhelp.load_model_xform(c, batch, stp)
xf3, ctx3 = xhelp.load_model_xform(c, batch, LN)
gc_pred = ctx1['val'].apply_mask()['pred'].as_continuous()
stp_pred = ctx2['val'].apply_mask()['pred'].as_continuous()
ln_pred = ctx3['val'].apply_mask()['pred'].as_continuous()
ff = np.isfinite(gc_pred) & np.isfinite(stp_pred) & np.isfinite(
ln_pred)
gcff = gc_pred[ff]
stpff = stp_pred[ff]
lnff = ln_pred[ff]
rs.append(np.corrcoef(gcff - lnff, stpff - lnff)[0, 1])
blank = np.full_like(rs, np.nan)
results = {
'cellid': a[:test_limit],
'equivalence': rs,
'effect_size': blank,
'corr_gc_LN': blank,
'corr_stp_LN': blank
}
df = pd.DataFrame.from_dict(results)
df.set_index('cellid', inplace=True)
if save_path is not None:
df.to_pickle(save_path)
else:
df = pd.read_pickle(load_path)
df = df[cellids]
rs = df[equiv_key].values
if exclude_low_snr:
snr_df = pd.read_pickle(snr_path)
med_snr = snr_df['snr'].median()
high_snr = snr_df.loc[snr_df['snr'] >= med_snr]
high_snr_cells = high_snr.index.values.tolist()
improved = list(set(improved) & set(high_snr_cells))
not_improved = list(set(not_improved) & set(high_snr_cells))
imp = np.array(improved)
not_imp = np.array(not_improved)
imp_mask = np.isin(a, imp)
not_mask = np.isin(a, not_imp)
rs_not = rs[not_mask]
rs_imp = rs[imp_mask]
md_not = np.nanmedian(rs_not)
md_imp = np.nanmedian(rs_imp)
u, p = st.mannwhitneyu(rs_not, rs_imp, alternative='two-sided')
n_not = len(not_improved)
n_imp = len(improved)
if self_equiv:
stp1, stp2, gc1, gc2, LN1, LN2 = eq_models
g1, s2, s1, g2, L1, L2 = cross_models
_, ga, _, _, _ = improved_cells_to_list(batch,
gc1,
gc2,
LN1,
LN2,
as_lists=True)
_, sa, _, _, _ = improved_cells_to_list(batch,
stp1,
stp2,
LN1,
LN2,
as_lists=True)
aa = list(set(ga) & set(sa))
if exclude_low_snr:
snr_df = pd.read_pickle(snr_path)
med_snr = snr_df['snr'].median()
high_snr = snr_df.loc[snr_df['snr'] >= med_snr]
high_snr_cells = high_snr.index.values.tolist()
aa = list(set(aa) & set(high_snr_cells))
eqs_stp, eqs_gc = _get_self_equivs(**self_kwargs, cellids=aa)
md_stpeq = np.nanmedian(eqs_stp)
md_gceq = np.nanmedian(eqs_gc)
n_eq = eqs_stp.size
u_gceq, p_gceq = st.mannwhitneyu(eqs_gc,
rs_imp,
alternative='two-sided')
u_stpeq, p_stpeq = st.mannwhitneyu(eqs_stp,
rs_imp,
alternative='two-sided')
eqs_x1, eqs_x2 = _get_self_equivs(**cross_kwargs, cellids=aa)
md_x1 = np.nanmedian(eqs_x1)
md_x2 = np.nanmedian(eqs_x2)
sub1 = df.index.isin(ga) & df.index.isin(aa)
sub2 = df.index.isin(sa) & df.index.isin(aa)
eqs_sub1 = df[equiv_key][sub1].values
eqs_sub2 = df[equiv_key][sub2].values
md_sub1 = np.nanmedian(eqs_sub1)
md_sub2 = np.nanmedian(eqs_sub2)
if adjust_scores:
if use_median:
md_avg1 = 0.5 * (md_x1 + md_x2)
md_avg2 = 0.5 * (md_sub1 + md_sub2)
ratio = md_avg2 / md_avg1
md_stpeq *= ratio
md_gceq *= ratio
else:
eqs_avg1 = 0.5 * (eqs_x1 + eqs_x2) # between-model, halved est
eqs_avg2 = 0.5 * (eqs_sub1 + eqs_sub2
) # between-model, full data
ratios = np.abs(eqs_avg2 / eqs_avg1)
if use_log_ratios:
log_ratios = np.abs(np.log(ratios))
log_ratios /= log_ratios.max()
stp_scaled = eqs_stp + (1 - eqs_stp) * log_ratios
gc_scaled = eqs_gc + (1 - eqs_gc) * log_ratios
else:
stp_scaled = eqs_stp * ratios
gc_scaled = eqs_gc * ratios
md_stpeq = np.nanmedian(stp_scaled)
md_gceq = np.nanmedian(gc_scaled)
not_color = model_colors['LN']
imp_color = model_colors['max']
weights1 = [np.ones(len(rs_not)) / len(rs_not)]
weights2 = [np.ones(len(rs_imp)) / len(rs_imp)]
#n_cells = rs.shape[0]
fig1, (a1, a2) = plt.subplots(2, 1)
a1.hist(rs_not,
bins=30,
range=[-0.5, 1],
weights=weights1,
fc=faded_LN,
edgecolor=dark_LN,
linewidth=1)
a2.hist(rs_imp,
bins=30,
range=[-0.5, 1],
weights=weights2,
fc=faded_max,
edgecolor=dark_max,
linewidth=1)
a1.axes.axvline(md_not,
color=dark_LN,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
a1.axes.axvline(md_imp,
color=dark_max,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
a2.axes.axvline(md_not,
color=dark_LN,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
a2.axes.axvline(md_imp,
color=dark_max,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
if self_equiv:
a1.axes.annotate('',
xy=(md_gceq, 0),
xycoords='data',
xytext=(md_gceq, 0.07),
textcoords='data',
arrowprops=dict(arrowstyle="->",
connectionstyle="arc3"))
a1.axes.annotate('',
xy=(md_stpeq, 0),
xycoords='data',
xytext=(md_stpeq, 0.07),
textcoords='data',
arrowprops=dict(arrowstyle="->",
connectionstyle="arc3"))
a2.axes.annotate('',
xy=(md_gceq, 0),
xycoords='data',
xytext=(md_gceq, 0.07),
textcoords='data',
arrowprops=dict(arrowstyle="->",
connectionstyle="arc3"))
a2.axes.annotate('',
xy=(md_stpeq, 0),
xycoords='data',
xytext=(md_stpeq, 0.07),
textcoords='data',
arrowprops=dict(arrowstyle="->",
connectionstyle="arc3"))
ymin1, ymax1 = a1.get_ylim()
ymin2, ymax2 = a2.get_ylim()
ymax = max(ymax1, ymax2)
a1.set_ylim(0, ymax)
a2.set_ylim(0, ymax)
ax_remove_box(a1)
ax_remove_box(a2)
plt.tight_layout()
if equiv_key == 'equivalence':
x_text = 'equivalence, CC(GC-LN, STP-LN)\n'
elif equiv_key == 'partial_corr':
x_text = 'equivalence, partial correlation\n'
else:
x_text = 'unknown equivalence key'
fig3 = plt.figure(figsize=text_fig)
text2 = ("hist: equivalence of changein prediction relative to LN model\n"
"batch: %d\n"
"x: %s"
"y: cell fraction\n"
"n not imp: %d, md: %.2f\n"
"n sig. imp: %d, md: %.2f\n"
"st.mannwhitneyu: u: %.4E p: %.4E" %
(batch, x_text, n_not, md_not, n_imp, md_imp, u, p))
if self_equiv:
text2 += ("\n\nSelf equivalence, n: %d\n"
"stp: md: %.2f, u: %.4E p %.4E\n"
"gc: md: %.2f, u: %.4E p %.4E\n"
"md sub1: %.2E\n"
"md sub2: %.2E\n"
"md x1: %.2E\n"
"md x2: %.2E" %
(n_eq, md_stpeq, u_stpeq, p_stpeq, md_gceq, u_gceq, p_gceq,
md_sub1, md_sub2, md_x1, md_x2))
plt.text(0.1, 0.5, text2)
return fig1, fig3
def equivalence_scatter(batch,
gc,
stp,
LN,
combined,
se_filter=True,
LN_filter=False,
plot_stat='r_ceiling',
enable_hover=False,
manual_lims=None,
drop_outliers=False,
color_improvements=True,
xmodel='GC',
ymodel='STP',
legend=False,
self_equiv=False,
self_eq_models=[],
show_highlights=False,
exclude_low_snr=False,
snr_path=None):
'''
model1: GC
model2: STP
model3: LN
'''
df_r, df_c, df_e = get_dataframes(batch, gc, stp, LN, combined)
if plot_stat == 'r_ceiling':
plot_df = df_c
else:
plot_df = df_r
e, a, g, s, c = improved_cells_to_list(batch,
gc,
stp,
LN,
combined,
se_filter=se_filter,
LN_filter=LN_filter)
improved = c
not_improved = list(set(a) - set(c))
if exclude_low_snr:
snr_df = pd.read_pickle(snr_path)
med_snr = snr_df['snr'].median()
high_snr = snr_df.loc[snr_df['snr'] >= med_snr]
high_snr_cells = high_snr.index.values.tolist()
improved = list(set(improved) & set(high_snr_cells))
not_improved = list(set(not_improved) & set(high_snr_cells))
a = list(set(a) & set(high_snr_cells))
# check number of animals included
prefixes = [s[:3] for s in a]
n_animals = len(list(set(prefixes)))
print('n_animals: %d' % n_animals)
models = [gc, stp, LN]
gc_rel_imp, stp_rel_imp = _relative_score(plot_df, models, improved)
gc_rel_not, stp_rel_not = _relative_score(plot_df, models, not_improved)
gc_rel_all, stp_rel_all = _relative_score(plot_df, models, a)
# LN, STP, GC
cells_to_highlight = ['TAR010c-40-1', 'AMT005c-20-1', 'TAR009d-22-1']
cells_to_plot_gc_rel = []
cells_to_plot_stp_rel = []
for c in cells_to_highlight:
stp_rel = plot_df[stp][c] - plot_df[LN][c]
gc_rel = plot_df[gc][c] - plot_df[LN][c]
cells_to_plot_gc_rel.append(gc_rel)
cells_to_plot_stp_rel.append(stp_rel)
# compute corr. before dropping outliers (only dropping for visualization)
r_imp, p_imp = st.pearsonr(gc_rel_imp, stp_rel_imp)
r_not, p_not = st.pearsonr(gc_rel_not, stp_rel_not)
r_all, p_all = st.pearsonr(gc_rel_all, stp_rel_all)
if self_equiv:
stp1, stp2, gc1, gc2, LN1, LN2 = self_eq_models
_, ga, _, _, _ = improved_cells_to_list(batch,
gc1,
gc2,
LN1,
LN2,
as_lists=True)
_, sa, _, _, _ = improved_cells_to_list(batch,
stp1,
stp2,
LN1,
LN2,
as_lists=True)
aa = list(set(ga) & set(sa))
if exclude_low_snr:
snr_df = pd.read_pickle(snr_path)
med_snr = snr_df['snr'].median()
high_snr = snr_df.loc[snr_df['snr'] >= med_snr]
high_snr_cells = high_snr.index.values.tolist()
aa = list(set(aa) & set(high_snr_cells))
df_r_eq = nd.batch_comp(batch, [gc1, gc2, stp1, stp2, LN1, LN2],
stat=plot_stat)
df_r_eq.dropna(axis=0, how='any', inplace=True)
df_r_eq.sort_index(inplace=True)
df_r_eq = df_r_eq[df_r_eq.index.isin(aa)]
gc1_rel_imp = df_r_eq[gc1].values - df_r_eq[LN1].values
gc2_rel_imp = df_r_eq[gc2].values - df_r_eq[LN2].values
stp1_rel_imp = df_r_eq[stp1].values - df_r_eq[LN1].values
stp2_rel_imp = df_r_eq[stp2].values - df_r_eq[LN2].values
r_gceq, p_gceq = st.pearsonr(gc1_rel_imp, gc2_rel_imp)
r_stpeq, p_stpeq = st.pearsonr(stp1_rel_imp, stp2_rel_imp)
n_eq = gc1_rel_imp.size
# compute on same subset for full estimation data
# to compare to cross-set
gc_subset1 = df_r[gc][ga].values
gc_subset2 = df_r[gc][sa].values
stp_subset1 = df_r[stp][ga].values
stp_subset2 = df_r[stp][sa].values
LN_subset1 = df_r[LN][ga].values
LN_subset2 = df_r[LN][sa].values
gc_rel1 = gc_subset1 - LN_subset1
gc_rel2 = gc_subset2 - LN_subset2
stp_rel1 = stp_subset1 - LN_subset1
stp_rel2 = stp_subset2 - LN_subset2
r_sub1, p_sub1 = st.pearsonr(gc_rel1, stp_rel1)
r_sub2, p_sub2 = st.pearsonr(gc_rel2, stp_rel2)
gc_rel_imp, stp_rel_imp = drop_common_outliers(gc_rel_imp, stp_rel_imp)
gc_rel_not, stp_rel_not = drop_common_outliers(gc_rel_not, stp_rel_not)
gc_rel_all, stp_rel_all = drop_common_outliers(gc_rel_all, stp_rel_all)
n_imp = len(improved)
n_not = len(not_improved)
n_all = len(a)
y_max = np.max(stp_rel_all)
y_min = np.min(stp_rel_all)
x_max = np.max(gc_rel_all)
x_min = np.min(gc_rel_all)
fig = plt.figure()
ax = plt.gca()
ax.axes.axhline(0,
color='black',
linewidth=1,
linestyle='dashed',
dashes=dash_spacing)
ax.axes.axvline(0,
color='black',
linewidth=1,
linestyle='dashed',
dashes=dash_spacing)
if color_improvements:
ax.scatter(gc_rel_not,
stp_rel_not,
c=model_colors['LN'],
s=small_scatter)
ax.scatter(gc_rel_imp,
stp_rel_imp,
c=model_colors['max'],
s=big_scatter)
if show_highlights:
for i, (g, s) in enumerate(
zip(cells_to_plot_gc_rel, cells_to_plot_stp_rel)):
plt.text(g, s, str(i + 1), fontsize=12, color='black')
else:
ax.scatter(gc_rel_all, stp_rel_all, c='black', s=big_scatter)
if legend:
plt.legend()
if manual_lims is not None:
ax.set_ylim(*manual_lims)
ax.set_xlim(*manual_lims)
else:
upper = max(y_max, x_max)
lower = min(y_min, x_min)
upper_lim = np.ceil(10 * upper) / 10
lower_lim = np.floor(10 * lower) / 10
ax.set_ylim(lower_lim, upper_lim)
ax.set_xlim(lower_lim, upper_lim)
plt.axes().set_aspect('equal')
if enable_hover:
mplcursors.cursor(ax, hover=True).connect(
"add", lambda sel: sel.annotation.set_text(a[sel.target.index]))
plt.tight_layout()
fig2 = plt.figure(figsize=text_fig)
text = ("Performance Improvements over LN\n"
"batch: %d\n"
"dropped outliers?: %s\n"
"all cells: r: %.2E, p: %.2E, n: %d\n"
"improved: r: %.2E, p: %.2E, n: %d\n"
"not imp: r: %.2E, p: %.2E, n: %d\n"
"x: %s - LN\n"
"y: %s - LN" % (batch, drop_outliers, r_all, p_all, n_all, r_imp,
p_imp, n_imp, r_not, p_not, n_not, xmodel, ymodel))
if self_equiv:
text += ("\n\nSelf Equivalence, n: %d\n"
"gc, r: %.2Ef, p: %.2E\n"
"stp, r: %.2Ef, p: %.2E\n"
"sub1, r: %.2E, p: %.2E\n"
"sub2, r: %.2E, p: %.2E\n" %
(n_eq, r_gceq, p_gceq, r_stpeq, p_stpeq, r_sub1, p_sub1,
r_sub2, p_sub2))
plt.text(0.1, 0.5, text)
ax_remove_box(ax)
return fig, fig2
def compare_sim_fits(batch, gc, stp, LN, combined, simulation_spec=None,
start=0, end=None, load_path=None, skip_combined=True,
save_path=None, tag='', ext_start=1.1):
if load_path is None:
if simulation_spec is None:
raise ValueError("simulation_spec required unless loading previous"
" result")
stp_ctx = fit_to_simulation(stp, simulation_spec)
gc_ctx = fit_to_simulation(gc, simulation_spec)
LN_ctx = fit_to_simulation(LN, simulation_spec)
combined_ctx = fit_to_simulation(combined, simulation_spec)
if save_path is not None:
results = {'simulation': simulation_spec,
'contexts': [stp_ctx, gc_ctx, LN_ctx, combined_ctx]}
pickle.dump(results, open(save_path, 'wb'))
else:
results = pickle.load(open(load_path, 'rb'))
simulation_spec = results['simulation']
stp_ctx, gc_ctx, LN_ctx, combined_ctx = results['contexts']
simulation = stp_ctx['val']['resp'].as_continuous().flatten()
stp_pred = stp_ctx['val']['pred'].as_continuous().flatten()
gc_pred = gc_ctx['val']['pred'].as_continuous().flatten()
LN_pred = LN_ctx['val']['pred'].as_continuous().flatten()
combined_pred = combined_ctx['val']['pred'].as_continuous().flatten()
stim = stp_ctx['val']['stim'].as_continuous()
if end is None:
end = stim.shape[-1]
fig1 = plt.figure(figsize=wide_fig)
if end is None:
end = stim.shape[-1]
ext_stop = 1.25*(ext_start+0.1)
plt.imshow(stim, aspect='auto', cmap=spectrogram_cmap,
origin='lower', extent=(0, stim.shape[-1], ext_start, ext_stop))
lw = 0.75
plt.plot(simulation, color='gray', alpha=0.65, linewidth=lw*2)
t = np.linspace(0, simulation.shape[-1]-1, simulation.shape[-1])
plt.fill_between(t, simulation, color='gray', alpha=0.15)
plt.plot(LN_pred, color='black', alpha=0.55, linewidth=lw)
plt.plot(gc_pred, color=model_colors['gc'], linewidth=lw*1.25)
plt.plot(stp_pred, color=model_colors['stp'], linewidth=lw*1.25)
if not skip_combined:
plt.plot(combined_pred, color=model_colors['combined'], \
linewidth=lw*1.25)
plt.ylim(-0.1, ext_stop)
plt.xlim(start, end)
ax = plt.gca()
ax_remove_box(ax)
fig2 = plt.figure(figsize=text_fig)
text = ("simulation_spec: %s\n"
"cellid: %s\n"
"tag: %s\n"
"stp_r_test: %.4f\n"
"gc_r_test: %.4f\n"
"LN_r_test: %.4f\n"
"combined_r_test: %.4f"
% (simulation_spec.meta['modelname'],
simulation_spec.meta['cellid'],
tag,
stp_ctx['modelspec'].meta['r_test'],
gc_ctx['modelspec'].meta['r_test'],
LN_ctx['modelspec'].meta['r_test'],
combined_ctx['modelspec'].meta['r_test']
))
plt.text(0.1, 0.5, text)
return fig1, fig2
dotcolor_ns = 'lightgray'
thinlinecolor = 'gray'
barcolors = [(211/255, 211/255, 211/255), (102/255, 1/255, 104/255)]
barwidth = 0.5
ax = plt.subplot(2, 3, 1)
plt.plot(amp_bounds, amp_bounds, 'k--')
plt.plot(amp_mtx[~show_units, 0], amp_mtx[~show_units, 1], '.',
color=dotcolor_ns)
plt.plot(amp_mtx[show_units, 0], amp_mtx[show_units, 1], '.', color=dotcolor)
plt.title('bat {} n={}/{} good units'.format(
batch, np.sum(show_units), u_mtx.shape[0]))
plt.xlabel(xstr+' gain')
plt.ylabel(ystr+' gain')
plt.axis('equal')
ax_remove_box(ax)
ax = plt.subplot(2, 3, 2)
plt.plot(np.array([-0.5, 1.5]), np.array([0, 0]), 'k--')
plt.bar(np.arange(2), ampmean, color=barcolors, width=barwidth)
plt.errorbar(np.arange(2), ampmean, yerr=amperr, color='black', linewidth=2)
plt.plot(amp_mtx[show_units].T, linewidth=0.5, color=thinlinecolor)
w, p = ss.wilcoxon(amp_mtx_norm[show_units, 0], amp_mtx_norm[show_units, 1])
plt.ylim(amp_bounds)
plt.ylabel('STRF gain')
plt.xlabel('{} {:.3f} - {} {:.3f} - rat {:.3f} - p<{:.5f}'.format(
xstr, ampmean[0], ystr, ampmean[1], ampmean[1]/ampmean[0], p))
ax_remove_box(ax)
ax = plt.subplot(2, 3, 3)
def combined_vs_max(batch,
gc,
stp,
LN,
combined,
se_filter=True,
LN_filter=False,
plot_stat='r_ceiling',
legend=False,
improved_only=True,
exclude_low_snr=False,
snr_path=None):
df_r, df_c, df_e = get_dataframes(batch, gc, stp, LN, combined)
# cellids, under_chance, less_LN = get_filtered_cellids(df_r, df_e, gc, stp,
# LN, combined,
# se_filter,
# LN_filter)
e, a, g, s, c = improved_cells_to_list(batch,
gc,
stp,
LN,
combined,
se_filter=se_filter,
LN_filter=LN_filter)
improved = c
not_improved = list(set(a) - set(c))
if exclude_low_snr:
snr_df = pd.read_pickle(snr_path)
med_snr = snr_df['snr'].median()
high_snr = snr_df.loc[snr_df['snr'] >= med_snr]
high_snr_cells = high_snr.index.values.tolist()
improved = list(set(improved) & set(high_snr_cells))
not_improved = list(set(not_improved) & set(high_snr_cells))
if plot_stat == 'r_ceiling':
plot_df = df_c
else:
plot_df = df_r
gc_not = plot_df[gc][not_improved]
gc_imp = plot_df[gc][improved]
#gc_test_under_chance = plot_df[gc][under_chance]
stp_not = plot_df[stp][not_improved]
stp_imp = plot_df[stp][improved]
#stp_test_under_chance = plot_df[stp][under_chance]
#ln_test = plot_df[LN][cellids]
gc_stp_not = plot_df[combined][not_improved]
gc_stp_imp = plot_df[combined][improved]
max_not = np.maximum(gc_not, stp_not)
max_imp = np.maximum(gc_imp, stp_imp)
#gc_stp_test_rel = gc_stp_test - ln_test
#max_test_rel = np.maximum(gc_test, stp_test) - ln_test
imp_T, imp_p = st.wilcoxon(gc_stp_imp, max_imp)
med_combined = np.nanmedian(gc_stp_imp)
med_max = np.nanmedian(max_imp)
import pdb
pdb.set_trace()
fig1 = plt.figure()
c_not = model_colors['LN']
c_imp = model_colors['max']
if not improved_only:
plt.scatter(max_not,
gc_stp_not,
c=c_not,
s=small_scatter,
label='no imp.')
plt.scatter(max_imp, gc_stp_imp, c=c_imp, s=big_scatter, label='sig. imp.')
ax = fig1.axes[0]
plt.plot(ax.get_xlim(),
ax.get_xlim(),
'k--',
linewidth=1,
dashes=dash_spacing)
if legend:
plt.legend()
plt.xlim(0, 1)
plt.ylim(0, 1)
plt.tight_layout()
plt.axes().set_aspect('equal')
ax_remove_box()
fig2 = plt.figure(figsize=text_fig)
text = ("batch: %d\n"
"x: Max(GC,STP)\n"
"y: GC+STP\n"
"wilcoxon: T: %.4E, p: %.4E\n"
"combined median: %.4E\n"
"max median: %.4E" % (batch, imp_T, imp_p, med_combined, med_max))
plt.text(0.1, 0.5, text)
return fig1, fig2
def snr_vs_equivalence(snr_path, stp_path, gc_path):
stp_equiv_df = pd.read_pickle(stp_path)
gc_equiv_df = pd.read_pickle(gc_path)
snr_df = pd.read_pickle(snr_path)
cellids = list(
set(stp_equiv_df.index.values.tolist())
& set(gc_equiv_df.index.values.tolist()))
snr_df = snr_df.loc[cellids].reindex(cellids)
stp_equiv_df = stp_equiv_df.loc[cellids].reindex(cellids)
gc_equiv_df = gc_equiv_df.loc[cellids].reindex(cellids)
stp_equivs = stp_equiv_df['equivalence'].values
gc_equivs = gc_equiv_df['equivalence'].values
snrs = snr_df['snr'].values
md_snr = np.nanmedian(snrs)
low_snr_mask = snrs < md_snr
high_snr_mask = snrs >= md_snr
stp_low_equivs = stp_equivs[low_snr_mask]
stp_high_equivs = stp_equivs[high_snr_mask]
gc_low_equivs = gc_equivs[low_snr_mask]
gc_high_equivs = gc_equivs[high_snr_mask]
md_stp_low = np.median(stp_low_equivs)
md_stp_high = np.median(stp_high_equivs)
md_gc_low = np.median(gc_low_equivs)
md_gc_high = np.median(gc_high_equivs)
u_stp, p_stp = st.mannwhitneyu(stp_low_equivs,
stp_high_equivs,
alternative='two-sided')
u_gc, p_gc = st.mannwhitneyu(gc_low_equivs,
gc_high_equivs,
alternative='two-sided')
#r_stp, p_stp = st.pearsonr(stp_equivs, snrs)
#r_gc, p_gc = st.pearsonr(gc_equivs, snrs)
fig1 = plt.figure(figsize=small_fig)
ax1 = plt.gca()
plt.scatter(snrs, stp_equivs, c=model_colors['stp'], s=big_scatter)
ax1.axes.axvline(md_snr,
color='black',
linewidth=1,
linestyle='dashed',
dashes=dash_spacing)
plt.tight_layout()
plt.subplots_adjust(left=0.25)
ax_remove_box(ax1)
fig2 = plt.figure(figsize=small_fig)
ax2 = plt.gca()
plt.scatter(snrs, gc_equivs, c=model_colors['gc'], s=big_scatter)
ax2.axes.axvline(md_snr,
color='black',
linewidth=1,
linestyle='dashed',
dashes=dash_spacing)
plt.tight_layout()
plt.subplots_adjust(left=0.25)
ax_remove_box(ax2)
ymin1, ymax1 = ax1.get_ylim()
ymin2, ymax2 = ax2.get_ylim()
ax1.set_ylim(min(ymin1, ymin2), max(ymax1, ymax2))
ax2.set_ylim(min(ymin1, ymin2), max(ymax1, ymax2))
fig3 = plt.figure(figsize=text_fig)
text = ("SNR vs equivalence\n"
"x axis: signal power / total power\n"
"y axis: equivalence (partial corr)\n"
"mannwhitneyu two sided low vs high snr\n"
"n_high: %d\n"
"n_low: %d\n"
"u_stp: %.4E\n"
"p_stp: %.4E\n"
"md_stp_low: %.4E\n"
"md_stp_high: %.4E\n"
"u_gc: %.4E\n"
"p_gc: %.4E\n"
"md_gc_low: %.4E\n"
"md_gc_high: %.4E" %
(stp_high_equivs.size, stp_low_equivs.size, u_stp, p_stp,
md_stp_low, md_stp_high, u_gc, p_gc, md_gc_low, md_gc_high))
plt.text(0.1, 0.5, text)
return fig1, fig2, fig3
def rate_histogram(batch,
gc,
stp,
LN,
combined,
load_path,
rate_type='mean',
plot_stat='r_ceiling',
fs=100,
allow_overlap=True):
e, a, g, s, c = improved_cells_to_list(batch, gc, stp, LN, combined)
if allow_overlap:
gc_imp = g
stp_imp = s
not_imp = list(set(a) - set(c))
both_imp = list((set(g) & set(s)) | set(c))
else:
gc_imp = list(set(g) - set(s))
stp_imp = list(set(s) - set(g))
not_imp = list(set(a) - set(c) - set(g) - set(s))
# either both improve or only combined improve
both_imp = list((set(g) & set(s)) | ((set(c) - set(s) - set(g))))
df = pd.read_pickle(load_path)
# * fs to get spikes per second
#rates_LN = df.loc[not_imp]['rate'].values * fs
rates_LN = df[df.index.isin(not_imp)]['rate'].values * fs
#rates_gc = df.loc[gc_imp]['rate'].values * fs
rates_gc = df[df.index.isin(gc_imp)]['rate'].values * fs
#rates_stp = df.loc[stp_imp]['rate'].values * fs
rates_stp = df[df.index.isin(stp_imp)]['rate'].values * fs
rates_both = df[df.index.isin(both_imp)]['rate'].values * fs
xmax = max(rates_gc.max(), rates_stp.max(), rates_both.max()) * 1.10
md_LN = np.nanmedian(rates_LN)
n_LN = rates_LN.size
md_gc = np.nanmedian(rates_gc)
n_gc = rates_gc.size
md_stp = np.nanmedian(rates_stp)
n_stp = rates_stp.size
md_both = np.nanmedian(rates_both)
n_both = rates_both.size
# vs each other
u, p = st.mannwhitneyu(rates_gc, rates_stp, alternative='two-sided')
u_both_gc, p_both_gc = st.mannwhitneyu(rates_both,
rates_gc,
alternative='two-sided')
u_both_stp, p_both_stp = st.mannwhitneyu(rates_both,
rates_stp,
alternative='two-sided')
# vs LN
u_gc, p_gc = st.mannwhitneyu(rates_gc, rates_LN, alternative='two-sided')
u_stp, p_stp = st.mannwhitneyu(rates_stp,
rates_LN,
alternative='two-sided')
u_both, p_both = st.mannwhitneyu(rates_both,
rates_LN,
alternative='two-sided')
# TODO: stat comparison for both group
weights1 = [np.ones(len(rates_stp)) / len(rates_stp)]
weights2 = [np.ones(len(rates_gc)) / len(rates_gc)]
weights3 = [np.ones(len(rates_LN)) / len(rates_LN)]
weights4 = [np.ones(len(rates_both)) / len(rates_both)]
fig, (a3, a1, a2, a4) = plt.subplots(4, 1, figsize=tall_fig)
axes = [a3, a1, a2, a4]
a1.hist(rates_stp,
bins=30,
range=[0, xmax],
weights=weights1,
fc=faded_stp,
edgecolor=dark_stp,
linewidth=1)
a2.hist(rates_gc,
bins=30,
range=[0, xmax],
weights=weights2,
fc=faded_gc,
edgecolor=dark_gc,
linewidth=1)
a3.hist(rates_LN,
bins=30,
range=[0, xmax],
weights=weights3,
fc=model_colors['LN'],
alpha=0.5,
edgecolor=dark_LN,
linewidth=1)
a4.hist(rates_both,
bins=30,
range=[0, xmax],
weights=weights4,
fc=model_colors['combined'],
alpha=0.5,
edgecolor=dark_combined,
linewidth=1)
for ax in axes:
ax.axes.axvline(md_stp,
color=dark_stp,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
ax.axes.axvline(md_gc,
color=dark_gc,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
ax.axes.axvline(md_LN,
color=dark_LN,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
ax.axes.axvline(md_both,
color=dark_combined,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
ymaxes = [ax.get_ylim()[1] for ax in axes]
ymins = [ax.get_ylim()[0] for ax in axes]
ymax = max(ymaxes)
ymin = min(ymins)
for ax in axes:
ax.set_ylim(ymin, ymax)
fig.tight_layout()
ax_remove_box(a1)
ax_remove_box(a2)
ax_remove_box(a3)
ax_remove_box(a4)
fig2 = plt.figure(figsize=text_fig)
text = ("%s rate blocked by model improvement\n"
"gc, md: %.2E, n: %d\n"
"stp, md: %.2E, n: %d\n"
"LN, md: %.2E, n: %d\n"
"both, md:%.2E, n: %d\n"
"m.w. stp v gc: u: %.4E, p: %.4E\n"
"gc vs LN: u: %.4E, p: %.4E\n"
"stp vs LN: u: %.4E, p: %.4E\n"
"both vs gc: u: %.4E, p: %.4E\n"
"both vs stp: u: %.4E, p: %.4E\n"
"both vs LN: u: %.4E, p: %.4E\n" %
(rate_type, md_gc, n_gc, md_stp, n_stp, md_LN, n_LN, md_both,
n_both, u, p, u_gc, p_gc, u_stp, p_stp, u_both_gc, p_both_gc,
u_both_stp, p_both_stp, u_both, p_both))
plt.text(0.1, 0.5, text)
return fig, fig2
def stp_parameter_comp(batch, modelname, modelname0=None):
d = nems_db.params.fitted_params_per_batch(batch,
modelname,
stats_keys=[],
multi='first')
u_bounds = np.array([-0.6, 2.1])
tau_bounds = np.array([-0.1, 1.5])
str_bounds = np.array([-0.25, 0.55])
amp_bounds = np.array([-1, 1.5])
indices = list(d.index)
fir_index = None
do_index = None
for ind in indices:
if '--u' in ind:
u_index = ind
elif '--tau' in ind:
tau_index = ind
elif '--fir' in ind:
fir_index = ind
elif ('--do' in ind) and ('gains' in ind):
do_index = ind
u = d.loc[u_index]
tau = d.loc[tau_index]
if fir_index:
fir = d.loc[fir_index]
elif do_index:
fir = d.loc[do_index]
delay_index = do_index.replace('gains', 'delays')
f1s_index = do_index.replace('gains', 'f1s')
taus_index = do_index.replace('gains', 'taus')
for cellid in fir.index:
print(cellid)
c = da_coefficients(f1s=d.loc[f1s_index, cellid],
taus=d.loc[taus_index, cellid],
delays=d.loc[delay_index, cellid],
gains=d.loc[do_index, cellid],
n_coefs=10)
fir[cellid] = c
else:
raise ValueError('FIR/DO index not found')
r_test = d.loc['meta--r_test']
se_test = d.loc['meta--se_test']
print(u)
if modelname0 is not None:
d0 = nems_db.params.fitted_params_per_batch(batch,
modelname0,
stats_keys=[],
multi='first')
r0_test = d0.loc['meta--r_test']
se0_test = d0.loc['meta--se_test']
u_mtx = np.zeros((len(u), 2))
tau_mtx = np.zeros_like(u_mtx)
m_fir = np.zeros_like(u_mtx)
r_test_mtx = np.zeros(len(u))
r0_test_mtx = np.zeros(len(u))
se_test_mtx = np.zeros(len(u))
se0_test_mtx = np.zeros(len(u))
str_mtx = np.zeros_like(u_mtx)
i = 0
for cellid in u.index:
r_test_mtx[i] = r_test[cellid]
se_test_mtx[i] = se_test[cellid]
if modelname0 is not None:
r0_test_mtx[i] = r0_test[cellid]
se0_test_mtx[i] = se0_test[cellid]
t_fir = fir[cellid]
x = np.mean(t_fir, axis=1) / np.std(t_fir)
mn, = np.where(x == np.min(x))
mx, = np.where(x == np.max(x))
xidx = np.array([mx[0], mn[0]])
m_fir[i, :] = x[xidx]
u_mtx[i, :] = u[cellid][xidx]
tau_mtx[i, :] = np.abs(tau[cellid][xidx])
str_mtx[i, :] = stp_magnitude(tau_mtx[i, :], u_mtx[i, :], fs=100,
A=1)[0]
i += 1
# EI_units = (m_fir[:,0]>0) & (m_fir[:,1]<0)
EI_units = (m_fir[:, 1] < 0)
#good_pred = (r_test_mtx > se_test_mtx*2)
good_pred = ((r_test_mtx > se_test_mtx * 3) |
(r0_test_mtx > se0_test_mtx * 3))
mod_units = (r_test_mtx - se_test_mtx) > (r0_test_mtx + se0_test_mtx)
show_units = mod_units & good_pred
u_mtx[u_mtx < u_bounds[0]] = u_bounds[0]
u_mtx[u_mtx > u_bounds[1]] = u_bounds[1]
tau_mtx[tau_mtx > tau_bounds[1]] = tau_bounds[1]
str_mtx[str_mtx < str_bounds[0]] = str_bounds[0]
str_mtx[str_mtx > str_bounds[1]] = str_bounds[1]
m_fir[m_fir < amp_bounds[0]] = amp_bounds[0]
m_fir[m_fir > amp_bounds[1]] = amp_bounds[1]
umean = np.median(u_mtx[show_units], axis=0)
uerr = np.std(u_mtx[show_units], axis=0) / np.sqrt(np.sum(show_units))
taumean = np.median(tau_mtx[show_units], axis=0)
tauerr = np.std(tau_mtx[show_units], axis=0) / np.sqrt(str_mtx.shape[0])
strmean = np.median(str_mtx[show_units], axis=0)
strerr = np.std(str_mtx[show_units], axis=0) / np.sqrt(str_mtx.shape[0])
xstr = 'E'
ystr = 'I'
fh = plt.figure(figsize=(8, 5))
dotcolor = 'black'
dotcolor_ns = 'lightgray'
thinlinecolor = 'gray'
barcolors = [(235 / 255, 47 / 255, 40 / 255),
(115 / 255, 200 / 255, 239 / 255)]
barwidth = 0.5
ax = plt.subplot(2, 3, 1)
plt.plot(np.array(amp_bounds), np.array(amp_bounds), 'k--')
plt.plot(m_fir[~show_units, 0],
m_fir[~show_units, 1],
'.',
color=dotcolor_ns)
plt.plot(m_fir[show_units, 0], m_fir[show_units, 1], '.', color=dotcolor)
plt.title('n={}/{} good units'.format(np.sum(show_units),
np.sum(good_pred)))
plt.xlabel('exc channel gain')
plt.ylabel('inh channel gain')
ax_remove_box(ax)
ax = plt.subplot(2, 3, 2)
plt.plot(u_bounds, u_bounds, 'k--')
plt.plot(u_mtx[~show_units, 0],
u_mtx[~show_units, 1],
'.',
color=dotcolor_ns)
plt.plot(u_mtx[show_units, 0], u_mtx[show_units, 1], '.', color=dotcolor)
plt.axis('equal')
plt.xlabel('exc channel u')
plt.ylabel('inh channel u')
plt.ylim(u_bounds)
ax_remove_box(ax)
ax = plt.subplot(2, 3, 3)
plt.plot(str_bounds, str_bounds, 'k--')
plt.plot(str_mtx[~show_units, 0],
str_mtx[~show_units, 1],
'.',
color=dotcolor_ns)
plt.plot(str_mtx[show_units, 0],
str_mtx[show_units, 1],
'.',
color=dotcolor)
plt.axis('equal')
plt.xlabel('exc channel str')
plt.ylabel('inh channel str')
plt.ylim(str_bounds)
ax_remove_box(ax)
ax = plt.subplot(2, 3, 4)
plt.plot(np.array([-0.5, 1.5]), np.array([0, 0]), 'k--')
plt.bar(np.arange(2), umean, color=barcolors, width=barwidth)
plt.errorbar(np.arange(2), umean, yerr=uerr, color='black', linewidth=2)
plt.plot(u_mtx[show_units].T, linewidth=0.5, color=thinlinecolor)
# plt.plot(np.random.normal(0, 0.05, size=u_mtx[show_units, 0].shape),
# u_mtx[show_units, 0], '.', color=dotcolor)
# plt.plot(np.random.normal(1, 0.05, size=u_mtx[show_units, 0].shape),
# u_mtx[show_units, 1], '.', color=dotcolor)
w, p = ss.wilcoxon(u_mtx[show_units, 0], u_mtx[show_units, 1])
plt.ylim(u_bounds)
plt.ylabel('u')
plt.xlabel('{} {:.3f} - {} {:.3f} - rat {:.3f} - p={:.1e}'.format(
xstr, umean[0], ystr, umean[1], umean[1] / umean[0], p))
ax_remove_box(ax)
ax = plt.subplot(2, 3, 5)
plt.plot(np.array([-0.5, 1.5]), np.array([0, 0]), 'k--')
plt.bar(np.arange(2), np.sqrt(taumean), color=barcolors, width=barwidth)
plt.errorbar(np.arange(2),
np.sqrt(taumean),
yerr=np.sqrt(tauerr),
color='black',
linewidth=2)
plt.plot(np.sqrt(tau_mtx[show_units].T),
linewidth=0.5,
color=thinlinecolor)
w, p = ss.wilcoxon(tau_mtx[show_units, 0], tau_mtx[show_units, 1])
plt.ylim((-np.sqrt(np.abs(tau_bounds[0])), np.sqrt(tau_bounds[1])))
plt.ylabel('sqrt(tau)')
plt.xlabel('E {:.3f} - I {:.3f} - rat {:.3f} - p={:.1e}'.format(
taumean[0], taumean[1], taumean[1] / taumean[0], p))
ax_remove_box(ax)
ax = plt.subplot(2, 3, 6)
plt.plot(np.array([-0.5, 1.5]), np.array([0, 0]), 'k--')
plt.bar(np.arange(2), strmean, color=barcolors, width=barwidth)
plt.errorbar(np.arange(2),
strmean,
yerr=strerr,
color='black',
linewidth=2)
plt.plot(str_mtx[show_units].T, linewidth=0.5, color=thinlinecolor)
w, p = ss.wilcoxon(str_mtx[show_units, 0], str_mtx[show_units, 1])
plt.ylim(str_bounds)
plt.ylabel('STP str')
plt.xlabel('E {:.3f} - I {:.3f} - rat {:.3f} - p={:.1e}'.format(
strmean[0], strmean[1], strmean[1] / strmean[0], p))
ax_remove_box(ax)
plt.tight_layout()
return fh
def model_comp_pareto(batch,
modelgroups,
ax,
cellids,
nparms_modelgroups=None,
dot_colors=None,
dot_markers=None,
fill_styles=None,
plot_stat='r_test',
plot_medians=False,
labeled_models=None,
show_legend=True):
if labeled_models is None:
labeled_models = []
if nparms_modelgroups is None:
nparms_modelgroups = copy.copy(modelgroups)
if fill_styles is None:
fill_styles = {k: 'full' for (k, v) in dot_colors.items()}
mean_cells_per_site = len(cellids) # NAT4 dataset, so all cellids are used
overall_min = 100
overall_max = -100
all_model_means = []
labeled_data = []
for k, modelnames in modelgroups.items():
np_modelnames = nparms_modelgroups[k]
b_ceiling = nd.batch_comp(batch,
modelnames,
cellids=cellids,
stat=plot_stat)
b_n = nd.batch_comp(batch,
np_modelnames,
cellids=cellids,
stat='n_parms')
if not plot_medians:
model_mean = b_ceiling.mean()
else:
model_mean = b_ceiling.median()
b_m = np.array(model_mean)
print(
f"{k} modelcount {len(modelnames)} fits per model: {b_n.count().values}"
)
n_parms = np.array([np.mean(b_n[m]) for m in np_modelnames])
# don't divide by cells per site if only one cell was fit
if ('single' not in k) and (k != 'LN') and (k != 'stp'):
n_parms = n_parms / mean_cells_per_site
y_max = b_m.max() * 1.05
y_min = b_m.min() * 0.9
overall_max = max(overall_max, y_max)
overall_min = min(overall_min, y_min)
ax.plot(n_parms,
b_m,
color=dot_colors[k],
marker=dot_markers[k],
label=k,
markersize=4.5,
fillstyle=fill_styles[k])
for m in labeled_models:
if m in modelnames:
i = modelnames.index(m)
labeled_data.append([n_parms[i], b_m[i]])
all_model_means.append(model_mean)
ax.plot(*list(zip(*labeled_data)),
's',
color='black',
marker='o',
fillstyle='none',
markersize=10)
handles, labels = ax.get_legend_handles_labels()
# reverse the order
if show_legend:
ax.legend(handles,
labels,
loc='lower right',
fontsize=7,
frameon=False)
ax.set_xlabel('Free parameters per neuron')
ax.set_ylabel('Median prediction correlation')
ax.set_ylim((overall_min, overall_max))
ax_remove_box(ax)
plt.tight_layout()
return ax, b_ceiling, all_model_means, labels
def single_scatter(batch,
gc,
stp,
LN,
combined,
compare,
plot_stat='r_ceiling',
legend=False):
all_batch_cells = nd.get_batch_cells(batch, as_list=True)
df_r, df_c, df_e = get_dataframes(batch, gc, stp, LN, combined)
e, a, g, s, c = improved_cells_to_list(batch,
gc,
stp,
LN,
combined,
se_filter=True,
LN_filter=False,
as_lists=True)
if plot_stat == 'r_ceiling':
plot_df = df_c
else:
plot_df = df_r
improved = c
not_improved = list(set(a) - set(c))
models = [gc, stp, LN, combined]
names = ['gc', 'stp', 'LN', 'combined']
m1 = models[compare[0]]
m2 = models[compare[1]]
name1 = names[compare[0]]
name2 = names[compare[1]]
n_batch = len(all_batch_cells)
n_all = len(a)
n_imp = len(improved)
n_not_imp = len(not_improved)
m1_scores = plot_df[m1][not_improved]
m1_scores_improved = plot_df[m1][improved]
m2_scores = plot_df[m2][not_improved]
m2_scores_improved = plot_df[m2][improved]
fig = plt.figure()
plt.plot([0, 1], [0, 1],
color='black',
linewidth=1,
linestyle='dashed',
dashes=dash_spacing)
plt.scatter(m1_scores,
m2_scores,
s=small_scatter,
label='no imp.',
color=model_colors['LN'])
#color='none',
#edgecolors='black', linewidth=0.35)
plt.scatter(m1_scores_improved,
m2_scores_improved,
s=big_scatter,
label='sig. imp.',
color=model_colors['max'])
#color='none',
#edgecolors='black', linewidth=0.35)
ax_remove_box()
if legend:
plt.legend()
plt.xlim(0, 1)
plt.ylim(0, 1)
plt.tight_layout()
plt.axes().set_aspect('equal')
fig2 = plt.figure(figsize=text_fig)
plt.text(
0.1, 0.5, "batch %d\n"
"%d/%d auditory/total cells\n"
"%d no improvements\n"
"%d at least one improvement\n"
"stat: %s, x: %s, y: %s" %
(batch, n_all, n_batch, n_not_imp, n_imp, plot_stat, name1, name2))
return fig, fig2
def gc_distributions(batch,
gc,
stp,
LN,
combined,
se_filter=True,
good_ln=0,
use_combined=False):
df_r, df_c, df_e = get_dataframes(batch, gc, stp, LN, combined)
cellids, under_chance, less_LN = get_filtered_cellids(batch,
gc,
stp,
LN,
combined,
as_lists=False)
_, _, _, _, c = improved_cells_to_list(batch,
gc,
stp,
LN,
combined,
good_ln=good_ln)
if use_combined:
params_model = combined
else:
params_model = gc
gc_params = fitted_params_per_batch(batch,
params_model,
stats_keys=[],
meta=[])
gc_params_cells = gc_params.transpose().index.values.tolist()
for cell in gc_params_cells:
if cell not in cellids:
cellids[cell] = False
not_c = list(set(gc_params.transpose()[cellids].index.values) - set(c))
# index keys are formatted like "4--dsig.d--kappa"
mod_keys = params_model.split('_')[1]
for i, k in enumerate(mod_keys.split('-')):
if 'dsig' in k:
break
b_key = f'{i}--{k}--base'
a_key = f'{i}--{k}--amplitude'
s_key = f'{i}--{k}--shift'
k_key = f'{i}--{k}--kappa'
ka_key = k_key + '_mod'
ba_key = b_key + '_mod'
aa_key = a_key + '_mod'
sa_key = s_key + '_mod'
all_keys = [b_key, a_key, s_key, k_key, ba_key, aa_key, sa_key, ka_key]
phi_dfs = [
gc_params[gc_params.index == k].transpose()[cellids].transpose()
for k in all_keys
]
sep_dfs = [df[not_c].values.flatten().astype(np.float64) for df in phi_dfs]
gc_sep_dfs = [df[c].values.flatten().astype(np.float64) for df in phi_dfs]
# removing extreme outliers b/c kept getting one or two cells with
# values that were multiple orders of magnitude different than all others
# diffs = [sep_dfs[i+1] - sep_dfs[i]
# for i, _ in enumerate(sep_dfs[:-1])
# if i % 2 == 0]
#diffs = sep_dfs[1::2] - sep_dfs[::2]
# gc_diffs = [gc_sep_dfs[i+1] - gc_sep_dfs[i]
# for i, _ in enumerate(gc_sep_dfs[:-1])
# if i % 2 == 0]
#gc_diffs = gc_sep_dfs[1::2] - gc_sep_dfs[::2]
raw_low, raw_high = sep_dfs[:4], sep_dfs[4:]
diffs = [high - low for low, high in zip(raw_low, raw_high)]
medians = [np.median(d) for d in diffs]
medians_low = [np.median(d) for d in raw_low]
medians_high = [np.median(d) for d in raw_high]
gc_raw_low, gc_raw_high = gc_sep_dfs[:4], gc_sep_dfs[4:]
gc_diffs = [high - low for low, high in zip(gc_raw_low, gc_raw_high)]
gc_medians = [np.median(d) for d in gc_diffs]
gc_medians_low = [np.median(d) for d in gc_raw_low]
gc_medians_high = [np.median(d) for d in gc_raw_high]
ts, ps = zip(*[
st.mannwhitneyu(diff, gc_diff, alternative='two-sided')
for diff, gc_diff in zip(diffs, gc_diffs)
])
diffs = drop_common_outliers(*diffs)
gc_diffs = drop_common_outliers(*gc_diffs)
not_imp_outliers = len(diffs[0])
imp_outliers = len(gc_diffs[0])
color = model_colors['LN']
c_color = model_colors['max']
gc_label = 'GC ++ (%d)' % len(c)
total_cells = len(c) + len(not_c)
hist_kwargs = {'label': ['no imp', 'sig imp'], 'linewidth': 1}
figs = []
for i, name in zip([0, 1, 2, 3], ['base', 'amplitude', 'shift', 'kappa']):
f1 = _stacked_hists(diffs[i],
gc_diffs[i],
medians[i],
gc_medians[i],
color,
c_color,
hist_kwargs=hist_kwargs)
f2 = plt.figure(figsize=text_fig)
text = ("%s distributions, n: %d\n"
"n gc imp (bot): %d, med: %.4f\n"
"n not imp (top): %d, med: %.4f\n"
"yaxes: fraction of cells\n"
"xaxis: 'fractional change in parameter per unit contrast'\n"
"st.mannwhitneyu u: %.4E,\np: %.4E\n"
"not imp w/o outliers: %d\n"
"imp w/o outliers: %d" %
(name, total_cells, len(c), gc_medians[i], len(not_c),
medians[i], ts[i], ps[i], not_imp_outliers, imp_outliers))
plt.text(0.1, 0.5, text)
figs.append(f1)
figs.append(f2)
f3 = plt.figure(figsize=small_fig)
# median gc effect plots
yin1, out1 = gc_dummy_sigmoid(*medians_low, low=0.0, high=0.3)
yin2, out2 = gc_dummy_sigmoid(*medians_high, low=0.0, high=0.3)
plt.scatter(yin1, out1, color=color, s=big_scatter, alpha=0.3)
plt.scatter(yin2, out2, color=color, s=big_scatter * 2)
figs.append(f3)
plt.tight_layout()
ax_remove_box()
f3a = plt.figure(figsize=text_fig)
text = ("non improved cells\n"
"median low contrast:\n"
"base: %.4f, amplitude: %.4f\n"
"shift: %.4f, kappa: %.4f\n"
"median high contrast:\n"
"base: %.4f, amplitude: %.4f\n"
"shift: %.4f, kappa: %.4f\n" % (*medians_low, *medians_high))
plt.text(0.1, 0.5, text)
figs.append(f3a)
f4 = plt.figure(figsize=small_fig)
gc_yin1, gc_out1 = gc_dummy_sigmoid(*gc_medians_low, low=0.0, high=0.3)
gc_yin2, gc_out2 = gc_dummy_sigmoid(*gc_medians_high, low=0.0, high=0.3)
plt.scatter(gc_yin1, gc_out1, color=c_color, s=big_scatter, alpha=0.3)
plt.scatter(gc_yin2, gc_out2, color=c_color, s=big_scatter * 2)
figs.append(f4)
plt.tight_layout()
ax_remove_box()
f4a = plt.figure(figsize=text_fig)
text = ("improved cells\n"
"median low contrast:\n"
"base: %.4f, amplitude: %.4f\n"
"shift: %.4f, kappa: %.4f\n"
"median high contrast:\n"
"base: %.4f, amplitude: %.4f\n"
"shift: %.4f, kappa: %.4f\n" %
(*gc_medians_low, *gc_medians_high))
plt.text(0.1, 0.5, text)
figs.append(f4a)
return figs
def performance_bar(batch,
gc,
stp,
LN,
combined,
se_filter=True,
LN_filter=False,
manual_cellids=None,
abbr_yaxis=False,
plot_stat='r_ceiling',
y_adjust=0.05,
manual_y=None,
only_improvements=False,
show_text_labels=False):
'''
model1: GC
model2: STP
model3: LN
model4: GC+STP
'''
df_r, df_c, df_e = get_dataframes(batch, gc, stp, LN, combined)
# cellids, under_chance, less_LN = get_filtered_cellids(batch, gc, stp,
# LN, combined,
# se_filter,
# LN_filter)
e, a, g, s, c = improved_cells_to_list(batch,
gc,
stp,
LN,
combined,
se_filter=se_filter,
LN_filter=LN_filter)
cellids = a
if manual_cellids is not None:
# WARNING: Will override se and ratio filters even if they are set
cellids = manual_cellids
elif only_improvements:
e, a, g, s, c = improved_cells_to_list(batch,
gc,
stp,
LN,
combined,
as_lists=True)
cellids = e
if plot_stat == 'r_ceiling':
plot_df = df_c
else:
plot_df = df_r
n_cells = len(cellids)
gc_test = plot_df[gc][cellids]
stp_test = plot_df[stp][cellids]
ln_test = plot_df[LN][cellids]
gc_stp_test = plot_df[combined][cellids]
#max_test = np.maximum(gc_test, stp_test)
gc = np.median(gc_test.values)
stp = np.median(stp_test.values)
ln = np.median(ln_test.values)
gc_stp = np.median(gc_stp_test.values)
#maximum = np.median(max_test)
largest = max(gc, stp, ln, gc_stp) #, maximum)
colors = [model_colors[k]
for k in ['LN', 'gc', 'stp', 'combined']] #, 'max']]
#fig = plt.figure(figsize=(15, 12))
fig = plt.figure()
plt.bar(
[1, 2, 3, 4],
[ln, gc, stp, gc_stp], # maximum],
color=colors,
edgecolor="black",
linewidth=1)
plt.xticks([1, 2, 3, 4, 5],
['LN', 'GC', 'STP', 'GC+STP']) #, 'Max(GC,STP)'])
if abbr_yaxis:
if manual_y:
lower, upper = manual_y
else:
lower = np.floor(10 * min(gc, stp, ln, gc_stp)) / 10
upper = np.ceil(10 * max(gc, stp, ln, gc_stp)) / 10 + y_adjust
plt.ylim(ymin=lower, ymax=upper)
else:
plt.ylim(ymax=largest * 1.4)
common_kwargs = {'color': 'white', 'horizontalalignment': 'center'}
if abbr_yaxis:
y_text = 0.5 * (lower + min(gc, stp, ln, gc_stp))
else:
y_text = 0.2
if show_text_labels:
for i, m in enumerate([ln, gc, stp, gc_stp]): #, maximum]):
t = plt.text(i + 1, y_text, "%0.04f" % m, **common_kwargs)
#t.set_path_effects([pe.withStroke(linewidth=3, foreground='black')])
xmin, xmax = plt.xlim()
plt.xlim(xmin, xmax - 0.35)
ax_remove_box()
plt.tight_layout()
fig2 = plt.figure(figsize=text_fig)
text = "Median Performance, batch: %d\, n:%d" % (batch, n_cells)
plt.text(0.1, 0.5, text)
return fig, fig2
def stp_distributions(batch,
gc,
stp,
LN,
combined,
se_filter=True,
good_ln=0,
log_scale=False,
legend=False,
use_combined=False):
df_r, df_c, df_e = get_dataframes(batch, gc, stp, LN, combined)
cellids, under_chance, less_LN = get_filtered_cellids(batch,
gc,
stp,
LN,
combined,
as_lists=False)
_, _, _, _, c = improved_cells_to_list(batch,
gc,
stp,
LN,
combined,
good_ln=good_ln)
if use_combined:
params_model = combined
else:
params_model = stp
stp_params = fitted_params_per_batch(batch,
params_model,
stats_keys=[],
meta=[])
stp_params_cells = stp_params.transpose().index.values.tolist()
for cell in stp_params_cells:
if cell not in cellids:
cellids[cell] = False
not_c = list(set(stp_params.transpose()[cellids].index.values) - set(c))
# index keys are formatted like "2--stp.2--tau"
mod_keys = stp.split('_')[1]
for i, k in enumerate(mod_keys.split('-')):
if 'stp' in k:
break
tau_key = '%d--%s--tau' % (i, k)
u_key = '%d--%s--u' % (i, k)
all_taus = stp_params[stp_params.index ==
tau_key].transpose()[cellids].transpose()
all_us = stp_params[stp_params.index ==
u_key].transpose()[cellids].transpose()
dims = all_taus.values.flatten()[0].shape[0]
# convert to dims x cells array instead of cells, array w/ multidim values
#sep_taus = _df_to_array(all_taus, dims).mean(axis=0)
#sep_us = _df_to_array(all_us, dims).mean(axis=0)
#med_tau = np.median(sep_taus)
#med_u = np.median(sep_u)
sep_taus = _df_to_array(all_taus[not_c], dims).mean(axis=0)
sep_us = _df_to_array(all_us[not_c], dims).mean(axis=0)
med_tau = np.median(sep_taus)
med_u = np.median(sep_us)
stp_taus = all_taus[c]
stp_us = all_us[c]
stp_sep_taus = _df_to_array(stp_taus, dims).mean(axis=0)
stp_sep_us = _df_to_array(stp_us, dims).mean(axis=0)
stp_med_tau = np.median(stp_sep_taus)
stp_med_u = np.median(stp_sep_us)
#tau_t, tau_p = st.ttest_ind(sep_taus, stp_sep_taus)
#u_t, u_p = st.ttest_ind(sep_us, stp_sep_us)
# NOTE: not actually a t statistic now, it's mann-whitney U statistic,
# just didn't want to change all of the var names incase i revert
tau_t, tau_p = st.mannwhitneyu(sep_taus,
stp_sep_taus,
alternative='two-sided')
u_t, u_p = st.mannwhitneyu(sep_us, stp_sep_us, alternative='two-sided')
sep_taus, sep_us = drop_common_outliers(sep_taus, sep_us)
stp_sep_taus, stp_sep_us = drop_common_outliers(stp_sep_taus, stp_sep_us)
not_imp_outliers = len(sep_taus)
imp_outliers = len(stp_sep_taus)
fig1, (a1, a2) = plt.subplots(2, 1, sharex=True, sharey=True)
color = model_colors['LN']
imp_color = model_colors['max']
stp_label = 'STP ++ (%d)' % len(c)
total_cells = len(c) + len(not_c)
bin_count = 30
hist_kwargs = {'linewidth': 1, 'label': ['not imp', 'stp imp']}
plt.sca(a1)
weights1 = [np.ones(len(sep_taus)) / len(sep_taus)]
weights2 = [np.ones(len(stp_sep_taus)) / len(stp_sep_taus)]
upper = max(sep_taus.max(), stp_sep_taus.max())
lower = min(sep_taus.min(), stp_sep_taus.min())
bins = np.linspace(lower, upper, bin_count + 1)
# if log_scale:
# lower_bound = min(sep_taus.min(), stp_sep_taus.min())
# upper_bound = max(sep_taus.max(), stp_sep_taus.max())
# bins = np.logspace(lower_bound, upper_bound, bin_count+1)
# hist_kwargs['bins'] = bins
# plt.hist([sep_taus, stp_sep_taus], weights=weights, **hist_kwargs)
a1.hist(sep_taus,
weights=weights1,
fc=faded_LN,
edgecolor=dark_LN,
bins=bins,
**hist_kwargs)
a2.hist(stp_sep_taus,
weights=weights2,
fc=faded_max,
edgecolor=dark_max,
bins=bins,
**hist_kwargs)
a1.axes.axvline(med_tau,
color=dark_LN,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
a1.axes.axvline(stp_med_tau,
color=dark_max,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
a2.axes.axvline(med_tau,
color=dark_LN,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
a2.axes.axvline(stp_med_tau,
color=dark_max,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
ax_remove_box(a1)
ax_remove_box(a2)
#plt.title('tau, sig diff?: p=%.4E' % tau_p)
#plt.xlabel('tau (ms)')
fig2 = plt.figure(figsize=text_fig)
text = ("tau distributions, n: %d\n"
"n stp imp (bot): %d, med: %.4f\n"
"n not imp (top): %d, med: %.4f\n"
"yaxes: fraction of cells\n"
"xaxis: tau(ms)\n"
"st.mannwhitneyu u: %.4E,\np: %.4E\n"
"not imp after outliers: %d\n"
"imp after outliers: %d\n" %
(total_cells, len(c), stp_med_tau, len(not_c), med_tau, tau_t,
tau_p, not_imp_outliers, imp_outliers))
plt.text(0.1, 0.5, text)
fig3, (a3, a4) = plt.subplots(2, 1, sharex=True, sharey=True)
weights3 = [np.ones(len(sep_us)) / len(sep_us)]
weights4 = [np.ones(len(stp_sep_us)) / len(stp_sep_us)]
upper = max(sep_us.max(), stp_sep_us.max())
lower = min(sep_us.min(), stp_sep_us.min())
bins = np.linspace(lower, upper, bin_count + 1)
# if log_scale:
# lower_bound = min(sep_us.min(), stp_sep_us.min())
# upper_bound = max(sep_us.max(), stp_sep_us.max())
# bins = np.logspace(lower_bound, upper_bound, bin_count+1)
# hist_kwargs['bins'] = bins
# plt.hist([sep_us, stp_sep_us], weights=weights, **hist_kwargs)
a3.hist(sep_us,
weights=weights3,
fc=faded_LN,
edgecolor=dark_LN,
bins=bins,
**hist_kwargs)
a4.hist(stp_sep_us,
weights=weights4,
fc=faded_max,
edgecolor=dark_max,
bins=bins,
**hist_kwargs)
a3.axes.axvline(med_u,
color=dark_LN,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
a3.axes.axvline(stp_med_u,
color=dark_max,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
a4.axes.axvline(med_u,
color=dark_LN,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
a4.axes.axvline(stp_med_u,
color=dark_max,
linewidth=2,
linestyle='dashed',
dashes=dash_spacing)
ax_remove_box(a3)
ax_remove_box(a4)
#plt.title('u, sig diff?: p=%.4E' % u_p)
#plt.xlabel('u (fractional change in gain \nper unit of stimulus amplitude)')
#plt.ylabel('proportion within group')
fig4 = plt.figure(figsize=text_fig)
text = ("u distributions, n: %d\n"
"n stp imp (bot): %d, med: %.4f\n"
"n not imp (top): %d, med: %.4f\n"
"yaxes: fraction of cells\n"
"xaxis: u(fractional change in gain per unit stimulus amplitude)\n"
"st.mannwhitneyu u: %.4E,\np: %.4E" %
(total_cells, len(c), stp_med_u, len(not_c), med_u, u_t, u_p))
plt.text(0.1, 0.5, text)
stp_mag, stp_yin, stp_out = stp_magnitude(np.array([[stp_med_tau]]),
np.array([[stp_med_u]]))
mag, yin, out = stp_magnitude(np.array([[med_tau]]), np.array([[med_u]]))
fig5 = plt.figure(figsize=short_fig)
plt.plot(stp_out.as_continuous().flatten(),
color=imp_color,
label='STP ++')
plt.plot(out.as_continuous().flatten(), color=color)
if legend:
plt.legend()
ax_remove_box()
return fig1, fig2, fig3, fig4, fig5
def stp_v_beh():
batch1 = 274
batch2 = 275
modelnames=["env.fs100-ld-st.beh-ref_dlog.f-wc.2x1.c-fir.1x15-lvl.1-dexp.1_jk.nf5-init.st-basic",
"env.fs100-ld-st.beh-ref_dlog.f-wc.2x1.c-fir.1x15-lvl.1-rep.2-dexp.2-mrg_jk.nf5-init.st-basic",
"env.fs100-ld-st.beh-ref_dlog.f-wc.2x1.c-rep.2-fir.1x15x2-lvl.2-dexp.2-mrg_jk.nf5-init.st-basic",
"env.fs100-ld-st.beh-ref_dlog.f-wc.2x1.c-stp.1-fir.1x15-lvl.1-dexp.1_jk.nf5-init.st-basic",
"env.fs100-ld-st.beh-ref_dlog.f-wc.2x1.c-stp.1-fir.1x15-lvl.1-rep.2-dexp.2-mrg_jk.nf5-init.st-basic",
"env.fs100-ld-st.beh-ref_dlog.f-wc.2x1.c-stp.1-rep.2-fir.1x15x2-lvl.2-dexp.2-mrg_jk.nf5-init.st-basic",
"env.fs100-ld-st.beh-ref_dlog.f-wc.2x1.c-rep.2-stp.2-fir.1x15x2-lvl.2-dexp.2-mrg_jk.nf5-init.st-basic"]
fileprefix="fig8.stp_v_beh"
n1=modelnames[0]
n2=modelnames[-3]
xc_range = [-0.05, 0.6]
df1 = nd.batch_comp(batch1,modelnames,stat='r_test').reset_index()
df1_e = nd.batch_comp(batch1,modelnames,stat='se_test').reset_index()
df2 = nd.batch_comp(batch2,modelnames,stat='r_test').reset_index()
df2_e = nd.batch_comp(batch2,modelnames,stat='se_test').reset_index()
df = df1.append(df2)
df_e = df1_e.append(df2_e)
cellcount = len(df)
beta1 = df[n1]
beta2 = df[n2]
beta1_test = df[n1]
beta2_test = df[n2]
se1 = df_e[n1]
se2 = df_e[n2]
beta1[beta1>1]=1
beta2[beta2>1]=1
# test for significant improvement
improvedcells = (beta2_test-se2 > beta1_test+se1)
# test for signficant prediction at all
goodcells = ((beta2_test > se2*3) | (beta1_test > se1*3))
fh = plt.figure()
ax = plt.subplot(2,2,1)
stateplots.beta_comp(beta1[goodcells], beta2[goodcells],
n1='LN STRF', n2='STP+BEH LN STRF',
hist_range=xc_range, ax=ax,
highlight=improvedcells[goodcells])
# LN vs. STP:
beta1b = df[modelnames[3]]
beta1a = df[modelnames[0]]
beta1 = beta1b - beta1a
se1a = df_e[modelnames[3]]
se1b= df_e[modelnames[0]]
b1=4
b0=3
beta2b = df[modelnames[b1]]
beta2a = df[modelnames[b0]]
beta2 = beta2b - beta2a
se2a = df_e[modelnames[b1]]
se2b= df_e[modelnames[b0]]
stpgood = (beta1 > se1a+se1b)
behgood = (beta2 > se2a+se2b)
neither_good = np.logical_not(stpgood) & np.logical_not(behgood)
both_good = stpgood & behgood
stp_only_good = stpgood & np.logical_not(behgood)
beh_only_good = np.logical_not(stpgood) & behgood
xc_range = np.array([-0.05, 0.15])
beta1[beta1<xc_range[0]]=xc_range[0]
beta2[beta2<xc_range[0]]=xc_range[0]
zz = np.zeros(2)
ax=plt.subplot(2,2,2)
ax.plot(xc_range,zz,'k--',linewidth=0.5)
ax.plot(zz,xc_range,'k--',linewidth=0.5)
ax.plot(xc_range, xc_range, 'k--', linewidth=0.5)
l = ax.plot(beta1[neither_good], beta2[neither_good], '.', color='lightgray') +\
ax.plot(beta1[beh_only_good], beta2[beh_only_good], '.', color='purple') +\
ax.plot(beta1[stp_only_good], beta2[stp_only_good], '.', color='orange') +\
ax.plot(beta1[both_good], beta2[both_good], '.', color='black')
ax_remove_box(ax)
ax.set_aspect('equal', 'box')
#plt.axis('equal')
ax.set_xlim(xc_range)
ax.set_ylim(xc_range)
ax.set_xlabel('delta(stp)')
ax.set_ylabel('delta(beh)')
olap=np.zeros(100)
a = stpgood.values.copy()
b = behgood.values.copy()
for i in range(100):
np.random.shuffle(a)
olap[i] = np.sum(a & b)
ll=[np.sum(neither_good), np.sum(beh_only_good),
np.sum(stp_only_good), np.sum(both_good)]
ax.legend(l, ll)
ax=plt.subplot(2,2,3)
m = np.array(df.loc[goodcells].mean()[modelnames])
xc_range = [-0.02, 0.2]
plt.bar(np.arange(len(modelnames)), m, color='black')
plt.plot(np.array([-1, len(modelnames)]), np.array([0, 0]), 'k--',
linewidth=0.5)
plt.ylim(xc_range)
plt.title("batch {}, n={}/{} good cells".format(
batch, np.sum(goodcells), len(goodcells)))
plt.ylabel('median pred corr')
plt.xlabel('model architecture')
ax_remove_box(ax)
for i in range(len(modelnames)-1):
d1 = np.array(df[modelnames[i]])
d2 = np.array(df[modelnames[i+1]])
s, p = ss.wilcoxon(d1, d2)
plt.text(i+0.5, m[i+1], "{:.1e}".format(p), ha='center', fontsize=6)
plt.xticks(np.arange(len(m)),np.round(m,3))
return fh, df[stpgood]['cellid'].tolist()
def example_clip(cellid,
batch,
gc,
stp,
LN,
combined,
skip_combined=False,
normalize=True,
stim_idx=0,
trim_start=None,
trim_end=None,
smooth_response=False,
kernel_length=3,
strf_spec='LN',
load_path=None,
save_path=None):
if load_path is None:
gc_ctx, stp_ctx, LN_ctx, combined_ctx = \
_get_plot_contexts(cellid, batch, gc, stp, LN, combined)
if save_path is not None:
results = {'contexts': [gc_ctx, stp_ctx, LN_ctx, combined_ctx]}
pickle.dump(results, open(save_path, 'wb'))
else:
results = pickle.load(open(load_path, 'rb'))
gc_ctx, stp_ctx, LN_ctx, combined_ctx = results['contexts']
gc_pred, stp_pred, LN_pred, combined_pred, resp, stim = \
_get_plot_signals(gc_ctx, stp_ctx, LN_ctx, combined_ctx)
gc_v, stp_v, LN_v, combined_v = _get_plot_vals(gc_ctx, stp_ctx, LN_ctx,
combined_ctx)
# break up into separate stims
epochs = gc_v.epochs
stims = ep.epoch_names_matching(epochs, 'STIM_')
s = stims[stim_idx]
row = epochs[epochs.name == s]
fs = gc_v['resp'].fs
start = int(row['start'].values[0] * fs)
end = int(row['end'].values[0] * fs)
if trim_start is not None:
start += trim_start
if trim_end is not None:
end = start + (trim_end - trim_start)
resp_plot = resp[start:end]
if smooth_response:
# box filter, "simple average"
kernel = np.ones((kernel_length, )) * (1 / kernel_length)
resp_plot = convolve(resp_plot, kernel, mode='same')
LN_plot = LN_pred[start:end]
gc_plot = gc_pred[start:end]
stp_plot = stp_pred[start:end]
combined_plot = combined_pred[start:end]
stim_plot = stim[:, start:end]
if normalize:
max_all = np.nanmax(
np.concatenate(
[resp_plot, LN_plot, gc_plot, stp_plot, combined_plot]))
gc_plot = gc_plot / max_all
stp_plot = stp_plot / max_all
LN_plot = LN_plot / max_all
combined_plot = combined_plot / max_all
resp_plot = resp_plot / max_all
fig = plt.figure(figsize=wide_fig)
xmin = 0
xmax = end - start
plt.imshow(stim_plot,
aspect='auto',
cmap=spectrogram_cmap,
origin='lower',
extent=(xmin, xmax, 1.1, 1.5))
lw = 0.75
plt.plot(resp_plot, color=model_colors['LN'], linewidth=lw)
t = np.linspace(0, resp_plot.shape[-1] - 1, resp_plot.shape[-1])
plt.fill_between(t, resp_plot, color='gray', alpha=0.15)
plt.plot(gc_plot, color=model_colors['gc'], linewidth=lw)
plt.plot(stp_plot,
color=model_colors['stp'],
alpha=0.65,
linewidth=lw * 1.25)
plt.plot(LN_plot, color='black', alpha=0.55, linewidth=lw)
signals = ['Response', 'LN', 'GC', 'STP']
if not skip_combined:
plt.plot(combined_plot,
color=model_colors['combined'],
linewidth=lw,
linestyle='--')
signals.append('GC+STP')
plt.ylim(-0.1, 1.5)
ax = plt.gca()
ax_remove_box(ax)
fig2 = plt.figure(figsize=text_fig)
text = ("cellid: %s\n"
"stp_r_test: %.4f\n"
"gc_r_test: %.4f\n"
"LN_r_test: %.4f\n"
"comb_r_test: %.4f" % (cellid, stp_ctx['modelspec'].meta['r_test'],
gc_ctx['modelspec'].meta['r_test'],
LN_ctx['modelspec'].meta['r_test'],
combined_ctx['modelspec'].meta['r_test']))
plt.text(0.1, 0.5, text)
# TODO: probably need to just rip code out of strf_heatmap instead,
# setting the extent is not working. or alternatively just
# resize it manually to mach the spectrogram
fig3 = plt.figure(figsize=wide_fig)
ax2 = plt.gca()
if strf_spec == 'LN':
modelspec = LN_ctx['modelspec']
elif strf_spec == 'stp':
modelspec = stp_ctx['modelspec']
elif strf_spec == 'gc':
modelspec = gc_ctx['modelspec']
else:
modelspec = combined_ctx['modelspec']
nplt.strf_heatmap(modelspec,
ax=ax2,
show_factorized=False,
show_cbar=False,
manual_extent=(0, 1, 1.1, 1.5))
ax2.set_ylim(-0.1, 1.5)
ax_remove_box(ax2)
return fig, fig2, fig3