def plot_delta_xy(ds,
circ_pt_delts,
ax,
color_st=None,
line_color=(.8, .8, .8),
color_incr=.1):
delta_eg = np.linspace(-.9, .9, 1000)
dx, dy = am.dxdy_from_dsdelt(ds, delta_eg)
gpl.plot_trace_werr(dx,
dy,
ax=ax,
log_y=True,
log_x=True,
color=line_color)
color = color_st
for i, cpd in enumerate(circ_pt_delts):
dx, dy = am.dxdy_from_dsdelt(ds, cpd)
l = ax.plot(dx, dy, 'o', color=color)
color = gpl.add_color(l[0].get_color(), color_incr)
xl = ax.get_xlim()
yl = ax.get_ylim()
ax.hlines(ds, *xl, color='k', linestyle='dashed')
ax.vlines(ds, *yl, color='k', linestyle='dashed')
ax.set_xlabel(r'$D_{X}$')
ax.set_ylabel(r'$D_{Y}$')
def plot_spatial_bias(ds,
conds,
labels=None,
colors=None,
ax=None,
filt_func=None,
left_field='left_first',
right_field='right_first',
boots=1000):
if ax is None:
f = plt.figure()
ax = f.add_subplot(1, 1, 1)
if labels is None:
labels = ('', ) * len(ds)
if colors is None:
colors = (None, ) * len(ds)
l_func = lambda x: np.sum(x[left_field])
r_func = lambda x: np.sum(x[right_field])
ratio_func = _make_ratio_function(l_func, r_func)
for i, d in enumerate(ds):
trs = u.get_only_conds(d, conds)
if filt_func is not None:
trs = filt_func(trs)
v = u.bootstrap_list(trs, ratio_func, n=boots)
v = np.array(v).reshape((-1, 1))
gpl.plot_trace_werr(np.array([0]) + i,
v,
error_func=gpl.conf95_interval,
ax=ax,
label=labs[i],
fill=False,
color=cols[i])
return ax
def plot_load_mse(data,
ax=None,
plot_fit=True,
max_load=np.inf,
boots=None,
sep_subj=False,
data_color=(.7, .7, .7),
**plot_args):
if ax is None:
f, ax = plt.subplots(1, 1)
ls, errs = data
for i, err in enumerate(errs):
if sep_subj:
use_ax = ax[i]
else:
use_ax = ax
l = ls[i]
mask = l <= max_load
l = l[mask]
subj = i + 1
mse = np.array(err)[mask]**2
if boots is not None:
mse = np.array(
list(
u.bootstrap_list(mse_i.flatten(), np.nanmean, boots)
for mse_i in mse))
gpl.plot_trace_werr(l,
mse,
ax=use_ax,
label='S{}'.format(subj),
jagged=True,
color=data_color,
**plot_args)
return ax
def plot_eg_overlap(ax1,
ax2,
n_stim=2,
eg_s=100,
color1=(.6, .6, .6),
color2=(.6, .6, .6)):
ax1.set_aspect('equal')
ax2.set_aspect('equal')
stims = np.random.rand(n_stim, 3) * 100
for stim in stims:
gpl.plot_trace_werr(stim[1], stim[0], marker='o', ax=ax1, color=color1)
gpl.plot_trace_werr(stim[1], stim[2], marker='o', ax=ax2, color=color2)
ax1.set_xlim([0, eg_s])
ax1.set_ylim([0, eg_s])
_ = ax1.set_yticks([0, eg_s / 2, eg_s])
_ = ax1.set_yticklabels(['0', 's/2', 's'])
_ = ax2.set_yticks([0, eg_s / 2, eg_s])
_ = ax2.set_yticklabels(['0', 's/2', 's'])
_ = ax1.set_xticks([0, eg_s / 2, eg_s])
_ = ax1.set_xticklabels(['0', 's/2', 's'])
ax2.set_xlabel('position')
ax1.set_ylabel('audition')
ax2.set_ylabel('vision')
def plot_distance_error_prob(ax,
distortions=(1, 10, 20),
color=None,
distance_bounds=(.1, 20),
n_dists=1000,
label=True,
label_num=None,
line_label=False,
ll_buff=.1,
color_incr=.1,
emp_ders=None,
emp_xs=None):
distances = np.linspace(distance_bounds[0], distance_bounds[1], n_dists)
sps = np.zeros((len(distortions), n_dists))
for i, distort in enumerate(distortions):
swap_prob = sts.norm(distances, np.sqrt(2 * distort)).cdf(0)
sp = sts.norm(distances, np.sqrt(2 * distort)).cdf(0)
swap_prob = 2 * sp - 2 * sp**2
if label and label_num is None:
label = r'$D_{X/Y} = ' + '{}$'.format(distort)
elif label and label_num is not None:
label = r'$\Delta D = ' + '{}$'.format(label_num[i])
else:
label = ''
if label and line_label:
legend_label = ''
else:
legend_label = label
if i > 0:
color = gpl.add_color(color, i * color_incr)
gpl.plot_trace_werr(distances,
swap_prob,
ax=ax,
label=legend_label,
color=color)
if line_label:
ms = np.array([
int(np.floor(n_dists / 2 - ll_buff * n_dists)),
int(np.ceil(n_dists / 2 + ll_buff * n_dists))
])
gpl.label_plot_line(distances, swap_prob, label, ax, mid_samp=ms)
sps[i] = swap_prob
if emp_ders is not None and emp_xs is not None:
gpl.plot_trace_werr(emp_xs,
emp_ders[:, i].T,
color=color,
error_func=gpl.conf95_interval,
ax=ax)
_ = ax.set_xlabel('distance between stimuli')
_ = ax.set_ylabel('assignment error\nprobability')
return sps, distances
def plot_distance_distrib_prob(ax,
overlap_dims=(1, ),
funcs=(am.line_picking_line, ),
n_dists=1000):
for i, d in enumerate(overlap_dims):
dists = np.linspace(0, np.sqrt(d), n_dists)
func = funcs[i]
gpl.plot_trace_werr(dists,
func(dists),
ax=ax,
label='C = {}'.format(d))
ax.set_xlabel('distance between stimuli')
_ = ax.set_ylabel('probability density')
def plot_sdmst_bias(ds,
condlist,
cond_labels=None,
d_labels=None,
d_colors=None,
ax=None,
filt_func=None,
boots=1000,
err_field='TrialError',
corr=0,
incorr=6,
offset_div=6,
rotate_labels=True):
if cond_labels is None:
cond_labels = ('', ) * len(condlist)
if d_labels is None:
d_labels = ('', ) * len(ds)
if d_colors is None:
d_colors = ('', ) * len(ds)
if ax is None:
f = plt.figure()
ax = f.add_subplot(1, 1, 1)
corr_func = lambda x: np.sum(x['TrialError'] == corr)
incorr_func = lambda x: np.sum(x['TrialError'] == incorr)
ratio_func = _make_ratio_function(corr_func, incorr_func)
for i, d in enumerate(ds):
for j, c in enumerate(condlist):
trs = u.get_only_conds(d, (c, ))
c_r = u.bootstrap_list(trs, ratio_func, n=boots)
c_r = np.array(c_r).reshape((-1, 1))
offset = (i - len(ds) / 2) / 10
if j == 0:
use_label = d_labels[i]
else:
use_label = ''
gpl.plot_trace_werr(np.array([j]) + offset,
c_r,
error_func=gpl.conf95_interval,
ax=ax,
label=use_label,
fill=False,
color=d_colors[i])
ax.set_xticks(range(len(condlist)))
ax.set_xlabel('condition')
ax.set_ylabel('P(correct)')
if rotate_labels:
ax.set_xticklabels(cond_labels, rotation=90)
else:
ax.set_xticklabels(cond_labels)
return ax
def plot_dist_dependence(data,
ax=None,
eps=1e-4,
plot_fit=True,
boots=None,
sep_subj=False,
n_bins=5,
need_trials=20,
data_color=None,
digit_percentile=95,
**plot_args):
if ax is None:
f, ax = plt.subplots(1, 1)
ls, load_errs = data
for j, load in enumerate(load_errs):
if sep_subj:
use_ax = ax[j]
else:
use_ax = ax
for i, (errs, dists) in enumerate(load):
if ls[j][i] > 1:
l = ls[j][i]
dists = np.min(np.abs(dists[:, 1:l]), axis=1)
max_bin = np.percentile(dists, digit_percentile)
bins = np.linspace(0, max_bin + eps, n_bins + 1)
bin_inds = np.digitize(dists, bins)
binned_errs = []
bin_cents = []
for bi, binbeg in enumerate(bins[:-1]):
mask = bin_inds == bi
if np.sum(mask) > need_trials:
be = errs[mask].flatten()**2
binned_errs.append(be)
bin_cents.append((binbeg + bins[bi + 1]) / 2)
bin_cents = np.array(bin_cents)
binned_errs = np.array(binned_errs, dtype=object)
if boots is not None:
binned_errs = np.array(
list(
u.bootstrap_list(be_i, np.mean, boots)
for be_i in binned_errs))
gpl.plot_trace_werr(bin_cents,
binned_errs,
ax=use_ax,
jagged=True,
color=data_color,
**plot_args)
return ax
def plot_rdb(ax, bits_range=(0, 20), n_bits=1000, size=100):
bits = np.linspace(bits_range[0], bits_range[1], n_bits)
p = size
dist = ((p**2) / (2 * np.pi)) * np.exp(-bits)
gpl.plot_trace_werr(bits, dist, ax=ax, log_y=True, color='r')
poly_pts = [[bits[0], dist[0]], [bits[-1], dist[-1]], [0, 0]]
imp_region = plt.Polygon(poly_pts, color='r', alpha=.2)
ax.add_patch(imp_region)
ax.set_xlabel(r'information rate $I(X; \hat{X})$ (bits)')
ax.set_ylabel('estimator variance (MSE)')
_ = ax.set_xticks([0, 5, 10, 15, 20])
ax.set_xlim((bits[0], bits[-1]))
ax.set_ylim((dist[-1], dist[0]))
def _plot_di(di, t_ind, xs, axs, n_boots=1000, buff=.01, avg_models=False):
x_pts = di[:, 0, 0, t_ind]
y_pts = di[:, 0, 1, t_ind]
diffs = di[:, :, 1] - di[:, :, 0]
if avg_models:
diffs = np.mean(diffs, axis=0)
else:
diffs = diffs[:, 0]
diffs_b = u.bootstrap_list(diffs,
u.mean_axis0,
n=n_boots,
out_shape=(diffs.shape[1], ))
gpl.plot_trace_werr(xs, diffs_b, ax=axs[1], conf95=True)
axs[0].plot(x_pts, y_pts, 'o')
bound_low = min(np.min(x_pts), np.min(y_pts)) - buff
bound_high = max(np.max(x_pts), np.max(y_pts)) + buff
axs[0].plot([bound_low, bound_high], [bound_low, bound_high])
return axs
def plot_ae_rate(a_rate, a_approx, pr, s_counts, ax, colors=None):
for i, s in enumerate(s_counts):
l = gpl.plot_trace_werr(pr,
a_rate[i],
label='N = {}'.format(s),
ax=ax,
log_x=True,
log_y=True,
error_func=gpl.conf95_interval,
color=colors[i])
gpl.plot_trace_werr(pr,
a_approx[i],
ax=ax,
linestyle='dashed',
color=colors[i])
ax.set_xlabel(r'precision ratio ($s/D_{X/Y}$)')
ax.set_ylabel('assignment error rate')
def plot_fsc_bias(ds, labels=None, colors=None, ax=None, **kwargs):
if labels is None:
labels = ('', ) * len(ds)
if colors is None:
colors = (None, ) * len(ds)
if ax is None:
f = plt.figure()
ax = f.add_subplot(1, 1, 1)
for i, d in enumerate(ds):
x_oas, err_rates = get_fsc_bias(d, **kwargs)
gpl.plot_trace_werr(x_oas,
err_rates.T,
error_func=gpl.conf95_interval,
ax=ax,
label=labels[i],
color=colors[i])
ax.set_ylabel('P(look left)')
ax.set_xlabel('onset asynchrony (left - right)')
return ax
def plot_metrics(x_vals,
metrics,
x_label,
y_labels=None,
axs=None,
fwid=3,
theory=None,
eps=.1,
**kwargs):
if theory is None:
theory = {}
if axs is None:
fsize = (fwid * len(metrics), fwid)
f, axs = plt.subplots(1, len(metrics), figsize=fsize)
for i, (k, v) in enumerate(metrics.items()):
ax = axs[i]
if len(v.shape) == 3:
v = np.expand_dims(v, 2)
vs = v.shape
col = None
for j in range(vs[2]):
v_plot = v[:, :, j]
v_plot_shape = np.reshape(v_plot, (vs[0], vs[1] * vs[3]))
l = gpl.plot_trace_werr(x_vals,
v_plot_shape.T,
ax=ax,
color=col,
**kwargs)
col = l[0].get_color()
v_theor = theory.get(k)
if v_theor is not None:
gpl.plot_trace_werr(x_vals, v_theor, linestyle='dashed', ax=ax)
ax.set_title(k)
ax.set_xlabel(x_label)
if y_labels is not None:
ax.set_ylabel(y_labels[k])
yl = ax.get_ylim()
if np.diff(yl) < eps:
ax.set_ylim(yl[0] - eps, yl[1] + eps)
return axs
def plot_single_neuron_color(neur_dict,
xs,
plot_x,
filter_keys=None,
axs=None,
n_shuffs=100):
x_ind = np.argmin(np.abs(xs - plot_x))
mi_cs = []
for i, (k, v) in enumerate(neur_dict.items()):
if filter_keys is not None and k[-1] in filter_keys:
if axs is None:
f, ax = plt.subplots(1, 1)
else:
ax = axs[i]
edges = np.linspace(0, 2 * np.pi, 9)
bin_ids = np.digitize(v[1], edges)
jag_tr = []
jag_tr_shuff = []
unique_ids = np.unique(bin_ids)
for i, bi in enumerate(unique_ids):
jag_tr.append(v[0][bi == bin_ids])
mi_null = np.zeros(n_shuffs)
for j in range(n_shuffs):
bin_ids_shuff = np.random.choice(bin_ids,
len(bin_ids),
replace=False)
for i, bi in enumerate(unique_ids):
jag_tr_shuff.append(v[0][bi == bin_ids_shuff])
mi_null[j] = color_index(jag_tr_shuff)
gpl.plot_trace_werr(unique_ids, jag_tr, ax=ax, jagged=True)
mi_c = color_index(jag_tr)
print(mi_null)
print('m null', np.nanmean(mi_null))
print('s null', np.nanstd(mi_null))
print('unnorm', mi_c)
mi_c = (mi_c - np.nanmean(mi_null)) / np.nanstd(mi_null)
print('final', mi_c)
mi_cs.append(mi_c)
ax.set_title('MI: {}; {}'.format(mi_c, k[-1]))
return np.array(mi_cs)
def plot_asymmetric_eg(ds,
delt,
integ_ax,
indiv_ax,
colors,
n_pts=1000,
sd_mult=3):
dx, dy = am.dxdy_from_dsdelt(ds, delt)
pdf_pts = np.linspace(-sd_mult * np.sqrt(dy), sd_mult * np.sqrt(dy), n_pts)
c_x, c_y, c_s = colors
g_x = sts.norm(0, np.sqrt(dx)).pdf(pdf_pts)
g_y = sts.norm(0, np.sqrt(dy)).pdf(pdf_pts)
g_s = sts.norm(0, np.sqrt(ds)).pdf(pdf_pts)
gpl.plot_trace_werr(pdf_pts,
g_s,
ax=integ_ax,
color=c_s,
label=r'$s | \hat{x}, \hat{y}$')
gpl.plot_trace_werr(pdf_pts,
g_x,
ax=indiv_ax,
color=c_x,
label=r'$s | \hat{y}$')
gpl.plot_trace_werr(pdf_pts,
g_y,
ax=indiv_ax,
color=c_y,
label=r'$s | \hat{x}$')
indiv_ax.set_xlabel(r'stimulus value $s$')
indiv_ax.set_ylabel(r'posterior')
integ_ax.set_ylabel(r'posterior')
def plot_loss_summary(loss_a, tr_corr, tr_swap, val_corr, val_swap, fwid=5):
f, (ax_l, ax_ang, ax_val) = plt.subplots(
1,
3,
figsize=(fwid * 3, fwid),
)
ax_l.plot(loss_a)
xs_full = np.arange(len(tr_corr))
xs = np.arange(len(val_corr))
gpl.plot_trace_werr(xs_full, np.abs(np.array(tr_corr).T), ax=ax_ang)
gpl.plot_trace_werr(xs_full, np.abs(np.array(tr_swap).T), ax=ax_ang)
gpl.plot_trace_werr(xs, np.abs(np.array(val_corr).T), ax=ax_val)
gpl.plot_trace_werr(xs, np.abs(np.array(val_swap).T), ax=ax_val)
gpl.add_hlines(np.pi / 2, ax_ang)
gpl.add_hlines(np.pi / 2, ax_val)
def plot_plt_bias(ds,
labs=None,
cols=None,
filt_errs=True,
err_field='TrialError',
corr=0,
sep_field='angular_separation',
axs=None,
cond_nf=22,
cond_fn=19,
cond_nn=21,
cond_ff=20,
postthr='fixation_off',
sacc_vthr=.1,
readdpost=False,
lc=(-9, 0),
rc=(9, 0),
wid=3,
hei=3,
centoffset=(0, 0),
use_bhv_img_params=True,
boots=1000,
sep_filt=None,
figsize=(12, 4)):
if labs is None:
labs = ('', ) * len(ds)
if cols is None:
cols = ('', ) * len(ds)
if axs is None:
f = plt.figure(figsize=figsize)
ax_fs_nl = f.add_subplot(1, 3, 1)
ax_fs_nr = f.add_subplot(1, 3, 2)
ax_fs_bias = f.add_subplot(1, 3, 3)
else:
ax_fs_nl, ax_fs_nr, ax_fs_bias = axs
ax_fs_nl.set_title('left novelty bias')
ax_fs_nr.set_title('right novelty bias')
ax_fs_bias.set_title('full bias')
ax_fs_nl.set_ylabel('P(look left| novel vs familiar) -\n'
'P(look left | homogeneous)')
ax_fs_bias.set_ylabel('P(look novel)')
ax_fs_nl.set_xlabel('session')
ax_fs_nr.set_xlabel('session')
ax_fs_bias.set_xlabel('session')
conds = (cond_nn, cond_fn, cond_nf, cond_ff)
for i, d in enumerate(ds):
seps = np.unique(d[sep_field])
if sep_filt is not None:
seps = sep_filt(seps)
for j, s in enumerate(seps):
d_sep = d[d[sep_field] == s]
x = es.get_fixtimes(d,
conds,
postthr=postthr,
thr=sacc_vthr,
readdpost=readdpost,
lc=lc,
rc=rc,
wid=wid,
hei=hei,
centoffset=centoffset,
use_bhv_img_params=use_bhv_img_params)
ls, ts, begs, ends = x
fls = es.get_first_sacc_latency_nocompute(begs,
ts,
onim=False,
first_n=1,
sidesplit=True)
sacc_arr1 = _make_fls_arr(fls, cond_nf)
sacc_arr_nn = _make_fls_arr(fls, cond_nn)
sacc_arr_ff = _make_fls_arr(fls, cond_ff)
sacc_arr_null = np.concatenate((sacc_arr_nn, sacc_arr_ff))
# look novel when on left
f1 = lambda x: np.sum(x == 0)
f2 = lambda x: np.sum(x == 1)
rf1 = _make_ratio_function(f1, f2)
nov_left = u.bootstrap_list(sacc_arr1, rf1, n=boots)
nov_left = nov_left.reshape((-1, 1))
sub1 = np.mean(u.bootstrap_list(sacc_arr_null, rf1, n=boots))
gpl.plot_trace_werr(np.array([0]) + i,
nov_left - sub1,
error_func=gpl.conf95_interval,
ax=ax_fs_nl,
label=labs[i],
fill=False,
color=cols[i])
sacc_arr2 = _make_fls_arr(fls, cond_fn, l=1, r=0)
# look novel when on right
nov_right = u.bootstrap_list(sacc_arr2, rf1, n=boots)
nov_right = nov_right.reshape((-1, 1))
rf2 = _make_ratio_function(f2, f1)
sub2 = np.mean(u.bootstrap_list(sacc_arr_null, rf2, n=boots))
gpl.plot_trace_werr(np.array([0]) + i,
nov_right - sub2,
error_func=gpl.conf95_interval,
ax=ax_fs_nr,
fill=False,
color=cols[i])
full_sacc_arr = np.concatenate((sacc_arr1, sacc_arr2))
nov_full = u.bootstrap_list(full_sacc_arr, rf1, n=boots)
nov_full = nov_full.reshape((-1, 1))
gpl.plot_trace_werr(np.array([0]) + i,
nov_full,
error_func=gpl.conf95_interval,
ax=ax_fs_bias,
fill=False,
color=cols[i])
def plot_stan_model(model,
ae_ax,
dist_ax,
uni_ax,
n=4,
spacing=np.pi / 4,
sz=8):
m = model[0]
rb_means = np.mean(m.samples['report_bits'], axis=0)
db_means = np.mean(m.samples['dist_bits'], axis=0)
sm_means = np.mean(m.samples['stim_mem'], axis=0)
ae_prob, _ = da.ae_var_discrete(db_means, n, spacing=spacing, sz=sz)
unif_prob = da.uniform_prob(sm_means, n)
dist = da.dr_gaussian(rb_means, n)
subj_xs = np.random.randn(len(dist))
x_pos = np.array([0])
ae_prob_arr = np.expand_dims(ae_prob, 1)
p = ae_ax.violinplot(ae_prob, positions=x_pos, showextrema=False)
gpl.plot_trace_werr(x_pos,
ae_prob_arr,
points=True,
ax=ae_ax,
error_func=gpl.conf95_interval)
dist_arr = np.expand_dims(dist, 1)
p = dist_ax.violinplot(dist, positions=x_pos, showextrema=False)
gpl.plot_trace_werr(x_pos,
dist_arr,
points=True,
ax=dist_ax,
error_func=gpl.conf95_interval)
up_arr = np.expand_dims(unif_prob, 1)
p = uni_ax.violinplot(up_arr, positions=x_pos, showextrema=False)
gpl.plot_trace_werr(x_pos,
up_arr,
points=True,
ax=uni_ax,
error_func=gpl.conf95_interval)
gpl.clean_plot(ae_ax, 0)
gpl.clean_plot_bottom(ae_ax)
gpl.clean_plot(dist_ax, 0)
gpl.clean_plot_bottom(dist_ax)
gpl.clean_plot(uni_ax, 0)
gpl.clean_plot_bottom(uni_ax)
gpl.make_yaxis_scale_bar(ae_ax,
anchor=0,
magnitude=.2,
double=False,
label='assignment\nerror rate',
text_buff=.95)
gpl.make_yaxis_scale_bar(dist_ax,
anchor=0,
magnitude=.5,
double=False,
label='local distortion\n(MSE)',
text_buff=.8)
gpl.make_yaxis_scale_bar(uni_ax,
anchor=0,
magnitude=.2,
double=False,
label='guess rate',
text_buff=.7)
def plot_stan_models(model_dict,
f=None,
fsize=(12, 4),
lw=10,
chains=4,
nov_param='eps.*',
bias_param='bias\[.*',
sal_param='s\[.*',
lil=.1,
sort_by_nov=True,
sal_pairs=1000,
remove_errs=True,
errfield=None,
diag_ind=2):
if f is None:
f = plt.figure(figsize=fsize)
if remove_errs:
model_dict = _remove_errs_models(model_dict,
errfield,
diag_ind=diag_ind)
ax_sal = f.add_subplot(2, 1, 1)
ax_par = f.add_subplot(2, 1, 2)
nov_col = None
fam_col = None
nov_fits = np.zeros((len(model_dict), chains))
bias_fits = np.zeros((len(model_dict), 2, chains))
expsal_fits = np.zeros((len(model_dict), chains))
sal_diff = np.zeros((len(model_dict), chains))
for i, (k, v) in enumerate(model_dict.items()):
fit, params, diags = v
nov_sals = su.get_stan_params(fit, sal_param, params['img_cats'] == 1)
nov_sals = np.expand_dims(np.mean(nov_sals, axis=1), axis=0).T
fam_sals = su.get_stan_params(fit, sal_param, params['img_cats'] == 0)
fam_sals = np.expand_dims(np.mean(fam_sals, axis=1), axis=0).T
xs = np.array([i])
nl = gpl.plot_trace_werr(xs - lil,
nov_sals,
ax=ax_sal,
linewidth=lw,
color=nov_col,
error_func=gpl.conf95_interval)
fl = gpl.plot_trace_werr(xs + lil,
fam_sals,
ax=ax_sal,
linewidth=lw,
color=fam_col,
error_func=gpl.conf95_interval)
nov_col = nl[0].get_color()
fam_col = fl[0].get_color()
nov_fits[i] = su.get_stan_params(fit, param=nov_param)
bias_fits[i] = su.get_stan_params(fit, param=bias_param)
expsal_fits[i] = np.mean(np.abs(np.concatenate((nov_sals, fam_sals))))
sals = _sample_pairs(np.concatenate((nov_sals, fam_sals)), n=sal_pairs)
sal_diff[i] = np.mean(sals)
xs = np.arange(len(model_dict))
nov_mag = np.abs(nov_fits)
bias_diff = np.abs(np.diff(bias_fits, axis=1))
norm = nov_mag + bias_diff[:, 0] + sal_diff
if sort_by_nov:
sort_inds = np.argsort(np.mean(nov_mag / norm, axis=1))
norm = norm[sort_inds].T
gpl.plot_trace_werr(xs,
nov_mag[sort_inds].T / norm,
ax=ax_par,
label='novel',
marker='o')
gpl.plot_trace_werr(xs,
bias_diff[sort_inds, 0].T / norm,
ax=ax_par,
label='bias diff',
marker='o')
gpl.plot_trace_werr(xs,
sal_diff[sort_inds].T / norm,
ax=ax_par,
marker='o',
label='salience')
return f
def plot_ae_error(ax1,
ax2,
aes,
redund,
ols,
pr,
cut_end=10,
delta_d=None,
aes_est=None,
col_mult=.1):
redund[redund < 0] = np.nan
if delta_d is None:
for i, ae in enumerate(aes):
l = gpl.plot_trace_werr(pr[:-cut_end],
ae[:-cut_end],
ax=ax1,
log_x=True,
log_y=True,
label='C = {}'.format(ols[i]))
gpl.plot_trace_werr(pr[:-cut_end],
redund[i, :-cut_end],
ax=ax2,
log_x=True,
log_y=False)
if aes_est is not None:
ae_est_plot = aes_est[i, 0, :-cut_end].T
ae_col = l[0].get_color()
gpl.plot_trace_werr(pr[:-cut_end],
ae_est_plot,
ax=ax1,
color=ae_col,
error_func=gpl.conf95_interval)
else:
for i, ae in enumerate(aes):
color = None
for j, dd in enumerate(delta_d):
l_c = 'C = {}'.format(ols[i])
l_d = r'$\Delta D = ' + '{}$'.format(dd)
l = ' , '.join((l_c, l_d))
if j > 0:
color = gpl.add_color(color, j * col_mult)
l = gpl.plot_trace_werr(pr[:-cut_end],
ae[j, :-cut_end],
ax=ax1,
log_x=True,
log_y=True,
label=l,
color=color)
if aes_est is not None:
ae_est_plot = aes_est[i, j, :-cut_end].T
ae_col = l[0].get_color()
gpl.plot_trace_werr(pr[:-cut_end],
ae_est_plot,
ax=ax1,
color=ae_col,
error_func=gpl.conf95_interval)
if j == 0:
color = l[0].get_color()
gpl.plot_trace_werr(pr[:-cut_end],
redund[i, j, :-cut_end],
ax=ax2,
log_x=True,
log_y=False,
color=color)
ax1.set_xlabel('precision ratio ($s/D_{S}$)')
ax2.set_xlabel('precision ratio ($s/D_{S}$)')
ax1.set_ylabel('assignment error rate')
ax2.set_ylabel('redundancy (nats)')