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)
