def setUp(self):
folder = os.path.dirname(os.path.realpath(__file__))
time = np.load(os.path.join(folder, "data/t_test.npy"))
V = np.load(os.path.join(folder, "data/U_test.npy"))
self.implemented_features = [
"nr_spikes", "time_before_first_spike", "spike_rate",
"average_AP_overshoot", "average_AHP_depth", "average_AP_width",
"accommodation_index"
]
self.implemented_labels = {
"nr_spikes": ["Number of spikes"],
"spike_rate": ["Spike rate (Hz)"],
"time_before_first_spike": ["Time (ms)"],
"accommodation_index": ["Accommodation index"],
"average_AP_overshoot": ["Voltage (mV)"],
"average_AHP_depth": ["Voltage (mV)"],
"average_AP_width": ["Time (ms)"]
}
self.features = SpikingFeatures(verbose_level="error")
self.info = {"stimulus_start": time[0], "stimulus_end": time[-1]}
self.time, self.spikes, info = self.features.preprocess(
time, V, self.info)
def test_calculate_all_features_normalize(self):
self.features = SpikingFeatures(logger_level="error", threshold=0.4, end_threshold=-0.1)
self.info = {"stimulus_start": self.t[0], "stimulus_end": self.t[-1]}
self.time, self.spikes, info = self.features.preprocess(self.t, self.V, self.info)
result = self.features.calculate_all_features(self.t, self.V, self.info)
self.assertEqual(set(result.keys()),
set(self.implemented_features))
def test_feature_functions_base(self):
def feature_function(time, values):
return "time", "values"
def feature_function2(time, values):
return "time2", "values2"
implemented_features = [
"nr_spikes", "time_before_first_spike", "spike_rate",
"average_AP_overshoot", "average_AHP_depth", "average_AP_width",
"accommodation_index"
]
self.runmodel.features = SpikingFeatures(
[feature_function, feature_function2])
self.assertIsInstance(self.runmodel.features, SpikingFeatures)
time, values = self.runmodel.features.feature_function(None, None)
self.assertEqual(time, "time")
self.assertEqual(values, "values")
time, values = self.runmodel.features.feature_function2(None, None)
self.assertEqual(time, "time2")
self.assertEqual(values, "values2")
self.assertEqual(
set(self.runmodel.features.features_to_run),
set(["feature_function", "feature_function2"] +
implemented_features))
def test_initLabels(self):
features = SpikingFeatures(labels={"nr_spikes": ["changed"],
"new": ["new"]},
logger_level="error")
labels = {"nr_spikes": ["changed"],
"new": ["new"],
"spike_rate": ["Spike rate (1/ms)"],
"time_before_first_spike": ["Time (ms)"],
"accommodation_index": ["Accommodation index"],
"average_AP_overshoot": ["Voltage (mV)"],
"average_AHP_depth": ["Voltage (mV)"],
"average_AP_width": ["Time (ms)"],
"average_duration": ["Time (ms)"]
}
self.assertEqual(features.labels, labels)
def test_adaptive_all(self):
features = SpikingFeatures(adaptive="all")
self.assertEqual(set(features.adaptive),
set(self.implemented_features))
def test_features_to_run_all(self):
features = SpikingFeatures(features_to_run="all")
self.assertEqual(set(features.features_to_run),
set(self.implemented_features))
def test_initNone(self):
self.features = SpikingFeatures()
self.assertIsInstance(self.features, SpikingFeatures)
self.assertIsNone(self.features.spikes)
class TestSpikingFeatures(unittest.TestCase):
def setUp(self):
folder = os.path.dirname(os.path.realpath(__file__))
time = np.load(os.path.join(folder, "data/t_test.npy"))
V = np.load(os.path.join(folder, "data/U_test.npy"))
self.implemented_features = [
"nr_spikes", "time_before_first_spike", "spike_rate",
"average_AP_overshoot", "average_AHP_depth", "average_AP_width",
"accommodation_index"
]
self.implemented_labels = {
"nr_spikes": ["Number of spikes"],
"spike_rate": ["Spike rate (Hz)"],
"time_before_first_spike": ["Time (ms)"],
"accommodation_index": ["Accommodation index"],
"average_AP_overshoot": ["Voltage (mV)"],
"average_AHP_depth": ["Voltage (mV)"],
"average_AP_width": ["Time (ms)"]
}
self.features = SpikingFeatures(verbose_level="error")
self.info = {"stimulus_start": time[0], "stimulus_end": time[-1]}
self.time, self.spikes, info = self.features.preprocess(
time, V, self.info)
def test_initNone(self):
self.features = SpikingFeatures()
self.assertIsInstance(self.features, SpikingFeatures)
self.assertIsNone(self.features.spikes)
def test_init(self):
self.assertIsInstance(self.features, SpikingFeatures)
self.assertIsNotNone(self.features.spikes)
self.assertEqual(self.features.spikes.nr_spikes, 12)
self.assertEqual(self.features.labels, self.implemented_labels)
def test_initLabels(self):
features = SpikingFeatures(labels={
"nr_spikes": ["changed"],
"new": ["new"]
})
labels = {
"nr_spikes": ["changed"],
"new": ["new"],
"spike_rate": ["Spike rate (Hz)"],
"time_before_first_spike": ["Time (ms)"],
"accommodation_index": ["Accommodation index"],
"average_AP_overshoot": ["Voltage (mV)"],
"average_AHP_depth": ["Voltage (mV)"],
"average_AP_width": ["Time (ms)"]
}
self.assertEqual(features.labels, labels)
def test_features_to_run_all(self):
features = SpikingFeatures(features_to_run="all")
self.assertEqual(set(features.features_to_run),
set(self.implemented_features))
def test_adaptive_all(self):
features = SpikingFeatures(adaptive="all")
self.assertEqual(set(features.adaptive),
set(self.implemented_features))
def test_implemented_features(self):
self.assertEqual(set(self.features.implemented_features()),
set(self.implemented_features))
def test_nr_spikes(self):
self.assertEqual(
self.features.nr_spikes(self.time, self.spikes, self.info),
(None, 12))
def test_nr_spikes_no_stimulus(self):
info = {"stimulus_start": -2, "stimulus_end": -1}
self.assertEqual(self.features.nr_spikes(self.time, self.spikes, info),
(None, 0))
def test_nr_spikes_error(self):
self.features.strict = True
with self.assertRaises(ValueError):
self.features.nr_spikes(self.time, self.spikes, {})
self.features.nr_spikes(self.time, self.spikes,
{"stimulus_start": 1})
self.features.nr_spikes(self.time, self.spikes,
{"stimulus_end": 1})
self.features.nr_spikes(self.time, self.spikes, {
"stimulus_end": 1,
"stimulus_start": -1
})
def test_time_before_first_spike(self):
self.assertGreater(
self.features.time_before_first_spike(self.time, self.spikes,
self.info)[1], 10)
def test_time_before_first_spikeNone(self):
self.features.spikes.nr_spikes = 0
self.assertEqual(
self.features.time_before_first_spike(self.time, self.spikes,
self.info), (None, None))
def test_time_before_first_spike_no_strict(self):
self.features.strict = False
self.features.spikes.nr_spikes = 0
self.assertEqual(
self.features.time_before_first_spike(self.time, self.spikes, {}),
(None, None))
def test_time_before_first_spike_error(self):
with self.assertRaises(ValueError):
self.features.time_before_first_spike(self.time, self.spikes, {})
self.features.time_before_first_spike(self.time, self.spikes,
{"stimulus_end": 1})
def test_spike_rate(self):
self.assertEqual(
self.features.spike_rate(self.time, self.spikes, self.info),
(None, 0.12))
def test_spike_rate_no_strict(self):
self.features.strict = False
self.assertEqual(self.features.spike_rate(self.time, self.spikes, {}),
(None, 0.12))
def test_spike_rateNone(self):
self.features.spikes.nr_spikes = -1
self.assertEqual(
self.features.spike_rate(self.time, self.spikes, self.info),
(None, None))
def test_spike_rate_error(self):
with self.assertRaises(ValueError):
self.features.spike_rate(self.time, self.spikes, {})
self.features.spike_rate(self.time, self.spikes,
{"stimulus_start": 1})
self.features.spike_rate(self.time, self.spikes,
{"stimulus_end": 1})
self.features.spike_rate(self.time, self.spikes, {
"stimulus_end": 1,
"stimulus_start": -1
})
def test_average_AP_overshoot(self):
self.assertEqual(
self.features.average_AP_overshoot(self.time, self.spikes,
self.info), (None, 30))
def test_average_AP_overshootNone(self):
self.features.spikes.nr_spikes = 0
self.assertEqual(
self.features.average_AP_overshoot(self.time, self.spikes,
self.info), (None, None))
# TODO Find correct testime, this is a rough bound only
def test_average_AHP_depth(self):
self.features.average_AHP_depth(self.time, self.spikes, self.info)
self.assertLess(
self.features.average_AHP_depth(self.time, self.spikes,
self.info)[1], 0)
def test_average_AHP_depthNone(self):
self.features.spikes.nr_spikes = 0
self.assertEqual(
self.features.average_AHP_depth(self.time, self.spikes, self.info),
(None, None))
# TODO Find correct testime, this is a rough bound only
def test_average_AP_width(self):
self.assertLess(
self.features.average_AP_width(self.time, self.spikes,
self.info)[1], 5)
def test_average_AP_widthNone(self):
self.features.spikes.nr_spikes = 0
self.assertEqual(
self.features.average_AP_width(self.time, self.spikes, self.info),
(None, None))
# TODO Find correct testime, this is a rough bound only
def test_accommodation_index(self):
self.assertIsNotNone(
self.features.accommodation_index(self.time, self.spikes,
self.info)[1])
def test_accommodation_indexNone(self):
self.features.spikes.nr_spikes = 0
self.assertEqual(
self.features.accommodation_index(self.time, self.spikes,
self.info), (None, None))
def test_calculate_all_features(self):
result = self.features.calculate_all_features(self.time, self.spikes,
self.info)
self.assertEqual(set(result.keys()), set(self.implemented_features))
def test_reference_feature(self):
time, values = self.features.reference_feature(1, 1, 1)
self.assertIsNone(time)
self.assertIsNone(values)
def test_interpolate_all(self):
features = SpikingFeatures(interpolate="all", logger_level="error")
self.assertEqual(set(features.interpolate),
set(self.implemented_features))
def test_initNone(self):
self.features = SpikingFeatures(logger_level="error")
self.assertIsInstance(self.features, SpikingFeatures)
self.assertIsNone(self.features.spikes)
