def test_get_heatmaps():
position = np.vstack([
np.arange(0, 10, 1),
np.hstack((np.arange(0, 10, 2), np.arange(10, 0, -2)))
]),
position = nept.Position(position, np.arange(0, 30, 3))
neuron_list = [0, 2, 3]
spikes = [
nept.SpikeTrain(np.array([19.9, 20., 20.1]), 'test'),
nept.SpikeTrain(np.array([8.]), 'test'),
nept.SpikeTrain(np.array([0., 15., 27.]), 'test'),
nept.SpikeTrain(np.array([9., 10., 11., 15., 16.]), 'test')
]
heatmaps = nept.get_heatmaps(neuron_list, spikes, position, num_bins=5)
assert np.allclose(len(heatmaps), 3)
assert np.allclose(np.max(heatmaps[0]), 3.)
assert np.allclose(np.mean(heatmaps[0]), 0.12)
assert np.allclose(np.max(heatmaps[2]), 1.)
assert np.allclose(np.mean(heatmaps[2]), 0.12)
assert np.allclose(np.max(heatmaps[3]), 2.)
assert np.allclose(np.mean(heatmaps[3]), 0.2)
def test_spiketrain_sort_times():
spikes = [
nept.SpikeTrain(np.array([9., 7., 5., 3., 1.])),
nept.SpikeTrain(np.array([1.3, 5.3, 3.3]))
]
assert np.allclose(spikes[0].time, np.array([1., 3., 5., 7., 9.]))
assert np.allclose(spikes[1].time, np.array([1.3, 3.3, 5.3]))
def test_spiketrain_labels():
spikes = [
nept.SpikeTrain(np.array([1., 3., 5., 7., 9.])),
nept.SpikeTrain(np.array([1.3, 3.3, 5.3]), 'check_label')
]
assert spikes[0].label == None
assert spikes[1].label == 'check_label'
def test_spiketrain_n_spikes_simple():
spikes = [
nept.SpikeTrain(np.array([1., 3., 5., 7., 9.])),
nept.SpikeTrain(np.array([1.3, 3.3, 5.3]))
]
assert np.allclose(spikes[0].n_spikes, 5)
assert np.allclose(spikes[1].n_spikes, 3)
def test_neurons_get_tuning_shape():
spikes = np.array([
nept.SpikeTrain(np.array([0.5]), 'test'),
nept.SpikeTrain(np.array([1.5]), 'test'),
nept.SpikeTrain(np.array([2.5]), 'test')
])
tuning = np.array([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.]])
neurons = nept.Neurons(spikes, tuning)
assert np.allclose(neurons.tuning_shape, tuning[0].shape)
def test_spike_counts_window():
intervals = nept.Epoch([2., 7.], [6., 10.])
spikes = [
nept.SpikeTrain(np.array([0., 3.4, 6., 8.]), 'test'),
nept.SpikeTrain(np.array([0., 3.5, 6., 8.]), 'test'),
nept.SpikeTrain(np.array([1., 7., 11.]))
]
count_matrix = nept.spike_counts(spikes, intervals, window=1)
assert np.allclose(count_matrix, np.array([[0., 1.], [1., 1.], [0., 0.]]))
def test_neurons_basic():
spikes = np.array([
nept.SpikeTrain(np.array([0.5]), 'test'),
nept.SpikeTrain(np.array([1.5]), 'test'),
nept.SpikeTrain(np.array([2.5]), 'test')
])
tuning = np.array([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.]])
neurons = nept.Neurons(spikes, tuning)
assert np.allclose(neurons.spikes[0].time, spikes[0].time)
assert np.allclose(neurons.tuning_curves, tuning)
def test_spiketrain_time_slices():
spikes = [
nept.SpikeTrain(np.array([1., 3., 5., 7., 9.])),
nept.SpikeTrain(np.array([1.3, 3.3, 5.3]))
]
starts = np.array([1., 7.])
stops = np.array([4., 10.])
sliced_spikes = [spike.time_slice(starts, stops) for spike in spikes]
assert np.allclose(sliced_spikes[0].time, np.array([1., 3., 7., 9.]))
assert np.allclose(sliced_spikes[1].time, np.array([1.3, 3.3]))
def test_simple_tc():
linear = nept.Position(np.linspace(0, 10, 4), np.linspace(0, 3, 4))
spikes = [
nept.SpikeTrain(np.array([0.5]), 'test'),
nept.SpikeTrain(np.array([1.5]), 'test'),
nept.SpikeTrain(np.array([2.5]), 'test')
]
tuning = nept.tuning_curve_1d(linear, spikes, binsize=3, gaussian_std=None)
assert np.allclose(tuning,
([1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.]))
def test_sort_idx():
linear = nept.Position(np.linspace(0, 10, 4), np.linspace(0, 3, 4))
spikes = [
nept.SpikeTrain(np.array([1.5]), 'test'),
nept.SpikeTrain(np.array([0.5]), 'test'),
nept.SpikeTrain(np.array([2.5]), 'test')
]
tuning = nept.tuning_curve_1d(linear, spikes, binsize=3, gaussian_std=None)
sort_idx = nept.get_sort_idx(tuning)
assert np.allclose(sort_idx, [1, 0, 2])
def test_multi_in_epochs_mult():
epochs = nept.Epoch([1.0, 4.0, 6.0], [2.0, 5.0, 7.0])
spikes = [
nept.SpikeTrain(np.array([1.1, 6.5])),
nept.SpikeTrain(np.array([1.3, 4.1])),
nept.SpikeTrain(np.array([1.7, 4.3]))
]
min_involved = 2
multi_epochs = nept.find_multi_in_epochs(spikes, epochs, min_involved)
assert np.allclose(multi_epochs.starts, np.array([1., 4.]))
assert np.allclose(multi_epochs.stops, np.array([2., 5.]))
def test_spike_counts():
intervals = nept.Epoch([2., 7.], [6., 10.])
spikes = [
nept.SpikeTrain(np.array([0., 3., 4., 8.]), 'test'),
nept.SpikeTrain(np.array([0., 3., 4., 8.]), 'test'),
nept.SpikeTrain(np.array([1., 7., 11.])),
nept.SpikeTrain(np.array([0., 3., 4., 8.]), 'test')
]
count_matrix = nept.spike_counts(spikes, intervals)
assert np.allclose(np.mean(count_matrix), 1.25)
assert np.allclose(count_matrix[0], count_matrix[1], count_matrix[3])
def test_tuning_curve_1d_gaussian():
linear = nept.Position(np.linspace(0, 9, 4), np.linspace(0, 3, 4))
spikes = [
nept.SpikeTrain(np.array([0.0]), 'test'),
nept.SpikeTrain(np.array([1.0]), 'test'),
nept.SpikeTrain(np.array([2.0]), 'test'),
nept.SpikeTrain(np.array([2.5]), 'test')
]
tuning = nept.tuning_curve_1d(linear, spikes, binsize=3, gaussian_std=1.5)
assert np.allclose(tuning, ([0.78698604, 0.10650698, 0.0], [
0.10650698, 0.78698604, 0.10650698
], [0.0, 0.05325349, 0.39349302], [0.0, 0.05325349, 0.39349302]))
def test_simple_tc1():
"""Time spent in each bin not the same."""
linear = nept.Position(np.linspace(0, 9, 4), np.linspace(0, 3, 4))
spikes = [
nept.SpikeTrain(np.array([0.0]), 'test'),
nept.SpikeTrain(np.array([1.0]), 'test'),
nept.SpikeTrain(np.array([2.0]), 'test'),
nept.SpikeTrain(np.array([2.5]), 'test')
]
tuning = nept.tuning_curve_1d(linear, spikes, binsize=3, gaussian_std=None)
assert np.allclose(
tuning, ([1., 0., 0.], [0., 1., 0.], [0., 0., 0.5], [0., 0., 0.5]))
def test_neurons_n_wrong():
spikes = np.array([
nept.SpikeTrain(np.array([0.5]), 'test'),
nept.SpikeTrain(np.array([1.5]), 'test'),
nept.SpikeTrain(np.array([2.5]), 'test')
])
tuning = np.array([[1., 0., 0., 0.], [0., 1., 0., 0.]])
with pytest.raises(ValueError) as excinfo:
neurons = nept.Neurons(spikes, tuning)
assert str(
excinfo.value
) == 'spikes and tuning curves must have the same number of neurons'
def test_get_tetrode_mask():
spikes = [
nept.SpikeTrain([1., 2., 3.], 'a'),
nept.SpikeTrain([1., 2., 3.], 'b'),
nept.SpikeTrain([1., 2., 3.], 'a'),
nept.SpikeTrain([1., 2., 3.], 'b'),
nept.SpikeTrain([1., 2., 3.], 'c')
]
tetrode_mask = nept.get_tetrode_mask(spikes)
true_compare = np.array([[1, 0, 1, 0, 0], [0, 1, 0, 1, 0], [1, 0, 1, 0, 0],
[0, 1, 0, 1, 0], [0, 0, 0, 0, 1]])
assert np.all(true_compare == tetrode_mask)
def test_neurons_getitem_single():
spikes = np.array([
nept.SpikeTrain(np.array([0.5]), 'test'),
nept.SpikeTrain(np.array([1.5]), 'test'),
nept.SpikeTrain(np.array([2.5]), 'test')
])
tuning = np.array([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.]])
neurons = nept.Neurons(spikes, tuning)
sliced = neurons[1]
assert np.allclose(sliced.spikes[0].time, np.array([1.5]))
assert np.allclose(sliced.tuning_curves[0], np.array([0., 1., 0., 0.]))
def test_get_heatmaps_1d_position():
position = nept.Position(np.arange(0, 10, 1), np.arange(0, 30, 3))
neuron_list = [0, 2, 3]
spikes = [
nept.SpikeTrain(np.array([19.9, 20., 20.1]), 'test'),
nept.SpikeTrain(np.array([8.]), 'test'),
nept.SpikeTrain(np.array([0., 15., 27.]), 'test'),
nept.SpikeTrain(np.array([9., 10., 11., 15., 16.]), 'test')
]
with pytest.raises(ValueError) as excinfo:
heatmaps = nept.get_heatmaps(neuron_list, spikes, position, num_bins=5)
assert str(excinfo.value) == 'pos must be two-dimensional'
def test_bin_spikes_mult_neurons_adjust_window():
spikes = [
nept.SpikeTrain([0.8, 1.1, 1.2, 1.2, 2.1, 3.1]),
nept.SpikeTrain([0.8, 1.1, 1.2, 1.2, 2.1, 3.1])
]
counts = nept.bin_spikes(spikes,
0.0,
4.0,
dt=0.5,
window=2.5,
gaussian_std=None)
assert np.allclose(
counts.data,
np.array([[0.8, 0.8], [0.8, 0.8], [1.0, 1.0], [1.0, 1.0], [1.0, 1.0],
[0.4, 0.4], [0.4, 0.4]]))
def test_spiketrain_timeslice_none_list_start():
spikes = nept.SpikeTrain(np.array([1., 2., 3., 4., 5., 6.]), 'test')
starts = [None, 4.5]
stops = [3., 5.]
sliced_spikes = spikes.time_slice(starts, stops)
assert np.allclose(sliced_spikes.time, np.array([1., 2., 3., 5.]))
def test_spiketrain_timeslice_single():
spikes = nept.SpikeTrain(np.array([1., 2., 3., 4., 5., 6.]), 'test')
starts = 2.
stops = 5.
sliced_spikes = spikes.time_slice(starts, stops)
assert np.allclose(sliced_spikes.time, np.array([2., 3., 4., 5.]))
def test_neurons_slicing_specified_stop():
spikes = np.array([
nept.SpikeTrain(np.array([0.5]), 'test'),
nept.SpikeTrain(np.array([1.5]), 'test'),
nept.SpikeTrain(np.array([2.5]), 'test')
])
tuning = np.array([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.]])
neurons = nept.Neurons(spikes, tuning)
t_stop = 2.0
sliced_neurons = neurons.time_slice(None, t_stop)
assert np.allclose(sliced_neurons.spikes[0].time, np.array([0.5]))
assert np.allclose(sliced_neurons.spikes[1].time, np.array([1.5]))
assert np.allclose(sliced_neurons.spikes[2].time, np.array([]))
assert np.allclose(neurons.tuning_curves, tuning)
def test_spiketrain_timeslice_uneven_startstop():
spikes = nept.SpikeTrain(np.array([1., 2., 3., 4., 5., 6.]), 'test')
starts = [0.1]
stops = [1.5, 6.]
with pytest.raises(ValueError) as excinfo:
sliced_spikes = spikes.time_slice(starts, stops)
assert str(
excinfo.value) == "must have same number of start and stop times"
def test_neurons_slicing_mult():
spikes = np.array([
nept.SpikeTrain(np.array([0.5]), 'test'),
nept.SpikeTrain(np.array([1.5]), 'test'),
nept.SpikeTrain(np.array([2.5]), 'test')
])
tuning = np.array([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 1., 0.]])
neurons = nept.Neurons(spikes, tuning)
t_starts = [0.0, 2.0]
t_stops = [1.0, 3.0]
sliced_neurons = neurons.time_slice(t_starts, t_stops)
assert np.allclose(sliced_neurons.spikes[0].time, np.array([0.5]))
assert np.allclose(sliced_neurons.spikes[1].time, np.array([]))
assert np.allclose(sliced_neurons.spikes[2].time, np.array([2.5]))
assert np.allclose(neurons.tuning_curves, tuning)
def test_bin_spikes_no_window():
spikes = np.hstack((np.arange(0, 10, 1.4), np.arange(0.2, 5, 0.3)))
spikes = [nept.SpikeTrain(np.sort(spikes), 'test')]
counts = nept.bin_spikes(spikes,
0.0,
10.0,
dt=4.,
gaussian_std=None,
normalized=False)
assert np.allclose(counts.data, np.array([[16.], [6.]]))
def test_bin_spikes_actual():
spikes = [nept.SpikeTrain([0.8, 1.1, 1.2, 1.2, 2.1, 3.1])]
counts = nept.bin_spikes(spikes,
0.0,
4.0,
dt=0.5,
window=2.,
gaussian_std=None,
normalized=False)
assert np.allclose(counts.data,
np.array([[1.], [4.], [4.], [5.], [4.], [2.], [2.]]))
def test_spiketrain_time_slice():
spikes_a = nept.SpikeTrain(np.arange(1, 100, 5), 'test')
spikes_b = nept.SpikeTrain(np.arange(24, 62, 1), 'test')
spikes_c = nept.SpikeTrain(
np.hstack((np.arange(0, 24, 3), np.arange(61, 100, 3))), 'test')
t_start = 25.
t_stop = 60.
sliced_spikes_a = spikes_a.time_slice(t_start, t_stop)
sliced_spikes_b = spikes_b.time_slice(t_start, t_stop)
sliced_spikes_c = spikes_c.time_slice(t_start, t_stop)
assert np.allclose(sliced_spikes_a.time,
np.array([26, 31, 36, 41, 46, 51, 56]))
assert np.allclose(
sliced_spikes_b.time,
np.array([
25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60
]))
assert np.allclose(sliced_spikes_c.time, np.array([]))
def test_bin_spikes_normalized():
spikes = [nept.SpikeTrain([0.8, 1.1, 1.2, 1.2, 2.1, 3.1])]
counts = nept.bin_spikes(spikes,
0.0,
4.0,
dt=0.5,
window=2.,
gaussian_std=None,
normalized=True)
assert np.allclose(
counts.data, np.array([[0.25], [1.], [1.], [1.25], [1.], [0.5],
[0.5]]))
def get_spiketrain(spike_times, label):
"""Converts spike times to nept.SpikeTrain.
Parameters
----------
spike_times: np.array
label: str
Returns
-------
spiketrain: nept.SpikeTrain
"""
return nept.SpikeTrain(spike_times, label)
def test_tuning_curve_1d_with_2d_position():
position = nept.Position(
np.hstack([
np.array([2, 4, 6, 8])[..., np.newaxis],
np.array([7, 5, 3, 1])[..., np.newaxis]
]), np.array([0., 1., 2., 3.]))
binsize = 2
spikes = [nept.SpikeTrain(np.array([0., 3., 3., 3.]), 'test')]
with pytest.raises(ValueError) as excinfo:
nept.tuning_curve_1d(position, spikes, binsize=binsize)
assert str(excinfo.value) == 'position must be linear'
