Merge pull request #3724 from alejoe91/fix-3723

alejoe91 · web-flow · commit f2dd3292c134 · 2025-03-07T18:11:18.000+01:00
Renaming: `from_time_labels` -&gt; `from_samples_and_labels`
diff --git a/doc/how_to/load_your_data_into_sorting.rst b/doc/how_to/load_your_data_into_sorting.rst
@@ -65,8 +65,8 @@ the requested unit_ids).
 
     # in this case we are making a monosegment sorting
     # we have four spikes that are spread among two neurons
-    my_sorting = NumpySorting.from_times_labels(
-        times_list=[
+    my_sorting = NumpySorting.from_samples_and_labels(
+        samples_list=[
             np.array([1000,12000,15000,22000])   # Note these are samples/frames not times in seconds
             ],
         labels_list=[
@@ -120,7 +120,7 @@ Loading multisegment data into a :code:`Sorting`
 One of the great advantages of SpikeInterface :code:`Sorting` objects is that they can also handle
 multisegment recordings and sortings (e.g. you have a baseline, stimulus, post-stimulus). The
 exact same machinery can be used to generate your sorting, but in this case we do a list of arrays instead of
-a single list. Let's go through one example for using :code:`from_times_labels`:
+a single list. Let's go through one example for using :code:`from_samples_and_labels`:
 
 .. code-block:: python
 
@@ -130,8 +130,8 @@ a single list. Let's go through one example for using :code:`from_times_labels`:
     # in this case we are making three-segment sorting
     # we have four spikes that are spread among two neurons
     # in each segment
-    my_sorting = NumpySorting.from_times_labels(
-        times_list=[
+    my_sorting = NumpySorting.from_samples_and_labels(
+        samples_list=[
             np.array([1000,12000,15000,22000]),
             np.array([30000,33000, 41000, 47000]),
             np.array([50000,53000,64000,70000]),
diff --git a/doc/modules/core.rst b/doc/modules/core.rst
@@ -711,8 +711,13 @@ In this example, we create a recording and a sorting object from numpy objects:
         spike_trains += spike_trains_i
         labels += labels_i
 
-    sorting_memory = NumpySorting.from_times_labels(times=spike_trains, labels=labels,
-                                                    sampling_frequency=sampling_frequency)
+    # construct a mono-segment
+    samples_list = [np.array(spike_trains)]
+    labels_list = [np.array(labels)]
+
+    sorting_memory = NumpySorting.from_samples_and_labels(
+        samples_list=samples_list, labels_list=labels_list, sampling_frequency=sampling_frequency
+    )
 
 
 Any sorting object can be transformed into a :py:class:`~spikeinterface.core.NumpySorting` or
diff --git a/examples/tutorials/core/plot_2_sorting_extractor.py b/examples/tutorials/core/plot_2_sorting_extractor.py
@@ -40,7 +40,7 @@
 ##############################################################################
 # And instantiate a :py:class:`~spikeinterface.core.NumpySorting` object:
 
-sorting = se.NumpySorting.from_times_labels([times0, times1], [labels0, labels1], sampling_frequency)
+sorting = se.NumpySorting.from_samples_and_labels([times0, times1], [labels0, labels1], sampling_frequency)
 print(sorting)
 
 ##############################################################################
diff --git a/src/spikeinterface/benchmark/benchmark_clustering.py b/src/spikeinterface/benchmark/benchmark_clustering.py
@@ -60,7 +60,7 @@ def compute_result(self, **result_params):
 
         self.result["sliced_gt_sorting"].set_property("gt_unit_locations", gt_unit_locations)
 
-        self.result["clustering"] = NumpySorting.from_times_labels(
+        self.result["clustering"] = NumpySorting.from_samples_and_labels(
             data["sample_index"], self.result["peak_labels"][~self.noise], self.recording.sampling_frequency
         )
 
diff --git a/src/spikeinterface/benchmark/benchmark_peak_selection.py b/src/spikeinterface/benchmark/benchmark_peak_selection.py
@@ -160,7 +160,7 @@ def create_benchmark(self, key):
 #         nb_garbage = len(garbage_peaks)
 
 #         ratio = 100 * len(garbage_peaks) / len(times2)
-#         self.garbage_sorting = NumpySorting.from_times_labels(garbage_peaks, garbage_channels, self.sampling_rate)
+#         self.garbage_sorting = NumpySorting.from_samples_and_labels(garbage_peaks, garbage_channels, self.sampling_rate)
 
 #         print("The peaks have {0:.2f}% of garbage (without gt around)".format(ratio))
 
diff --git a/src/spikeinterface/comparison/tests/test_comparisontools.py b/src/spikeinterface/comparison/tests/test_comparisontools.py
@@ -20,8 +20,8 @@
 
 def make_sorting(times1, labels1, times2, labels2):
     sampling_frequency = 30000.0
-    sorting1 = NumpySorting.from_times_labels([times1], [labels1], sampling_frequency)
-    sorting2 = NumpySorting.from_times_labels([times2], [labels2], sampling_frequency)
+    sorting1 = NumpySorting.from_samples_and_labels([times1], [labels1], sampling_frequency)
+    sorting2 = NumpySorting.from_samples_and_labels([times2], [labels2], sampling_frequency)
     return sorting1, sorting2
 
 
diff --git a/src/spikeinterface/comparison/tests/test_groundtruthcomparison.py b/src/spikeinterface/comparison/tests/test_groundtruthcomparison.py
@@ -8,8 +8,8 @@
 
 def make_sorting(times1, labels1, times2, labels2):
     sampling_frequency = 30000.0
-    gt_sorting = NumpySorting.from_times_labels([times1], [labels1], sampling_frequency)
-    tested_sorting = NumpySorting.from_times_labels([times2], [labels2], sampling_frequency)
+    gt_sorting = NumpySorting.from_samples_and_labels([times1], [labels1], sampling_frequency)
+    tested_sorting = NumpySorting.from_samples_and_labels([times2], [labels2], sampling_frequency)
     return gt_sorting, tested_sorting
 
 
diff --git a/src/spikeinterface/comparison/tests/test_multisortingcomparison.py b/src/spikeinterface/comparison/tests/test_multisortingcomparison.py
@@ -19,9 +19,9 @@ def setup_module(tmp_path_factory):
 
 def make_sorting(times1, labels1, times2, labels2, times3, labels3):
     sampling_frequency = 30000.0
-    sorting1 = NumpySorting.from_times_labels([times1], [labels1], sampling_frequency)
-    sorting2 = NumpySorting.from_times_labels([times2], [labels2], sampling_frequency)
-    sorting3 = NumpySorting.from_times_labels([times3], [labels3], sampling_frequency)
+    sorting1 = NumpySorting.from_samples_and_labels([times1], [labels1], sampling_frequency)
+    sorting2 = NumpySorting.from_samples_and_labels([times2], [labels2], sampling_frequency)
+    sorting3 = NumpySorting.from_samples_and_labels([times3], [labels3], sampling_frequency)
     sorting1 = sorting1.save()
     sorting2 = sorting2.save()
     sorting3 = sorting3.save()
diff --git a/src/spikeinterface/comparison/tests/test_symmetricsortingcomparison.py b/src/spikeinterface/comparison/tests/test_symmetricsortingcomparison.py
@@ -7,8 +7,8 @@
 
 def make_sorting(times1, labels1, times2, labels2):
     sampling_frequency = 30000.0
-    sorting1 = NumpySorting.from_times_labels([times1], [labels1], sampling_frequency)
-    sorting2 = NumpySorting.from_times_labels([times2], [labels2], sampling_frequency)
+    sorting1 = NumpySorting.from_samples_and_labels([times1], [labels1], sampling_frequency)
+    sorting2 = NumpySorting.from_samples_and_labels([times2], [labels2], sampling_frequency)
     return sorting1, sorting2
 
 
diff --git a/src/spikeinterface/core/generate.py b/src/spikeinterface/core/generate.py
@@ -509,7 +509,7 @@ def add_from_unit_dict(
         return sorting
 
     @staticmethod
-    def from_times_labels(
+    def from_samples_and_labels(
         sorting1, times_list, labels_list, sampling_frequency, unit_ids=None, refractory_period_ms=None
     ) -> "NumpySorting":
         """
@@ -537,7 +537,7 @@ def from_times_labels(
             discarded.
         """
 
-        sorting2 = NumpySorting.from_times_labels(times_list, labels_list, sampling_frequency, unit_ids)
+        sorting2 = NumpySorting.from_samples_and_labels(times_list, labels_list, sampling_frequency, unit_ids)
         sorting = TransformSorting.add_from_sorting(sorting1, sorting2, refractory_period_ms)
         return sorting
 
diff --git a/src/spikeinterface/core/numpyextractors.py b/src/spikeinterface/core/numpyextractors.py
@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import warnings
 import numpy as np
 from spikeinterface.core import (
     BaseRecording,
@@ -236,7 +237,8 @@ class NumpySorting(BaseSorting):
 
     But we have convenient class methods to instantiate from:
       * other sorting object: `NumpySorting.from_sorting()`
-      * from time+labels: `NumpySorting.from_times_labels()`
+      * from samples+labels: `NumpySorting.from_samples_and_labels()`
+      * from times+labels: `NumpySorting.from_times_and_labels()`
       * from dict of list: `NumpySorting.from_unit_dict()`
       * from neo: `NumpySorting.from_neo_spiketrain_list()`
 
@@ -287,40 +289,40 @@ def from_sorting(source_sorting: BaseSorting, with_metadata=False, copy_spike_ve
         return sorting
 
     @staticmethod
-    def from_times_labels(times_list, labels_list, sampling_frequency, unit_ids=None) -> "NumpySorting":
+    def from_samples_and_labels(samples_list, labels_list, sampling_frequency, unit_ids=None) -> "NumpySorting":
         """
         Construct NumpySorting extractor from:
-          * an array of spike times (in frames)
-          * an array of spike labels and adds all the
+          * an array of spike samples
+          * an array of spike labels
         In case of multisegment, it is a list of array.
 
         Parameters
         ----------
-        times_list : list of array (or array)
-            An array of spike times (in frames)
+        samples_list : list of array (or array)
+            An array of spike samples
         labels_list : list of array (or array)
             An array of spike labels corresponding to the given times
         unit_ids : list or None, default: None
             The explicit list of unit_ids that should be extracted from labels_list
             If None, then it will be np.unique(labels_list)
         """
 
-        if isinstance(times_list, np.ndarray):
+        if isinstance(samples_list, np.ndarray):
             assert isinstance(labels_list, np.ndarray)
-            times_list = [times_list]
+            samples_list = [samples_list]
             labels_list = [labels_list]
 
-        times_list = [np.asarray(e) for e in times_list]
+        samples_list = [np.asarray(e) for e in samples_list]
         labels_list = [np.asarray(e) for e in labels_list]
 
-        nseg = len(times_list)
+        nseg = len(samples_list)
 
         if unit_ids is None:
             unit_ids = np.unique(np.concatenate([np.unique(labels_list[i]) for i in range(nseg)]))
 
         spikes = []
         for i in range(nseg):
-            times, labels = times_list[i], labels_list[i]
+            times, labels = samples_list[i], labels_list[i]
             unit_index = np.zeros(labels.size, dtype="int64")
             for u, unit_id in enumerate(unit_ids):
                 unit_index[labels == unit_id] = u
@@ -337,6 +339,41 @@ def from_times_labels(times_list, labels_list, sampling_frequency, unit_ids=None
 
         return sorting
 
+    @staticmethod
+    def from_times_and_labels(times_list, labels_list, sampling_frequency, unit_ids=None) -> "NumpySorting":
+        """
+        Construct NumpySorting extractor from:
+          * an array of spike times (in s)
+          * an array of spike labels
+        In case of multisegment, it is a list of array.
+
+        Parameters
+        ----------
+        times_list : list of array (or array)
+            An array of spike samples
+        labels_list : list of array (or array)
+            An array of spike labels corresponding to the given times
+        unit_ids : list or None, default: None
+            The explicit list of unit_ids that should be extracted from labels_list
+            If None, then it will be np.unique(labels_list)
+        """
+        if isinstance(times_list, np.ndarray):
+            assert isinstance(labels_list, np.ndarray)
+            times_list = [times_list]
+            labels_list = [labels_list]
+
+        sample_list = [np.round(t * sampling_frequency).astype("int64") for t in times_list]
+        return NumpySorting.from_samples_and_labels(sample_list, labels_list, sampling_frequency, unit_ids)
+
+    @staticmethod
+    def from_times_labels(times_list, labels_list, sampling_frequency, unit_ids=None) -> "NumpySorting":
+        warnings.warn(
+            "from_times_labels is deprecated and will be removed in 0.104.0, use from_sample_and_labels instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return NumpySorting.from_times_and_labels(times_list, labels_list, sampling_frequency, unit_ids)
+
     @staticmethod
     def from_unit_dict(units_dict_list, sampling_frequency) -> "NumpySorting":
         """
diff --git a/src/spikeinterface/core/tests/test_numpy_extractors.py b/src/spikeinterface/core/tests/test_numpy_extractors.py
@@ -2,7 +2,6 @@
 import numpy as np
 
 from spikeinterface.core import (
-    BaseRecording,
     NumpyRecording,
     SharedMemoryRecording,
     NumpySorting,
@@ -15,6 +14,7 @@
 )
 
 from spikeinterface.core.basesorting import minimum_spike_dtype
+from spikeinterface.core.testing import check_sortings_equal
 
 
 @pytest.fixture(scope="module")
@@ -61,16 +61,20 @@ def test_NumpySorting(setup_NumpyRecording):
     # print(sorting)
 
     # 2 columns
-    times = np.arange(0, 1000, 10)
-    labels = np.zeros(times.size, dtype="int64")
+    samples = np.arange(0, 1000, 10)
+    labels = np.zeros(samples.size, dtype="int64")
     labels[0::3] = 0
     labels[1::3] = 1
     labels[2::3] = 2
-    sorting = NumpySorting.from_times_labels(times, labels, sampling_frequency)
+    sorting = NumpySorting.from_samples_and_labels(samples, labels, sampling_frequency)
     # print(sorting)
     assert sorting.get_num_segments() == 1
 
-    sorting = NumpySorting.from_times_labels([times] * 3, [labels] * 3, sampling_frequency)
+    times = samples / sampling_frequency
+    sorting_from_times = NumpySorting.from_times_and_labels(times, labels, sampling_frequency)
+    check_sortings_equal(sorting, sorting_from_times)
+
+    sorting = NumpySorting.from_samples_and_labels([samples] * 3, [labels] * 3, sampling_frequency)
     # print(sorting)
     assert sorting.get_num_segments() == 3
 
diff --git a/src/spikeinterface/core/tests/test_segmentutils.py b/src/spikeinterface/core/tests/test_segmentutils.py
@@ -109,17 +109,17 @@ def test_append_concatenate_sortings():
     labels1[2::3] = 2
 
     # Multisegment sortings
-    sorting0 = NumpySorting.from_times_labels([times0] * 3, [labels0] * 3, sampling_frequency)
-    sorting1 = NumpySorting.from_times_labels([times1] * 2, [labels1] * 2, sampling_frequency)
+    sorting0 = NumpySorting.from_samples_and_labels([times0] * 3, [labels0] * 3, sampling_frequency)
+    sorting1 = NumpySorting.from_samples_and_labels([times1] * 2, [labels1] * 2, sampling_frequency)
     sorting_list = [sorting0, sorting1]
     # Associated multisegment recordings
     traces0 = np.zeros((nsamp0, 5), dtype="float64")
     traces1 = np.zeros((nsamp1, 5), dtype="float64")
     rec0 = NumpyRecording([traces0] * 3, sampling_frequency)
     rec1 = NumpyRecording([traces1] * 2, sampling_frequency)
     # Monosegemnt sortings
-    sorting0_mono = NumpySorting.from_times_labels([times0], [labels0], sampling_frequency)
-    sorting1_mono = NumpySorting.from_times_labels([times1], [labels1], sampling_frequency)
+    sorting0_mono = NumpySorting.from_samples_and_labels([times0], [labels0], sampling_frequency)
+    sorting1_mono = NumpySorting.from_samples_and_labels([times1], [labels1], sampling_frequency)
     sorting_list_mono = [sorting0_mono, sorting1_mono]
     # Associated multisegment recordings
     traces0 = np.zeros((nsamp0, 5), dtype="float64")
@@ -266,8 +266,8 @@ def test_append_concatenate_sortings():
     assert np.array_equal(sorting.get_unit_spike_train(unit_id=0, return_times=True), unit_0_train / sampling_frequency)
 
     # Time conversion with non-trivial t_start/time_vector
-    sorting0 = NumpySorting.from_times_labels([[0, 1]], [[0, 0]], sampling_frequency)
-    sorting1 = NumpySorting.from_times_labels([[0, 1]], [[0, 0]], sampling_frequency)
+    sorting0 = NumpySorting.from_samples_and_labels([[0, 1]], [[0, 0]], sampling_frequency)
+    sorting1 = NumpySorting.from_samples_and_labels([[0, 1]], [[0, 0]], sampling_frequency)
     traces = np.zeros((2, 5), dtype="float64")
     rec0 = NumpyRecording([traces], sampling_frequency)
     rec1 = NumpyRecording([traces], sampling_frequency)
diff --git a/src/spikeinterface/core/tests/test_sorting_tools.py b/src/spikeinterface/core/tests/test_sorting_tools.py
@@ -84,7 +84,9 @@ def test_apply_merges_to_sorting():
     labels = np.array(["a", "b", "c", "a", "b"])
 
     # unit_ids str
-    sorting1 = NumpySorting.from_times_labels([times, times], [labels, labels], 10_000.0, unit_ids=["a", "b", "c"])
+    sorting1 = NumpySorting.from_samples_and_labels(
+        [times, times], [labels, labels], 10_000.0, unit_ids=["a", "b", "c"]
+    )
     spikes1 = sorting1.to_spike_vector()
 
     sorting2 = apply_merges_to_sorting(sorting1, [["a", "b"]], censor_ms=None)
@@ -104,12 +106,14 @@ def test_apply_merges_to_sorting():
     assert st.size == 3  # one spike is removed by censor period
 
     # unit_ids int
-    sorting1 = NumpySorting.from_times_labels([times, times], [labels, labels], 10_000.0, unit_ids=[10, 20, 30])
+    sorting1 = NumpySorting.from_samples_and_labels([times, times], [labels, labels], 10_000.0, unit_ids=[10, 20, 30])
     spikes1 = sorting1.to_spike_vector()
     sorting2 = apply_merges_to_sorting(sorting1, [[10, 20]], censor_ms=None)
     assert np.array_equal(sorting2.unit_ids, [30, 31])
 
-    sorting1 = NumpySorting.from_times_labels([times, times], [labels, labels], 10_000.0, unit_ids=["a", "b", "c"])
+    sorting1 = NumpySorting.from_samples_and_labels(
+        [times, times], [labels, labels], 10_000.0, unit_ids=["a", "b", "c"]
+    )
     sorting2 = apply_merges_to_sorting(sorting1, [["a", "b"]], censor_ms=None, new_id_strategy="take_first")
     assert np.array_equal(sorting2.unit_ids, ["a", "c"])
 
diff --git a/src/spikeinterface/curation/tests/test_remove_excess_spikes.py b/src/spikeinterface/curation/tests/test_remove_excess_spikes.py
@@ -38,7 +38,7 @@ def test_remove_excess_spikes():
         times.append(times_segment)
         labels.append(labels_segment)
 
-    sorting = NumpySorting.from_times_labels(times, labels, sampling_frequency=sampling_frequency)
+    sorting = NumpySorting.from_samples_and_labels(times, labels, sampling_frequency=sampling_frequency)
     assert has_exceeding_spikes(sorting, recording)
 
     sorting_corrected = remove_excess_spikes(sorting, recording)
diff --git a/src/spikeinterface/curation/tests/test_sortingview_curation.py b/src/spikeinterface/curation/tests/test_sortingview_curation.py
@@ -149,7 +149,7 @@ def test_false_positive_curation():
     times = np.int_(np.sort(np.random.uniform(0, num_timepoints, num_spikes)))
     labels = np.random.randint(1, num_units + 1, size=num_spikes)
 
-    sorting = se.NumpySorting.from_times_labels(times, labels, sampling_frequency)
+    sorting = se.NumpySorting.from_samples_and_labels(times, labels, sampling_frequency)
     # print("Sorting: {}".format(sorting.get_unit_ids()))
 
     json_file = parent_folder / "sv-sorting-curation-false-positive.json"
@@ -175,7 +175,7 @@ def test_label_inheritance_int():
     times = np.int_(np.sort(np.random.uniform(0, num_timepoints, num_spikes)))
     labels = np.random.randint(1, 1 + num_units, size=num_spikes)  # 7 units: 1 to 7
 
-    sorting = se.NumpySorting.from_times_labels(times, labels, sampling_frequency)
+    sorting = se.NumpySorting.from_samples_and_labels(times, labels, sampling_frequency)
 
     json_file = parent_folder / "sv-sorting-curation-int.json"
     sorting_merge = apply_sortingview_curation(sorting, uri_or_json=json_file)
@@ -217,7 +217,7 @@ def test_label_inheritance_str():
     times = np.int_(np.sort(np.random.uniform(0, num_timepoints, num_spikes)))
     labels = np.random.choice(["a", "b", "c", "d", "e", "f", "g"], size=num_spikes)
 
-    sorting = se.NumpySorting.from_times_labels(times, labels, sampling_frequency)
+    sorting = se.NumpySorting.from_samples_and_labels(times, labels, sampling_frequency)
     # print(f"Sorting: {sorting.get_unit_ids()}")
 
     # Apply curation
diff --git a/src/spikeinterface/extractors/toy_example.py b/src/spikeinterface/extractors/toy_example.py
@@ -135,7 +135,7 @@ def toy_example(
         assert isinstance(spike_labels, list)
         assert len(spike_times) == len(spike_labels)
         assert len(spike_times) == num_segments
-        sorting = NumpySorting.from_times_labels(spike_times, spike_labels, sampling_frequency, unit_ids=unit_ids)
+        sorting = NumpySorting.from_samples_and_labels(spike_times, spike_labels, sampling_frequency, unit_ids=unit_ids)
     else:
         sorting = generate_sorting(
             num_units=num_units,
diff --git a/src/spikeinterface/postprocessing/tests/test_correlograms.py b/src/spikeinterface/postprocessing/tests/test_correlograms.py
diff --git a/src/spikeinterface/preprocessing/remove_artifacts.py b/src/spikeinterface/preprocessing/remove_artifacts.py
diff --git a/src/spikeinterface/qualitymetrics/tests/test_metrics_functions.py b/src/spikeinterface/qualitymetrics/tests/test_metrics_functions.py
diff --git a/src/spikeinterface/sorters/internal/simplesorter.py b/src/spikeinterface/sorters/internal/simplesorter.py
diff --git a/src/spikeinterface/sorters/internal/tridesclous2.py b/src/spikeinterface/sorters/internal/tridesclous2.py
diff --git a/src/spikeinterface/sortingcomponents/clustering/position_and_features.py b/src/spikeinterface/sortingcomponents/clustering/position_and_features.py
diff --git a/src/spikeinterface/sortingcomponents/tests/test_template_matching.py b/src/spikeinterface/sortingcomponents/tests/test_template_matching.py

Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ def compute_result(self, **result_params):`
`60`	`60`
`61`	`61`	`self.result["sliced_gt_sorting"].set_property("gt_unit_locations", gt_unit_locations)`
`62`	`62`
`63`		`- self.result["clustering"] = NumpySorting.from_times_labels(`
	`63`	`+ self.result["clustering"] = NumpySorting.from_samples_and_labels(`
`64`	`64`	`data["sample_index"], self.result["peak_labels"][~self.noise], self.recording.sampling_frequency`
`65`	`65`	`)`
`66`	`66`