def test_allows_use_of_different_kernel(self):
a = neo.SpikeTrain(sp.array([1.0, 2.5, 6.5]) * pq.s, t_stop=7.0 * pq.s)
b = neo.SpikeTrain(
sp.array([1.2, 5.7, 8.0, 9.0]) * pq.s, t_stop=10.0 * pq.s)
kernel = sigproc.TriangularKernel(1.0 * pq.s, normalize=False)
expected = sp.array(
[[1.0, 0.29166666666666663], [0.29166666666666663, 1.0]])
actual = stm.hunter_milton_similarity([a, b], kernel=kernel)
assert_array_almost_equal(expected, actual)
def test_returns_correct_hunter_milton_similarity(self):
a = neo.SpikeTrain(sp.array([1.0, 2.5, 6.5]) * pq.s, t_stop=7.0 * pq.s)
b = neo.SpikeTrain(
sp.array([1.2, 5.7, 8.0, 9.0]) * pq.s, t_stop=10.0 * pq.s)
c = neo.SpikeTrain(sp.array([2.1, 2.0, 5.0]) * pq.s, t_stop=10.0 * pq.s)
tau = 2.0 * pq.s
expected = sp.array(
[[1.0, 0.64128747518120299, 0.661254342403672],
[0.64128747518120299, 1.0, 0.5521235786217787],
[0.661254342403672, 0.5521235786217787, 1.0]])
actual = stm.hunter_milton_similarity([a, b, c], tau)
assert_array_almost_equal(expected, actual)
* 'vp': :func:`Victor Purpura's distance
<.spike_train_metrics.victor_purpura_dist>` with :math:`q = 2/\\tau`
* 'vr': :func:`Van Rossum distance <.spike_train_metrics.van_rossum_dist>`
"""
import quantities as pq
import scipy as sp
import sklearn.base
import spykeutils.spike_train_metrics as stm
metric_defs = {
'es': ("Event synchronization",
lambda trains, tau: 1.0 - stm.event_synchronization(trains, tau)),
'hm': ("Hunter-Milton similarity measure",
lambda trains, tau: 1.0 - stm.hunter_milton_similarity(trains, tau)),
'vp': ("Victor-Purpura\'s distance",
lambda trains, tau: stm.victor_purpura_dist(trains, 2.0 / tau)),
'vr': ("Van Rossum distance",
lambda trains, tau: stm.van_rossum_dist(trains, tau))
}
class PrecomputedSpikeTrainMetricApplier(
sklearn.base.BaseEstimator, sklearn.base.TransformerMixin):
""" Precomputes a spike train metric on spike trains and retrieves the
corresponding Gram matrix (the matrix of all pairwise distances) for
requested sets of the initial data.
The spike trains will be passed only once to this class when constructing
it. At this point the 1D array attribute :attr:`x_in` will be created
def test_spike_trains_may_be_empty(self):
empty = create_empty_spike_train()
non_empty = neo.SpikeTrain(sp.array([1.0]) * pq.s, t_stop=3.0 * pq.s)
expected = sp.array([[1.0, 0.0], [0.0, 1.0]])
actual = stm.hunter_milton_similarity([empty, non_empty])
assert_array_almost_equal(expected, actual)
def calc_similarity(self, trains):
return stm.hunter_milton_similarity(trains)
import spykeutils.spike_train_metrics as stm
import sys
import timeit
tau = 5.0 * pq.ms
sampling_rate = 1000 * pq.Hz
metrics = {
"cs": (
r"$D_{\mathrm{CS}}$",
lambda trains: stm.cs_dist(trains, sigproc.CausalDecayingExpKernel(tau), sampling_rate),
),
"es": (r"$S_{\mathrm{ES}}$", lambda trains: stm.event_synchronization(trains, tau, sort=False)),
"hm": (r"$S_{\mathrm{HM}}$", lambda trains: stm.hunter_milton_similarity(trains, tau)),
"norm": (
r"$D_{\mathrm{ND}}$",
lambda trains: stm.norm_dist(trains, sigproc.CausalDecayingExpKernel(tau), sampling_rate),
),
"ss": (r"$S_{S}}$", lambda trains: stm.schreiber_similarity(trains, sigproc.LaplacianKernel(tau), sort=False)),
"vr": (r"$D_{\mathrm{R}}$", lambda trains: stm.van_rossum_dist(trains, tau, sort=False)),
"vp": (r"$D_{\mathrm{V}}$", lambda trains: stm.victor_purpura_dist(trains, 2.0 / tau)),
}
def print_available_metrics():
for key in metrics:
print "%s (%s)" % (key, metrics[key][0])
