spikeinterface 0.103.0__tar.gz → 0.103.2__tar.gz

{spikeinterface-0.103.0/src/spikeinterface.egg-info → spikeinterface-0.103.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spikeinterface
-Version: 0.103.0
+Version: 0.103.2
 Summary: Python toolkit for analysis, visualization, and comparison of spike sorting output
 Author-email: Alessio Buccino <alessiop.buccino@gmail.com>, Samuel Garcia <sam.garcia.die@gmail.com>
 Project-URL: homepage, https://github.com/SpikeInterface/spikeinterface
@@ -14,7 +14,7 @@ Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: OS Independent
-Requires-Python: <3.14,>=3.9
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.20; python_version < "3.13"
@@ -22,8 +22,8 @@ Requires-Dist: numpy>=2.0.0; python_version >= "3.13"
 Requires-Dist: threadpoolctl>=3.0.0
 Requires-Dist: tqdm
 Requires-Dist: zarr<3,>=2.18
-Requires-Dist: neo>=0.14.1
-Requires-Dist: probeinterface>=0.3.0
+Requires-Dist: neo>=0.14.3
+Requires-Dist: probeinterface>=0.3.1
 Requires-Dist: packaging
 Requires-Dist: pydantic
 Requires-Dist: numcodecs<0.16.0
@@ -57,7 +57,7 @@ Requires-Dist: scikit-learn; extra == "full"
 Requires-Dist: networkx; extra == "full"
 Requires-Dist: distinctipy; extra == "full"
 Requires-Dist: matplotlib>=3.6; extra == "full"
-Requires-Dist: cuda-python; platform_system != "Darwin" and extra == "full"
+Requires-Dist: cuda-python>=11.8.6; platform_system != "Darwin" and extra == "full"
 Requires-Dist: numba>=0.59; extra == "full"
 Requires-Dist: skops; extra == "full"
 Requires-Dist: huggingface_hub; extra == "full"
@@ -100,12 +100,13 @@ Requires-Dist: huggingface_hub; extra == "test"
 Requires-Dist: pytest-mock; extra == "test"
 Provides-Extra: docs
 Requires-Dist: Sphinx; extra == "docs"
+Requires-Dist: ipython; extra == "docs"
 Requires-Dist: sphinx_rtd_theme>=1.2; extra == "docs"
 Requires-Dist: sphinx-gallery; extra == "docs"
 Requires-Dist: sphinx-design; extra == "docs"
 Requires-Dist: numpydoc; extra == "docs"
-Requires-Dist: ipython; extra == "docs"
 Requires-Dist: sphinxcontrib-jquery; extra == "docs"
+Requires-Dist: autodoc_pydantic; extra == "docs"
 Requires-Dist: MEArec; extra == "docs"
 Requires-Dist: pandas; extra == "docs"
 Requires-Dist: hdbscan>=0.8.33; extra == "docs"

{spikeinterface-0.103.0 → spikeinterface-0.103.2}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "spikeinterface"
-version = "0.103.0"
+version = "0.103.2"
 authors = [
   { name="Alessio Buccino", email="alessiop.buccino@gmail.com" },
   { name="Samuel Garcia", email="sam.garcia.die@gmail.com" },
 ]
 description = "Python toolkit for analysis, visualization, and comparison of spike sorting output"
 readme = "README.md"
-requires-python = ">=3.9,<3.14"
+requires-python = ">=3.9"
 classifiers = [
     "Programming Language :: Python :: 3 :: Only",
     "License :: OSI Approved :: MIT License",
@@ -25,8 +25,8 @@ dependencies = [
     "threadpoolctl>=3.0.0",
     "tqdm",
     "zarr>=2.18,<3",
-    "neo>=0.14.1",
-    "probeinterface>=0.3.0",
+    "neo>=0.14.3",
+    "probeinterface>=0.3.1",
     "packaging",
     "pydantic",
     "numcodecs<0.16.0", # For supporting zarr < 3
@@ -100,7 +100,7 @@ full = [
     "networkx",
     "distinctipy",
     "matplotlib>=3.6", # matplotlib.colormaps
-    "cuda-python; platform_system != 'Darwin'",
+    "cuda-python>=11.8.6; platform_system != 'Darwin'",
     "numba>=0.59",
     "skops",
     "huggingface_hub"
@@ -194,12 +194,13 @@ test = [
 
 docs = [
     "Sphinx",
+    "ipython",
     "sphinx_rtd_theme>=1.2",
     "sphinx-gallery",
     "sphinx-design",
     "numpydoc",
-    "ipython",
     "sphinxcontrib-jquery",
+    "autodoc_pydantic",
 
     # for notebooks in the gallery
     "MEArec", # Use as an example

{spikeinterface-0.103.0 → spikeinterface-0.103.2}/src/spikeinterface/benchmark/benchmark_base.py

@@ -431,7 +431,7 @@ class BenchmarkStudy:
             if verbose:
                 print("### Compute result", key, "###")
             benchmark = self.benchmarks[key]
-            assert benchmark is not None
+            assert benchmark is not None, f"Benchmkark for key {key} has not been run yet!"
             benchmark.compute_result(**result_params)
             benchmark.save_result(self.folder / "results" / self.key_to_str(key))
 

{spikeinterface-0.103.0 → spikeinterface-0.103.2}/src/spikeinterface/benchmark/benchmark_clustering.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from spikeinterface.sortingcomponents.clustering import find_cluster_from_peaks
+from spikeinterface.sortingcomponents.clustering import find_clusters_from_peaks
 from spikeinterface.core import NumpySorting
 from spikeinterface.comparison import GroundTruthComparison
 from spikeinterface.widgets import (
@@ -30,8 +30,8 @@ class ClusteringBenchmark(Benchmark):
         self.result = {}
 
     def run(self, **job_kwargs):
-        labels, peak_labels = find_cluster_from_peaks(
-            self.recording, self.peaks, method=self.method, method_kwargs=self.method_kwargs, **job_kwargs
+        labels, peak_labels = find_clusters_from_peaks(
+            self.recording, self.peaks, method=self.method, method_kwargs=self.method_kwargs, job_kwargs=job_kwargs
         )
         self.result["peak_labels"] = peak_labels
 
@@ -95,6 +95,16 @@ class ClusteringBenchmark(Benchmark):
 
 
 class ClusteringStudy(BenchmarkStudy, MixinStudyUnitCount):
+    """
+    Benchmark study to compare clustering methods.
+
+    The ground truth sorting objects must be given and method outputs
+    will be compared to them.
+
+    The input of methods are the detected peaks. Because the clustering
+    can be performed on only a subset of the detected peaks, then selected peak
+    must be also given as index of all spikes.
+    """
 
     benchmark_class = ClusteringBenchmark
 
@@ -182,6 +192,11 @@ class ClusteringStudy(BenchmarkStudy, MixinStudyUnitCount):
 
         return plot_performances_vs_snr(self, **kwargs)
 
+    def plot_performances_vs_firing_rate(self, **kwargs):
+        from .benchmark_plot_tools import plot_performances_vs_firing_rate
+
+        return plot_performances_vs_firing_rate(self, **kwargs)
+
     def plot_performances_comparison(self, *args, **kwargs):
         from .benchmark_plot_tools import plot_performances_comparison
 

{spikeinterface-0.103.0 → spikeinterface-0.103.2}/src/spikeinterface/benchmark/benchmark_matching.py

@@ -21,13 +21,14 @@ class MatchingBenchmark(Benchmark):
         self.recording = recording
         self.gt_sorting = gt_sorting
         self.method = params["method"]
-        self.templates = params["method_kwargs"]["templates"]
+        # self.templates = params["method_kwargs"]["templates"]
+        self.templates = params["templates"]
         self.method_kwargs = params["method_kwargs"]
         self.result = {}
 
     def run(self, **job_kwargs):
         spikes = find_spikes_from_templates(
-            self.recording, method=self.method, method_kwargs=self.method_kwargs, **job_kwargs
+            self.recording, self.templates, method=self.method, method_kwargs=self.method_kwargs, job_kwargs=job_kwargs
         )
         unit_ids = self.templates.unit_ids
         sorting = np.zeros(spikes.size, dtype=minimum_spike_dtype)
@@ -56,6 +57,16 @@ class MatchingBenchmark(Benchmark):
 
 
 class MatchingStudy(BenchmarkStudy, MixinStudyUnitCount):
+    """
+    Benchmark study to compare template matchong methods.
+
+    The ground truth sorting objects must be given and method outputs
+    will be compared to them.
+
+    Templates must be also given. Note that the full template can be given but also
+    only a partial catalogue can be given to challenge the template matching
+    methods when catalogue is not entirely known.
+    """
 
     benchmark_class = MatchingBenchmark
 

{spikeinterface-0.103.0 → spikeinterface-0.103.2}/src/spikeinterface/benchmark/benchmark_motion_estimation.py

@@ -89,7 +89,9 @@ class MotionEstimationBenchmark(Benchmark):
         noise_levels = get_noise_levels(self.recording, return_in_uV=False, **job_kwargs)
 
         t0 = time.perf_counter()
-        peaks = detect_peaks(self.recording, noise_levels=noise_levels, **p["detect_kwargs"], **job_kwargs)
+        detect_kwargs = p["detect_kwargs"].copy()
+        detect_kwargs["noise_levels"] = noise_levels
+        peaks = detect_peaks(self.recording, method_kwargs=detect_kwargs, job_kwargs=job_kwargs)
         t1 = time.perf_counter()
         if p["select_kwargs"] is not None:
             selected_peaks = select_peaks(self.peaks, **p["select_kwargs"], **job_kwargs)
@@ -97,7 +99,9 @@ class MotionEstimationBenchmark(Benchmark):
             selected_peaks = peaks
 
         t2 = time.perf_counter()
-        peak_locations = localize_peaks(self.recording, selected_peaks, **p["localize_kwargs"], **job_kwargs)
+        peak_locations = localize_peaks(
+            self.recording, selected_peaks, method_kwargs=p["localize_kwargs"], job_kwargs=job_kwargs
+        )
         t3 = time.perf_counter()
         motion = estimate_motion(self.recording, selected_peaks, peak_locations, **p["estimate_motion_kwargs"])
         t4 = time.perf_counter()
@@ -151,6 +155,15 @@ class MotionEstimationBenchmark(Benchmark):
 
 
 class MotionEstimationStudy(BenchmarkStudy):
+    """
+    Benchmark study to compare motion estimation methods.
+
+    The ground truth displaements of all units must be known and method outputs
+    will be compared to them.
+
+    See also :py:func:`~spikeinterface.generation.generate_drifting_recording`,
+    for generation drifting recording.
+    """
 
     benchmark_class = MotionEstimationBenchmark
 
@@ -240,6 +253,8 @@ class MotionEstimationStudy(BenchmarkStudy):
 
             # ax0.set_ylim()
 
+        return fig
+
     def plot_errors(self, case_keys=None, figsize=None, lim=None):
         import matplotlib.pyplot as plt
 
@@ -305,6 +320,8 @@ class MotionEstimationStudy(BenchmarkStudy):
             if lim is not None:
                 ax.set_ylim(0, lim)
 
+        return fig
+
     def plot_summary_errors(self, case_keys=None, show_legend=True, figsize=(15, 5)):
         import matplotlib.pyplot as plt
 
@@ -368,6 +385,8 @@ class MotionEstimationStudy(BenchmarkStudy):
 
         despine(ax2)
 
+        return fig
+
         # ax1.sharey(ax0)
         # ax2.sharey(ax0)
 

{spikeinterface-0.103.0 → spikeinterface-0.103.2}/src/spikeinterface/benchmark/benchmark_peak_detection.py

@@ -33,7 +33,7 @@ class PeakDetectionBenchmark(Benchmark):
         self.result = {}
 
     def run(self, **job_kwargs):
-        peaks = detect_peaks(self.recording, self.method, **self.params, **job_kwargs)
+        peaks = detect_peaks(self.recording, self.method, method_kwargs=self.params, job_kwargs=job_kwargs)
         self.result["peaks"] = peaks
 
     def compute_result(self, **result_params):
@@ -57,7 +57,7 @@ class PeakDetectionBenchmark(Benchmark):
             spikes, self.recording.sampling_frequency, unit_ids=self.recording.channel_ids
         )
 
-        self.result["gt_comparison"] = GroundTruthComparison(
+        self.result["gt_comparison_by_channels"] = GroundTruthComparison(
             self.result["gt_on_channels"], self.result["peak_on_channels"], exhaustive_gt=self.exhaustive_gt
         )
 
@@ -82,41 +82,47 @@ class PeakDetectionBenchmark(Benchmark):
         sorting["segment_index"] = peaks[detected_matches]["segment_index"]
         order = np.lexsort((sorting["sample_index"], sorting["segment_index"]))
         sorting = sorting[order]
-        self.result["sliced_gt_sorting"] = NumpySorting(
+        self.result["matched_sorting"] = NumpySorting(
             sorting, self.recording.sampling_frequency, self.gt_sorting.unit_ids
         )
-        self.result["sliced_gt_comparison"] = GroundTruthComparison(
-            self.gt_sorting, self.result["sliced_gt_sorting"], exhaustive_gt=self.exhaustive_gt
+        self.result["gt_comparison"] = GroundTruthComparison(
+            self.gt_sorting, self.result["matched_sorting"], exhaustive_gt=self.exhaustive_gt
         )
 
         ratio = 100 * len(gt_matches) / len(times2)
         print("Only {0:.2f}% of gt peaks are matched to detected peaks".format(ratio))
 
         sorting_analyzer = create_sorting_analyzer(
-            self.result["sliced_gt_sorting"], self.recording, format="memory", sparse=False, **job_kwargs
+            self.result["matched_sorting"], self.recording, format="memory", sparse=False, **job_kwargs
         )
         sorting_analyzer.compute("random_spikes")
         sorting_analyzer.compute("templates", **job_kwargs)
 
-        self.result["templates"] = sorting_analyzer.get_extension("templates").get_data()
+        self.result["matched_templates"] = sorting_analyzer.get_extension("templates").get_data()
 
     _run_key_saved = [("peaks", "npy")]
 
     _result_key_saved = [
+        ("gt_comparison_by_channels", "pickle"),
+        ("matched_sorting", "sorting"),
         ("gt_comparison", "pickle"),
-        ("sliced_gt_sorting", "sorting"),
-        ("sliced_gt_comparison", "pickle"),
-        ("sliced_gt_sorting", "sorting"),
         ("peak_on_channels", "sorting"),
         ("gt_on_channels", "sorting"),
         ("matches", "pickle"),
-        ("templates", "npy"),
+        ("matched_templates", "npy"),
         ("gt_amplitudes", "npy"),
         ("gt_templates", "npy"),
     ]
 
 
 class PeakDetectionStudy(BenchmarkStudy):
+    """
+    Benchmark study to compare peak detection methods.
+
+    The ground truth sorting must be given.
+    Peak detected by methods will be compared to the ground truth to estimate the
+    recall.
+    """
 
     benchmark_class = PeakDetectionBenchmark
 
@@ -128,6 +134,11 @@ class PeakDetectionStudy(BenchmarkStudy):
         benchmark = PeakDetectionBenchmark(recording, gt_sorting, params, **init_kwargs)
         return benchmark
 
+    def plot_performances_vs_snr(self, **kwargs):
+        from .benchmark_plot_tools import plot_performances_vs_snr
+
+        return plot_performances_vs_snr(self, **kwargs)
+
     def plot_agreements_by_channels(self, case_keys=None, figsize=(15, 15)):
         if case_keys is None:
             case_keys = list(self.cases.keys())
@@ -138,7 +149,7 @@ class PeakDetectionStudy(BenchmarkStudy):
         for count, key in enumerate(case_keys):
             ax = axs[0, count]
             ax.set_title(self.cases[key]["label"])
-            plot_agreement_matrix(self.get_result(key)["gt_comparison"], ax=ax)
+            plot_agreement_matrix(self.get_result(key)["gt_comparison_by_channels"], ax=ax)
 
     def plot_agreements_by_units(self, case_keys=None, figsize=(15, 15)):
         if case_keys is None:
@@ -150,37 +161,49 @@ class PeakDetectionStudy(BenchmarkStudy):
         for count, key in enumerate(case_keys):
             ax = axs[0, count]
             ax.set_title(self.cases[key]["label"])
-            plot_agreement_matrix(self.get_result(key)["sliced_gt_comparison"], ax=ax)
+            plot_agreement_matrix(self.get_result(key)["gt_comparison"], ax=ax)
 
-    def plot_detected_amplitudes(self, case_keys=None, figsize=(15, 5), detect_threshold=None, axs=None):
+    def plot_detected_amplitude_distributions(
+        self, case_keys=None, show_legend=True, detect_threshold=None, figsize=(15, 5), ax=None
+    ):
 
         if case_keys is None:
             case_keys = list(self.cases.keys())
         import matplotlib.pyplot as plt
 
-        if axs is None:
-            fig, axs = plt.subplots(ncols=len(case_keys), figsize=figsize, squeeze=False)
+        if ax is None:
+            fig, ax = plt.subplots(figsize=figsize)
         else:
-            fig = axs[0].get_figure()
-            assert len(axs) == len(case_keys), "axs should be the same length as case_keys"
+            fig = ax.get_figure()
+
+        # plot only the first key for gt amplitude
+        # TODO make a loop for all of then
+        key0 = case_keys[0]
+        data2 = self.get_result(key0)["gt_amplitudes"]
+        bins = np.linspace(data2.min(), data2.max(), 100)
+        ax.hist(data2, bins=bins, alpha=0.1, label="gt", color="k")
 
         for count, key in enumerate(case_keys):
-            ax = axs[count]
             despine(ax)
             data1 = self.get_result(key)["peaks"]["amplitude"]
-            data2 = self.get_result(key)["gt_amplitudes"]
+
             color = self.get_colors()[key]
-            bins = np.linspace(data2.min(), data2.max(), 100)
-            ax.hist(data1, bins=bins, label="detected", histtype="step", color=color, linewidth=2)
-            ax.hist(data2, bins=bins, alpha=0.1, label="gt", color="k")
-            ax.set_yscale("log")
+
+            label = self.cases[key]["label"]
+            ax.hist(data1, bins=bins, label=label, histtype="step", color=color, linewidth=2)
+
             # ax.set_title(self.cases[key]["label"])
+
+        ax.set_yscale("log")
+
+        if detect_threshold is not None:
+            noise_levels = get_noise_levels(self.benchmarks[key].recording, return_in_uV=False).mean()
+            ymin, ymax = ax.get_ylim()
+            abs_threshold = -detect_threshold * noise_levels
+            ax.plot([abs_threshold, abs_threshold], [ymin, ymax], "k--")
+
+        if show_legend:
             ax.legend()
-            if detect_threshold is not None:
-                noise_levels = get_noise_levels(self.benchmarks[key].recording, return_in_uV=False).mean()
-                ymin, ymax = ax.get_ylim()
-                abs_threshold = -detect_threshold * noise_levels
-                ax.plot([abs_threshold, abs_threshold], [ymin, ymax], "k--")
 
         return fig
 
@@ -266,7 +289,7 @@ class PeakDetectionStudy(BenchmarkStudy):
             import sklearn.metrics
 
             gt_templates = self.get_result(key)["gt_templates"]
-            found_templates = self.get_result(key)["templates"]
+            found_templates = self.get_result(key)["matched_templates"]
             num_templates = len(gt_templates)
             distances = np.zeros(num_templates)
 

{spikeinterface-0.103.0 → spikeinterface-0.103.2}/src/spikeinterface/benchmark/benchmark_peak_localization.py

@@ -199,6 +199,14 @@ class UnitLocalizationBenchmark(Benchmark):
 
 
 class UnitLocalizationStudy(BenchmarkStudy):
+    """
+    Benchmark study to compare peaks localization methods.
+
+    The ground truth position of units must be known and method outputs
+    will be compared to them.
+
+    See also UnitLocalizationStudy.
+    """
 
     benchmark_class = UnitLocalizationBenchmark
 

{spikeinterface-0.103.0 → spikeinterface-0.103.2}/src/spikeinterface/benchmark/benchmark_peak_selection.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from spikeinterface.sortingcomponents.clustering import find_cluster_from_peaks
+from spikeinterface.sortingcomponents.clustering import find_clusters_from_peaks
 from spikeinterface.core import NumpySorting
 from spikeinterface.comparison import GroundTruthComparison
 from spikeinterface.comparison.comparisontools import make_matching_events