def load_results_train_test_scores(data_path):
res = defaultdict(list)
experiment_dirs = sorted(
[os.path.join(data_path, d) for d in os.listdir(data_path)])
keys = [
'DAQ_O_ON_F', 'DAQ_O_OFF_F', 'DAQ_W_ON_F', 'DAQ_O_ON', 'DAQ_O_OFF',
'DAQ_W_ON', 'TRIAL_FRAMES', 'TRIAL_PERIOD', 'NAME_MOUSE', 'NAME_PLANE',
'NAME_DATE', 'decode_style', 'neurons', 'shuffle', 'split_style'
]
for exp_dir in experiment_dirs:
data_dirs = sorted(glob.glob(os.path.join(exp_dir, '*' + '.pkl')))
config_dirs = sorted(glob.glob(os.path.join(exp_dir, '*.json')))
for data_dir, config_dir in zip(data_dirs, config_dirs):
config = tools.file_io.load_json(config_dir)
cur_res = tools.file_io.load_pickle(data_dir)
for k in keys:
cur_res[k] = np.array([config[k]] * len(cur_res['scores']))
reduce.chain_defaultdicts(res, cur_res)
add_indices(res)
add_time(res)
for i, _ in enumerate(res['scores']):
res['top_score'].append(np.max(res['scores'][i]))
res['top_score'] = np.array(res['top_score'])
return res
def custom_get_res(start_time, end_time):
list_of_res = []
for i, condition in enumerate(conditions):
if any(s in condition.name for s in ['YFP', 'HALO', 'JAWS']):
data_path = os.path.join(Config.LOCAL_DATA_PATH,
Config.LOCAL_DATA_BEHAVIOR_FOLDER,
condition.name)
else:
data_path = os.path.join(Config.LOCAL_DATA_PATH,
Config.LOCAL_DATA_TIMEPOINT_FOLDER,
condition.name)
res = custom_analyze_behavior(data_path,
condition,
start_time=start_time,
end_time=end_time)
if condition.name == 'OFC_LONGTERM':
res = filter.exclude(res, {'mouse': 3})
if 'YFP' in condition.name:
res['condition'] = np.array(['YFP'] * len(res['mouse']))
elif 'JAWS' in condition.name:
res['condition'] = np.array(['JAWS'] * len(res['mouse']))
elif 'HALO' in condition.name:
res['condition'] = np.array(['HALO'] * len(res['mouse']))
else:
res['condition'] = np.array([condition.name] * len(res['mouse']))
list_of_res.append(res)
all_res = defaultdict(list)
for res, condition in zip(list_of_res, conditions):
reduce.chain_defaultdicts(all_res, res)
return all_res
def plot_overlap_water(res, start_days, end_days, figure_path):
ax_args_copy = overlap_ax_args.copy()
res = copy.copy(res)
mice = np.unique(res['mouse'])
res = filter.filter_days_per_mouse(res, days_per_mouse=end_days)
add_naive_learned(res, start_days, end_days)
ax_args_copy.update({'xlim': [-1, 2]})
y_keys = ['US/CS+', 'CS+/US']
summary_res = defaultdict(list)
for arg in y_keys:
_get_overlap_water(res, arg=arg)
new_res = reduce.new_filter_reduce(
res,
filter_keys=['mouse', 'day', 'odor_valence'],
reduce_key='Overlap')
new_res['Type'] = np.array([arg] * len(new_res['training_day']))
reduce.chain_defaultdicts(summary_res, new_res)
summary_res.pop('Overlap_sem')
summary_res.pop('Overlap_std')
summary_res = filter.filter(summary_res, {'odor_valence': 'CS+'})
mean_std_res = reduce.new_filter_reduce(summary_res,
filter_keys='Type',
reduce_key='Overlap')
types = np.unique(summary_res['Type'])
scatter_args_copy = scatter_args.copy()
scatter_args_copy.update({'s': 2, 'alpha': .6})
for i, type in enumerate(types):
reuse_arg = True
if i == 0:
reuse_arg = False
temp = filter.filter(summary_res, {'Type': type})
plot.plot_results(temp,
x_key='Type',
y_key='Overlap',
loop_keys='mouse',
colors=['Black'] * len(mice),
plot_function=plt.scatter,
path=figure_path,
plot_args=scatter_args_copy,
ax_args=ax_args_copy,
save=False,
reuse=reuse_arg,
fig_size=(1.5, 1.5),
rect=(.25, .25, .6, .6),
legend=False)
plot.plot_results(mean_std_res,
x_key='Type',
y_key='Overlap',
error_key='Overlap_sem',
path=figure_path,
plot_function=plt.errorbar,
plot_args=error_args,
ax_args=ax_args,
save=True,
reuse=True,
fig_size=(1.5, 1.5),
legend=False)
print(mean_std_res['Overlap'])
def load_pca(save_path):
res = defaultdict(list)
experiment_dirs = sorted(
[os.path.join(save_path, d) for d in os.listdir(save_path)])
for d in experiment_dirs:
temp_res = fio.load_pickle(d)
reduce.chain_defaultdicts(res, temp_res)
return res
def easy_shuffle(res, shuffle_keys, n):
shuffled_res = defaultdict(list)
for i in range(n):
temp = shuffle_data(res, shuffle_keys=shuffle_keys)
reduce.chain_defaultdicts(shuffled_res, temp)
shuffled_res['shuffle'] = np.ones(len(shuffled_res['odor']), dtype=int)
reduce.chain_defaultdicts(res, shuffled_res)
return res
def _filter(res):
out = defaultdict(list)
for mouse in np.unique(res['mouse']):
temp = filter.filter(res, {'mouse': mouse})
data = temp['ball_data'].flatten()
max, min = np.max(data), np.min(data)
if (max - min) > 4:
reduce.chain_defaultdicts(out, temp)
return out
def scalpel(res2, keys, mouse, sessions, valence='CS+'):
temp = filter.filter(res2, {'mouse': mouse, 'odor_valence': valence})
print(temp['mouse'].size)
assert temp['mouse'].size == 1
ix = np.isin(temp['session'][0], sessions)
ix = np.invert(ix)
for k in keys:
temp[k][0] = temp[k][0][ix]
_, inverse = np.unique(temp['session'][0], return_inverse=True)
temp['session'][0] = inverse
res2 = filter.exclude(res2, {'mouse': mouse, 'odor_valence': valence})
reduce.chain_defaultdicts(res2, temp)
return res2
def plot_bar(res,
days_per_mouse,
odor_valence,
day_pad,
save,
reuse,
figure_path,
color='black',
normalize=False):
res = copy.copy(res)
res['day_'] = np.zeros_like(res['day'])
res_ = defaultdict(list)
for i, days in enumerate(days_per_mouse):
temp = filter.filter_days_per_mouse(res, days_per_mouse=days)
temp = filter.filter(temp, {'odor_valence': odor_valence[i]})
temp['day_'] = np.array([i + day_pad] * len(temp['day_']))
reduce.chain_defaultdicts(res_, temp)
_max_dff(res_)
res_ = reduce.new_filter_reduce(
res_,
filter_keys=['odor_valence', 'mouse', 'day_'],
reduce_key='max_dff')
res_.pop('max_dff_sem')
summary = reduce.new_filter_reduce(res_,
filter_keys=['day_', 'odor_valence'],
reduce_key='max_dff')
if normalize:
_normalize_across_days(summary)
# plot.plot_results(summary, x_key='day_', y_key='max_dff', error_key='max_dff_sem',
# path=figure_path,
# colors='black', legend=False, plot_args=error_args, plot_function= plt.errorbar,
# fig_size=(2, 1.5), save=False, reuse=reuse)
line_args_copy = line_args.copy()
line_args_copy.update({'alpha': .75, 'linewidth': 1})
plot.plot_results(summary,
x_key='day_',
y_key='max_dff',
path=figure_path,
colors=color,
legend=False,
plot_args=line_args_copy,
fig_size=(2, 1.5),
save=save,
reuse=reuse,
name_str=odor_valence[-1])
{'odor_valence': ['CS+', 'CS-', 'PT CS+']})
all_res_lick = reduce.new_filter_reduce(
all_res,
filter_keys=['condition', 'odor_valence', 'mouse'],
reduce_key=lick)
for i, x in enumerate(all_res_lick[lick]):
all_res_lick['training_end_licks'].append(np.mean(x[-20:]))
all_res_lick['start_time'].append(start_time)
all_res_lick['end_time'].append(end_time)
for k, v in all_res_lick.items():
all_res_lick[k] = np.array(v)
list_of_res.append(all_res_lick)
for res in list_of_res:
reduce.chain_defaultdicts(full, res)
line_args_copy = line_args.copy()
line_args_copy.update({'marker': '.', 'linewidth': .5, 'markersize': .5})
valences = np.unique(full['odor_valence'])
for valence in valences:
color = [color_dict_valence[valence]]
mean_std_res = reduce.new_filter_reduce(
full,
filter_keys=['odor_valence', 'start_time'],
reduce_key='training_end_licks')
plot.plot_results(full,
x_key='start_time',
def plot_summary_odor_pretraining(res,
start_days,
end_days,
arg_naive,
figure_path,
save,
excitatory=True):
ax_args_copy = ax_args.copy()
res = copy.copy(res)
list_of_days = list(zip(start_days, end_days))
mice = np.unique(res['mouse'])
start_end_day_res = filter.filter_days_per_mouse(
res, days_per_mouse=list_of_days)
get_responsive_cells(start_end_day_res)
if arg_naive:
day_start = filter.filter(start_end_day_res,
{'odor_standard': 'PT Naive'})
day_start['odor_standard'] = np.array(['PT CS+'] *
len(day_start['odor_standard']))
day_end = filter.filter_days_per_mouse(start_end_day_res,
days_per_mouse=end_days)
day_end = filter.filter(day_end, {'odor_standard': 'PT CS+'})
reduce.chain_defaultdicts(day_start, day_end)
start_end_day_res = day_start
else:
start_end_day_res = filter.exclude(start_end_day_res,
{'odor_standard': 'PT Naive'})
add_naive_learned(start_end_day_res, start_days, end_days, 'a', 'b')
filter.assign_composite(start_end_day_res,
loop_keys=['odor_standard', 'training_day'])
odor_list = ['PT CS+']
colors = ['Orange']
ax_args_copy = ax_args_copy.copy()
ax_args_copy.update({
'xlim': [-1, 10],
'ylim': [0, .4],
'yticks': [0, .1, .2, .3, .4]
})
for i, odor in enumerate(odor_list):
save_arg = False
reuse_arg = True
if i == 0:
reuse_arg = False
if save and i == len(odor_list) - 1:
save_arg = True
plot.plot_results(start_end_day_res,
select_dict={'odor_standard': odor},
x_key='odor_standard_training_day',
y_key='Fraction Responsive',
loop_keys='mouse',
colors=[colors[i]] * len(mice),
path=figure_path,
plot_args=line_args,
ax_args=ax_args_copy,
save=save_arg,
reuse=reuse_arg,
fig_size=(2.5, 1.5),
legend=False,
name_str='_E' if excitatory else '_I')
before_csm = filter.filter(start_end_day_res,
filter_dict={
'training_day': 'a',
'odor_standard': 'PT CS+'
})
after_csm = filter.filter(start_end_day_res,
filter_dict={
'training_day': 'b',
'odor_standard': 'PT CS+'
})
from scipy.stats import ranksums, wilcoxon, kruskal
print('Before PT CS+: {}'.format(np.mean(
before_csm['Fraction Responsive'])))
print('After PT CS+: {}'.format(np.mean(after_csm['Fraction Responsive'])))
from scipy.stats import sem
print('After PT CS+ STD: {}'.format(sem(after_csm['Fraction Responsive'])))
print('Wilcoxin:{}'.format(
wilcoxon(before_csm['Fraction Responsive'],
after_csm['Fraction Responsive'])))
def plot_responsive_difference_odor_and_water(res,
odor_start_days,
water_start_days,
end_days,
use_colors=True,
figure_path=None,
include_water=True,
normalize=False,
pt_start=None,
pt_learned=None,
average=True,
ylim=.22,
reuse_arg=False,
save_arg=True):
key = 'Change in Fraction Responsive'
if normalize:
key = 'Norm. Fraction Responsive'
def _helper(start_end_day_res):
combs, list_of_ixs = filter.retrieve_unique_entries(
start_end_day_res, ['mouse', 'odor_standard'])
for i, comb in enumerate(combs):
ixs = list_of_ixs[i]
assert len(ixs) == 2
if start_end_day_res['training_day'][0] == 'Naive':
ref = ixs[0]
test = ixs[1]
elif start_end_day_res['training_day'][0] == 'Learned':
ref = ixs[1]
test = ixs[0]
else:
raise ValueError('cannot find ref day')
if normalize:
start_end_day_res[key][test] = start_end_day_res['Fraction Responsive'][test] / \
start_end_day_res['Fraction Responsive'][ref]
start_end_day_res[key][ref] = 1
else:
start_end_day_res[key][test] = start_end_day_res['Fraction Responsive'][test] - \
start_end_day_res['Fraction Responsive'][ref]
start_end_day_res[key][ref] = 0
ax_args_copy = ax_args.copy()
res = copy.copy(res)
get_responsive_cells(res)
list_of_days = list(zip(odor_start_days, end_days))
mice = np.unique(res['mouse'])
res[key] = np.zeros_like(res['Fraction Responsive'])
start_end_day_res = filter.filter_days_per_mouse(
res, days_per_mouse=list_of_days)
start_end_day_res = filter.filter(
start_end_day_res, {'odor_valence': ['CS+', 'CS-', 'Naive']})
add_naive_learned(start_end_day_res, odor_start_days, end_days)
odors = ['CS+', 'CS-', 'Naive']
if 'PT CS+' in np.unique(res['odor_valence']):
odors = ['PT CS+'] + odors
list_of_days = list(zip(pt_start, pt_learned))
start_end_day_res_pt = filter.filter_days_per_mouse(
res, days_per_mouse=list_of_days)
start_end_day_res_pt = filter.filter(start_end_day_res_pt,
{'odor_valence': 'PT CS+'})
add_naive_learned(start_end_day_res_pt, pt_start, pt_learned)
reduce.chain_defaultdicts(start_end_day_res, start_end_day_res_pt)
if include_water:
odors += ['US']
list_of_days = list(zip(water_start_days, end_days))
start_end_day_res_water = filter.filter_days_per_mouse(
res, days_per_mouse=list_of_days)
start_end_day_res_water = filter.filter(start_end_day_res_water,
{'odor_valence': 'US'})
add_naive_learned(start_end_day_res_water, water_start_days, end_days)
reduce.chain_defaultdicts(start_end_day_res, start_end_day_res_water)
filter.assign_composite(start_end_day_res,
loop_keys=['odor_standard', 'training_day'])
if average:
start_end_day_res = reduce.new_filter_reduce(
start_end_day_res,
filter_keys=['odor_valence', 'mouse', 'training_day'],
reduce_key=key)
start_end_day_res.pop(key + '_sem')
_helper(start_end_day_res)
start_end_day_res = filter.filter(start_end_day_res,
{'training_day': 'Learned'})
summary_res = reduce.new_filter_reduce(start_end_day_res,
filter_keys='odor_valence',
reduce_key=key)
dict = {
'CS+': 'Green',
'CS-': 'Red',
'US': 'Turquoise',
'PT CS+': 'Orange',
'Naive': 'Gray'
}
if use_colors:
colors = [
dict[key] for key in np.unique(start_end_day_res['odor_valence'])
]
else:
colors = ['Black'] * 6
ax_args_copy = ax_args_copy.copy()
n_valence = len(np.unique(summary_res['odor_valence']))
ax_args_copy.update({
'xlim': [-.5, 3.5],
'ylim': [-ylim, ylim],
'yticks': [-.3, -.2, -.1, 0, .1, .2, .3]
})
if normalize:
ax_args_copy.update({
'xlim': [-.5, 3.5],
'ylim': [-.1, 1.5],
'yticks': [0, .5, 1, 1.5]
})
error_args_ = {
'fmt': '.',
'capsize': 2,
'elinewidth': 1,
'markersize': 2,
'alpha': .75
}
scatter_args_copy = scatter_args.copy()
scatter_args_copy.update({'s': 3})
for i, odor in enumerate(odors):
reuse = True
if i == 0:
reuse = reuse_arg
plot.plot_results(start_end_day_res,
loop_keys='odor_valence',
select_dict={'odor_valence': odor},
x_key='odor_valence',
y_key=key,
colors=[dict[odor]] * len(mice),
path=figure_path,
plot_args=scatter_args_copy,
plot_function=plt.scatter,
ax_args=ax_args_copy,
save=False,
reuse=reuse,
fig_size=(2, 1.5),
rect=(.25, .2, .6, .6),
legend=False,
name_str=','.join([str(x) for x in odor_start_days]))
if not normalize:
plt.plot(plt.xlim(), [0, 0], '--', color='gray', linewidth=1, alpha=.5)
plot.plot_results(summary_res,
x_key='odor_valence',
y_key=key,
error_key=key + '_sem',
colors='black',
path=figure_path,
plot_args=error_args_,
plot_function=plt.errorbar,
ax_args=ax_args_copy,
save=save_arg,
reuse=True,
fig_size=(2, 1.5),
legend=False)
def plot_summary_odor_and_water(res,
odor_start_days,
water_start_days,
end_days,
use_colors=True,
excitatory=True,
arg='odor_valence',
figure_path=None):
include_water = True
ax_args_copy = ax_args.copy()
res = copy.copy(res)
get_responsive_cells(res)
mice = np.unique(res['mouse'])
list_of_days = list(zip(odor_start_days, end_days))
start_end_day_res = filter.filter_days_per_mouse(
res, days_per_mouse=list_of_days)
start_end_day_res = filter.exclude(start_end_day_res,
{'odor_valence': 'US'})
add_naive_learned(start_end_day_res, odor_start_days, end_days, 'a', 'b')
if include_water:
list_of_days = list(zip(water_start_days, end_days))
start_end_day_res_water = filter.filter_days_per_mouse(
res, days_per_mouse=list_of_days)
start_end_day_res_water = filter.filter(start_end_day_res_water,
{'odor_valence': 'US'})
add_naive_learned(start_end_day_res_water, water_start_days, end_days,
'a', 'b')
reduce.chain_defaultdicts(start_end_day_res, start_end_day_res_water)
ax_args_copy = ax_args_copy.copy()
if arg == 'odor_valence':
start_end_day_res = reduce.new_filter_reduce(
start_end_day_res,
filter_keys=['training_day', 'mouse', 'odor_valence'],
reduce_key='Fraction Responsive')
odor_list = ['CS+', 'CS-']
ax_args_copy.update({
'xlim': [-1, 6],
'ylim': [0, .6],
'yticks': [0, .1, .2, .3, .4, .5]
})
colors = ['Green', 'Red']
elif arg == 'naive':
arg = 'odor_valence'
start_end_day_res = reduce.new_filter_reduce(
start_end_day_res,
filter_keys=['training_day', 'mouse', 'odor_valence'],
reduce_key='Fraction Responsive')
odor_list = ['CS+']
ax_args_copy.update({
'xlim': [-1, 4],
'ylim': [0, .6],
'yticks': [0, .1, .2, .3, .4, .5]
})
colors = ['GoldenRod']
else:
odor_list = ['CS+1', 'CS+2', 'CS-1', 'CS-2']
colors = ['Green', 'Green', 'Red', 'Red']
ax_args_copy.update({
'xlim': [-1, 10],
'ylim': [0, .6],
'yticks': [0, .1, .2, .3, .4, .5]
})
filter.assign_composite(start_end_day_res, loop_keys=[arg, 'training_day'])
if not use_colors:
colors = ['Black'] * 4
name_str = '_E' if excitatory else '_I'
for i, odor in enumerate(odor_list):
reuse_arg = True
if i == 0:
reuse_arg = False
plot.plot_results(start_end_day_res,
select_dict={arg: odor},
x_key=arg + '_training_day',
y_key='Fraction Responsive',
loop_keys='mouse',
colors=[colors[i]] * len(mice),
path=figure_path,
plot_args=line_args,
ax_args=ax_args_copy,
save=False,
reuse=reuse_arg,
fig_size=(2.5, 1.5),
legend=False,
name_str=','.join([str(x) for x in odor_start_days]))
plot.plot_results(start_end_day_res,
select_dict={'odor_standard': 'US'},
x_key='training_day',
y_key='Fraction Responsive',
loop_keys='mouse',
colors=['Turquoise'] * len(mice),
path=figure_path,
plot_args=line_args,
ax_args=ax_args_copy,
fig_size=(1.6, 1.5),
legend=False,
reuse=True,
save=True,
name_str=name_str)
before_odor = filter.filter(start_end_day_res,
filter_dict={
'training_day': 'a',
'odor_valence': ['CS+', 'CS-']
})
after_odor = filter.filter(start_end_day_res,
filter_dict={
'training_day': 'b',
'odor_valence': ['CS+', 'CS-']
})
before_csp = filter.filter(start_end_day_res,
filter_dict={
'training_day': 'a',
'odor_valence': 'CS+'
})
after_csp = filter.filter(start_end_day_res,
filter_dict={
'training_day': 'b',
'odor_valence': 'CS+'
})
before_csm = filter.filter(start_end_day_res,
filter_dict={
'training_day': 'a',
'odor_valence': 'CS-'
})
after_csm = filter.filter(start_end_day_res,
filter_dict={
'training_day': 'b',
'odor_valence': 'CS-'
})
before_water = filter.filter(start_end_day_res,
filter_dict={
'training_day': 'a',
'odor_valence': 'US'
})
after_water = filter.filter(start_end_day_res,
filter_dict={
'training_day': 'b',
'odor_valence': 'US'
})
try:
from scipy.stats import ranksums, wilcoxon, kruskal
print('Before Odor: {}'.format(
np.mean(before_odor['Fraction Responsive'])))
print('After Odor: {}'.format(
np.mean(after_odor['Fraction Responsive'])))
print('Wilcoxin:{}'.format(
wilcoxon(before_odor['Fraction Responsive'],
after_odor['Fraction Responsive'])))
print('Before CS+: {}'.format(
np.mean(before_csp['Fraction Responsive'])))
print('After CS+: {}'.format(np.mean(
after_csp['Fraction Responsive'])))
print('Wilcoxin:{}'.format(
wilcoxon(before_csp['Fraction Responsive'],
after_csp['Fraction Responsive'])))
print('Before CS-: {}'.format(
np.mean(before_csm['Fraction Responsive'])))
print('After CS-: {}'.format(np.mean(
after_csm['Fraction Responsive'])))
print('Wilcoxin:{}'.format(
wilcoxon(before_csm['Fraction Responsive'],
after_csm['Fraction Responsive'])))
print('Before US: {}'.format(
np.mean(before_water['Fraction Responsive'])))
print('After US: {}'.format(np.mean(
after_water['Fraction Responsive'])))
print('Wilcoxin:{}'.format(
wilcoxon(before_water['Fraction Responsive'],
after_water['Fraction Responsive'])))
except:
print('stats didnt work')
from tools import file_io
import filter
import reduce
import plot
data_directory = Config().LOCAL_DATA_PATH
data_directory = os.path.join(data_directory, 'registration','motion_metrics')
conditions = glob.glob(os.path.join(data_directory, '*/'))
res = defaultdict(list)
for c in conditions:
mouse_pickles = glob.glob(os.path.join(c, '*.pkl'))
for pickle in mouse_pickles:
temp = file_io.load_pickle(pickle)
reduce.chain_defaultdicts(res, temp)
res['within_day_crisp_average'] = []
for v in res['within_day_crisp']:
res['within_day_crisp_average'].append(np.mean(v))
for k, v in res.items():
res[k] = np.array(v)
save_path = os.path.join(Config.LOCAL_FIGURE_PATH, 'MISC', 'MOTION_METRICS')
mouse = 'M4_OFC'
vmin, vmax = 0.6, 1
ix = res['mouse'] == mouse
glob.glob(
os.path.join(experiment.path, directory, constants.yfp + '*')))
res2 = analysis.parse(yfp_files,
experiment=experiment,
condition=constants.yfp,
phase=directory)
res2['experiment'] = np.array([experiment.name] *
len(res2['odor_valence']))
# if experiment.name == 'MPFC_DT':
# res1 = filter.exclude(res1, {'mouse':['H01']})
# res2 = filter.exclude(res2, {'mouse':['H01']})
# if experiment.name == 'MPFC_PT':
# res1 = filter.exclude(res1, {'mouse': ['Y01']})
# res2 = filter.exclude(res2, {'mouse': ['Y01']})
reduce.chain_defaultdicts(res, res1)
reduce.chain_defaultdicts(res, res2)
# analysis
def _get_number_of_licks(mat, start, end):
on_off = np.diff(mat, n=1)
n_licks = np.sum(on_off[start:end, :] > 0, axis=1)
return n_licks
for i in range(len(res['bin_ant_1_raw'])):
a, b = res['bin_ir_raw'][i], res['bin_samp_raw'][i]
c, d, e = res['bin_ant_1_raw'][i], res['bin_ant_2_raw'][i], res[
'bin_ant_3_raw'][i]
f, g = res['bin_col_1_raw'][i], res['bin_col_2_raw'][i]
def plot_correlation(res,
start_days,
end_days,
figure_path,
odor_end=True,
linestyle='-',
direction=0,
arg=False,
save=False,
reuse=False,
color='black'):
def _get_ixs(r, arg):
A = r['Odor_A']
B = r['Odor_B']
l = []
for i, a in enumerate(A):
b = B[i]
if arg == 'opposing':
if a < 2 and b > 1:
l.append(i)
elif arg == 'CS+':
if a == 0 and b == 1:
l.append(i)
elif arg == 'CS-':
if a == 2 and b == 3:
l.append(i)
return np.array(l)
res = filter.filter(res, {'odor_valence': ['CS+', 'CS-']})
res_before = filter.filter_days_per_mouse(res, start_days)
corr_before = _correlation(res_before, ['mouse'],
shuffle=False,
odor_end=odor_end,
direction=direction)
corr_before['day'] = np.array(['A'] * len(corr_before['Odor_A']))
res_after = filter.filter_days_per_mouse(res, end_days)
corr_after = _correlation(res_after, ['mouse'],
shuffle=False,
odor_end=odor_end,
direction=direction)
corr_after['day'] = np.array(['B'] * len(corr_after['Odor_A']))
corr = defaultdict(list)
reduce.chain_defaultdicts(corr, corr_before)
reduce.chain_defaultdicts(corr, corr_after)
ix_same = np.equal(corr['Odor_A'], corr['Odor_B'])
ix_different = np.invert(ix_same)
for k, v in corr.items():
corr[k] = v[ix_different]
if arg is not False:
ixs = _get_ixs(corr, arg)
for k, v in corr.items():
corr[k] = v[ixs]
mouse_corr = reduce.new_filter_reduce(corr,
filter_keys=['mouse', 'day'],
reduce_key='corrcoef')
mouse_corr.pop('corrcoef_sem')
mouse_corr.pop('corrcoef_std')
average_corr = reduce.new_filter_reduce(mouse_corr,
filter_keys=['day'],
reduce_key='corrcoef')
error_args = {'capsize': 2, 'elinewidth': 1, 'markersize': 2, 'alpha': .5}
error_args.update({'linestyle': linestyle})
plot.plot_results(average_corr,
x_key='day',
y_key='corrcoef',
error_key='corrcoef_sem',
plot_args=error_args,
plot_function=plt.errorbar,
colors=color,
ax_args={
'ylim': [0, 1],
'xlim': [-.5, 1.5]
},
save=save,
reuse=reuse,
path=figure_path,
name_str=str(direction) + '_' + str(arg))
#stats
before_odor = filter.filter(corr, filter_dict={'day': 'A'})
after_odor = filter.filter(corr, filter_dict={'day': 'B'})
from scipy.stats import ranksums, wilcoxon, kruskal
print('direction: {}'.format(direction))
# print('Data Before: {}'.format(before_odor['corrcoef']))
# print('Data After: {}'.format(after_odor['corrcoef']))
print('Before: {}'.format(np.mean(before_odor['corrcoef'])))
print('After: {}'.format(np.mean(after_odor['corrcoef'])))
print('Wilcoxin:{}'.format(
wilcoxon(before_odor['corrcoef'], after_odor['corrcoef'])))
def plot_max_dff_days(res,
days_per_mouse,
odor_valence,
save,
reuse,
day_pad,
ylim=.115,
colors=None,
normalize=False,
figure_path=None):
res = copy.copy(res)
res['day_'] = np.zeros_like(res['day'])
res_ = defaultdict(list)
for i, days in enumerate(days_per_mouse):
temp = filter.filter_days_per_mouse(res, days_per_mouse=days)
temp = filter.filter(temp, {'odor_valence': odor_valence[i]})
temp['day_'] = np.array([i + day_pad] * len(temp['day_']))
reduce.chain_defaultdicts(res_, temp)
_max_dff(res_)
res_ = reduce.new_filter_reduce(
res_,
filter_keys=['odor_valence', 'mouse', 'day_'],
reduce_key='max_dff')
if normalize:
_normalize_across_days(res_)
yticks = [0, 1, 2, 3, 4, 5, 6]
else:
yticks = np.arange(0, ylim, .05)
dict = {
'CS+': 'Green',
'CS-': 'Red',
'US': 'Turquoise',
'PT CS+': 'Orange'
}
n_mice = len(np.unique(res['mouse']))
ax_args_copy = ax_args.copy()
ax_args_copy.update({
'ylim': [0, ylim],
'yticks': yticks,
'xticks': list(range(20))
})
line_args_copy = line_args.copy()
line_args_copy.update({
'marker': '.',
'linestyle': '--',
'linewidth': .5,
'alpha': .5,
'markersize': 2
})
if colors is None:
colors = [dict[x] for x in odor_valence]
else:
line_args_copy.update({'marker': None})
plot.plot_results(res_,
loop_keys='mouse',
x_key='day_',
y_key='max_dff',
path=figure_path,
colors=colors * n_mice,
legend=False,
plot_args=line_args_copy,
ax_args=ax_args_copy,
fig_size=(2, 2),
save=save,
reuse=reuse)
def plot_correlation_across_days(res,
days,
loop_keys,
shuffle,
figure_path,
reuse,
save,
analyze,
plot_bool,
odor_end=True):
if analyze:
res_ = defaultdict(list)
for day_list in days:
d = list(zip(day_list[0], day_list[1]))
res_temp = filter.filter_days_per_mouse(res, d)
corr_res = _correlation(res_temp,
loop_keys,
shuffle,
odor_end=odor_end)
reduce.chain_defaultdicts(res_, corr_res)
res_ = filter.filter(res_, {'Odor_A': 0, 'Odor_B': 1})
res_ = reduce.new_filter_reduce(res_,
filter_keys=['mouse', 'odor_standard'],
reduce_key='corrcoef')
res_.pop('corrcoef_sem')
return res_
if plot_bool:
res_ = res
if shuffle:
s = '_shuffled'
else:
s = ''
ax_args_copy = ax_args.copy()
ax_args_copy.update({
'xlim': [-.5, 2.5],
'ylim': [0, 1.05],
'yticks': np.arange(0, 1.1, .2)
})
swarm_args_copy = swarm_args.copy()
swarm_args_copy.update({'palette': ['green', 'red', 'gray']})
plot.plot_results(res_,
x_key='odor_valence',
y_key='corrcoef',
path=figure_path,
plot_args=swarm_args_copy,
plot_function=sns.stripplot,
ax_args=ax_args_copy,
reuse=reuse,
save=False,
sort=True,
name_str=s)
summary = reduce.new_filter_reduce(res_,
filter_keys=['odor_valence'],
reduce_key='corrcoef')
plot.plot_results(summary,
x_key='odor_valence',
y_key='corrcoef',
error_key='corrcoef_sem',
colors='black',
path=figure_path,
plot_args=error_args,
plot_function=plt.errorbar,
save=save,
reuse=True,
legend=False,
name_str=s)
from scipy.stats import ranksums
print(summary['corrcoef'])
day_dt_learned = filter.filter(day_dt_learned,
{'odor_valence': 'CS+'})
day_dt_learned['title'] = np.array(
['DT_L'] * len(day_dt_learned['mouse']))
day_dt_last = filter.filter_days_per_mouse(
summary_res, days_per_mouse=dt_last_day)
day_dt_last = filter.filter(day_dt_last,
{'odor_valence': 'CS+'})
day_dt_last['title'] = np.array(['DT_E'] *
len(day_dt_last['mouse']))
from collections import defaultdict
plot_res = defaultdict(list)
plot_res = reduce.chain_defaultdicts(plot_res,
day_pt_start,
copy_dict=True)
plot_res = reduce.chain_defaultdicts(plot_res,
day_pt_learned,
copy_dict=True)
plot_res = reduce.chain_defaultdicts(plot_res,
day_dt_naive,
copy_dict=True)
plot_res = reduce.chain_defaultdicts(plot_res,
day_dt_start,
copy_dict=True)
plot_res = reduce.chain_defaultdicts(plot_res,
day_dt_learned,
copy_dict=True)
plot_res = reduce.chain_defaultdicts(plot_res,
day_dt_last,
res = analyze_behavior(data_path, condition)
if 'YFP' in condition.name:
res['condition'] = np.array(['YFP'] * len(res['mouse']))
elif 'CHANNEL' in condition.name:
res['condition'] = np.array(['CHANNEL'] * len(res['mouse']))
else:
res['condition'] = np.array([condition.name] * len(res['mouse']))
list_of_res.append(res)
names.append(condition.name)
directory_name = ','.join(names)
save_path_all = os.path.join(Config.LOCAL_FIGURE_PATH, 'BEHAVIOR', directory_name)
all_res = defaultdict(list)
for res, condition in zip(list_of_res, conditions):
reduce.chain_defaultdicts(all_res, res)
ax_args_pt = {'yticks': [0, 5, 10], 'ylim': [-1, 12], 'xticks': [0, 100, 200, 300], 'xlim': [0, 300]}
bool_ax_args_pt = {'yticks': [0, 50, 100], 'ylim': [-5, 105], 'xticks': [0, 100, 200, 300], 'xlim': [0, 300]}
bar_args = {'alpha': .6, 'fill': False}
scatter_args = {'marker': 'o', 's': 10, 'alpha': .6}
lick = 'lick'
lick_smoothed = 'lick_smoothed'
boolean_smoothed = 'boolean_smoothed'
boolean_sem = 'boolean_smoothed_sem'
lick_sem = 'lick_smoothed_sem'
if 'trials_to_criterion' in experiments:
reduce_key = 'criterion'
res1 = filter.exclude(res1, {'mouse': ['Y01']})
res2 = filter.exclude(res2, {'mouse': ['Y01']})
# if experiment.name == 'OFC_DT': # the unusual mouse
# res1 = filter.exclude(res1, {'mouse': ['H03']})
# res2 = filter.exclude(res2, {'mouse': ['H03']})
keys = analysis.Indices().__dict__.keys()
if experiment.name == 'OFC_PT' and directory == constants.pretraining_directory:
mice = ['Y11','Y12','Y13']
session_list = [[2,3,4,5,6], [5,7,9,11],[4,5,6]]
for mouse, sessions in zip(mice, session_list):
res2 = scalpel(res2, keys, mouse, sessions)
print(np.unique(res2['session'][-1]))
reduce.chain_defaultdicts(res, res1)
reduce.chain_defaultdicts(res, res2)
print(np.unique(res['mouse']))
if collapse_arg:
res1 = filter.filter(res, filter_dict={'experiment': collapse_arg, 'condition':'H'})
res2 = filter.filter(res, filter_dict={'condition': 'Y'})
res = reduce.chain_defaultdicts(res1, res2, copy_dict=True)
analysis.analyze(res)
analysis.shift_discrimination_index(res)
filter.assign_composite(res, ['phase', 'odor_valence'])
res = filter.filter(res, {'phase_odor_valence': ['Pretraining_CS+', 'Discrimination_CS+', 'Discrimination_CS-']})
if 'release_of_inhibition' in plotting:
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)