def plot_correlation_matrix(res, days, loop_keys, shuffle, figure_path, odor_end=True, direction=0): res = filter.filter_days_per_mouse(res, days) res_ = _correlation(res, loop_keys, shuffle, odor_end, direction=direction) res = reduce.new_filter_reduce(res_, filter_keys=['Odor_A', 'Odor_B'], reduce_key='corrcoef') if shuffle: s = '_shuffled' else: s = '' plot.plot_weight(res, x_key='Odor_A', y_key='Odor_B', val_key='corrcoef', title='Correlation', label='Correlation', vmin=0, vmax=1, mask=True, xticklabel=['CS+1', 'CS+2', 'CS-1', 'CS-2'], yticklabel=['CS+1', 'CS+2', 'CS-1', 'CS-2'], save_path=figure_path, text=','.join([str(x) for x in days]) + s + '_direction_' + str(direction)) return res_
def plot_max_dff_valence(res, start_days, end_days, figure_path): res = copy.copy(res) # list_of_days = list(zip(start_days, end_days)) list_of_days = end_days 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-']}) _max_dff(start_end_day_res) start_end_day_res = reduce.new_filter_reduce( start_end_day_res, filter_keys=['odor_valence', 'mouse'], reduce_key='max_dff') add_naive_learned(start_end_day_res, start_days, end_days) ax_args_copy = ax_args.copy() # ax_args_copy.update({'xticks':[res['DAQ_O_ON_F'][-1], res['DAQ_W_ON_F'][-1]], 'xticklabels':['ON', 'US'], # 'ylim':[0, .2]}) nMice = len(np.unique(res['mouse'])) # colors = ['Green'] * nMice + ['Red'] * nMice # trace_args_copy = trace_args.copy() # trace_args_copy.update({'linestyle':'--','alpha':.5, 'linewidth':.75}) plot.plot_results(start_end_day_res, loop_keys='mouse', x_key='odor_valence', y_key='max_dff', path=figure_path, colors=['gray'] * 10, legend=False, fig_size=(2, 1.5))
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 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_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])
def plot_summary_water(res, start_days, end_days, figure_path): ax_args_copy = ax_args.copy() res = copy.copy(res) get_responsive_cells(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) add_naive_learned(start_end_day_res, start_days, end_days, 'a', 'b') odor_list = ['US'] colors = ['Turquoise'] ax_args_copy.update({'xlim': [-1, 2]}) for i, odor in enumerate(odor_list): plot.plot_results(start_end_day_res, select_dict={'odor_standard': odor}, x_key='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, fig_size=(1.6, 1.5), legend=False) before_csm = filter.filter(start_end_day_res, filter_dict={ 'training_day': 'a', 'odor_standard': 'US' }) after_csm = filter.filter(start_end_day_res, filter_dict={ 'training_day': 'b', 'odor_standard': 'US' }) 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']))) print('Wilcoxin:{}'.format( wilcoxon(before_csm['Fraction Responsive'], after_csm['Fraction Responsive'])))
def plot_responsive_difference_odor_and_water(res, odor_start_days, end_days, use_colors=True, figure_path=None, normalize=False, ylim=.6): key = 'Change in Fraction' if normalize: key = 'Norm. Fraction' def _helper(start_end_day_res): combs, list_of_ixs = filter.retrieve_unique_entries( start_end_day_res, ['mouse', 'odor_valence']) 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'][test] / \ start_end_day_res['Fraction'][ref] start_end_day_res[key][ref] = 1 else: start_end_day_res[key][test] = start_end_day_res['Fraction'][test] - \ start_end_day_res['Fraction'][ref] start_end_day_res[key][ref] = 0 ax_args_copy = ax_args.copy() res = get_compare_responsive_sig(res) list_of_days = list(zip(odor_start_days, end_days)) mice = np.unique(res['mouse']) res[key] = np.zeros_like(res['Fraction']) 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-']}) add_naive_learned(start_end_day_res, odor_start_days, end_days) _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'} 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': [-1, n_valence], 'ylim': [-ylim, ylim], 'yticks': np.arange(-1, 1, .2) }) if normalize: ax_args_copy.update({ 'xlim': [-1, n_valence], 'ylim': [-.1, 1.5], 'yticks': [0, .5, 1, 1.5] }) scatter_args_copy = scatter_args.copy() scatter_args_copy.update({'s': 8}) odors = ['CS+', 'CS-'] for i, odor in enumerate(odors): reuse = True if i == 0: reuse = False 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), 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=True, reuse=True, fig_size=(2, 1.5), legend=False)
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))
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
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)
conditions = [ conditions.PIR, conditions.OFC, conditions.OFC_LONGTERM, conditions.OFC_COMPOSITE, conditions.MPFC_COMPOSITE ] save_path = os.path.join(Config.LOCAL_FIGURE_PATH, 'MISC', 'SNR') out = defaultdict(list) psth = False for condition in conditions: data_path = os.path.join(Config.LOCAL_EXPERIMENT_PATH, 'COUNTING', condition.name) res = fio.load_pickle(os.path.join(data_path, 'dict.pkl')) mice = np.unique(res['mouse']) res = filter.filter_days_per_mouse(res, len(mice) * [0]) if psth: for i, d in enumerate(res['data']): res['data'][i] = np.mean(d, axis=1) for mouse in mice: temp = filter.filter(res, {'mouse': mouse}) data = np.concatenate(temp['data'], axis=1) out['condition'].append(condition.name) out['mouse'].append(mouse) out['data'].append(data) x = data.reshape(data.shape[0], -1) max_each_cell = np.max(x, axis=1)
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_summary_odor(res, start_days, end_days, use_colors=True, figure_path=None, reuse=False, excitatory=True): ax_args_copy = ax_args.copy() res = copy.copy(res) get_responsive_cells(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) add_naive_learned(start_end_day_res, start_days, end_days, 'a', 'b') filter.assign_composite(start_end_day_res, loop_keys=['odor_valence', 'training_day']) 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-'] if use_colors: colors = ['Green', 'Red'] else: colors = ['Black'] * 2 ax_args_copy = ax_args_copy.copy() ax_args_copy.update({ 'xlim': [-1, 8], 'ylim': [0, .4], 'yticks': [0, .1, .2, .3, .4] }) name_str = '_E' if excitatory else '_I' for i, odor in enumerate(odor_list): save_arg = False reuse_arg = True if i == 0 and not reuse: reuse_arg = False if i == len(odor_list) - 1: save_arg = True plot.plot_results(start_end_day_res, select_dict={'odor_valence': odor}, x_key='odor_valence_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=','.join([str(x) for x in start_days]) + name_str) start_end_day_res = filter.filter_days_per_mouse( res, days_per_mouse=list_of_days) add_naive_learned(start_end_day_res, start_days, end_days, 'a', 'b') filter.assign_composite(start_end_day_res, loop_keys=['odor_valence', 'training_day']) start_end_day_res = reduce.new_filter_reduce( start_end_day_res, filter_keys=['training_day', 'mouse', 'odor_standard'], reduce_key='Fraction Responsive') 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-' }) try: from scipy.stats import ranksums, wilcoxon, kruskal 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']))) except: print('stats didnt work')
def plot_power(res, start_days, end_days, figure_path, excitatory=True, odor_valence=('CS+'), naive=False, colors_before={ 'CS+': 'Green', 'CS-': 'Red' }, colors_after={ 'CS+': 'Green', 'CS-': 'Red' }, ylim=[0, .1], align=True, pad=True): res = copy.copy(res) _power(res, excitatory) if pad: right_on = np.median(res['DAQ_O_ON_F']) for i, odor_on in enumerate(res['DAQ_O_ON_F']): if np.abs(odor_on - right_on) > 2: diff = (right_on - odor_on).astype(int) if diff > 0: p = res['Power'][i] newp = np.zeros_like(p) newp[:diff] = p[0] newp[diff:] = p[:-diff] res['Power'][i] = newp print('early odor time. mouse: {}, day: {}'.format( res['mouse'][i], res['day'][i])) else: p = res['Power'][i] newp = np.zeros_like(p) newp[:diff] = p[-diff:] newp[diff:] = p[-1] res['Power'][i] = newp print('late odor time. mouse: {}, day: {}'.format( res['mouse'][i], res['day'][i])) if align: nF = [len(x) for x in res['Power']] max_frame = np.max(nF) for i, p in enumerate(res['Power']): if len(p) < max_frame: newp = np.zeros(max_frame) newp[:len(p)] = p newp[len(p):] = p[-1] res['Power'][i] = newp res['Time'][i] = np.arange(0, max_frame) print('pad frames. mouse: {}, day: {}'.format( res['mouse'][i], res['day'][i])) list_of_days = list(zip(start_days, end_days)) start_end_day_res = filter.filter_days_per_mouse( res, days_per_mouse=list_of_days) add_naive_learned(start_end_day_res, start_days, end_days) if naive: start_end_day_res = filter.exclude(start_end_day_res, { 'odor_standard': 'PT CS+', 'training_day': 'Naive' }) ix = start_end_day_res['odor_valence'] == 'PT Naive' start_end_day_res['odor_valence'][ix] = 'PT CS+' start_end_day_sum_res = reduce.new_filter_reduce( start_end_day_res, filter_keys=['training_day', 'odor_valence'], reduce_key='Power') ax_args_copy = trace_ax_args.copy() if excitatory: yticks = np.arange(0, .2, .05) else: yticks = -1 * np.arange(0, .2, .025) ax_args_copy.update({ 'xticks': [res['DAQ_O_ON_F'][-1], res['DAQ_W_ON_F'][-1]], 'xticklabels': ['ON', 'US'], 'ylim': ylim, 'yticks': yticks }) colors_b = [colors_before[x] for x in odor_valence] colors = [colors_after[x] for x in odor_valence] strr = ','.join([str(x) for x in start_days]) + '_' + ','.join( [str(x) for x in end_days]) if excitatory: strr += '_E' else: strr += '_I' plot.plot_results(start_end_day_sum_res, select_dict={ 'odor_valence': odor_valence, 'training_day': 'Naive' }, x_key='Time', y_key='Power', loop_keys='odor_valence', error_key='Power_sem', path=figure_path, plot_function=plt.fill_between, plot_args=fill_args, ax_args=ax_args_copy, colors=colors_b, fig_size=(2, 1.5), rect=(.3, .2, .6, .6), save=False) plot.plot_results(start_end_day_sum_res, select_dict={ 'odor_valence': odor_valence, 'training_day': 'Naive' }, x_key='Time', y_key='Power', loop_keys='odor_valence', path=figure_path, plot_args=trace_args, ax_args=ax_args_copy, colors=colors_b, fig_size=(2, 1.5), reuse=True, save=False) plot.plot_results(start_end_day_sum_res, select_dict={ 'odor_valence': odor_valence, 'training_day': 'Learned' }, x_key='Time', y_key='Power', loop_keys='odor_valence', error_key='Power_sem', path=figure_path, plot_function=plt.fill_between, plot_args=fill_args, ax_args=ax_args_copy, colors=colors, fig_size=(2, 1.5), reuse=True, save=False) plot.plot_results(start_end_day_sum_res, select_dict={ 'odor_valence': odor_valence, 'training_day': 'Learned' }, x_key='Time', y_key='Power', loop_keys='odor_valence', path=figure_path, plot_args=trace_args, ax_args=ax_args_copy, colors=colors, fig_size=(2, 1.5), reuse=True, name_str=strr) for i, x in enumerate(start_end_day_res['Power']): on, off = [ start_end_day_res['DAQ_O_ON_F'][i], start_end_day_res['DAQ_W_ON_F'][i] ] y = np.max(x[on:off]) - np.min(x) start_end_day_res['stat'].append(y) start_end_day_res['stat'] = np.array(start_end_day_res['stat']) for valence in odor_valence: before_odor = filter.filter(start_end_day_res, filter_dict={ 'training_day': 'Naive', 'odor_valence': valence }) after_odor = filter.filter(start_end_day_res, filter_dict={ 'training_day': 'Learned', 'odor_valence': valence }) try: from scipy.stats import ranksums, wilcoxon, kruskal print(before_odor['odor_valence']) # print('Before: {}'.format(before_odor['stat'])) print('Before: {}'.format(np.mean(before_odor['stat']))) # print('After: {}'.format(after_odor['stat'])) print('After: {}'.format(np.mean(after_odor['stat']))) print('Wilcoxin:{}'.format( wilcoxon(before_odor['stat'], after_odor['stat']))) except: print('stats didnt work') return before_odor['stat'], after_odor['stat']
def _helper(lick_res, summary_res, mouse, odor_valence): behavior_colors = [colors_dict[x] for x in odor_valence] colors = [colors_dict[x] for x in odor_valence] if 'COMPOSITE' in condition.name: days = behavior.behavior_analysis._get_days_per_condition( data_path, condition) res_dt_naive = filter.filter_days_per_mouse( summary_res, [x[0] for x in days]) res_dt_train = filter.filter_days_per_mouse( summary_res, [x[1:] for x in days]) list_of_res = [res_dt_naive, res_dt_train] lick_dt_naive = filter.filter_days_per_mouse( lick_res, [x[0] for x in days]) lick_dt_train = filter.filter_days_per_mouse( lick_res, [x[1:] for x in days]) list_of_lick_res = [lick_dt_naive, lick_dt_train] else: list_of_res = [summary_res] list_of_lick_res = [lick_res] # plot.plot_results(summary_res, x_key='day', y_key='PCA Distance', # select_dict={'mouse': mouse, 'shuffle': 1, 'odor_valence': odor_valence}, # colors='grey', # ax_args=ax_args, plot_args=line_args, # path=figure_path, reuse=False, save=False) # # plot.plot_results(summary_res, x_key='day', y_key='PCA Distance', error_key='PCA Distance_sem', # select_dict={'mouse': mouse, 'shuffle': 1, 'odor_valence': odor_valence}, # colors='gray', plot_function=plt.fill_between, # ax_args=ax_args, plot_args=fill_args, # path=figure_path, reuse=True, save=False) for i, res in enumerate(list_of_res): reuse = True if i == 0: reuse = False save = False if i == len(list_of_res) - 1: save = True l_res = list_of_lick_res[i] plot.plot_results(l_res, x_key='day', y_key='lick_boolean', loop_keys='odor_valence', select_dict={ 'mouse': mouse, 'odor_valence': odor_valence }, colors=behavior_colors, ax_args=ax_args, plot_args=behavior_line_args, path=figure_path, save=False, sort=False, reuse=reuse) plot.plot_results(res, x_key='day', y_key='PCA Distance', loop_keys='odor_valence', select_dict={ 'mouse': mouse, 'shuffle': 0, 'odor_valence': odor_valence }, colors=colors, ax_args=ax_args, plot_args=line_args, path=figure_path, reuse=True, sort=False, save=save)
def organizer_test_fp_fn(condition, decodeConfig, data_path, save_path): ''' :param condition: :param decodeConfig: :param data_path: :param save_path: :return: ''' data_pathnames = sorted( glob.glob(os.path.join(data_path, '*' + Config.mat_ext))) config_pathnames = sorted( glob.glob(os.path.join(data_path, '*' + Config.cons_ext))) list_of_all_data = np.array([Config.load_mat_f(d) for d in data_pathnames]) list_of_all_cons = np.array( [Config.load_cons_f(d) for d in config_pathnames]) mouse_names_per_file = np.array( [cons.NAME_MOUSE for cons in list_of_all_cons]) mouse_names, list_of_mouse_ix = np.unique(mouse_names_per_file, return_inverse=True) if mouse_names.size != len(condition.paths): raise ValueError( "res has {0:d} mice, but filter has {1:d} mice".format( mouse_names.size, len(condition.paths))) import copy counting_res = copy.copy(decodeConfig.res_counting) start_days = decodeConfig.start_day end_days = decodeConfig.end_day days_per_mouse = [] for x, y in zip(start_days, end_days): days_per_mouse.append(np.arange(x, y + 1)) print(days_per_mouse) for i, mouse_name in enumerate(mouse_names): start_time = time.time() ix = mouse_name == mouse_names_per_file list_of_cons_ = list_of_all_cons[ix] list_of_data_ = list_of_all_data[ix] for cons in list_of_cons_: assert cons.NAME_MOUSE == mouse_name, 'Wrong mouse file!' if len(days_per_mouse[i]): list_of_cons = list_of_cons_[days_per_mouse[i]] list_of_data = list_of_data_[days_per_mouse[i]] if counting_res is not None: temp = filter.filter(counting_res, { 'mouse': i, 'odor_valence': 'US' }) temp = filter.filter_days_per_mouse( temp, days_per_mouse=[days_per_mouse[i]]) list_of_neural_ixs = temp['sig'] else: list_of_neural_ixs = None cons = list_of_cons[0] cons_dict = cons.__dict__ for key, value in cons_dict.items(): if isinstance(value, list) or isinstance(value, np.ndarray): pass else: setattr(decodeConfig, key, value) if hasattr(condition, 'odors'): odor = condition.odors[i] else: odor = condition.dt_odors[i] cons_odors = [cons.ODOR_UNIQUE for cons in list_of_cons] ix = [ i for i, unique_odors in enumerate(cons_odors) if odor[0] in unique_odors ] list_of_cons = [list_of_cons[i] for i in ix] list_of_data = [list_of_data[i] for i in ix] if decodeConfig.decode_style == 'identity': csp = None else: if hasattr(condition, 'odors'): csp = condition.csp[i] else: csp = condition.dt_csp[i] scores_res = decoding.test_fp_fn(list_of_cons, list_of_data, odor, csp, decodeConfig, list_of_neural_ixs) name = cons.NAME_MOUSE save_config = copy.copy(decodeConfig) save_config.res_counting = '' fio.save_json(save_path=save_path, save_name=name, config=save_config) fio.save_pickle(save_path=save_path, save_name=name, data=scores_res) print("Analyzed: {0:s} in {1:.2f} seconds".format( name, time.time() - start_time))
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)
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'])
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')
def plot_overlap_odor(res, start_days, end_days, delete_non_selective=False, figure_path=None, excitatory=True): ax_args_copy = overlap_ax_args.copy() res = copy.copy(res) res = _get_overlap_odor(res, delete_non_selective) 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) start_end_day_res = reduce.new_filter_reduce( start_end_day_res, filter_keys=['mouse', 'day', 'condition'], reduce_key='Overlap') add_naive_learned(start_end_day_res, start_days, end_days) filter.assign_composite(start_end_day_res, loop_keys=['condition', 'training_day']) odor_list = ['+:+', '-:-', '+:-'] colors = ['Green', 'Red', 'Gray'] name_str = '_E' if excitatory else '_I' ax_args_copy.update({'xlim': [-1, 6]}) for i, odor in enumerate(odor_list): save_arg = False reuse_arg = True if i == 0: reuse_arg = False if i == len(odor_list) - 1: save_arg = True temp = filter.filter(start_end_day_res, {'condition': odor}) name = ','.join([str(x) for x in start_days]) + '_' + ','.join( [str(x) for x in end_days]) name += name_str plot.plot_results(temp, x_key='condition_training_day', y_key='Overlap', 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, name_str=name, fig_size=(2, 1.5), legend=False) b = filter.filter(temp, {'training_day': 'Learned'}) print(odor) print(np.mean(b['Overlap'])) start_end_day_res = filter.filter_days_per_mouse( res, days_per_mouse=list_of_days) add_naive_learned(start_end_day_res, start_days, end_days, str1='0', str2='1') start_end_day_res.pop('Overlap_sem', None) summary_res = reduce.new_filter_reduce(start_end_day_res, filter_keys='training_day', reduce_key='Overlap') ax_args_copy.update({ 'xlim': [-1, 2], 'ylim': [0, .5], 'yticks': [0, .1, .2, .3, .4, .5] }) plot.plot_results(summary_res, x_key='training_day', y_key='Overlap', path=figure_path, plot_args=bar_args, ax_args=ax_args_copy, plot_function=plt.bar, fig_size=(2, 1.5), legend=False, reuse=False, save=False) plot.plot_results(summary_res, x_key='training_day', 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, name_str=name_str) before_odor = filter.filter(start_end_day_res, filter_dict={ 'training_day': '0', 'condition': '+:+' }) after_odor = filter.filter(start_end_day_res, filter_dict={ 'training_day': '1', 'condition': '+:+' }) before_csp = filter.filter(start_end_day_res, filter_dict={ 'training_day': '0', 'condition': '+:-' }) after_csp = filter.filter(start_end_day_res, filter_dict={ 'training_day': '1', 'condition': '+:-' }) before_csm = filter.filter(start_end_day_res, filter_dict={ 'training_day': '0', 'condition': '-:-' }) after_csm = filter.filter(start_end_day_res, filter_dict={ 'training_day': '1', 'condition': '-:-' }) from scipy.stats import ranksums, wilcoxon, kruskal print('Before ++: {}'.format(np.mean(before_odor['Overlap']))) print('After ++: {}'.format(np.mean(after_odor['Overlap']))) print('Wilcoxin:{}'.format( wilcoxon(before_odor['Overlap'], after_odor['Overlap']))) print('Before +-: {}'.format(np.mean(before_csp['Overlap']))) print('After +-: {}'.format(np.mean(after_csp['Overlap']))) print('Wilcoxin:{}'.format( wilcoxon(before_csp['Overlap'], after_csp['Overlap']))) print('Before --: {}'.format(np.mean(before_csm['Overlap']))) print('After --: {}'.format(np.mean(after_csm['Overlap']))) print('Wilcoxin:{}'.format( wilcoxon(before_csm['Overlap'], after_csm['Overlap'])))
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)
'marker': 'o', 'markersize': 1 } summary_res.pop('PCA Distance_std') summary_res.pop('PCA Distance_sem') summary_res = filter.filter(summary_res, filter_dict={'shuffle': 0}) if plot_cs: select_dict = {'odor_valence': 'CS+'} else: select_dict = None if condition.name == 'OFC_LONGTERM': dt_learned_day, dt_last_day = get_days_per_mouse( data_path, condition) dt_learned_day = [3, 2, 2, 3] filtered_res = filter.filter_days_per_mouse( summary_res, list(zip(dt_learned_day, dt_last_day))) analysis.add_naive_learned(filtered_res, dt_learned_day, dt_last_day, 'Learned', 'Over-trained') mean_std_res = reduce.new_filter_reduce( filtered_res, reduce_key='PCA Distance', filter_keys=['training_day', 'odor_valence']) plot.plot_results(filtered_res, x_key='training_day', y_key='PCA Distance', loop_keys=['odor_valence', 'mouse'], select_dict=select_dict, colors=['Green'] * mice.size + ['Red'] * mice.size, ax_args=summary_ax_args, plot_function=plt.plot,
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 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)
def plot_reversal(res, start_days, end_days, figure_path): ax_args_copy = ax_args.copy() ax_args_copy.update({'ylim': [0, .6]}) res = copy.copy(res) list_of_days = list(zip(start_days, end_days)) start_end_day_res = filter.filter_days_per_mouse( res, days_per_mouse=list_of_days) reversal_res, stats_res = get_reversal_sig(start_end_day_res) filter.assign_composite(reversal_res, loop_keys=['day', 'odor_valence']) import seaborn as sns swarm_args = { 'marker': '.', 'size': 8, 'facecolors': 'none', 'alpha': .5, 'palette': ['green', 'red'], 'jitter': .1 } mean_res = reduce.new_filter_reduce(reversal_res, filter_keys=['day', 'odor_valence'], reduce_key='Fraction') plot.plot_results(mean_res, x_key='day_odor_valence', y_key='Fraction', error_key='Fraction_sem', path=figure_path, plot_function=plt.errorbar, plot_args=error_args, ax_args=ax_args_copy, fig_size=(2, 1.5), save=False) plt.plot([1.5, 1.5], plt.ylim(), '--', color='gray', linewidth=2) plot.plot_results( reversal_res, x_key='day_odor_valence', y_key='Fraction', path=figure_path, colors=['Green', 'Red', 'Green', 'Red'], # plot_function=plt.scatter, plot_args=scatter_args, plot_function=sns.stripplot, plot_args=swarm_args, ax_args=ax_args_copy, fig_size=(2, 1.5), reuse=True, save=True, legend=False) print(mean_res['day_odor_valence']) print(mean_res['Fraction']) from scipy.stats import wilcoxon ix_before_p = reversal_res['day_odor_valence'] == 'Lrn_CS+' ix_after_p = reversal_res['day_odor_valence'] == 'Rev_CS+' ix_before_m = reversal_res['day_odor_valence'] == 'Lrn_CS-' ix_after_m = reversal_res['day_odor_valence'] == 'Rev_CS-' stat_csp = wilcoxon(reversal_res['Fraction'][ix_before_p], reversal_res['Fraction'][ix_after_p]) stat_csm = wilcoxon(reversal_res['Fraction'][ix_before_m], reversal_res['Fraction'][ix_after_m]) print('CS+ to CS-: {}'.format(stat_csp)) print('CS- to CS+: {}'.format(stat_csm)) titles = ['', 'CS+', 'CS-', 'None'] conditions = [['none-p', 'p-m', 'p-none', 'p-p'], ['p-m', 'p-none', 'p-p'], ['m-m', 'm-none', 'm-p'], ['none-m', 'none-none', 'none-p']] labels = [['Added', 'Reversed', 'Lost', 'Retained'], ['Reversed', 'Lost', 'Retained'], ['Retained', 'Lost', 'Reversed'], ['to CS-', 'Retained', 'to CS+']] for i, title in enumerate(titles): mean_stats = reduce.new_filter_reduce(stats_res, filter_keys='condition', reduce_key='Fraction') ax_args_copy.update({ 'ylim': [-.1, 1], 'yticks': [0, .5, 1], 'xticks': [0, 1, 2, 3], 'xticklabels': labels[i] }) plot.plot_results(mean_stats, select_dict={'condition': conditions[i]}, x_key='condition', y_key='Fraction', loop_keys='mouse', error_key='Fraction_sem', sort=True, path=figure_path, colors=['Black'] * 10, plot_function=plt.errorbar, plot_args=error_args, ax_args=ax_args_copy, fig_size=(2, 1.5), save=False) plt.title(title) plot.plot_results(stats_res, select_dict={'condition': conditions[i]}, x_key='condition', y_key='Fraction', loop_keys='mouse', sort=True, path=figure_path, colors=['Black'] * 10, plot_function=plt.scatter, plot_args=scatter_args, ax_args=ax_args_copy, fig_size=(2, 1.5), legend=False, save=True, reuse=True) print(mean_stats['Fraction']) print(mean_res['Fraction'])
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_consistency_within_day(res, start, end, shuffle, pretraining, figure_path): d = list(zip(start, end)) res_temp = filter.filter_days_per_mouse(res, d) if pretraining: res_temp = filter.filter(res_temp, {'odor_valence': ['PT CS+']}) else: res_temp = filter.filter(res_temp, {'odor_valence': ['CS+', 'CS-']}) corr_res = _correlation(res_temp) corr_res.pop('data') analysis.add_naive_learned(corr_res, start, end, '0', '1') res_ = reduce.new_filter_reduce( corr_res, filter_keys=['mouse', 'odor_standard', 'training_day'], reduce_key='consistency_corrcoef') res_.pop('consistency_corrcoef_sem') filter.assign_composite(res_, loop_keys=['training_day', 'odor_valence']) if shuffle: s = '_shuffled' else: s = '' ax_args_copy = ax_args.copy() ax_args_copy.update({ 'xlim': [-.5, 2.5], 'ylim': [0, .55], 'yticks': np.arange(0, 1.1, .1) }) swarm_args_copy = swarm_args.copy() if pretraining: swarm_args_copy.update({'palette': ['gray', 'orange', 'green', 'red']}) else: swarm_args_copy.update({'palette': ['gray', 'gray', 'green', 'red']}) ix = res_['training_day_odor_valence'] == '1_PT CS+' res_['training_day_odor_valence'][ix] = '1_APT CS+' plot.plot_results(res_, x_key='training_day_odor_valence', y_key='consistency_corrcoef', path=figure_path, plot_args=swarm_args_copy, plot_function=sns.stripplot, ax_args=ax_args_copy, reuse=False, save=False, sort=True, name_str=s) summary = reduce.new_filter_reduce(res_, filter_keys='training_day_odor_valence', reduce_key='consistency_corrcoef') plot.plot_results(summary, x_key='training_day_odor_valence', y_key='consistency_corrcoef', error_key='consistency_corrcoef_sem', colors='black', path=figure_path, plot_args=error_args, plot_function=plt.errorbar, save=True, reuse=True, legend=False, name_str=s) print(summary['consistency_corrcoef']) ix_a = res_['training_day_odor_valence'] == '0_CS+' ix_b = res_['training_day_odor_valence'] == '0_CS-' ix_c = res_['training_day_odor_valence'] == '1_CS+' ix_d = res_['training_day_odor_valence'] == '1_CS-' a = res_['consistency_corrcoef'][ix_a] b = res_['consistency_corrcoef'][ix_b] c = res_['consistency_corrcoef'][ix_c] d = res_['consistency_corrcoef'][ix_d] from scipy.stats import ranksums, wilcoxon, kruskal import scikit_posthocs print(kruskal(a, b, c)) x = scikit_posthocs.posthoc_dunn(a=[a, b, c, d], p_adjust=None) print(x)
def magnitude_histogram(res, learned_days, end_days, use_colors=True, figure_path=None, reuse=False): def _helper(res): list_odor_on = res['DAQ_O_ON_F'] list_water_on = res['DAQ_W_ON_F'] list_of_dff = res['dff'] for i, dff in enumerate(list_of_dff): s = list_odor_on[i] e = list_water_on[i] max = np.max(dff[:, s:e], axis=1) res['max_dff'].append(max) res['max_dff'] = np.array(res['max_dff']) def _helper1(res): for data in res['amplitude']: res['max_dff'].append(data[data > 0]) res['max_dff'] = np.array(res['max_dff']) res = copy.copy(res) # list_of_days = list(zip(learned_days, end_days)) list_of_days = end_days start_end_day_res = filter.filter_days_per_mouse( res, days_per_mouse=list_of_days) _helper(start_end_day_res) add_naive_learned(start_end_day_res, learned_days, end_days) filter.assign_composite(start_end_day_res, loop_keys=['odor_standard', 'training_day']) csp = filter.filter(start_end_day_res, filter_dict={'odor_valence': 'CS+'}) csm = filter.filter(start_end_day_res, filter_dict={'odor_valence': 'CS-'}) csp_data = np.hstack(csp['max_dff'].flat) csm_data = np.hstack(csm['max_dff'].flat) fig = plt.figure(figsize=(3, 2)) ax = fig.add_axes([.2, .2, .7, .7]) x_upper = 1.01 y_upper = .5 bins = 20 xrange = [0, x_upper] yrange = [0, y_upper] xticks = np.arange(0, x_upper, .2) yticks = np.arange(0, y_upper, 3) legends = ['CS+', 'CS-'] colors = ['green', 'red'] for i, data in enumerate([csp_data, csm_data]): plt.hist(data, bins=bins, range=xrange, density=True, color=colors[i], alpha=.5) plt.legend(legends, loc=1, bbox_to_anchor=(1.05, .4), fontsize=5) ax.set_xlabel('DF/F') ax.set_ylabel('Fraction') ax.set_xticks(xticks) # ax.set_yticks(yticks) plt.xlim(xrange) # plt.ylim(yrange) plt.show()