figure.clear() ax = figure.add_subplot(111) ax.imshow(image, interpolation='bicubic', vmin=1, vmax=10) figure.suptitle('Avg. F.R. = {}\nTotal spikes = {}\nMax value = {}'.format( str(np.mean(fr)), str(int(np.mean(fr) * len(fr) / 4)), str(image.max()))) neuron = 0 out = None figure = plt.figure(0) args = [figure] sl.connect_repl_var(globals(), 'neuron', 'out', 'plot_firing_rate_on_arena_tiles', 'args', slider_limits=[0, len(spike_rates_0p25) - 1]) # ------------------------------------------------- # MI THE SKAGGS WAY # ------------------------------------------------- updated_markers_filename = join( dlc_project_folder, 'post_processing', 'cleaned_body_marker_positions_order_{}_gap_{}.df'.format(str(4), str(10))) updated_body_markers_positions = pd.read_pickle(updated_markers_filename) # Use the markers to create a single body position body_positions = dlc_pp.average_multiple_markers_to_single_one( updated_body_markers_positions, flip=True) body_positions = dlc_pp.clean_large_movements_single_axis(body_positions, maximum_pixels=12)\
def draw1(index): plt.clf() plt.plot(speeds_patterned_behaviour_0p25) plt.plot(spike_rates_patterned_behaviour_0p25[ speed_corr_neurons_pb_index[index], :]) plt.vlines(x=np.cumsum(lengths_of_windows_of_patterned_behaviour) / 30, ymin=0, ymax=np.max(speeds_patterned_behaviour_0p25)) return None index = 0 out = None sl.connect_repl_var(globals(), 'index', 'out', 'draw1', slider_limits=[0, len(speed_corr_neurons_pb_index) - 1]) neuron_indices_that_change = speed_corr_neurons_pb_index[[ 0, 2, 3, 4, 5, 8, 9, 12, 13, 14, 17, 18, 20, 21, 22, 24, 26, 27, 29 ]] def plot_fr_of_neurons_that_change(index, fig1, fig2): fig1.clear() fig2.clear() ax1 = fig1.add_subplot(111) ax2 = fig2.add_subplot(111) ax1.plot(spike_rates_0p25[speed_corr_neurons_pb_index[index], :]) ax1.vlines(
args = [figure, freq, nominal_intensity, pre_muscimol] def change_freq(freq): args = [figure, freq, nominal_intensity, pre_muscimol] return args def change_nominal_intensity(nominal_intensity): args = [figure, freq, nominal_intensity, pre_muscimol] return args sl.connect_repl_var(globals(), 'freq', 'change_freq', 'args', slider_limits=[5, 15]) sl.connect_repl_var(globals(), 'nominal_intensity', 'change_nominal_intensity', 'args', slider_limits=[0, 3]) sl.connect_repl_var(globals(), 'neuron_index', 'out', 'get_hist_for_neuron_freq_intensity_set', 'args', slider_limits=[0, 141])
d = X_brain_buffer[f] a1.imshow(d) a1.set_title('Brain') im_before = X_images_buffer[f, :, :, :] * 255 a2.imshow(im_before) a2.set_title('Image Before') im_after = Y_buffer[f, :, :] * 255 a3.imshow(im_after) a3.set_title('Image After') fig1 = plt.figure(0) a1 = fig1.add_subplot(111) fig2 = plt.figure(1) a2 = fig2.add_subplot(111) fig3 = plt.figure(2) a3 = fig3.add_subplot(111) out = None f=0 sl.connect_repl_var(globals(),'f', 'out', 'show_X', slider_limits=[0, X_brain_buffer.shape[0]-1]) # </editor-fold>
return spread pane_data = None tr.connect_repl_var(globals(), 'pane', 'pane_data', 'spread_lfp_pane') one_v.graph(globals(), 'pane_data') def do_nothing(p): return p nothing = None slider_limits = [0, lfp_data_panes.shape[0] - 1] sl.connect_repl_var(globals(), 'pane', 'nothing', slider_limits=slider_limits) # ---------------------------------------------------------------------------------------------------------------------- # SUBSAMPLE THE LFPS WITH DIFFERENT RATIOS AND SAVE THE FILES # ---------------------------------------------------------------------------------------------------------------------- ds_filename = join(const.base_save_folder, const.rat_folder, const.date_folders[date], 'Data', 'Amplifier_LFPs_Downsampled_x4.bin') downsampled_lfp = ns_funcs.downsample(filename=ds_filename, data=raw_lfp, factor=const.LFP_DOWNSAMPLE_FACTOR) ds_numpy_filename = join(const.base_save_folder, const.rat_folder, const.date_folders[date], 'Analysis', 'Lfp',
def show(index, ax): ax.clear() ax.plot(space(lfps_around_event_spikes[neurons[index]]).T) return None index = 0 fig = plt.figure(0) ax = fig.add_subplot(111) out = None args = [ax] sl.connect_repl_var(globals(), 'index', 'out', 'show', 'args', slider_limits=[0, len(neurons) - 1]) # </editor-fold> # ------------------------------------------------- # ------------------------------------------------- # <editor-fold desc="CHECK FOR SOLUTIONS TO THE STRIPES PROBLEM"> amount = 0 f11 = plt.figure(11) ax = f11.add_subplot(111) args = [ax] out = None
def get_time_window(time, buffer, data): return data[:, :, time:time + buffer] def get_windowed_imf(imf, factor, time, buffer, data): return get_specific_imf_spaced(imf, factor, get_time_window(time, buffer, data)) def update_args(t): return [factor, t, buffer, imfs] sl.connect_repl_var(globals(), 'time', 'update_args', 'args', slider_limits=[1000000, 1200000]) window = None sl.connect_repl_var(globals(), 'imf', 'window', 'get_windowed_imf', 'args', slider_limits=[0, 12]) osv.graph(globals(), 'window') # ------------------------------------------------- # TEST WHAT HAPPENS IF I KILOSORT ONE IMF OF ALL CHANNELS # -------------------------------------------------
def create_image(templ): image = sh.create_heatmap_on_matplotlib_widget( a3, smoothed_avg_templates_all[templ, :, :], const_all.prb_file, window_size=40, bad_channels=None, num_of_shanks=1, rotate_90=False, flip_lr=False, flip_ud=False) sl.connect_repl_var(globals(), 'template', 'output', 'create_image') template_to_show = 0 output = None f1 = plt.figure(10) a1 = f1.add_subplot(111) def plot_topoplot_all(i): t = template_info_all_nonMUA.iloc[i]['template number'] _ = sh.create_heatmap_on_matplotlib_widget( a1, smoothed_avg_templates_all[t, :, :], const_all.prb_file, window_size=40, bad_channels=None,
def create_image(templ): image = sh.create_heatmap_on_matplotlib_widget( a3, smoothed_avg_templates_all[templ, :, :], const_all.prb_file, window_size=40, bad_channels=None, num_of_shanks=1, rotate_90=False, flip_lr=False, flip_ud=False) sl.connect_repl_var(globals(), 'template', 'output', 'create_image') template_to_show = 0 output = None f1 = plt.figure(10) a1 = f1.add_subplot(111) def plot_topoplot_all(i): t = template_info_all_nonMUA.iloc[i]['template number'] _ = sh.create_heatmap_on_matplotlib_widget( a1, smoothed_avg_templates_all[t, :, :], const_all.prb_file, window_size=40, bad_channels=None,
inset_axis.append(a4.inset_axes([w, h, 1 / 4, 1 / 4])) inset_axis[-1].axis('off') inset_axis[-1].set_ylim(min, max) inset_axis[-1].plot(decimated_data_used[c, :], c='k') f3 = plt.figure(3) a3 = f3.add_subplot(111) f4 = plt.figure(4) a4 = f4.add_subplot(111) template_to_show = 0 output = None sl.connect_repl_var(globals(), 'template_to_show', 'output', 'plot_timesries_superimposed_full_and_desi', slider_limits=[0, template_info_all_nonMUA.shape[0] - 1]) # For pre Desimated data f4 = plt.figure(4) a4 = f4.add_subplot(111) _ = a4.imshow(topoplot_desi, interpolation='bicubic', vmin=topoplot_desi.min(), vmax=topoplot_desi.max()) prb_file = join(const_deci.probe_layout_folder, 'probe_imec_256channels_decimated_file.txt') probe_desi = sh.get_probe_geometry_from_prb_file(prb_file)[0]['geometry'] inset_axis = []
frs = increasing_firing_rates_neuron_index # decreasing_firing_rates_neuron_index or increasing_firing_rates_neuron_index index = 0 fig1 = plt.figure(0) fig2 = plt.figure(1) output = None args = [ frs, avg_firing_rate_around_start_bal_mov, template_info, spike_info, start_of_ballistic_traj_time_points, frames_around_start_of_bal_mov, fig1, fig2 ] show_rasters_decrease = fr_funcs.show_rasters_for_live_update sl.connect_repl_var(globals(), 'index', 'output', 'show_rasters_decrease', 'args', slider_limits=[0, len(frs) - 1]) # ----- # Randomize to test robustness start_of_ballistic_traj_time_points_rand = start_of_ballistic_traj_time_points + \ ((np.random.choice([1], len(start_of_ballistic_traj_time_points))) * 20000).astype(np.int) avg_firing_rate_around_start_bal_mov_rand = fr_funcs.get_avg_firing_rates_around_events( spike_rates=spike_rates, event_time_points=start_of_ballistic_traj_time_points_rand, ev_video_df=ev_video, time_around_event=time_around_start_of_bal_mov)
def get_time_window(time, buffer, data): return data[:, :, time:time + buffer] def get_windowed_imf(imf, factor, time, buffer, data): return get_specific_imf_spaced(imf, factor, get_time_window(time, buffer, data)) def update_args(t): return [factor, t, buffer, imfs] sl.connect_repl_var(globals(), 'time', 'args', 'update_args', slider_limits=[1, imfs.shape[2] - 1]) window = None sl.connect_repl_var(globals(), 'imf', 'window', 'get_windowed_imf', 'args', slider_limits=[0, 12]) osv.graph(globals(), 'window') # ----------------------------------------------------------------------------------------------------------------------
neuron_in_dtp = True plt.title('Neuron index {}. Is in DTP = {}'.format(str(neuron), str(neuron_in_dtp))) cax = f.add_axes([0.83, 0.1, 0.05, 0.78]) f.colorbar(im, cax=cax, orientation='vertical') return None n_index = 0 out = None f = plt.figure(0) args = [f] sl.connect_repl_var(globals(), 'n_index', 'out', 'show_probs', 'args', slider_limits=[0, spike_rates.shape[0]]) sl.connect_repl_var( globals(), 'n_index', 'out', 'show_probs_only_dtp', 'args', slider_limits=[0, len(hipp_correlated_neurons_indices['dtp'])]) # </editor-fold> # ------------------------------------------------- # ------------------------------------------------- # <editor-fold desc="CHECK IF THE NEURONS THAT MODULATE AROUND AN EVENT ARE PLACE CELLS">
# Have a look fig = plt.figure() ax = fig.add_subplot(111) def show_trial(t): ax.clear() ax.imshow(neurons_spiking_4ms_bins[t, :, :], aspect='auto') return None trial = 0 out = None sl.connect_repl_var(globals(), 'trial', 'out', 'show_trial', slider_limits=[0, len(time_points_of_all_pokes) - 1]) def bin2int(x): y = np.int64(0) t = x.astype(np.int64) for i, j in enumerate(t): y += j << i return y codes_of_firing = np.zeros((number_of_pokes, number_of_bins), dtype=np.int64) for t in np.arange(number_of_pokes): codes_of_firing[t, :] = ([
plt.close() # ------------------ # Show live all the pics def draw_lfps(i): plt.clf() n = neuron_indices_pos_sorted[i] spike_triggered_lfps_avg_spaced = cdt.space_data( spike_triggered_lfps_avg[n, :, :], 20) plt.plot(spike_triggered_lfps_avg_spaced.T) neuron_template_index = neurons_with_high_frs[n] position = int(template_info['position Y'].iloc[neuron_template_index] ) * const.POSITION_MULT template = template_info['template number'].iloc[neuron_template_index] plt.title( 'Neuron : {}, Index_on_all_neurons = {}, Index_on_fast_neurons = {}, Y Position = {}' .format(template, neuron_template_index, n, position)) input = 0 output = None sl.connect_repl_var(globals(), 'input', 'output', 'draw_lfps', slider_limits=[0, len(neurons_with_high_frs)]) # --------------------- # </editor-fold>
c = 3 def t(a, b): return a + b tr.connect_repl_var(globals(), 'a', 'c', 't', 'b') ''' import drop_down as dd e = [1,2,3,4] dd.connect_repl_var(globals(), 'e', 't', 'c', 'b') ''' import slider as s s.connect_repl_var(globals(), 'a', 'c', 't', 'b', slider_limits=[0, 200]) import pandas as pd events_file = r'Y:\swc\kampff\George\DataAndResults\Experiments\Awake\NeuroSeeker\AK_47.2\2019_06_29-11_36\Events_worked_on.csv' events = pd.read_csv(events_file, parse_dates=[0], usecols=[0, 1, 2], skipinitialspace=True, index_col=False, header=None) te = events[events[8] == 'TrialEnd'] len(te) import matplotlib
ev_7 = events[events['frequencies'] == freq] plt.hist(ev_7['intensities']) def look_at_hists_of_intensities(freq, figure): ev = events[events['frequencies'] == freq] figure.clear() a = figure.add_subplot(111) a.hist(ev['intensities'], bins=200) freq = 5 fig = plt.figure(1) args = [fig] out = None sl.connect_repl_var(globals(), 'freq', 'out', 'look_at_hists_of_intensities', 'args', slider_limits=[5, 15]) nominal_intensities_cutoffs = {5: [100, 3690, 6000, 8600, 100000], 6: [100, 4700, 8000, 12000, 100000], 7: [100, 7500, 12500, 20000, 100000], 8: [100, 5000, 10000, 17500, 100000], 9: [100, 10000, 15000, 25000, 100000], 10: [100, 10000, 20000, 30000, 100000], 11: [100, 10000, 20000, 30000, 100000], 12: [100, 8000, 15000, 25000, 100000], 13: [100, 8000, 15000, 25000, 100000], 14: [100, 8000, 15000, 25000, 100000], 15: [100, 5000, 12500, 17000, 100000]} np.save(join(events_folder, 'nominal_intensities_cutoffs.npy'), nominal_intensities_cutoffs)
def get_time_window(time, buffer, data): return data[:, :, time:time + buffer] def get_windowed_imf(imf, factor, time, buffer, data): return get_specific_imf_spaced(imf, factor, get_time_window(time, buffer, data)) def update_args(t): return [factor, t, buffer, imfs] sl.connect_repl_var(globals(), 'time', 'update_args', 'args', slider_limits=[1000000, 1200000]) window = None sl.connect_repl_var(globals(), 'imf', 'window', 'get_windowed_imf', 'args', slider_limits=[0, 12]) osv.graph(globals(), 'window') # Emd spectrum psd_filename = join(const.base_save_folder, const.rat_folder, const.date_folders[date_folder], 'Analysis', 'Lfp', 'EMD', 'psd_of_imf_example.npy')
label = 0 out = None fig_scat = plt.figure(0) ax1 = fig_scat.add_subplot(111) ax1.imshow(tsne_pcs_count_image, extent=tsne_pcs_count_image_extent, aspect='auto') ax2 = ax1.twinx() fig_scat_ns = plt.figure(1) ax3 = fig_scat_ns.add_subplot(111) ax3.imshow(ns_tsne_pcs_count_image, extent=ns_tsne_pcs_count_image_extent, aspect='auto') ax4 = ax3.twinx() args = [ax2, ax4] sl.connect_repl_var(globals(), 'label', 'out', 'show_video_label_on_spikes_tsne', 'args', slider_limits=[0, video_tsne_labels.max()-1]) # </editor-fold> # ------------------------------------------------- # ------------------------------------------------- # <editor-fold desc="MAKE VIDEO OF RAT VIDEO WITH THE TSNE"> opencv_rat_video = cv2.VideoCapture(video_file) total_frames = int(opencv_rat_video.get(cv2.CAP_PROP_FRAME_COUNT)) frame_size_of_video_out = (int(2976), int(1549)) dpi = 100 fourcc = cv2.VideoWriter_fourcc('D', 'I', 'V', 'X') tsne_behaviour_video = cv2.VideoWriter(join(tsne_folder, 'tsne_behaviour_video.avi'), fourcc, 10.0, frame_size_of_video_out)
fig2.clear() ax2 = fig2.add_subplot(111) ax2.scatter(largest_increase_neuron_raster, np.tile(np.arange(len(largest_increase_neuron_raster)), largest_increase_neuron_raster.shape[1]), s=10) ax2.set_xlim(-time_points_around_switch / const.SAMPLING_FREQUENCY, time_points_around_switch / const.SAMPLING_FREQUENCY) return None sl.connect_repl_var( globals(), 'index', 'output', 'show_rasters_increase', 'args', slider_limits=[0, len(increasing_firing_rates_neuron_index) - 1]) # </editor-fold> # ------------------------------------------------- # <editor-fold desc="GET THE NEURONS WITH AN AVERAGE LARGE DECREASE AFTER THE EVENT (EITHER STOP TO START OR START TO STOP)"> decreasing_firing_rates = [] decreasing_firing_rates_neuron_index = [] decreasing_firing_rates_ratio = [] for n in np.arange(len(avg_firing_rate_around_switches)): neuron = avg_firing_rate_around_switches[n] if neuron[:base_end].mean() > 0.5: if neuron[:base_end].mean() > \ neuron[switch_start:switch_end].mean() * 3:
ymax=1) plt.title(str(mi_pb_spikes_vs_distance_to_poke[distance_to_poke_corr_neurons_pb_index[index]])) return None def draw1(index): plt.clf() plt.plot(speeds_patterned_behaviour_0p25) plt.plot(spike_rates_patterned_behaviour_0p25[distance_to_poke_corr_neurons_pb_index[index], :]) plt.vlines(x=np.cumsum(lengths_of_windows_of_patterned_behaviour) / 30, ymin=0, ymax=np.max(speeds_patterned_behaviour_0p25)) return None index = 0 out = None sl.connect_repl_var(globals(), 'index', 'out', 'draw1', slider_limits=[0, len(distance_to_poke_corr_neurons_pb_index) - 1]) ''' neuron_indices_that_change = speed_corr_neurons_pb_index[[0, 2, 3, 4, 5, 8, 9, 12, 13, 14, 17, 18, 20, 21, 22, 24, 26, 27, 29]] def plot_fr_of_neurons_that_change(index, fig1, fig2): fig1.clear() fig2.clear() ax1 = fig1.add_subplot(111) ax2 = fig2.add_subplot(111) ax1.plot(spike_rates_0p25[speed_corr_neurons_pb_index[index], :]) ax1.vlines(x=[57318/30, 212829/30], ymin=0, ymax=spike_rates_0p25[speed_corr_neurons_pb_index[index], :].max()) ax2.plot(speeds_patterned_behaviour_0p25) ax2.plot(spike_rates_patterned_behaviour_0p25[speed_corr_neurons_pb_index[index], :])
def create_image(templ): image = sh.create_heatmap_on_matplotlib_widget( a3, smoothed_avg_templates_all[templ, :, :], const_all.prb_file, window_size=40, bad_channels=None, num_of_shanks=1, rotate_90=False, flip_lr=False, flip_ud=False) sl.connect_repl_var(globals(), 'template', 'output', 'create_image') template = 0 output = None f = plt.figure(10) a = f.add_subplot(111) def plot_avg_template_desi(i): a.clear() a.plot(avg_templates_desi[100, i, 2000000:2020000]) sl.connect_repl_var( globals(), 'template',
fig1 = plt.figure(1) fig2 = plt.figure(2) output = None all_indices = np.arange(len(avg_firing_rate_around_suc_trials)) frames_around_beam_break = 120 * time_around_beam_break args = [ all_indices, avg_firing_rate_around_suc_trials, template_info, spike_info, start_pokes_after_delay, frames_around_beam_break, fig1, fig2 ] show_rasters_decrease = fr_funcs.show_rasters_for_live_update sl.connect_repl_var( globals(), 'index', 'output', 'show_rasters_decrease', 'args', slider_limits=[0, len(avg_firing_rate_around_suc_trials) - 1]) # </editor-fold> # ---------------------------------------------------------------------------------------------------------------------- # <editor-fold desc="COMPARE THE FRs AROUND THE POKE EVENTS WITH THE ONES AROUND THE RANDOM ONES"> minimum_delay = 5 start_pokes_after_delay = np.load( join( events_definitions_folder, 'events_first_pokes_after_{}_delay_non_reward.npy'.format( str(minimum_delay)))) start_pokes_after_delay = start_pokes_after_delay[:-1]
column = 0 positions = body_markers_positions.loc[:, body_markers_positions.columns[column]] if np.isnan(positions[0]): positions.loc[0] = positions.loc[1] gap = 5 order = 3 windows = dlc_pp.find_windows_with_nans(positions, gap=gap) figure = plt.figure(0) args = [windows, figure, positions, gap, order] slider_limits = [0, len(windows)] window_index = 0 output = None transform_to_interpolate = dlc_pp.transform_to_interpolate sl.connect_repl_var(globals(), 'window_index', 'output', 'transform_to_interpolate', 'args', slider_limits) # Clean all nans ''' gap = 10 order = 4 updated_markers_filename = join(dlc_project_folder, 'post_processing', 'cleaned_body_marker_positions_order_{}_gap_{}.df'. format(str(order), str(gap))) updated_body_markers_positions = dlc_pp.clean_dlc_outpout(updated_markers_filename, body_markers_positions, gap, order) ''' # Best results for gap = 10 and order = 4 updated_markers_filename = join( dlc_project_folder, 'post_processing', 'cleaned_body_marker_positions_order_{}_gap_{}.df'.format(str(4), str(10))) updated_body_markers_positions = pd.read_pickle(updated_markers_filename)