def _plot_power_each_mouse(res, figure_path, excitatory, valence):
res[ykey_b] /= 100
ax_lim = {'yticks': [0, .5, 1], 'ylim': [0, 1.05]}
name_str = '_E' if excitatory else '_I'
name_str += '_' + valence
for mouse in np.unique(res['mouse']):
path, name = plot.plot_results(res,
x_key=xkey_b,
y_key=ykey_b,
loop_keys='mouse',
select_dict={'mouse': mouse},
plot_args=trace_args_bhv,
path=figure_path,
save=False,
colors=['k'],
ax_args=ax_lim)
plot.plot_results(res,
x_key='trials',
y_key='power',
loop_keys='mouse',
select_dict={'mouse': mouse},
plot_args=trace_args,
path=figure_path,
reuse=True,
save=False,
colors=['k'],
ax_args=ax_lim)
plt.gca().set_xlim(left=0)
plt.gca().set_ylim(bottom=-0.05)
plt.legend(['neural', 'behavior'], frameon=False, loc=0)
plot._easy_save(path, name + name_str)
def _plot_power_statistics(res_, figure_path, excitatory, valence):
name_str = '_E' if excitatory else '_I'
name_str += '_' + valence
_ = reduce.new_filter_reduce(res_,
filter_keys=['mouse', 'odor_valence'],
reduce_key='half_lick')
res = reduce.new_filter_reduce(res_,
filter_keys=['mouse', 'odor_valence'],
reduce_key='half_power')
res['half_lick'] = _['half_lick']
from sklearn import linear_model
from sklearn.metrics import mean_squared_error, r2_score
regr = linear_model.LinearRegression()
regr.fit(res['half_lick'].reshape(-1, 1), res['half_power'].reshape(-1, 1))
y_pred = regr.predict(res['half_lick'].reshape(-1, 1))
score = regr.score(res['half_lick'].reshape(-1, 1),
res['half_power'].reshape(-1, 1))
lim = [10, 50]
ax_lim = {'xlim': lim, 'ylim': lim}
a, b = plot.plot_results(res,
x_key='half_lick',
y_key='half_power',
plot_args=scatter_args,
plot_function=plt.scatter,
path=figure_path,
save=False,
ax_args=ax_lim)
plt.plot(lim, lim, '--', color='red', alpha=.5, linewidth=1)
plt.text(25, lim[1], 'R = {:.2f}'.format(score), fontsize=5)
plot._easy_save(a, b + name_str, pdf=True)
def _hist(res, save_path):
## distribution
def histogram(real, label, bin, range, ax):
density, bins = np.histogram(real, bins=bin, density=True, range=range)
unity_density = density / density.sum()
widths = bins[:-1] - bins[1:]
ax.bar(bins[1:], unity_density, width=widths, alpha=.5, label=label)
for mouse in np.unique(res['mouse']):
pt_csp = filter.filter(res, {'mouse': mouse, 'odor_valence': 'PT CS+'})
csp = filter.filter(res, {'mouse': mouse})
csm = filter.filter(res, {'mouse': mouse})
data = pt_csp['velocity']
start = pt_csp['on'][0]
end = pt_csp['end'][0]
data_before = data[:, :start].flatten()
data_during = data[:, start:end].flatten()
data_after = data[:, end:].flatten()
bins = 50
range = [-70, 70]
fig = plt.figure(figsize=(2, 1.5))
ax = fig.add_axes([0.2, 0.2, 0.7, 0.7])
histogram(data_before, 'before', bin=bins, range=range, ax=ax)
histogram(data_during, 'during', bin=bins, range=range, ax=ax)
plt.xlim([range[0] - 0.5, range[1] + .5])
ax.spines["right"].set_visible(False)
ax.spines["top"].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
rs = ranksums(data_before, data_during)[-1]
xlim = plt.xlim()
ylim = plt.ylim()
x = xlim[0] + .7 * (xlim[1] - xlim[0])
y = ylim[0] + .7 * (ylim[1] - ylim[0])
plot.significance_str(x, y, rs)
name = 'before_during_mouse_{}'.format(mouse)
plot._easy_save(save_path, name=name)
fig = plt.figure(figsize=(2, 1.5))
ax = fig.add_axes([0.2, 0.2, 0.7, 0.7])
histogram(data_during, 'before', bin=bins, range=range, ax=ax)
histogram(data_after, 'during', bin=bins, range=range, ax=ax)
plt.xlim([range[0] - 0.5, range[1] + .5])
ax.spines["right"].set_visible(False)
ax.spines["top"].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
rs = ranksums(data_during, data_after)[-1]
xlim = plt.xlim()
ylim = plt.ylim()
x = xlim[0] + .7 * (xlim[1] - xlim[0])
y = ylim[0] + .7 * (ylim[1] - ylim[0])
plot.significance_str(x, y, rs)
name = 'during_after_mouse_{}'.format(mouse)
plot._easy_save(save_path, name=name)
def distribution_dff(res,
start_days,
end_days,
arg,
valence,
figure_path,
hist_range=(-.05, 1.2)):
list_of_days = list(zip(start_days, end_days))
res = filter.filter_days_per_mouse(res, days_per_mouse=list_of_days)
res = filter.filter(res, {'odor_valence': valence})
new = _compare_dff(res, loop_keys=['mouse', 'odor'], arg=arg)
#
def _helper(real, label, bin=20):
density, bins = np.histogram(real,
bins=bin,
density=True,
range=hist_range)
unity_density = density / density.sum()
widths = bins[:-1] - bins[1:]
ax.bar(bins[1:], unity_density, width=widths, alpha=.5, label=label)
fig = plt.figure(figsize=(2, 1.5))
ax = fig.add_axes([0.2, 0.2, 0.7, 0.7])
x = np.concatenate(new['day_0'])
y = np.concatenate(new['day_1'])
sr = wilcoxon(x, y)[-1]
_helper(x, 'Before')
_helper(y, 'After')
ax.set_xlabel('Amplitude')
ax.set_ylabel('Density')
ax.spines["right"].set_visible(False)
ax.spines["top"].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
plt.legend(frameon=False)
ylim = plt.ylim()
xlim = plt.xlim()
sig_str = plot.significance_str(x=(xlim[-1] - ylim[0]) * .7,
y=.7 * (ylim[-1] - ylim[0]),
val=sr)
_easy_save(os.path.join(figure_path, 'dff_distribution'),
valence,
dpi=300,
pdf=True)
print('Before mean: {}'.format(np.mean(x)))
print('After mean: {}'.format(np.mean(y)))
print('wilcoxon: {}'.format(sr))
def _plot(x, y, z, xlim, ylim, xticks, yticks, name, color=True):
fig = plt.figure(figsize=(3, 2))
ax = fig.add_axes((.2, .2, .6, .6))
if not color:
z = np.ones_like(x)
plt.scatter(x, y, c=z, s=3, edgecolor='')
plt.xlabel(xname)
plt.ylabel(yname)
plt.xlim(xlim)
plt.ylim(ylim)
plt.xticks(xticks)
plt.yticks(yticks)
ax = plt.gca()
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
folder = yname + '_vs_' + xname
name = name
#first method
from sklearn.linear_model import LinearRegression
x = x.reshape(-1, 1)
y = y.reshape(-1, 1)
model = LinearRegression().fit(x, y)
r2 = model.score(x, y)
slope = model.coef_[0][0]
intercept = model.intercept_[0]
y_pred = model.predict(x)
# second method
# slope, residual, _, _ = np.linalg.lstsq(x, y, rcond=-1)
# slope = slope[0][0]
# r2= 1 - residual[0] / (x.size * y.var())
# intercept = 0
# y_pred = slope * x
plt.plot(x, y_pred, 'r-', linewidth=1, alpha=.7)
xlim = plt.xlim()
ylim = plt.ylim()
plt.text(x=.1 * (xlim[-1] - xlim[0]),
y=.8 * (ylim[-1] - ylim[0]),
s='R = {0:.3f}'.format(r2))
plt.title('$y= {0:.3f} x+{1:.2f}$'.format(slope, intercept))
plot._easy_save(os.path.join(save_path, folder), name)
def _raw_plot(res, i):
res = filter.filter(res, {'condition': 'Y'})
print(res['mouse'][i])
print(res['session'][i])
a = res['bin_ir_raw'][i]
b = res['bin_samp_raw'][i]
x = res['bin_ant_raw'][i]
data = np.concatenate([a, b, x], axis=1)
fig = plt.figure(figsize=(3, 3))
ax = fig.add_axes((.25, .25, .6, .6))
plt.imshow(data, cmap='gray')
xticks = [0, 120, 220, 300]
xticklabels = ['Nosepoke', 'Odor', '1 S', 'US']
plt.xticks(xticks, xticklabels)
plt.xlim([120, 300])
plt.xlabel('Time')
plt.ylabel('Trial')
plot._easy_save(path=os.path.join(save_path, 'example_licks'),
name='Y_{}'.format(i))
def behavior_vs_neural_onset(neural_res, behavior_res, start, end, figure_path, neural_arg ='onset', behavior_arg ='onset'):
neural_key = 'neural'
behavior_key = 'behavior'
if behavior_arg == 'onset':
behavior_data_key = 'time_first_lick_raw'
elif behavior_arg == 'magnitude':
behavior_data_key = 'lick_5s'
elif behavior_arg == 'com':
behavior_data_key = 'lick_com_raw'
else:
raise ValueError('bad key')
if neural_arg == 'onset':
neural_data_key = 'onset'
elif neural_arg == 'magnitude':
neural_data_key = 'dff'
else:
raise ValueError('bad key')
list_of_days = [np.arange(s, e+1) for s, e in zip(start,end)]
neural_res_filtered = filter.filter_days_per_mouse(neural_res, days_per_mouse=list_of_days)
neural_res_filtered = filter.filter(neural_res_filtered, filter_dict={'odor_valence':'CS+'})
behavior_res_filtered = filter.filter(behavior_res, filter_dict={'odor_valence':'CS+'})
names_neu, ixs_neu = filter.retrieve_unique_entries(neural_res_filtered, ['mouse','day','odor_standard'])
out = defaultdict(list)
for ix, names in zip(ixs_neu, names_neu):
mouse = names[0]
day = names[1]
odor_standard = names[2]
assert len(ix) == 1
neural = neural_res_filtered[neural_data_key][ix[0]]
#test
ixs = np.where(neural > -1)[0]
for a in ixs:
plt.plot(np.transpose(neural_res_filtered['data'][ix[0]][a]))
plt.title(neural[a])
plt.show()
neural = neural[neural > -1] * .229
temp = filter.filter(behavior_res_filtered, {'mouse': mouse, 'odor_standard': odor_standard})
assert len(temp[behavior_data_key]) == 1
ix_day = [x == day for x in temp['day'][0]]
lick = temp[behavior_data_key][0][ix_day]
lick = lick[lick>-1]
out['mouse'].append(mouse)
out['day'].append(day)
out['odor_standard'].append(odor_standard)
out[neural_key + neural_arg].append(np.mean(neural))
out[behavior_key + behavior_arg].append(np.mean(lick))
out['neural_raw'].append(neural)
out['lick_raw'].append(lick)
for k, v in out.items():
out[k] = np.array(v)
## distribution
def _helper(real, label, bin, range, ax):
density, bins = np.histogram(real, bins=bin, density=True, range= range)
unity_density = density / density.sum()
widths = bins[:-1] - bins[1:]
ax.bar(bins[1:], unity_density, width=widths, alpha=.5, label=label)
all_neural = np.concatenate(out['neural_raw'])
all_licks = np.concatenate(out['lick_raw'])
bins = 20
range = [0, 5]
xticks = [0, 2, 5]
xticklabels = ['Odor ON', 'Odor OFF', 'US']
fig = plt.figure(figsize=(2, 1.5))
ax = fig.add_axes([0.2, 0.2, 0.7, 0.7])
_helper(all_neural, neural_key + neural_arg, bins, range, ax)
_helper(all_licks, behavior_key + behavior_arg, bins, range, ax)
plt.xticks(xticks, xticklabels)
plt.xlim([range[0]-0.5, range[1] + .5])
plt.ylabel('Density')
ax.spines["right"].set_visible(False)
ax.spines["top"].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
folder = 'onset_distribution_lick_neural_'
name = behavior_arg + '_' + ','.join([str(x) for x in start]) + '_' + ','.join([str(x) for x in end])
plt.legend(frameon=False)
_easy_save(os.path.join(figure_path, folder), name, dpi=300, pdf=True)
print('lick mean: {}'.format(np.mean(all_licks)))
print('neural mean: {}'.format(np.mean(all_neural)))
## versus
if behavior_arg in ['onset', 'com']:
xlim = [0, 5]
xticks = [0, 2, 5]
xticklabels = ['ON','OFF', 'US']
else:
xlim = [0, 35]
xticks = [0, 10, 20, 30]
xticklabels = [0, 10, 20, 30]
ax_args = {'xlim':xlim, 'ylim':[0, 3.5], 'xticks':xticks, 'yticks':[0, 2, 5],
'xticklabels':xticklabels, 'yticklabels': ['ON','OFF','US']}
path, name = plot.plot_results(out, x_key=behavior_key + behavior_arg, y_key=neural_key + neural_arg, loop_keys='mouse',
plot_function=plt.scatter,
plot_args= scatter_args,
ax_args=ax_args,
colormap='jet',
path = figure_path,
save=False)
from sklearn import linear_model
from sklearn.metrics import mean_squared_error, r2_score
scores = []
for mouse in np.unique(out['mouse']):
res = filter.filter(out, {'mouse':mouse})
regr = linear_model.LinearRegression()
x = res[behavior_key + behavior_arg].reshape(-1,1)
y = res[neural_key + neural_arg].reshape(-1,1)
regr.fit(x, y)
y_pred = regr.predict(x)
score = regr.score(x, y)
scores.append(score)
print('average regression: {}'.format(np.mean(scores)))
xlim = plt.xlim()
ylim = plt.ylim()
plt.text((xlim[1] - xlim[0])/2, ylim[1]-.5, 'Average R = {:.2f}'.format(np.mean(scores)))
name += '_' + behavior_arg
plot._easy_save(path, name)
if condition == 'H':
color = color_dict[phase]
fp = plot.plot_results(res, x_key='trials', y_key=y_key_bool,
select_dict={'phase_odor_valence': phase, 'condition':'H'},
ax_args=ax_args_bool_cur, plot_args=trace_args_copy,
colors=color,
save=False,
path=save_path)
c = behavior.behavior_config.behaviorConfig()
y = c.fully_learned_threshold_up / 100.
plt.plot(plt.xlim(), [y, y], '--', color='gray', linewidth=.5)
plot._easy_save(fp[0],fp[1],pdf=True)
fp = plot.plot_results(res, x_key='trials', y_key=y_key,
select_dict={'phase_odor_valence': phase, 'condition':'H'},
ax_args=ax_args_cur, plot_args=trace_args_copy,
colors=color,
save=False,
path=save_path)
c = behavior.behavior_config.behaviorConfig()
y = c.fully_learned_threshold_up / 100.
plt.plot(plt.xlim(), [y, y], '--', color='gray', linewidth=.5)
plot._easy_save(fp[0], fp[1], pdf=True)
ax_args=ax_args_pt_,
plot_function= sns.stripplot,
plot_args= swarm_args_copy,
sort=True,
fig_size=[1.5, 1.5], rect=(.3, .2, .6, .6),
path=save_path_all, reuse=False, save=False)
plot.plot_results(mean_std_res, x_key=collapse_arg, y_key= reduce_key, error_key= reduce_key + '_sem',
select_dict={'condition': 'CHANNEL'},
ax_args=ax_args_pt_,
plot_function= plt.errorbar,
plot_args= error_args,
fig_size=[2, 1.5],
path=save_path_all, reuse=True, save=False)
plt.xlim(-.1, .1)
plot._easy_save(path, name, pdf=True)
#stats
print(mean_std_res[x_key])
print(mean_std_res[reduce_key])
print(mean_std_res[reduce_key + '_sem'])
if 'summary' in experiments:
all_res = filter.filter(all_res, {'odor_valence':['CS+','CS-', 'PT CS+']})
all_res_lick = reduce.new_filter_reduce(all_res, filter_keys=['condition', 'odor_valence','mouse'],
reduce_key=lick_smoothed)
all_res_bool = reduce.new_filter_reduce(all_res, filter_keys=['condition', 'odor_valence','mouse'],
reduce_key=boolean_smoothed)
line_args_copy = line_args.copy()
line_args_copy.update({'marker': None, 'linewidth':.75})
def compare_to_shuffle(res, start, end, data_arg, figure_path):
'''
:param res:
:param start:
:param end:
:param data_arg: 'onset', 'duration', 'amplitude'
:param figure_path:
:return:
'''
n_shuffle = 1000
list_of_days = [np.arange(s, e+1) for s, e in zip(start,end)]
res_ = filter.filter_days_per_mouse(res, days_per_mouse=list_of_days)
res_ = filter.filter(res_, filter_dict={'odor_valence':'CS+'})
mice = np.unique(res_['mouse'])
real = []
shuffled = []
for mouse in mice:
res_mouse_ = filter.filter(res_, {'mouse': mouse})
days = np.unique(res_mouse_['day'])
for day in days:
res_mouse_day = filter.filter(res_mouse_, {'day': day})
assert res_mouse_day['onset'].size == 2, 'should be two entries corresponding to two CS+ per mouse'
a = res_mouse_day[data_arg][0]
b = res_mouse_day[data_arg][1]
responsive_to_both = np.array([x>-1 and y>-1 for x, y in zip(a,b)])
a_ = a[responsive_to_both]
b_ = b[responsive_to_both]
real_diff = np.abs(a_ - b_)
real.append(real_diff)
for n in range(n_shuffle):
a_shuffled = np.random.permutation(a_)
b_shuffled = np.random.permutation(b_)
shuffled_diff = np.abs(a_shuffled - b_shuffled)
shuffled.append(shuffled_diff)
flatten = lambda l: [item for sublist in l for item in sublist]
real = np.array(flatten(real), dtype=float)
shuffled = np.array(flatten(shuffled), dtype=float)
bin = 20
if data_arg == 'amplitude':
xlim = 1
hist_range = 1
else:
period = .229
xlim = np.ceil(bin * period)
hist_range = bin * period
real *= period
shuffled *= period
p = scipy.stats.ranksums(real, shuffled)[1]
fig = plt.figure(figsize=(2, 1.5))
ax = fig.add_axes([0.25, 0.25, 0.7, 0.7])
def _helper(real, label):
density, bins = np.histogram(real, bins=bin, density=True, range=[0, hist_range])
unity_density = density / density.sum()
widths = bins[:-1] - bins[1:]
ax.bar(bins[1:], unity_density, width=widths, alpha = .5, label=label)
_helper(real, 'Within Neurons')
_helper(shuffled, 'Shuffled')
ax.legend(frameon=False)
ax.set_xlabel((r'$\Delta$' + ' ' + data_arg.capitalize()))
ax.set_ylabel('Density')
plt.xlim([0, xlim])
# xticks = np.arange(xlim)
# ax.set_xticks(xticks)
# ax.set_xticklabels(xticks)
# yticks = np.array([0, .5, 1])
# ax.set_yticks(yticks)
# plt.ylim([0, 1])
ylim = ax.get_ylim()
xlim = ax.get_xlim()
x = (xlim[1] - xlim[0])/2
y = (ylim[1] - ylim[0])/2
t = 'P = {:.3e}'.format(p)
plt.text(x, y, t)
ax.spines["right"].set_visible(False)
ax.spines["top"].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
_easy_save(os.path.join(figure_path, data_arg), 'difference_' + data_arg, dpi=300, pdf=True)
print('real mean: {}'.format(np.mean(real)))
print('shuffled mean: {}'.format(np.mean(shuffled)))
print('ranksum: {}'.format(t))
ax.spines[loc].set_visible(False)
ax.tick_params('both', length=0)
xticks = np.arange(0, im.shape[1]) + .5
yticks = np.arange(0, im.shape[0]) + .5
ax.set_xticks(xticks)
ax.set_yticks(yticks[::-1])
ax.set_xticklabels((xticks + .5).astype(int), fontsize=7)
ax.set_yticklabels((yticks + .5).astype(int), fontsize=7)
ax = fig.add_axes(rect_cb)
cb = plt.colorbar(cax=ax, ticks=np.arange(vmin, vmax + 0.01, 0.1))
cb.outline.set_linewidth(0.5)
cb.set_label('Correlation', fontsize=7, labelpad=2)
plt.tick_params(axis='both', which='major', labelsize=7)
plt.axis('tight')
plot._easy_save(os.path.join(save_path, 'matrix', mouse), 'across_correlation_matrix')
res = filter.exclude(res, {'mouse':'M241_ofc'})
list = ['PIR','OFC','OFC_LONGTERM','OFC_COMPOSITE','MPFC_COMPOSITE']
scatter_args = {'marker':'.', 's':8, 'alpha': .5}
error_args = {'fmt': '', 'capsize': 2, 'elinewidth': 1, 'markersize': 2, 'alpha': .5}
reduce_keys = ['within_day_crisp_average', 'across_day_mean_corrs_average']
xkey = 'experiment'
for reduce_key in reduce_keys:
res_reduce = reduce.new_filter_reduce(res, filter_keys=['experiment'], reduce_key= reduce_key)
for i, element in enumerate(list):
reuse = True if i > 0 else False
save = False if i != len(list)-1 else True
plot.plot_results(res, x_key=xkey, y_key= reduce_key,
select_dict={xkey:element},
def plot_compare_dff(res,
start_days,
end_days,
arg,
valence,
more_stats,
figure_path,
lim=(-.05, 1.2),
ticks=(0, .5, 1)):
list_of_days = list(zip(start_days, end_days))
res = filter.filter_days_per_mouse(res, days_per_mouse=list_of_days)
res = filter.filter(res, {'odor_valence': valence})
new = _compare_dff(res, loop_keys=['mouse', 'odor'], arg=arg)
#analysis
xs, ys = new['day_0'], new['day_1']
a, b = [], []
for x, y in zip(xs, ys):
a.append(np.sum(x > y))
b.append(np.sum(y > x))
fraction = np.sum(a) / (np.sum(a) + np.sum(b))
ax_args_copy = {}
ax_args_copy.update({
'ylim': lim,
'xlim': lim,
'yticks': ticks,
'xticks': ticks
})
scatter_args_copy = scatter_args.copy()
scatter_args_copy.update({
'marker': ',',
's': 1,
'alpha': .2,
'facecolors': 'none'
})
colors = ['Black']
# if valence == 'CS+':
# colors = ['Green']
# if valence == 'CS-':
# colors = ['darkred']
colors *= 300
path, name = plot.plot_results(new,
select_dict={'odor_valence': valence},
x_key='day_0',
y_key='day_1',
loop_keys=['mouse', 'odor'],
path=figure_path,
plot_args=scatter_args_copy,
ax_args=ax_args_copy,
plot_function=plt.scatter,
colors=colors,
legend=False,
fig_size=(2, 1.5),
rect=(.25, .25, .6, .6),
save=False)
plt.xlim(lim)
plt.ylim(lim)
plt.plot(lim, lim, '--', color='red', alpha=.5, linewidth=1)
plt.title(valence)
if valence == 'CS+':
plt.text(0,
lim[1] - .1,
'{:.1f}% diminished'.format(fraction * 100),
fontsize=5)
if valence == 'CS-':
plt.text(0,
lim[1] - .1,
'{:.1f}% increased'.format(100 - fraction * 100),
fontsize=5)
if more_stats:
new = _compare_dff(res, loop_keys=['mouse', 'odor'], arg='first')
new = filter.filter(new, {'odor_valence': valence})
xs, ys = new['day_0'], new['day_1']
a, b, c = [], [], []
for x, y in zip(xs, ys):
a.append(np.sum(x > y))
b.append(np.sum(y > x))
c.append(np.sum(y < 0.1))
lost_fraction = np.sum(c) / (np.sum(a) + np.sum(b))
plt.text(0,
lim[1] - .2,
'Of those, {:.1f}% are unresponsive'.format(100 *
lost_fraction),
fontsize=5)
_easy_save(path, name, pdf=True)
plt.xticks(xticks, '')
plt.yticks([])
plt.tick_params(direction='out', length=2, width=.5, grid_alpha=0.5)
for line in condition_lines:
plt.plot([line, line], plt.ylim(), '--', color='grey', linewidth=.5)
for line in xticks:
plt.plot([line, line], plt.ylim(), '--', color='grey', linewidth=.25, alpha=0.5)
titles = ['Naive','Learned']
for j, x in enumerate(odor_on_lines):
plt.text(x, -1, titles[j])
plt.title(odor.upper())
ax = fig.add_axes(rect_cb)
cb = plt.colorbar(cax=ax, ticks=[-condition_config.vlim, condition_config.vlim])
cb.outline.set_linewidth(0.5)
cb.set_label(r'$\Delta$ F/F', fontsize=7, labelpad=-10)
plt.tick_params(axis='both', which='major', labelsize=7)
plot._easy_save(save_path,
'mouse_' + str(mouse) +
'_day_' + str(days) +
'_odor_' + str(odor))
def plotter(image,
odor_on,
water_on,
odor_names,
condition_config,
save_path,
name_str=''):
if black:
plt.style.use('dark_background')
frames_per_trial = 75
titles = odor_names
n_plots = int(image.shape[1] / frames_per_trial)
fig = plt.figure(figsize=(3.5, 3))
fig_width = .14 * n_plots
rect = [.1, .1, fig_width, .7]
rect_cb = [fig_width + .1 + .02, 0.1, 0.02, .7]
ax = fig.add_axes(rect)
if black:
from matplotlib.colors import LinearSegmentedColormap
cdict1 = {
'red': ((0.0, 0.0, 0.0), (0.5, 0.0, 0.1), (1.0, 1.0, 1.0)),
'green': ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)),
'blue': ((0.0, 0.0, 0.55), (0.5, 0.1, 0.0), (1.0, 0.0, 0.0))
}
cmap = LinearSegmentedColormap('BlueRed1', cdict1)
cmap = LinearSegmentedColormap.from_list("",
["turquoise", "black", "red"])
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.tick_params(axis=u'both', which=u'both', length=0)
else:
cmap = 'bwr'
plt.tick_params(direction='out', length=2, width=.5, grid_alpha=0.5)
plt.imshow(image,
vmin=-condition_config.vlim,
vmax=condition_config.vlim,
cmap=cmap)
plt.axis('tight')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
condition_lines = np.cumsum([frames_per_trial] * n_plots)[:-1]
odor_on_lines_raw = np.arange(odor_on, frames_per_trial * n_plots,
frames_per_trial)
water_on_lines = np.arange(water_on, frames_per_trial * n_plots,
frames_per_trial)
if 'water' in titles:
water_on_lines = water_on_lines[[0, 1, 4]]
# water_on_lines = water_on_lines[[2, 3, 4]]
odor_on_lines = odor_on_lines_raw[:-1]
else:
if condition_config.period == 'pt':
odor_on_lines = odor_on_lines_raw
else:
if condition_config.filter_ix is None:
water_on_lines = water_on_lines[:2]
# water_on_lines = water_on_lines[2:]
else:
water_on_lines = water_on_lines[[0]]
odor_on_lines = odor_on_lines_raw
if not naive:
xticks = np.concatenate(
(odor_on_lines, odor_on_lines + 8, water_on_lines))
xticklabels = ['ON'] * len(odor_on_lines) + ['OFF'] * len(
odor_on_lines) + ['US'] * len(water_on_lines)
else:
xticks = np.concatenate((odor_on_lines, odor_on_lines + 8))
xticklabels = ['ON'] * len(odor_on_lines) + ['OFF'
] * len(odor_on_lines)
plt.xticks(xticks, xticklabels, fontsize=5)
range = image.shape[0]
if range > 100:
interval = 50
else:
interval = 25
plt.yticks(np.arange(0, range, interval))
for line in xticks:
plt.plot([line, line],
plt.ylim(),
'--',
color='grey',
linewidth=.5,
alpha=0.5)
for line in condition_lines:
plt.plot([line, line],
plt.ylim(),
'--',
color='grey',
linewidth=.75,
alpha=1)
for j, x in enumerate(odor_on_lines_raw):
plt.text(x, -1, titles[j].upper())
axcb = fig.add_axes(rect_cb)
cb = plt.colorbar(cax=axcb,
ticks=[-condition_config.vlim, condition_config.vlim])
if black:
cb.outline.set_visible(False)
cb.set_ticks([])
else:
cb.outline.set_linewidth(0.5)
cb.set_label(r'$\Delta$ F/F', fontsize=7, labelpad=-10)
plt.tick_params(axis='both', which='major', labelsize=7)
name_black = '_black' if black else ''
if condition_config.plot_big:
name = 'big_mouse_' + ','.join(
[str(x) for x in condition_config.plot_big_days])
name += '_sorted_to_' + ','.join(
[str(x) for x in condition_config.sort_days])
name += name_black
else:
name = 'mouse_' + str(mouse) + name_str
if not condition_config.independent_sort:
name += '_sorted_to_' + str(condition_config.sort_days)
if condition_config.filter_ix is not None:
name += '_odor_' + str(condition_config.filter_ix)
plt.sca(ax)
# plt.title(name)
plot._easy_save(save_path, name)
plot_args=scatter_args_copy,
ax_args=ax_args_local,
colors=color,
save=False,
path=save_path)
plt.plot([0, 5], [0, 5], '--', color='gray')
try:
stat_res = filter.filter(res_use, {'odor_valence': valence})
a, b = stat_res[before_key], stat_res[after_key]
stat = wilcoxon(a, b)
ylim = plt.gca().get_ylim()
sig_str = plot.significance_str(x=.4,
y=.7 * (ylim[-1] - ylim[0]),
val=stat[-1])
plot._easy_save(path, name)
print('Before: {}, After: {}'.format(np.mean(a), np.mean(b)))
print(stat)
except:
print('no stats')
if 'summary_mouse_line' in experiments:
_collapse_conditions(all_res, control_condition='YFP', str=collapse_arg)
ykey = reduce_key_raw + '_mean'
for i, v in enumerate(all_res[reduce_key_raw]):
all_res[ykey].append(np.mean(v[v > 0]))
all_res[ykey] = np.array(all_res[ykey])
res_modified = reduce.new_filter_reduce(
all_res,
filter_keys=['condition', 'mouse', 'odor_valence'],
def plot_stability_across_days(res, start_days_per_mouse, learned_days_per_mouse, figure_path):
strengthen_starting_threshold = .1
strengthen_absolute_threshold = .2
strengthen_relative_threshold = 2
weaken_starting_threshold = .3
weaken_absolute_threshold = .15
weaken_relative_threshold = .5
res = copy.copy(res)
res = filter.filter(res, {'odor_valence':['CS+', 'CS-']})
list_odor_on = res['DAQ_O_ON_F']
list_water_on = res['DAQ_W_ON_F']
for i in range(len(list_odor_on)):
dff_list = res['dff'][i]
dff_max = np.max(dff_list[:,list_odor_on[i]: list_water_on[i]],axis=1)
res['dff_max'].append(dff_max)
res['dff_max'] = np.array(res['dff_max'])
out = defaultdict(list)
combinations, ixs = filter.retrieve_unique_entries(res, ['mouse','odor'])
for combination, ix in zip(combinations, ixs):
odor_valence = np.unique(res['odor_valence'][ix])
mouse = np.unique(res['mouse'][ix])
days = res['day'][ix]
assert len(days) == len(np.unique(days))
assert len(mouse) == 1
sort_ix = np.argsort(days)
list_of_dff_max = res['dff_max'][ix][sort_ix]
list_of_ssig = res['sig'][ix][sort_ix]
data = [x * y for x, y in zip(list_of_ssig, list_of_dff_max)]
data = np.array(data)
strengthen_mask = data[0,:] > strengthen_starting_threshold
strengthen_overall_threshold = np.max((data[0,:] * strengthen_relative_threshold, data[0,:] + strengthen_absolute_threshold), axis=0)
strengthen_passed_mask = strengthen_overall_threshold < data
strengthen_any = np.any(strengthen_passed_mask[1:,:], axis=0)
n_strengthen_passed = np.sum(strengthen_any * strengthen_mask)
n_strengthen_denom = np.sum(strengthen_mask)
new_mask = np.invert(strengthen_mask)
n_new_passed = np.sum(strengthen_any * new_mask)
n_new_denom = np.sum(new_mask)
weaken_mask = data[0,:] > weaken_starting_threshold
weaken_overall_threshold = np.min((data[0,:] * weaken_relative_threshold, data[0,:] - weaken_absolute_threshold), axis=0)
weaken_passed_mask = weaken_overall_threshold > data
weaken_any = np.any(weaken_passed_mask[1:,:], axis=0)
n_weaken_passed = np.sum(weaken_any * weaken_mask)
n_weaken_denom = np.sum(weaken_mask)
strs = ['strengthen_denom', 'strengthen_pass', 'new_denom', 'new_pass','weaken_denom','weaken_pass']
vals = [n_strengthen_denom, n_strengthen_passed, n_new_denom, n_new_passed, n_weaken_denom, n_weaken_passed]
for k, v in zip(strs,vals):
out['Type'].append(k)
out['Count'].append(v)
out['mouse'].append(mouse[0])
out['odor_valence'].append(odor_valence[0])
for k, v in out.items():
out[k] = np.array(v)
def _helper(res):
out = defaultdict(list)
strs = [['strengthen_denom', 'strengthen_pass'], ['new_denom', 'new_pass'], ['weaken_denom', 'weaken_pass']]
out_strs = ['up', 'new', 'down']
for i, keys in enumerate(strs):
ix_denom = res['Type'] == keys[0]
ix_numer = res['Type'] == keys[1]
numer = np.sum(res['Count'][ix_numer])
denom = np.sum(res['Count'][ix_denom])
fraction = numer/ denom
out['Type'].append(out_strs[i])
out['Fraction'].append(fraction)
out['numer'].append(numer)
out['denom'].append(denom)
for k, v in out.items():
out[k] = np.array(v)
return out
ax_args_copy = ax_args.copy()
ax_args_copy.update({'ylim':[0, 0.5], 'yticks':[0, .1, .2, .3, .4, .5]})
overall = copy.copy(out)
csm_res = filter.filter(overall, {'odor_valence':'CS-'})
csp_res = filter.filter(overall, {'odor_valence':'CS+'})
csp_stats = _helper(csp_res)
csp_stats['Condition'] = np.array(['CS+'] * len(csp_stats['Type']))
csm_stats = _helper(csm_res)
csm_stats['Condition'] = np.array(['CS-'] * len(csm_stats['Type']))
overall_stats = reduce.chain_defaultdicts(csp_stats, csm_stats, copy_dict=True)
filter.assign_composite(overall_stats, ['Type', 'Condition'])
bar_args = {'alpha': 1, 'edgecolor':'black','linewidth':1}
colors = ['Green','Red']
save_path, name = plot.plot_results(overall_stats, x_key='Type_Condition', y_key='Fraction', sort=True,
colors=colors,
path=figure_path,
plot_function=plt.bar, plot_args=bar_args, ax_args=ax_args_copy,
save=False, reuse=False)
strs = ['down','new','up']
fontsize = 4
for i in range(3):
ix = csp_stats['Type'] == strs[i]
numer = csp_stats['numer'][ix][0]
denom = csp_stats['denom'][ix][0]
x = i * 2
y = numer/denom
y_offset = .025
plt.text(x, y + y_offset, str(numer) + '/' + str(denom), horizontalalignment = 'center', fontsize= fontsize)
strs = ['down','new','up']
for i in range(3):
ix = csm_stats['Type'] == strs[i]
numer = csm_stats['numer'][ix][0]
denom = csm_stats['denom'][ix][0]
x = i * 2 + 1
y = numer/denom
y_offset = .025
plt.text(x, y + y_offset, str(numer) + '/' + str(denom), horizontalalignment = 'center', fontsize= fontsize)
plot._easy_save(save_path, name, pdf=True)
overall_stats_no_distinction = _helper(overall)
save_path, name = plot.plot_results(overall_stats_no_distinction, x_key='Type', y_key='Fraction', sort=True,
colors=['Grey']*10,
path=figure_path,
plot_function=plt.bar, plot_args=bar_args, ax_args=ax_args_copy,
save=False, reuse=False)
strs = ['down','new','up']
for i in range(3):
ix = overall_stats_no_distinction['Type'] == strs[i]
numer = overall_stats_no_distinction['numer'][ix][0]
denom = overall_stats_no_distinction['denom'][ix][0]
x = i
y = numer/denom
y_offset = .025
plt.text(x, y + y_offset, str(numer) + '/' + str(denom), horizontalalignment = 'center', fontsize= fontsize)
plot._easy_save(save_path, name, pdf=True)
plt.axis('tight')
for loc in ['top', 'right']:
ax.spines[loc].set_visible(False)
ax.tick_params('in', length=0.25)
cmap = mpl.cm.cool
norm = mpl.colors.Normalize(vmin=min, vmax=max)
cb = mpl.colorbar.ColorbarBase(ax1, cmap=cmap, norm=norm)
cb.set_ticks(np.arange(min, max + .01, .1))
cb.outline.set_linewidth(0.5)
cb.set_label('AP', fontsize=7, labelpad=5)
plt.tick_params(axis='both', which='major', labelsize=7)
plt.axis('tight')
save_path = os.path.join(Config.LOCAL_FIGURE_PATH, 'MISC', 'HISTOLOGY')
plot._easy_save(save_path, arg_type + '_' + arg)
if arg == 'OUTPUT':
min, max = 1.0, 1.8
ylim = [-5, -3]
yticks = [-3, -4, -5]
xlim = [0, 4]
xticks = [0, 1, 2, 3, 4]
for i, d in enumerate(res['coordinates virus (AP, ML, DV)']):
try:
numbers = _string_splitter(d, length=length)
res['ap_r_v'].append(numbers[0])
res['ml_r_v'].append(numbers[1])
res['dv_r_v'].append(numbers[2])
except:
color='turquoise')
xticks = [water_on]
xticklabels = ['US']
else:
raise ValueError('unrecognized odor valence for plotting')
if valence != 'US':
color = odor_dict[odor_standard_names[i]]
plt.fill_between([odor_on, odor_off],
cumsum[i] - .5,
cumsum[i + 1] - .5,
alpha=.7,
facecolor=color)
plt.text(0, (cumsum[i + 1] - cumsum[i]) / 2 + cumsum[i],
odor_standard_names[i])
# plt.xticks(xticks, xticklabels)
plt.title('Day {}'.format(day))
plt.xticks([])
plt.yticks([])
ax = plt.gca()
ax.spines['top'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
plot._easy_save(save_path,
'across_day_mouse_{}_day_{}'.format(mouse, day),
dpi=1000)
def behavior_vs_neural_power(neural_res, behavior_res, start, end, figure_path, neural_arg ='power', behavior_arg ='onset'):
neural_res = copy.copy(neural_res)
neural_key = 'neural'
behavior_key = 'behavior'
if behavior_arg == 'onset':
behavior_data_key = 'time_first_lick_raw'
elif behavior_arg == 'magnitude':
behavior_data_key = 'lick_5s'
elif behavior_arg == 'com':
behavior_data_key = 'lick_com_raw'
else:
raise ValueError('bad key')
neural_data_key = 'max_power'
_power(neural_res, excitatory=True)
for i, p in enumerate(neural_res['Power']):
s, e = neural_res['DAQ_O_ON_F'][i], neural_res['DAQ_W_ON_F'][i]
mp = np.max(p[s:e]) - np.mean(p[:s])
neural_res[neural_data_key].append(mp)
neural_res[neural_data_key] = np.array(neural_res[neural_data_key])
list_of_days = [np.arange(s, e+1) for s, e in zip(start,end)]
print(list_of_days)
neural_res_filtered = filter.filter_days_per_mouse(neural_res, days_per_mouse=list_of_days)
neural_res_filtered = filter.filter(neural_res_filtered, filter_dict={'odor_valence':'CS+'})
behavior_res_filtered = filter.filter(behavior_res, filter_dict={'odor_valence':'CS+'})
names_neu, ixs_neu = filter.retrieve_unique_entries(neural_res_filtered, ['mouse','day','odor_standard'])
out = defaultdict(list)
for ix, names in zip(ixs_neu, names_neu):
mouse = names[0]
day = names[1]
odor_standard = names[2]
assert len(ix) == 1
neural = neural_res_filtered[neural_data_key][ix[0]]
temp = filter.filter(behavior_res_filtered, {'mouse': mouse, 'odor_standard': odor_standard})
assert len(temp[behavior_data_key]) == 1
ix_day = [x == day for x in temp['day'][0]]
lick = temp[behavior_data_key][0][ix_day]
lick = lick[lick>-1]
out['mouse'].append(mouse)
out['day'].append(day)
out['odor_standard'].append(odor_standard)
out[neural_key + neural_arg].append(np.mean(neural))
out[behavior_key + behavior_arg].append(np.mean(lick))
out['neural_raw'].append(neural)
out['lick_raw'].append(lick)
for k, v in out.items():
out[k] = np.array(v)
## versus
if behavior_arg in ['onset', 'com']:
xlim = [0, 5]
xticks = [0, 2, 5]
xticklabels = ['ON', 'OFF', 'US']
else:
xlim = [0, 35]
xticks = [0, 10, 20, 30]
xticklabels = [0, 10, 20, 30]
ax_args = {'xlim': xlim, 'ylim': [0, .1], 'xticks': xticks, 'yticks': [0, .05, .1],
'xticklabels': xticklabels}
path, name = plot.plot_results(out, x_key=behavior_key + behavior_arg, y_key=neural_key + neural_arg,
loop_keys='mouse',
plot_function=plt.scatter,
plot_args=scatter_args,
ax_args=ax_args,
colormap='jet',
path=figure_path,
save=False)
from sklearn import linear_model
from sklearn.metrics import mean_squared_error, r2_score
scores = []
for mouse in np.unique(out['mouse']):
res = filter.filter(out, {'mouse':mouse})
regr = linear_model.LinearRegression()
x = res[behavior_key + behavior_arg].reshape(-1,1)
y = res[neural_key + neural_arg].reshape(-1,1)
regr.fit(x, y)
y_pred = regr.predict(x)
score = regr.score(x, y)
scores.append(score)
print('regression: {}'.format(scores))
xlim = plt.xlim()
ylim = plt.ylim()
plt.text((xlim[1] - xlim[0])/2, ylim[1]-.01, 'Average R = {:.2f}'.format(np.mean(scores)))
name += '_' + behavior_arg
plot._easy_save(path, name)
plt.plot([water_on, water_on],
ylim,
'-',
linewidth=1,
color='turquoise')
xticks = [water_on]
xticklabels = ['US']
else:
raise ValueError('unrecognized odor valence for plotting')
if odor_res['odor_valence'][0] != 'US':
plt.fill_between([odor_on, odor_off],
ylim[0],
ylim[1],
alpha=.7,
facecolor=color)
# plt.xticks(xticks, xticklabels)
plt.xticks([])
plt.yticks([])
plt.title(odor_name.upper())
ax = plt.gca()
ax.spines['top'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
plot._easy_save(save_path, str(mouse) + '_' + odor_standard)
def distribution(res, start, end, data_arg, figure_path, save):
list_of_days = [np.arange(s, e+1) for s, e in zip(start,end)]
res_ = filter.filter_days_per_mouse(res, days_per_mouse=list_of_days)
res_ = filter.filter(res_, filter_dict={'odor_valence':'CS+'})
mice = np.unique(res_['mouse'])
real = []
for mouse in mice:
res_mouse_ = filter.filter(res_, {'mouse': mouse})
days = np.unique(res_mouse_['day'])
for day in days:
res_mouse_day = filter.filter(res_mouse_, {'day': day})
assert res_mouse_day['onset'].size == 2, 'should be two entries corresponding to two CS+ per mouse'
a = res_mouse_day[data_arg][0]
b = res_mouse_day[data_arg][1]
a = a[a>-1]
b = b[b>-1]
real.append(a)
real.append(b)
flatten = lambda l: [item for sublist in l for item in sublist]
real = np.array(flatten(real), dtype=float)
print('Number of points: {}'.format(real.shape))
bin = 20
if data_arg == 'amplitude':
xlim = 1.5
hist_range = 1.5
else:
period = .229
xlim = np.ceil(bin * period)
hist_range = bin * period
real *= period
if not save:
fig = plt.figure(figsize=(2, 1.5))
ax = fig.add_axes([0.2, 0.2, 0.7, 0.7])
else:
ax = plt.gca()
def _helper(real, label):
density, bins = np.histogram(real, bins=bin, density=True, range=[0, hist_range])
unity_density = density / density.sum()
widths = bins[:-1] - bins[1:]
ax.bar(bins[1:], unity_density, width=widths, alpha=.5, label=label)
_helper(real, 'Data')
ax.set_xlabel((data_arg.capitalize()))
ax.set_ylabel('Density')
if data_arg != 'amplitude':
plt.xticks([0, 2, 5], ['Odor On', 'Off', 'US'])
plt.xlim([-0.5, 5.5])
else:
plt.xlim([0, xlim])
# xticks = np.arange(xlim)
# ax.set_xticks(xticks)
# ax.set_xticklabels(xticks)
# yticks = np.array([0, .5, 1])
# ax.set_yticks(yticks)
# plt.ylim([0, 1])
mean = np.mean(real)
median = np.median(real)
ylim = ax.get_ylim()
xlim = ax.get_xlim()
x = (xlim[1] - xlim[0]) / 2
y = (ylim[1] - ylim[0]) / 2
if save:
y -= .05
t = 'Median = {:.3f}, mean = {:.3f}'.format(median, mean)
# plt.text(x, y, t)
ax.spines["right"].set_visible(False)
ax.spines["top"].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
name = 'distribution ' + data_arg + '_' + ','.join([str(x) for x in start]) + '_' + ','.join([str(x) for x in end])
if save:
plt.legend(frameon=False)
_easy_save(os.path.join(figure_path, data_arg), name, dpi=300, pdf=True)
#statistics
if data_arg == 'onset':
odor = np.sum(real < 2) / real.size
delay = np.sum(real > 2) / real.size
print('mean, median: {}, {}'.format(mean, median))
print('Fraction of cells with onset during odor presentation: {}'.format(odor))
return real
condition.name)
load_path = os.path.join(data_directory, str(mouse) + '.npy')
save_path = os.path.join(config.Config().LOCAL_FIGURE_PATH, 'MISC',
'COUNTING_CELLS')
rois = file_io.load_numpy(load_path)
#ROIT has dimensions YDIM, XDIM, NROI, DAYS
roiT = np.transpose(rois, (1, 2, 3, 0)).astype('float32')
ydim, xdim, nroi, ndays = roiT.shape
for r in range(nroi):
fig, axs = plt.subplots(1, ndays, figsize=(6, 1))
for d in range(ndays):
roi = roiT[:, :, r, d]
comy, comx = np.round(center_of_mass(roi)).astype(int)
subset = roi[comy - pad:comy + pad, comx - pad:comx + pad]
im = axs[d].imshow(subset)
axs[d].set_title('Day {}'.format(1 + d * 2), fontsize=7)
axs[d].axis('off')
cm = im.get_cmap()
cm.colors[0] = [0, 0, 0]
im = axs[d].imshow(subset, cmap=cm)
fig.suptitle(str(r))
try:
plot._easy_save(path=save_path, name=str(r))
except:
plt.close()
mean - err,
mean + err,
zorder=0,
lw=0,
alpha=config.fill_alpha,
color=condition_config.colors[j])
# plt.xticks([time_odor_on, time_odor_off, time_water_on], labels=['ON', 'OFF', 'US'])
plt.xticks([time_odor_on, time_odor_off, time_water_on],
labels=['', '', ''])
plt.yticks([])
plt.ylim(condition_config.ylim)
# if condition_config.name == 'standard':
# legends = ['CS+1','CS+2','CS-1','CS-2']
# else:
# legends = [odor.upper() for odor in odors]
# plt.legend(legends, frameon=False)
# ax.set_xlabel('Time (s)')
# ax.set_ylabel(r'$\Delta$ F/F')
# draw_scale_line_xy(ax, length=[5, .5], offset=[0, 0], linewidth= config.scale_linewidth)
ax.spines['top'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
plot._easy_save(
save_path,
'mouse_' + str(mouse) + '_cell_' + str(cell) + '_day_' + str(i))
water_on_lines = np.arange(water_on, frames_per_trial * len(odors), frames_per_trial)
if 'water' in odors:
water_on_lines = water_on_lines[[0,1,4]]
else:
water_on_lines = water_on_lines[[0,1]]
if cell_days[i] >= condition.training_start_day[mouse]:
xticks = np.append(odor_on_lines, water_on_lines)
else:
xticks = odor_on_lines
plt.xticks(xticks, '')
plt.yticks([])
plt.tick_params(direction='out', length=2, width=.5, grid_alpha=0.5)
plt.ylabel(condition_config.title[i])
for line in condition_lines:
plt.plot([line, line], plt.ylim(), '--', color='grey', linewidth=.5)
for j, x in enumerate(odor_on_lines):
plt.text(x, -1, odors[j].upper())
ax = fig.add_axes(rect_cb)
cb = plt.colorbar(cax=ax, ticks=[-condition_config.vlim, condition_config.vlim])
cb.outline.set_linewidth(0.5)
cb.set_label(r'$\Delta$ F/F', fontsize=7, labelpad=-10)
plt.tick_params(axis='both', which='major', labelsize=7)
plot._easy_save(save_path,
'mouse_' + str(mouse) +
'_cell_' + str(cell) +
'_day_' + str(res_mouse['day'][i]))
xticks = np.concatenate((odor_on_lines, odor_on_lines + 8))
plt.xticks(xticks, '')
plt.yticks([])
for line in condition_lines:
plt.plot([line, line], plt.ylim(), '--', color='grey', linewidth=.5)
for j, x in enumerate(odor_on_lines_raw):
plt.text(x, -1, titles[j].upper())
ax = fig.add_axes(rect_cb)
cb = plt.colorbar(cax=ax,
ticks=[-condition_config.vlim, condition_config.vlim])
if black:
cb.outline.set_visible(False)
cb.set_ticks([])
else:
cb.outline.set_linewidth(0.5)
cb.set_label(r'$\Delta$ F/F', fontsize=7, labelpad=-10)
plt.tick_params(axis='both', which='major', labelsize=7)
name_black = '_black' if black else ''
name = 'mouse_' + str(mouse) + '_day_' + str(days[i]) + name_black
if condition_config.plot_big:
name += '_big' + ','.join(
[str(x) for x in condition_config.plot_big_days])
plot._easy_save(save_path, name)
for ims in imData:
ims = np.stack(ims, axis=0)
ims = ims[i]
mean_ims.append(ims.mean(axis=0))
mean_ims = np.stack(mean_ims, axis=0)
across_day_mean_corrs = across_corr_metric(mean_ims)
across_day_mean_corrs_average = across_day_mean_corrs[
~np.eye(across_day_mean_corrs.shape[0], dtype=bool)].mean()
imdir = os.path.join(d, 'python_reg.tif')
fi.imsave(imdir, mean_ims.astype('uint16'), photometric='minisblack')
for i, im in enumerate(mean_ims):
plt.imshow(im, cmap='gray')
plt.xticks([])
plt.yticks([])
plot._easy_save(d, str(i))
#saving
p, experiment = os.path.split(d)
p, mouse = os.path.split(p)
save_dir = os.path.join(data_directory, condition.name)
res = defaultdict(list)
res['within_day_corrs'].append(within_day_corrs)
res['within_day_corrs_average'].append(within_day_corr_average)
res['within_day_crisp'].append(within_day_crisp)
res['within_day_crisp_average'].append(np.mean(within_day_crisp))
res['across_day_mean_corrs'].append(across_day_mean_corrs)
res['across_day_mean_corrs_average'].append(across_day_mean_corrs_average)
# res['within_day_mean_corrs'].append(within_day_mean_corrs)
res['mouse'].append(mouse)
