regions_pos = np.array(list(const.BRAIN_REGIONS.values()))
pos_to_elect_factor = const.NUMBER_OF_AP_CHANNELS_IN_BINARY_FILE / 8100
region_lines = binning.scale(regions_pos, np.min(regions_pos) * pos_to_elect_factor, np.max(regions_pos) * pos_to_elect_factor)
_ = plt.figure(1)
plt.imshow(np.flipud(avg_muae_around_tp), aspect='auto')
plt.vlines(x=avg_muae_around_tp.shape[1] / 2, ymin=0, ymax=avg_muae_around_tp.shape[0] - 1)
plt.hlines(y=avg_muae_around_tp.shape[0] - region_lines, xmin=0, xmax=avg_muae_around_tp.shape[1]-1, linewidth=3, color='w')
tp_n = np.empty((avg_muae_around_ntp.shape))
for i in np.arange(len(avg_muae_around_ntp)):
tp_n[i, :] = binning.scale(avg_muae_around_ntp[i], 0, 1)
_= plt.figure(2)
plt.imshow(np.flipud(tp_n), aspect='auto')
plt.vlines(x=tp_n.shape[1] / 2, ymin=0, ymax=tp_n.shape[0] - 1)
plt.hlines(y=tp_n.shape[0] - region_lines, xmin=0, xmax=tp_n.shape[1]-1, linewidth=1, color='w')
tp_n_smooth = binning.rolling_window_with_step(tp_n, np.mean, 40, 40)
_= plt.figure(3)
plt.imshow(np.flipud(tp_n_smooth), aspect='auto')
plt.vlines(x=tp_n_smooth.shape[1] / 2, ymin=0, ymax=tp_n_smooth.shape[0] - 1)
plt.hlines(y=tp_n_smooth.shape[0] - region_lines, xmin=0, xmax=tp_n_smooth.shape[1]-1, linewidth=1, color='w')
_= plt.figure(3)
plt.imshow(np.flipud(tp_n_smooth), aspect='auto', extent=[-8, 8, len(tp_n_smooth), 0])
plt.hlines(y=tp_n_smooth.shape[0] - region_lines, xmin=-8, xmax=8, linewidth=3, color='w')
plt.vlines(x=0, ymin=0, ymax=tp_n_smooth.shape[0] - 1)
# Load the pre generated DataFrames for the event CSVs
event_dataframes = ns_funcs.load_events_dataframes(events_folder, sync_funcs.event_types)
file_to_save_to = join(kilosort_folder, 'firing_rate_with_video_frame_window.npy')
template_info = pd.read_pickle(join(kilosort_folder, 'template_info.df'))
spike_info = pd.read_pickle(join(kilosort_folder, 'spike_info_after_cleaning.df'))
spike_rates = binning.spike_count_per_frame(template_info, spike_info, event_dataframes['ev_video'],
sampling_freq, file_to_save_to=file_to_save_to)
# Using the frame based spikes rates do a rolling window to average a bit more
num_of_frames_to_average = 0.25/(1/120)
spike_rates_0p25 = []
for n in np.arange(spike_rates.shape[0]):
spike_rates_0p25.append(binning.rolling_window_with_step(spike_rates[n, :], np.mean,
num_of_frames_to_average, num_of_frames_to_average))
spike_rates_0p25 = np.array(spike_rates_0p25)
np.save(join(kilosort_folder, 'firing_rate_with_0p25s_window.npy'), spike_rates_0p25)
# </editor-fold>
# ----------------------------------------------------------------------------------------------------------------------
# -------------------------------------------------
# <editor-fold desc="GET TIMES AND FRAMES OF SUCCESSFUL TRIALS">
video_frame_spike_rates_filename = join(kilosort_folder, 'firing_rate_with_video_frame_window.npy')
spike_rates = np.load(video_frame_spike_rates_filename)
camera_pulses, beam_breaks, sounds = \
sync_funcs.get_time_points_of_events_in_sync_file(data_folder, clean=True,
cam_ttl_pulse_period=
const_com.CAMERA_TTL_PULSES_TIMEPOINT_PERIOD)
sounds_dur = sounds[:, 1] - sounds[:, 0]
sr_trials = sr[:, trial_windows_in_frames]
sr_non_trials = sr[:, non_trial_windows_in_frames]
sr_baseline_trials = sr[:, baseline_trial_windows_in_frames]
sr_baseline_non_trials = sr[:, baseline_non_trial_windows_in_frames]
# Smooth
smoothing_window = int(0.25 * 120) # in frames
step_window = 10 # in frames
sr_trials_smoothed = []
sr_baseline_trials_smoothed = []
for trial in np.arange(number_of_trial_pokes):
sr_trials_smoothed.append(
binning.rolling_window_with_step(sr_trials[:, trial, :], np.mean,
smoothing_window, step_window))
sr_baseline_trials_smoothed.append(
binning.rolling_window_with_step(sr_baseline_trials[:,
trial, :], np.mean,
smoothing_window, step_window))
sr_non_trials_smoothed = []
sr_baseline_non_trials_smoothed = []
for non_trial in np.arange(number_of_non_trial_pokes):
sr_non_trials_smoothed.append(
binning.rolling_window_with_step(sr_non_trials[:,
non_trial, :], np.mean,
smoothing_window, step_window))
avg_voltage_around_trials = np.mean(voltage_around_trials, axis=0)
_ = plt.imshow(np.flipud(avg_voltage_around_trials), aspect='auto')
# </editor-fold>
# -------------------------------------------------
# <editor-fold desc="LOOK AT ALL THE NEURONS AROUND THE POKE EVENT">
smooth_time = 0.5
smooth_frames = smooth_time * 120
#data = avg_firing_rate_around_random
data = avg_firing_rate_around_suc_trials
t = binning.rolling_window_with_step(data, np.mean, smooth_frames,
int(smooth_frames / 3))
tn = preproc.normalize(t, norm='l1', axis=0)
tn = np.asarray(t)
for i in np.arange(len(t)):
tn[i, :] = binning.scale(t[i], 0, 1)
y_positions = template_info['position Y'].values
position_sorted_indices = np.argsort(y_positions)
regions_pos = list(const.BRAIN_REGIONS.values())
region_lines = []
for rp in regions_pos:
region_lines.append(
sync_funcs.find_nearest(
y_positions[position_sorted_indices] * const.POSITION_MULT, rp)[0])
(avg_lfps_around_event[channel, :] -
random_triggered_lfps_mean[channel, :]) /
(random_triggered_lfps_std[channel, :] / np.sqrt(len(events))))
z_score = np.array(z_score)
time_x_axis = np.arange(-window_timepoints / const.SAMPLING_FREQUENCY,
window_timepoints / const.SAMPLING_FREQUENCY,
1 / const.SAMPLING_FREQUENCY)
_ = plt.plot(time_x_axis, z_score.T)
_ = plt.plot(time_x_axis, cdf.space_data(z_score, 3).T)
_ = plt.plot(
time_x_axis[:-300:100],
cdf.space_data(
binning.rolling_window_with_step(z_score, np.mean, 300, 100), 3).T)
_ = plt.plot(time_x_axis[:-300:100],
binning.rolling_window_with_step(z_score, np.mean, 300, 100).T)
index = 0
sv.graph_pane(globals(), 'index', 'z_factor', 'time_x_axis')
t = np.argwhere(np.abs(z_score) > 5)
channels_with_large_changes = np.unique(t[:, 0])
smooth_factor = 1000
#smoothed_z_score = binning.rolling_window_with_step(z_score, np.mean, smooth_factor, smooth_factor)
smoothed_avg_lfps_around_event = binning.rolling_window_with_step(
avg_lfps_around_event, np.mean, smooth_factor, smooth_factor)
smoothed_time_x_axis = np.arange(-window_timepoints / const.SAMPLING_FREQUENCY,
window_timepoints / const.SAMPLING_FREQUENCY,
speeds = body_velocities_polar[:, 0].copy()
acc = np.diff(speeds)
for i in np.arange(len(acc)):
if speeds[i] > 200:
speeds[i] = np.mean(speeds[i - 10:i + 10])
# Get the 250ms averages of firing rates for all neurons and of the speed (body_velocity_polar[0] of the animal
video_frame_spike_rates_filename = join(
kilosort_folder, 'firing_rate_with_video_frame_window.npy')
spike_rates = np.load(video_frame_spike_rates_filename)
spike_rates_0p25 = np.load(
join(kilosort_folder, 'firing_rate_with_0p25s_window.npy'))
num_of_frames_to_average = 0.25 / (1 / 120)
speeds_0p25 = binning.rolling_window_with_step(speeds, np.mean,
num_of_frames_to_average,
num_of_frames_to_average)
speeds_0p25[0] = 0
# </editor-fold>
# -------------------------------------------------
# <editor-fold desc="CREATE THE MUTUAL INFORMATION MEASURE BETWEEN SPEED AND THE FIRING RATES OF ALL NEURONS (FOR THE WHOLE RECORDING)">
# Calculate the mutual information between the speed and all firing rates (for the whole of the experiment)
# using the lnc code (a Kraskov with some local non-uniform correction for better very high correlations)
n = 0
mutual_infos_spikes_vs_speed = []
for rate in spike_rates_0p25:
mutual_infos_spikes_vs_speed.append(
MI.mi_LNC([rate.tolist(), speeds_0p25],
k=10,
body_velocities_polar = np.array([
np.sqrt(
np.power(body_velocities[:, 0], 2) +
np.power(body_velocities[:, 1], 2)), 180 * (1 / np.pi) *
np.arctan2(body_velocities[:, 1], body_velocities[:, 0])
]).transpose()
# Correct the speeds by removing the very large spikes (replace them with the average speeds around them)
speeds = body_velocities_polar[:, 0].copy()
acc = np.diff(speeds)
for i in np.arange(len(acc)):
if speeds[i] > 200:
speeds[i] = np.mean(speeds[i - 10:i + 10])
num_of_frames_to_average = 1 / (1 / 120)
speeds_smoothed = binning.rolling_window_with_step(speeds, np.mean,
num_of_frames_to_average, 1)
speeds_smoothed[0] = 0
speeds_smoothed = np.array(speeds_smoothed)
rest_speed_threshold_cm_per_sec = 15
rest_move_periods = np.zeros(len(speeds_smoothed))
rest_move_periods[np.where(
speeds_smoothed > rest_speed_threshold_cm_per_sec)] = 1
# plt.plot(rest_move_periods)
# plt.plot((speeds_smoothed - np.nanmin(speeds_smoothed)) / np.nanmax(speeds_smoothed - np.nanmin(speeds_smoothed)))
# Check the calculated speeds on the video
frame = 1
sv.image_sequence(globals(), 'frame', 'full_video_file')
template_info = pd.read_pickle(join(kilosort_folder, 'template_info.df'))
time_to_bin = 0.1
frames_to_bin = time_to_bin * 120
# </editor-fold>
# -------------------------------------------------
# -------------------------------------------------
# <editor-fold desc="CREATE MATRIX, PCA IT AND RUN T-SNE ON THE PCs">
tsne_folder = join(tsne_folder_base, 'All_spikes_100msbin_count_top40PCs_6Kiter')
spike_rates_max_0p1 = binning.rolling_window_with_step(spike_rates_per_video_frame, np.max, frames_to_bin,
frames_to_bin)
spike_rates_binary_0p1 = np.copy(spike_rates_max_0p1)
spike_rates_binary_0p1[spike_rates_max_0p1 > 0] = 1
spike_rates_binary_0p1 = spike_rates_binary_0p1.transpose()
pca_sr_bin_0p1 = PCA()
pcs_ar_bin_0p1 = pca_sr_bin_0p1.fit_transform(spike_rates_binary_0p1)
number_of_top_pcs = 40
num_dims = 2
perplexity = 100
theta = 0.3
eta = 200
exageration = 12
iterations = 4000
# </editor-fold>
# -------------------------------------------------
# -------------------------------------------------
# <editor-fold desc="PCA THE 3D ARRAY (VIDEO) AND RUN T-SNE">
grayscale_resized_video_array = np.load(
join(subsumpled_video_folder, 'grayscale_resized_cropped_video_array.npy'))
# Flatten
grayscale_resized_video_array = \
grayscale_resized_video_array.reshape((num_of_frames, video_resolution[0] * video_resolution[1]))
# Smooth over time to 100ms per frame
grayscale_resized_video_array_frame_smoothed = np.transpose(
binning.rolling_window_with_step(grayscale_resized_video_array.transpose(),
np.mean, 12, 12))
np.save(
join(subsumpled_video_folder,
'grayscale_resized_cropped_video_array_frame_smoothed.npy'),
grayscale_resized_video_array_frame_smoothed)
# PCA
#pca_flat_video = PCA(n_components=100)
pca_flat_video = PCA()
pcs_flat_video = pca_flat_video.fit_transform(
grayscale_resized_video_array_frame_smoothed)
pickle.dump(
pca_flat_video,
open(
join(subsumpled_video_folder,
'full_pca_of_greyscale_subsampled_video.pcl'), 'wb'))
orientation_categories = pd.cut(body_velocities_polar[:, 1], bins=20)
event_dataframes = ns_funcs.load_events_dataframes(events_folder,
sync_funcs.event_types)
file_to_save_to = join(spikes_folder,
'firing_rate_with_video_frame_window.npy')
template_info = pd.read_pickle(join(spikes_folder, 'template_info.df'))
spike_rates = np.load(file_to_save_to)
num_of_frames_to_average = 0.25 / (1 / 120)
spike_rates_0p25 = np.load(
join(spikes_folder, 'firing_rate_with_0p25s_window.npy'))
speeds_0p25 = binning.rolling_window_with_step(body_velocities_polar[:, 0],
np.mean,
num_of_frames_to_average,
num_of_frames_to_average)
mutual_infos_spikes_vs_speed = np.load(
join(mutual_information_folder, 'mutual_infos_spikes_vs_speed.npy'))
shuffled = np.load(
join(mutual_information_folder,
'shuffled_mut_info_spike_rate_522_vs_speed.npy'))
mean_sh = np.mean(shuffled)
confidence_level = 0.999
confi_intervals = shuffled[int(
(1. - confidence_level) / 2 * 1000)], shuffled[int(
(1. + confidence_level) / 2 * 1000)]
plt.hist(mutual_infos_spikes_vs_speed,
bins=np.logspace(np.log10(0.0001), np.log10(30), 50))
plt.hist(shuffled,
correlated_neuron_indices[s] = np.squeeze(
np.argwhere(mis[s] > mean_sh + confi_intervals[1]))
if 'pb' in s:
correlated_neuron_indices['n' + s] = np.squeeze(
np.argwhere(mis['n' + s] > mean_sh + confi_intervals[1]))
# </editor-fold>
# -------------------------------------------------
# -------------------------------------------------
# <editor-fold desc="SIMPLE LINEAR REGRESSIONS">
# <editor-fold desc="SPEED REGRESSION V0">
X = spike_rates_0p25[correlated_neuron_indices['speed']].transpose()
X = spike_rates_0p25[522].transpose()
Y = binning.rolling_window_with_step(speeds, np.nanmean, 30, 30)[:-1]
X_train, X_test, y_train, y_test = train_test_split(X,
Y,
test_size=0.2,
random_state=0)
regressor_speed = linear_model.LinearRegression(normalize=True)
regressor_speed.fit(np.transpose([X_train]), y_train)
print(regressor_speed.score(np.transpose([X_train]), y_train))
Y_pred = regressor_speed.predict(np.transpose([X_test]))
plt.plot(Y_pred)
plt.plot(y_test)
plt.scatter(np.diff(Y_pred), np.diff(y_test))
plt.plot([0, 10, 20, 30, 40], [0, 10, 20, 30, 40], c='k')
# </editor-fold>
# -------------------------------------------------
# <editor-fold desc="PREPARE THE DATA FOR THE MUTUAL INFORMATION CALC (AND THE FRAME WIDNOWS THAT THE PERIODS ARE IN)">
frame_windows_away_from_poke = np.empty(0)
frame_windows_away_from_poke_in_periods = []
duration_in_frames_of_travel_periods = []
for f in frame_regions_away_from_poke:
period_frames = np.arange(f[0], f[1]).astype(np.int)
frame_windows_away_from_poke_in_periods.append(period_frames)
duration_in_frames_of_travel_periods.append(len(period_frames))
frame_windows_away_from_poke = np.concatenate((frame_windows_away_from_poke, period_frames))
frame_windows_away_from_poke = frame_windows_away_from_poke.astype(np.int)
spike_rates_away_from_poke = spike_rates[:, frame_windows_away_from_poke]
spike_rates_away_from_poke_smoothed = binning.rolling_window_with_step(spike_rates_away_from_poke,
np.mean, fr_smooth_frames, fr_smooth_frames)
distance_traveled_from_poke_smoothed = binning.rolling_window_with_step(distance_traveled_from_poke,
np.mean, fr_smooth_frames, fr_smooth_frames)
# </editor-fold>
# -------------------------------------------------
# -------------------------------------------------
# <editor-fold desc="DO THE MIs (RUN ONCE)">
# NOTE The MIs were done with fr_smooth_time = 0.5
n = 0
mi_spike_rates_vs_distance_traveled_from_poke = []
for rate in spike_rates_away_from_poke_smoothed:
mi_spike_rates_vs_distance_traveled_from_poke.append(MI.mi_LNC([rate.tolist(), distance_traveled_from_poke_smoothed],
correlated_neuron_indices[s] = np.squeeze(
np.argwhere(mis[s] > mean_sh + confi_intervals[1]))
if 'pb' in s:
correlated_neuron_indices['n' + s] = np.squeeze(
np.argwhere(mis['n' + s] > mean_sh + confi_intervals[1]))
# </editor-fold>
# -------------------------------------------------
# -------------------------------------------------
# <editor-fold desc="SIMPLE LINEAR REGRESSIONS">
# <editor-fold desc="SPEED REGRESSION">
X = spike_rates_0p25[correlated_neuron_indices['speed']].transpose()
Y = binning.rolling_window_with_step(speeds, np.nanmean, 30, 30)[:-1]
#X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=0)
X_train = X[:10000, :]
y_train = Y[:10000]
X_test = X[10000:, :]
y_test = Y[10000:]
# Linear
regressor_speed = linear_model.LinearRegression(normalize=True)
regressor_speed.fit(X_train, y_train)
print(regressor_speed.score(X_train, y_train))
print(regressor_speed.score(X_test, y_test))
Y_pred = regressor_speed.predict(X_test)
correlated_neuron_indices_unique_npb_dtp = np.delete(correlated_neuron_indices['npb_dtp'],
np.argwhere(np.isin(correlated_neuron_indices['npb_dtp'],
common_pb_npb_dtp_neuron_indices)))
# </editor-fold>
# -------------------------------------------------
# -------------------------------------------------
# <editor-fold desc="REGRESSION OF DISTANCE TO POKE WITH FIRING RATES FOR PATTERNED BEHAVIOUR NEURONS AND EPOCHS">
# First smooth the distance to poke and the firing rates with a small window and then smooth only the firing rates
# further denoting the amount of past time a classifier needs to use
spike_rates_patterned_behaviour_smoothed = \
binning.rolling_window_with_step(spike_rates[:, windows_of_patterned_behaviour],
np.mean, smoothing_frames, smoothing_frames) * 0.00833 * smoothing_frames
distance_to_poke_patterned_behaviour_smoothed = \
binning.rolling_window_with_step(distances_rat_to_poke_all_frames[windows_of_patterned_behaviour],
np.mean, smoothing_frames, smoothing_frames)
spike_rates_patterned_behaviour_smoothed = \
binning.rolling_window_with_step(spike_rates_patterned_behaviour_smoothed, np.mean, fr_extra_smoothing_frames, 1)
distance_to_poke_patterned_behaviour_smoothed = \
np.array(distance_to_poke_patterned_behaviour_smoothed[len(distance_to_poke_patterned_behaviour_smoothed)
- spike_rates_patterned_behaviour_smoothed.shape[1]:])
distance_to_poke_patterned_behaviour_smoothed = preprocessing.StandardScaler().\
fit_transform(np.reshape(distance_to_poke_patterned_behaviour_smoothed, (-1, 1))).reshape(-1)
# Then run mutliple times the regression leaving out some samples every time
analysis_folder, 'Images',
'Tsne_of_40_top_PCs_of_0p1_count_spike_vectors.png')
tsne_pcs_count_image = plt.imread(tsne_pcs_count_image_file)
tsne_pcs_count_image_extent = [-31, 45, -45, 30]
# </editor-fold>
# -------------------------------------------------
# -------------------------------------------------
# <editor-fold desc="CREATE MATRIX OF COUNTS PER 100ms, PCA THIS AND RUN T-SNE">
tsne_folder = join(tsne_folder_base,
'All_spikes_100msbin_count_top40PCs_6Kiter')
time_to_bin = 0.1
frames_to_bin = time_to_bin * 120
spike_rates_count_0p1 = binning.rolling_window_with_step(
spike_rates_per_video_frame, np.sum, frames_to_bin, frames_to_bin)
spike_rates_count_0p1 = spike_rates_count_0p1.transpose() * 0.00833
pca_sr_count_0p1 = PCA()
pcs_ar_count_0p1 = pca_sr_count_0p1.fit_transform(
spike_rates_count_0p1).astype(np.int16)
number_of_top_pcs = 40
num_dims = 2
perplexity = 100
theta = 0.2
eta = 200
exageration = 12
iterations = 6000
random_seed = 1
's': 'Successful',
'ns': 'Not successful',
'tb': 'Ball Touch',
'r': 'Random'
}
avg_muae_around_event = np.load(
join(results_folder, 'Lfp', 'Averages',
'Muaes_around_{}.npy'.format(trial_type)))
regions_pos = np.array(list(const.BRAIN_REGIONS.values()))
pos_to_elect_factor = const_comm.NUMBER_OF_AP_CHANNELS_IN_BINARY_FILE / 8100
region_lines = binning.scale(regions_pos,
np.min(regions_pos) * pos_to_elect_factor,
np.max(regions_pos) * pos_to_elect_factor)
muae_smooth = binning.rolling_window_with_step(avg_muae_around_event, np.mean,
40, 40)
muae_smooth = (muae_smooth - muae_smooth.min()) / (muae_smooth.max() -
muae_smooth.min())
_ = plt.figure(1)
plt.imshow(np.flipud(muae_smooth),
aspect='auto',
extent=[-8, 8, len(muae_smooth), 0])
plt.vlines(x=0, ymin=0, ymax=muae_smooth.shape[0] - 1)
plt.hlines(y=muae_smooth.shape[0] - region_lines,
xmin=-8,
xmax=8,
linewidth=3,
color='w')
plt.title('Rat = {}, Day from Imp. = {}, Event = {}, Trials = {}'\
.format(const.rat_folder[3:], str(date_folder), events[trial_type],
str(len(trials[trial_type]))))
spike_info = pd.read_pickle(
join(kilosort_folder, 'spike_info_after_cleaning.df'))
spike_rates = binning.spike_count_per_frame(template_info,
spike_info,
event_dataframes['ev_video'],
sampling_freq,
file_to_save_to=file_to_save_to)
# Using the frame based spikes rates do a rolling window to average a bit more
num_of_frames_to_average = 0.25 / (1 / 120)
spike_rates_0p25 = []
for n in np.arange(spike_rates.shape[0]):
spike_rates_0p25.append(
binning.rolling_window_with_step(spike_rates[n, :], np.mean,
num_of_frames_to_average,
num_of_frames_to_average))
spike_rates_0p25 = np.array(spike_rates_0p25)
np.save(join(kilosort_folder, 'firing_rate_with_0p25s_window.npy'),
spike_rates_0p25)
# </editor-fold>
# ----------------------------------------------------------------------------------------------------------------------
# -------------------------------------------------
# <editor-fold desc="GET TIMES AND FRAMES OF SUCCESSFUL TRIALS">
video_frame_spike_rates_filename = join(
kilosort_folder, 'firing_rate_with_video_frame_window.npy')
spike_rates = np.load(video_frame_spike_rates_filename)
camera_pulses, beam_breaks, sounds = \
sync_funcs.get_time_points_of_events_in_sync_file(data_folder, clean=True,
sv.image_sequence(globals(), 'frame', 'video_file')
# </editor-fold>
# </editor-fold>
# -------------------------------------------------
# -------------------------------------------------
# <editor-fold desc="USING THE GENERATED WINDOWS SMOOTH THE CORRESPONDING PARTS OF THE SPEED AND THE FIRING RATES">
# Smooth speeds and spike rates for each patterned behaviour
windows_of_patterned_behaviour_list = windows_of_patterned_behaviour[0]
for k in np.arange(1, number_of_patterned_events):
windows_of_patterned_behaviour_list = np.concatenate((windows_of_patterned_behaviour_list,
windows_of_patterned_behaviour[k]))
speeds_patterned_behaviour_0p25 = binning.rolling_window_with_step(speeds[windows_of_patterned_behaviour_list],
np.mean, 30, 30)
distances_rat_to_poke_all_frames = np.sqrt(
np.power(body_positions_normalised[:, 0] - poke_position[0], 2) +
np.power(body_positions_normalised[:, 1] - poke_position[1], 2))
distance_to_poke_patterned_behaviour_0p25 = \
binning.rolling_window_with_step(distances_rat_to_poke_all_frames[windows_of_patterned_behaviour_list],
np.mean, 30, 30)
spike_rates_patterned_behaviour_all_frames = spike_rates[:, windows_of_patterned_behaviour_list]
spike_rates_patterned_behaviour_0p25 = \
binning.rolling_window_with_step(spike_rates_patterned_behaviour_all_frames, np.mean, 30, 30)
# Smooth speeds and spike rates for each non patterned trial
# Make the spike rates using each frame as a binning window
# Load the pre generated DataFrames for the event CSVs
event_dataframes = ns_funcs.load_events_dataframes(events_folder,
sync_funcs.event_types)
file_to_save_to = join(kilosort_folder,
'firing_rate_with_video_frame_window.npy')
template_info = pd.read_pickle(join(kilosort_folder, 'template_info.df'))
spike_info = pd.read_pickle(
join(kilosort_folder, 'spike_info_after_cleaning.df'))
sampling_frequency = const.SAMPLING_FREQUENCY
spike_rates = binning.spike_count_per_frame(template_info,
spike_info,
event_dataframes['ev_video'],
sampling_frequency,
file_to_save_to=file_to_save_to)
# Using the frame based spikes rates do a rolling window to average a bit more
num_of_frames_to_average = 0.25 / (1 / 120)
spike_rates_0p25 = []
for n in np.arange(spike_rates.shape[0]):
spike_rates_0p25.append(
binning.rolling_window_with_step(spike_rates[n, :], np.mean,
num_of_frames_to_average,
num_of_frames_to_average))
spike_rates_0p25 = np.array(spike_rates_0p25)
np.save(join(kilosort_folder, 'firing_rate_with_0p25s_window.npy'),
spike_rates_0p25)
np.argwhere(
np.isin(correlated_neuron_indices['npb_dtp'],
common_pb_npb_dtp_neuron_indices)))
# </editor-fold>
# -------------------------------------------------
# -------------------------------------------------
# <editor-fold desc="REGRESSION OF DISTANCE TO POKE WITH FIRING RATES FOR PATTERNED BEHAVIOUR NEURONS AND EPOCHS">
# First smooth the distance to poke and the firing rates with a small window and then smooth only the firing rates
# further denoting the amount of past time a classifier needs to use
spike_rates_patterned_behaviour_smoothed = \
binning.rolling_window_with_step(spike_rates[:, windows_of_patterned_behaviour],
np.mean, smoothing_frames, smoothing_frames) * 0.00833 * smoothing_frames
distance_to_poke_patterned_behaviour_smoothed = \
binning.rolling_window_with_step(distances_rat_to_poke_all_frames[windows_of_patterned_behaviour],
np.mean, smoothing_frames, smoothing_frames)
spike_rates_patterned_behaviour_smoothed = \
binning.rolling_window_with_step(spike_rates_patterned_behaviour_smoothed, np.mean, fr_extra_smoothing_frames, 1)
distance_to_poke_patterned_behaviour_smoothed = \
np.array(distance_to_poke_patterned_behaviour_smoothed[len(distance_to_poke_patterned_behaviour_smoothed)
- spike_rates_patterned_behaviour_smoothed.shape[1]:])
distance_to_poke_patterned_behaviour_smoothed = preprocessing.StandardScaler().\
fit_transform(np.reshape(distance_to_poke_patterned_behaviour_smoothed, (-1, 1))).reshape(-1)
# Then run mutliple times the regression leaving out some samples every time
body_velocities_polar = np.array([
np.sqrt(
np.power(body_velocities[:, 0], 2) +
np.power(body_velocities[:, 1], 2)), 180 * (1 / np.pi) *
np.arctan2(body_velocities[:, 1], body_velocities[:, 0])
]).transpose()
# Get the 250ms averages of firing rates for all neurons and of the speed (body_velocity_polar[0] of the animal
video_frame_spike_rates_filename = join(
spikes_folder, 'firing_rate_with_video_frame_window.npy')
spike_rates = np.load(video_frame_spike_rates_filename)
spike_rates_0p25 = np.load(
join(spikes_folder, 'firing_rate_with_0p25s_window.npy'))
speeds_0p25 = binning.rolling_window_with_step(body_velocities_polar[:, 0],
np.mean,
num_of_frames_to_average,
num_of_frames_to_average)
# -------------------------------------------------
# CREATE THE MUTUAL INFORMATION MEASURE BETWEEN SPEED AND THE FIRING RATES OF ALL NEURONS (FOR THE WHOLE RECORDING)
# -------------------------------------------------
# Calculate the mutual information between the speed and all firing rates (for the whole of the experiment)
# using the lnc code (a Kraskov with some local non-uniform correction for better very high correlations)
'''
n = 0
mutual_infos_spikes_vs_speed = []
for rate in spike_rates_0p25:
mutual_infos_spikes_vs_speed.append(MI.mi_LNC([rate.tolist()[:const.BRAIN_DATA_UP_TO_QUARTER_SECOND],
speeds_0p25[:const.BRAIN_DATA_UP_TO_QUARTER_SECOND]],
k=10, base=np.exp(1), alpha=0.4, intens=1e-10))
const.BRAIN_REGIONS,
const.PROBE_DIMENSIONS,
const.POSITION_MULT,
template_info=template_info_decreasing_fr_neurons)
pd.to_pickle(template_info_decreasing_fr_neurons,
join(poke_folder, 'ti_decreasing_neurons_on_non_trial_pokes.df'))
# -------------------------------------------------
# <editor-fold desc="LOOK AT ALL THE NEURONS AROUND THE POKE EVENT">
smooth_time = 0.5
smooth_frames = smooth_time * 120
t = binning.rolling_window_with_step(avg_firing_rate_around_suc_trials,
np.mean, smooth_frames,
int(smooth_frames / 3))
tn = preproc.normalize(t, norm='l1', axis=0)
tn = np.asarray(t)
for i in np.arange(len(t)):
tn[i, :] = binning.scale(t[i], 0, 1)
y_positions = template_info['position Y'].values
position_sorted_indices = np.argsort(y_positions)
regions_pos = list(const.BRAIN_REGIONS.values())
region_lines = []
for rp in regions_pos:
region_lines.append(
sync_funcs.find_nearest(
# <editor-fold desc="SEE LFPS IN RESPECT TO THE REFERENCE CHANNELS">
closest_reference_positions_bottom = np.arange(2, 72, 6) + 0.5
event_choise = 'ntp'
events = possible_events[event_choise]
num_of_events = len(events)
avg_lfps_around_event, std_lfps_around_event, time_axis = \
tla_funcs.time_lock_raw_data(lfps, events, times_to_cut=[-window_time, window_time],
sampling_freq=const.SAMPLING_FREQUENCY,
baseline_time=[-window_time, -0.5 * window_time], sub_sample_freq=None,
high_pass_cutoff=None, rectify=None, low_pass_cutoff=100,
avg_reref=True, keep_trials=False)
smooth_factor = 1000
smoothed_avg_lfps_around_event = binning.rolling_window_with_step(
avg_lfps_around_event, np.mean, smooth_factor, smooth_factor)
smoothed_time_x_axis = np.arange(-window_timepoints / const.SAMPLING_FREQUENCY,
window_timepoints / const.SAMPLING_FREQUENCY,
1 / const.SAMPLING_FREQUENCY * smooth_factor)
plt.figure(2)
plt.imshow(smoothed_avg_lfps_around_event, aspect='auto')
plt.hlines(y=closest_reference_positions_bottom,
xmin=0,
xmax=smoothed_avg_lfps_around_event.shape[1])
plt.hlines(y=np.arange(0, 72, 6) - 0.5,
xmin=0,
xmax=smoothed_avg_lfps_around_event.shape[1],
color='r')
# </editor-fold>
