def test_bayesian_prob_smalltc():
tuning_curve = np.array([[0., 0., 1.]])
counts = nept.AnalogSignal(np.array([[10.], [5.]]), np.array([1.]))
binsize = 1.0
likelihood = nept.bayesian_prob(counts, tuning_curve, binsize, min_neurons=1, min_spikes=1)
assert np.sum(np.isnan(likelihood)) == likelihood.size
def get_likelihood(spikes, tuning_curves, tc_shape, start, stop):
sliced_spikes = [spiketrain.time_slice(start, stop) for spiketrain in spikes]
t_window = stop-start # 0.1 for running, 0.025 for swr
counts = bin_spikes(sliced_spikes, np.array([start, stop]), dt=t_window, window=t_window,
gaussian_std=0.0075, normalized=False)
likelihood = nept.bayesian_prob(counts, tuning_curves, binsize=t_window, min_neurons=3, min_spikes=1)
return likelihood.reshape(tc_shape[1], tc_shape[2])
def test_bayesian_prob_onetime():
tuning_curve = np.array([[0., 0., 2.]])
counts = nept.AnalogSignal(np.array([[10.]]), np.array([1.]))
binsize = 1.0
likelihood = nept.bayesian_prob(counts, tuning_curve, binsize, min_neurons=1, min_spikes=1)
assert np.allclose(likelihood[0][2], 1.0)
def test_bayesian_prob_multtc():
tuning_curve = np.array([[2., 0., 0.],
[0., 5., 0.],
[0., 0., 5.]])
counts = nept.AnalogSignal(np.array([[0.], [4.], [2.]]), np.array([1.]))
binsize = 1.0
likelihood = nept.bayesian_prob(counts, tuning_curve, binsize, min_neurons=1, min_spikes=1)
assert np.allclose(likelihood, np.array([[0.02997459, 0.93271674, 0.03730867]]))
def test_bayesian_prob_smalltc():
tuning_curve = np.array([[0., 0., 1.]])
counts = nept.AnalogSignal(np.array([[10.], [5.]]), np.array([1.]))
binsize = 1.0
likelihood = nept.bayesian_prob(counts,
tuning_curve,
binsize,
min_neurons=1,
min_spikes=1)
assert np.sum(np.isnan(likelihood)) == likelihood.size
def test_bayesian_prob_onetime():
tuning_curve = np.array([[0., 0., 2.]])
counts = nept.AnalogSignal(np.array([[10.]]), np.array([1.]))
binsize = 1.0
likelihood = nept.bayesian_prob(counts,
tuning_curve,
binsize,
min_neurons=1,
min_spikes=1)
assert np.allclose(likelihood[0][2], 1.0)
def test_bayesian_prob_multtimepos():
tuning_curve = np.array([[3., 0., 0.]])
counts = nept.AnalogSignal(np.array([[0., 2., 4.]]), np.array([1., 2., 3.]))
binsize = 1.0
likelihood = nept.bayesian_prob(counts, tuning_curve, binsize, min_neurons=1, min_spikes=1)
assert np.sum(np.isnan(likelihood[0])) == 3
assert np.allclose(likelihood[1][0], 1.0)
assert np.sum(np.isnan(likelihood[1])) == 2
assert np.allclose(likelihood[2][0], 1.0)
assert np.sum(np.isnan(likelihood[2])) == 2
def test_bayesian_prob_emptytcbin():
tuning_curve = np.array([[0., 1., 0.],
[0., 5., 0.],
[0., 0., 5.]])
counts = nept.AnalogSignal(np.array([[0.], [2.], [2.]]), np.array([1.]))
binsize = 1.0
likelihood = nept.bayesian_prob(counts, tuning_curve, binsize, min_neurons=1, min_spikes=1)
assert np.isnan(likelihood[0][0])
assert np.allclose(likelihood[0][1], 0.5)
assert np.allclose(likelihood[0][2], 0.5)
def test_bayesian_prob_multtc():
tuning_curve = np.array([[2., 0., 0.], [0., 5., 0.], [0., 0., 5.]])
counts = nept.AnalogSignal(np.array([[0.], [4.], [2.]]), np.array([1.]))
binsize = 1.0
likelihood = nept.bayesian_prob(counts,
tuning_curve,
binsize,
min_neurons=1,
min_spikes=1)
assert np.allclose(likelihood,
np.array([[0.02997459, 0.93271674, 0.03730867]]))
def test_bayesian_prob_multneurons():
tuning_curve = np.array([[2., 0., 0.],
[0., 5., 0.],
[0., 0., 5.]])
counts = nept.AnalogSignal(np.array([[0., 8, 0.],
[4., 0., 1.],
[0., 1., 3.]]).T, np.array([1., 2., 3.]))
binsize = 1.0
likelihood = nept.bayesian_prob(counts, tuning_curve, binsize, min_neurons=1, min_spikes=1)
assert np.allclose(likelihood[0], np.array([0.0310880460, 0.967364171, 0.00154778267]))
assert np.allclose(likelihood[1], np.array([0.998834476, 0.000194254064, 0.000971270319]))
assert np.allclose(likelihood[2], np.array([0.133827265, 0.0333143360, 0.832858399]))
def test_bayesian_prob_emptytcbin():
tuning_curve = np.array([[0., 1., 0.], [0., 5., 0.], [0., 0., 5.]])
counts = nept.AnalogSignal(np.array([[0.], [2.], [2.]]), np.array([1.]))
binsize = 1.0
likelihood = nept.bayesian_prob(counts,
tuning_curve,
binsize,
min_neurons=1,
min_spikes=1)
assert np.isnan(likelihood[0][0])
assert np.allclose(likelihood[0][1], 0.5)
assert np.allclose(likelihood[0][2], 0.5)
def test_bayesian_prob_multtimepos():
tuning_curve = np.array([[3., 0., 0.]])
counts = nept.AnalogSignal(np.array([[0., 2., 4.]]), np.array([1., 2.,
3.]))
binsize = 1.0
likelihood = nept.bayesian_prob(counts,
tuning_curve,
binsize,
min_neurons=1,
min_spikes=1)
assert np.sum(np.isnan(likelihood[0])) == 3
assert np.allclose(likelihood[1][0], 1.0)
assert np.sum(np.isnan(likelihood[1])) == 2
assert np.allclose(likelihood[2][0], 1.0)
assert np.sum(np.isnan(likelihood[2])) == 2
def test_bayesian_prob_multneurons():
tuning_curve = np.array([[2., 0., 0.], [0., 5., 0.], [0., 0., 5.]])
counts = nept.AnalogSignal(
np.array([[0., 8, 0.], [4., 0., 1.], [0., 1., 3.]]).T,
np.array([1., 2., 3.]))
binsize = 1.0
likelihood = nept.bayesian_prob(counts,
tuning_curve,
binsize,
min_neurons=1,
min_spikes=1)
assert np.allclose(likelihood[0],
np.array([0.0310880460, 0.967364171, 0.00154778267]))
assert np.allclose(likelihood[1],
np.array([0.998834476, 0.000194254064, 0.000971270319]))
assert np.allclose(likelihood[2],
np.array([0.133827265, 0.0333143360, 0.832858399]))
def get_likelihoods(info, swr_params, task_labels, n_shuffles=0, save_path=None):
_, position, spikes, lfp, _ = get_data(info)
zones = dict()
zones["u"], zones["shortcut"], zones["novel"] = get_zones(info, position, subset=True)
combined_zones = zones["u"] + zones["shortcut"] + zones["novel"]
zones["other"] = ~combined_zones
if n_shuffles > 0:
n_passes = n_shuffles
else:
n_passes = 1
session = Session(position, task_labels, zones)
tuning_curves_fromdata = get_only_tuning_curves(info, position, spikes, info.task_times["phase3"])
tc_shape = tuning_curves_fromdata.shape
phase_for_zthresh = "pauseB"
swrs = nept.detect_swr_hilbert(lfp,
fs=info.fs,
thresh=swr_params["swr_thresh"],
z_thresh=info.lfp_z_thresh,
merge_thresh=swr_params["merge_thresh"],
min_length=swr_params["min_length"],
times_for_z=nept.Epoch(info.task_times[phase_for_zthresh].start,
info.task_times[phase_for_zthresh].stop))
swrs = nept.find_multi_in_epochs(spikes, swrs, min_involved=swr_params["min_involved"])
rest_epochs = nept.rest_threshold(position, thresh=12., t_smooth=0.8)
for task_label in task_labels:
epochs_of_interest = info.task_times[task_label].intersect(rest_epochs)
phase_swrs = epochs_of_interest.overlaps(swrs)
phase_swrs = phase_swrs[phase_swrs.durations >= 0.05]
phase_likelihoods = np.zeros((n_passes, phase_swrs.n_epochs, tc_shape[1], tc_shape[2]))
phase_tuningcurves = np.zeros((n_passes, tc_shape[0], tc_shape[1], tc_shape[2]))
for n_pass in range(n_passes):
if n_shuffles > 0:
tuning_curves = np.random.permutation(tuning_curves_fromdata)
else:
tuning_curves = tuning_curves_fromdata
phase_tuningcurves[n_pass, ] = tuning_curves
tuning_curves = tuning_curves.reshape(tc_shape[0], tc_shape[1] * tc_shape[2])
if phase_swrs.n_epochs == 0:
phase_likelihoods = np.ones((n_passes, 1, tc_shape[1], tc_shape[2])) * np.nan
else:
counts_data = []
counts_time = []
t_windows = []
for n_timebin, (start, stop) in enumerate(zip(phase_swrs.starts,
phase_swrs.stops)):
t_window = stop - start # 0.1 for running, 0.025 for swr
sliced_spikes = [spiketrain.time_slice(start, stop) for spiketrain in spikes]
these_counts = nept.bin_spikes(sliced_spikes,
start,
stop,
dt=t_window,
gaussian_std=0.0075,
normalized=False,
lastbin=True)
counts_data.append(these_counts.data)
counts_time.append(these_counts.time)
t_windows.append(t_window)
counts = nept.AnalogSignal(np.vstack(counts_data), np.hstack(counts_time))
likelihood = nept.bayesian_prob(counts,
tuning_curves,
binsize=t_windows,
min_neurons=3,
min_spikes=1)
phase_likelihoods[n_pass] = likelihood.reshape(phase_swrs.n_epochs, tc_shape[1], tc_shape[2])
tasktime = getattr(session, task_label)
tasktime.likelihoods = phase_likelihoods
tasktime.tuning_curves = phase_tuningcurves
tasktime.swrs = phase_swrs
if save_path is not None:
session.pickle(save_path)
return session
def get_decoded(info, dt, gaussian_std, min_neurons, min_spikes, min_swr, neurons, normalized, run_time,
speed_limit, t_smooth, shuffle_id, window, decoding_times, min_proportion_decoded,
decode_sequences, sequence_len=3, sequence_speed=5., min_epochs=3, random_shuffle=False):
"""Finds decoded for each session.
Parameters
----------
info: module
dt: float
gaussian_std: float
min_epochs: int
min_neurons: int
min_spikes: int
min_swr: int
neurons: nept.Neurons
normalized: boolean
run_time: boolean
speed_limit: float
sequence_speed: float
shuffle_id: boolean
window: float
min_proportion_decoded: float
decoding_times: nept.Epoch
decode_sequences: bool
sequence_len: int
sequence_speed: float
random_shuffle: bool
Returns
-------
decoded: nept.Position
decoded_epochs: nept.Epoch
errors: np.array
"""
if decoding_times.n_epochs != 1:
raise AssertionError("decoding_times must only contain one epoch (start, stop)")
events, position, all_spikes, lfp, lfp_theta = get_data(info)
xedges, yedges = nept.get_xyedges(position, binsize=8)
sliced_spikes = neurons.time_slice(decoding_times.start, decoding_times.stop)
position = position.time_slice(decoding_times.start, decoding_times.stop)
sliced_spikes = sliced_spikes.spikes
if shuffle_id:
tuning_curves = np.random.permutation(neurons.tuning_curves)
else:
tuning_curves = neurons.tuning_curves
if run_time:
# limit position to only times when the subject is moving faster than a certain threshold
run_epoch = nept.run_threshold(position, thresh=speed_limit, t_smooth=t_smooth)
position = position[run_epoch]
epochs_interest = nept.Epoch(position.time[0], position.time[-1])
else:
sliced_lfp = lfp.time_slice(t_start, t_stop)
z_thresh = 3.0
power_thresh = 5.0
merge_thresh = 0.02
min_length = 0.05
swrs = nept.detect_swr_hilbert(sliced_lfp, fs=info.fs, thresh=(140.0, 250.0), z_thresh=z_thresh,
merge_thresh=merge_thresh, min_length=min_length)
min_involved = 4
multi_swr = nept.find_multi_in_epochs(sliced_spikes, swrs, min_involved=min_involved)
if multi_swr.n_epochs < min_swr:
epochs_interest = nept.Epoch([], [])
else:
epochs_interest = multi_swr
# print('sharp-wave ripples, total:', swrs.n_epochs)
# print('sharp-wave ripples, min', min_involved, 'neurons :', multi_swr.n_epochs)
# print('sharp-wave ripples, used :', epochs_interest.n_epochs)
# print('sharp-wave ripples, mean durations: ', np.mean(epochs_interest.durations))
counts = nept.bin_spikes(sliced_spikes, position.time, dt=dt, window=window,
gaussian_std=gaussian_std, normalized=normalized)
tc_shape = tuning_curves.shape
decoding_tc = tuning_curves.reshape(tc_shape[0], tc_shape[1] * tc_shape[2])
likelihood = nept.bayesian_prob(counts, decoding_tc, window, min_neurons=min_neurons, min_spikes=min_spikes)
xcenters, ycenters = get_bin_centers(info)
xy_centers = nept.cartesian(xcenters, ycenters)
decoded = nept.decode_location(likelihood, xy_centers, counts.time)
nan_idx = np.logical_and(np.isnan(decoded.x), np.isnan(decoded.y))
decoded = decoded[~nan_idx]
if random_shuffle:
random_x = [np.random.choice(decoded.x) for val in decoded.x]
random_y = [np.random.choice(decoded.y) for val in decoded.y]
decoded = nept.Position(np.array([random_x, random_y]).T, decoded.time)
if decode_sequences:
print('decoded n_samples before sequence:', decoded.n_samples)
sequences = nept.remove_teleports(decoded, speed_thresh=sequence_speed, min_length=sequence_len)
decoded_epochs = epochs_interest.intersect(sequences)
decoded_epochs = decoded_epochs.expand(0.002)
if decoded_epochs.n_epochs < min_epochs:
decoded = nept.Position(np.array([]), np.array([]))
else:
decoded = decoded[decoded_epochs]
print('decoded n_samples after sequence:', decoded.n_samples)
else:
decoded_epochs = epochs_interest
f_xy = scipy.interpolate.interp1d(position.time, position.data.T, kind="nearest")
decoded_xy = f_xy(decoded.time)
actual_position = nept.Position(np.hstack((decoded_xy[0][..., np.newaxis],
decoded_xy[1][..., np.newaxis])),
decoded.time)
if decoded.n_samples > 0:
errors = actual_position.distance(decoded)
else:
errors = np.array([])
percent_decoded = (decoded.n_samples/counts.n_samples)*100
if (decoded.n_samples/counts.n_samples) < min_proportion_decoded:
print("Decoded bins make up %d%% of possible bins ..."
"removing due to too few bins" % percent_decoded)
decoded = nept.Position([np.array([]), np.array([])], np.array([]))
decoded_epochs = nept.Epoch([np.array([]), np.array([])])
errors = np.array([])
actual_position = nept.Position([np.array([]), np.array([])], np.array([]))
return decoded, decoded_epochs, errors, actual_position, likelihood, percent_decoded
def get_decoded(info, position, spikes, shuffled_id):
phase = info.task_times["phase3"]
sliced_position = position.time_slice(phase.start, phase.stop)
# trials = get_trials(events, phase)
trials = get_matched_trials(info, sliced_position)
error_byactual_position = np.zeros((len(info.yedges), len(info.xedges)))
n_byactual_position = np.ones((len(info.yedges), len(info.xedges)))
session_n_active = []
session_likelihoods = []
session_decoded = []
session_actual = []
session_errors = []
n_timebins = []
for trial in trials:
epoch_of_interest = phase.excludes(trial)
tuning_curves = get_only_tuning_curves(info,
position,
spikes,
epoch_of_interest)
if shuffled_id:
tuning_curves = np.random.permutation(tuning_curves)
sliced_position = position.time_slice(trial.start, trial.stop)
sliced_spikes = [spiketrain.time_slice(trial.start,
trial.stop) for spiketrain in spikes]
# limit position to only times when the subject is moving faster than a certain threshold
run_epoch = nept.run_threshold(sliced_position, thresh=10., t_smooth=0.8)
sliced_position = sliced_position[run_epoch]
sliced_spikes = [spiketrain.time_slice(run_epoch.start,
run_epoch.stop) for spiketrain in sliced_spikes]
# epochs_interest = nept.Epoch(sliced_position.time[0], sliced_position.time[-1])
t_window = 0.025 # 0.1 for running, 0.025 for swr
counts = nept.bin_spikes(sliced_spikes, sliced_position.time, dt=t_window, window=t_window,
gaussian_std=0.0075, normalized=False)
n_timebins.append(len(counts.time))
min_neurons = 3
tc_shape = tuning_curves.shape
decoding_tc = tuning_curves.reshape(tc_shape[0], tc_shape[1] * tc_shape[2])
likelihood = nept.bayesian_prob(counts, decoding_tc, binsize=t_window, min_neurons=min_neurons, min_spikes=1)
# Find decoded location based on max likelihood for each valid timestep
xcenters, ycenters = get_bin_centers(info)
xy_centers = nept.cartesian(xcenters, ycenters)
decoded = nept.decode_location(likelihood, xy_centers, counts.time)
session_decoded.append(decoded)
# Remove nans from likelihood and reshape for plotting
keep_idx = np.sum(np.isnan(likelihood), axis=1) < likelihood.shape[1]
likelihood = likelihood[keep_idx]
likelihood = likelihood.reshape(np.shape(likelihood)[0], tc_shape[1], tc_shape[2])
session_likelihoods.append(likelihood)
n_active_neurons = np.asarray([n_active if n_active >= min_neurons else 0
for n_active in np.sum(counts.data >= 1, axis=1)])
n_active_neurons = n_active_neurons[keep_idx]
session_n_active.append(n_active_neurons)
f_xy = scipy.interpolate.interp1d(sliced_position.time, sliced_position.data.T, kind="nearest")
counts_xy = f_xy(decoded.time)
true_position = nept.Position(np.hstack((counts_xy[0][..., np.newaxis],
counts_xy[1][..., np.newaxis])),
decoded.time)
session_actual.append(true_position)
trial_errors = true_position.distance(decoded)
session_errors.append(trial_errors)
return session_decoded, session_actual, session_likelihoods, session_errors, session_n_active, n_timebins