spikeinterface 0.102.2__tar.gz → 0.102.3__tar.gz

{spikeinterface-0.102.2/src/spikeinterface.egg-info → spikeinterface-0.102.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spikeinterface
-Version: 0.102.2
+Version: 0.102.3
 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
@@ -22,14 +22,15 @@ 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.0
+Requires-Dist: neo>=0.14.1
 Requires-Dist: probeinterface>=0.2.23
 Requires-Dist: packaging
+Requires-Dist: numcodecs<0.16.0
 Provides-Extra: extractors
 Requires-Dist: MEArec>=1.8; extra == "extractors"
 Requires-Dist: pynwb>=2.6.0; extra == "extractors"
 Requires-Dist: hdmf-zarr>=0.11.0; extra == "extractors"
-Requires-Dist: pyedflib<0.1.39,>=0.1.30; extra == "extractors"
+Requires-Dist: pyedflib>=0.1.30; extra == "extractors"
 Requires-Dist: sonpy; python_version < "3.10" and extra == "extractors"
 Requires-Dist: lxml; extra == "extractors"
 Requires-Dist: scipy; extra == "extractors"
@@ -84,7 +85,6 @@ Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-dependency; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: psutil; extra == "test"
-Requires-Dist: huggingface_hub; extra == "test"
 Requires-Dist: ibllib; extra == "test"
 Requires-Dist: s3fs; extra == "test"
 Requires-Dist: numba<0.61.0; python_version < "3.13" and extra == "test"

{spikeinterface-0.102.2 → spikeinterface-0.102.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "spikeinterface"
-version = "0.102.2"
+version = "0.102.3"
 authors = [
   { name="Alessio Buccino", email="alessiop.buccino@gmail.com" },
   { name="Samuel Garcia", email="sam.garcia.die@gmail.com" },
@@ -25,9 +25,10 @@ dependencies = [
     "threadpoolctl>=3.0.0",
     "tqdm",
     "zarr>=2.18,<3",
-    "neo>=0.14.0",
+    "neo>=0.14.1",
     "probeinterface>=0.2.23",
     "packaging",
+    "numcodecs<0.16.0", # For supporting zarr < 3
 ]
 
 [build-system]
@@ -63,7 +64,7 @@ extractors = [
     "MEArec>=1.8",
     "pynwb>=2.6.0",
     "hdmf-zarr>=0.11.0",
-    "pyedflib>=0.1.30,<0.1.39",
+    "pyedflib>=0.1.30",
     "sonpy;python_version<'3.10'",
     "lxml", # lxml for neuroscope
     "scipy",
@@ -150,8 +151,6 @@ test = [
     "pytest-cov",
     "psutil",
 
-    "huggingface_hub",
-
     # preprocessing
     "ibllib", # for IBL
 
@@ -194,8 +193,8 @@ docs = [
     "hdbscan>=0.8.33",   # For sorters spykingcircus2 + tridesclous
     "numba", # For many postprocessing functions
     "networkx",
-    "skops", # For auotmated curation
-    "scikit-learn", # For auotmated curation
+    "skops", # For automated curation
+    "scikit-learn", # For automated curation
     # Download data
     "pooch>=1.8.2",
     "datalad>=1.0.2",

{spikeinterface-0.102.2 → spikeinterface-0.102.3}/src/spikeinterface/benchmark/benchmark_base.py

@@ -176,18 +176,12 @@ class BenchmarkStudy:
         self.levels = self.info["levels"]
 
         for key, folder in self.analyzers_path.items():
-            analyzer = load_sorting_analyzer(folder)
+            analyzer = load_sorting_analyzer(folder, load_extensions=False)
             self.analyzers[key] = analyzer
             # the sorting is in memory here we take the saved one because comparisons need to pickle it later
             sorting = load(analyzer.folder / "sorting")
             self.datasets[key] = analyzer.recording, sorting
 
-        # for rec_file in (self.folder / "datasets" / "recordings").glob("*.pickle"):
-        #     key = rec_file.stem
-        #     rec = load(rec_file)
-        #     gt_sorting = load(self.folder / f"datasets" / "gt_sortings" / key)
-        #     self.datasets[key] = (rec, gt_sorting)
-
         with open(self.folder / "cases.pickle", "rb") as f:
             self.cases = pickle.load(f)
 
@@ -619,3 +613,68 @@ class Benchmark:
     def compute_result(self):
         # run becnhmark result
         raise NotImplementedError
+
+
+# Common feature accross some benchmark : sorter + matching
+class MixinStudyUnitCount:
+    def get_count_units(self, case_keys=None, well_detected_score=None, redundant_score=None, overmerged_score=None):
+        import pandas as pd
+
+        if case_keys is None:
+            case_keys = list(self.cases.keys())
+
+        if isinstance(case_keys[0], str):
+            index = pd.Index(case_keys, name=self.levels)
+        else:
+            index = pd.MultiIndex.from_tuples(case_keys, names=self.levels)
+
+        columns = ["num_gt", "num_sorter", "num_well_detected"]
+        key0 = case_keys[0]
+        comp = self.get_result(key0)["gt_comparison"]
+        if comp.exhaustive_gt:
+            columns.extend(["num_false_positive", "num_redundant", "num_overmerged", "num_bad"])
+        count_units = pd.DataFrame(index=index, columns=columns, dtype=int)
+
+        for key in case_keys:
+            comp = self.get_result(key)["gt_comparison"]
+
+            gt_sorting = comp.sorting1
+            sorting = comp.sorting2
+
+            count_units.loc[key, "num_gt"] = len(gt_sorting.get_unit_ids())
+            count_units.loc[key, "num_sorter"] = len(sorting.get_unit_ids())
+            count_units.loc[key, "num_well_detected"] = comp.count_well_detected_units(well_detected_score)
+
+            if comp.exhaustive_gt:
+                count_units.loc[key, "num_redundant"] = comp.count_redundant_units(redundant_score)
+                count_units.loc[key, "num_overmerged"] = comp.count_overmerged_units(overmerged_score)
+                count_units.loc[key, "num_false_positive"] = comp.count_false_positive_units(redundant_score)
+                count_units.loc[key, "num_bad"] = comp.count_bad_units()
+
+        return count_units
+
+    def get_performance_by_unit(self, case_keys=None):
+        import pandas as pd
+
+        if case_keys is None:
+            case_keys = self.cases.keys()
+
+        perf_by_unit = []
+        for key in case_keys:
+            comp = self.get_result(key)["gt_comparison"]
+
+            perf = comp.get_performance(method="by_unit", output="pandas")
+
+            if isinstance(key, str):
+                perf[self.levels] = key
+            elif isinstance(key, tuple):
+                for col, k in zip(self.levels, key):
+                    perf[col] = k
+
+            perf = perf.reset_index()
+            perf_by_unit.append(perf)
+
+        perf_by_unit = pd.concat(perf_by_unit)
+        perf_by_unit = perf_by_unit.set_index(self.levels)
+        perf_by_unit = perf_by_unit.sort_index()
+        return perf_by_unit

{spikeinterface-0.102.2 → spikeinterface-0.102.3}/src/spikeinterface/benchmark/benchmark_clustering.py

@@ -11,7 +11,7 @@ from spikeinterface.widgets import (
 
 import numpy as np
 from spikeinterface.core.job_tools import fix_job_kwargs, split_job_kwargs
-from .benchmark_base import Benchmark, BenchmarkStudy
+from .benchmark_base import Benchmark, BenchmarkStudy, MixinStudyUnitCount
 from spikeinterface.core.sortinganalyzer import create_sorting_analyzer
 from spikeinterface.core.template_tools import get_template_extremum_channel
 
@@ -93,7 +93,7 @@ class ClusteringBenchmark(Benchmark):
     ]
 
 
-class ClusteringStudy(BenchmarkStudy):
+class ClusteringStudy(BenchmarkStudy, MixinStudyUnitCount):
 
     benchmark_class = ClusteringBenchmark
 
@@ -196,6 +196,11 @@ class ClusteringStudy(BenchmarkStudy):
 
         return plot_performances_vs_depth_and_snr(self, *args, **kwargs)
 
+    def plot_performances_ordered(self, *args, **kwargs):
+        from .benchmark_plot_tools import plot_performances_ordered
+
+        return plot_performances_ordered(self, *args, **kwargs)
+
     def plot_error_metrics(self, metric="cosine", case_keys=None, figsize=(15, 5)):
 
         if case_keys is None:

{spikeinterface-0.102.2 → spikeinterface-0.102.3}/src/spikeinterface/benchmark/benchmark_matching.py

@@ -11,7 +11,7 @@ from spikeinterface.widgets import (
 )
 
 import numpy as np
-from .benchmark_base import Benchmark, BenchmarkStudy
+from .benchmark_base import Benchmark, BenchmarkStudy, MixinStudyUnitCount
 from spikeinterface.core.basesorting import minimum_spike_dtype
 
 
@@ -53,7 +53,7 @@ class MatchingBenchmark(Benchmark):
     _result_key_saved = [("gt_collision", "pickle"), ("gt_comparison", "pickle")]
 
 
-class MatchingStudy(BenchmarkStudy):
+class MatchingStudy(BenchmarkStudy, MixinStudyUnitCount):
 
     benchmark_class = MatchingBenchmark
 
@@ -84,6 +84,11 @@ class MatchingStudy(BenchmarkStudy):
 
         return plot_performances_vs_depth_and_snr(self, *args, **kwargs)
 
+    def plot_performances_ordered(self, *args, **kwargs):
+        from .benchmark_plot_tools import plot_performances_ordered
+
+        return plot_performances_ordered(self, *args, **kwargs)
+
     def plot_collisions(self, case_keys=None, figsize=None):
         if case_keys is None:
             case_keys = list(self.cases.keys())
@@ -104,42 +109,6 @@ class MatchingStudy(BenchmarkStudy):
 
         return fig
 
-    def get_count_units(self, case_keys=None, well_detected_score=None, redundant_score=None, overmerged_score=None):
-        import pandas as pd
-
-        if case_keys is None:
-            case_keys = list(self.cases.keys())
-
-        if isinstance(case_keys[0], str):
-            index = pd.Index(case_keys, name=self.levels)
-        else:
-            index = pd.MultiIndex.from_tuples(case_keys, names=self.levels)
-
-        columns = ["num_gt", "num_sorter", "num_well_detected"]
-        comp = self.get_result(case_keys[0])["gt_comparison"]
-        if comp.exhaustive_gt:
-            columns.extend(["num_false_positive", "num_redundant", "num_overmerged", "num_bad"])
-        count_units = pd.DataFrame(index=index, columns=columns, dtype=int)
-
-        for key in case_keys:
-            comp = self.get_result(key)["gt_comparison"]
-            assert comp is not None, "You need to do study.run_comparisons() first"
-
-            gt_sorting = comp.sorting1
-            sorting = comp.sorting2
-
-            count_units.loc[key, "num_gt"] = len(gt_sorting.get_unit_ids())
-            count_units.loc[key, "num_sorter"] = len(sorting.get_unit_ids())
-            count_units.loc[key, "num_well_detected"] = comp.count_well_detected_units(well_detected_score)
-
-            if comp.exhaustive_gt:
-                count_units.loc[key, "num_redundant"] = comp.count_redundant_units(redundant_score)
-                count_units.loc[key, "num_overmerged"] = comp.count_overmerged_units(overmerged_score)
-                count_units.loc[key, "num_false_positive"] = comp.count_false_positive_units(redundant_score)
-                count_units.loc[key, "num_bad"] = comp.count_bad_units()
-
-        return count_units
-
     def plot_unit_counts(self, case_keys=None, **kwargs):
         from .benchmark_plot_tools import plot_unit_counts
 

{spikeinterface-0.102.2 → spikeinterface-0.102.3}/src/spikeinterface/benchmark/benchmark_peak_detection.py

@@ -8,7 +8,7 @@ from spikeinterface.widgets import (
 )
 from spikeinterface.comparison.comparisontools import make_matching_events
 from spikeinterface.core import get_noise_levels
-
+from spikeinterface.benchmark.benchmark_plot_tools import despine
 
 import numpy as np
 from spikeinterface.core.job_tools import fix_job_kwargs, split_job_kwargs
@@ -152,54 +152,29 @@ class PeakDetectionStudy(BenchmarkStudy):
             ax.set_title(self.cases[key]["label"])
             plot_agreement_matrix(self.get_result(key)["sliced_gt_comparison"], ax=ax)
 
-    def plot_performances_vs_snr(self, case_keys=None, figsize=(15, 15), detect_threshold=None):
-        if case_keys is None:
-            case_keys = list(self.cases.keys())
-
-        import matplotlib.pyplot as plt
-
-        fig, axs = plt.subplots(ncols=1, nrows=3, figsize=figsize)
-
-        for count, k in enumerate(("accuracy", "recall", "precision")):
-
-            ax = axs[count]
-            for key in case_keys:
-                color = self.get_colors()[key]
-                label = self.cases[key]["label"]
-
-                analyzer = self.get_sorting_analyzer(key)
-                metrics = analyzer.get_extension("quality_metrics").get_data()
-                x = metrics["snr"].values
-                y = self.get_result(key)["sliced_gt_comparison"].get_performance()[k].values
-                ax.scatter(x, y, marker=".", label=label, color=color)
-                ax.set_title(k)
-                if detect_threshold is not None:
-                    ymin, ymax = ax.get_ylim()
-                    ax.plot([detect_threshold, detect_threshold], [ymin, ymax], "k--")
-
-                popt = fit_sigmoid(x, y, p0=None)
-                xfit = np.linspace(0, max(metrics["snr"].values), 100)
-                ax.plot(xfit, sigmoid(xfit, *popt), color=color)
-
-            if count == 2:
-                ax.legend()
-
-    def plot_detected_amplitudes(self, case_keys=None, figsize=(15, 5), detect_threshold=None):
+    def plot_detected_amplitudes(self, case_keys=None, figsize=(15, 5), detect_threshold=None, axs=None):
 
         if case_keys is None:
             case_keys = list(self.cases.keys())
         import matplotlib.pyplot as plt
 
-        fig, axs = plt.subplots(ncols=len(case_keys), nrows=1, figsize=figsize, squeeze=False)
+        if axs is None:
+            fig, axs = plt.subplots(ncols=len(case_keys), figsize=figsize, squeeze=False)
+        else:
+            fig = axs[0].get_figure()
+            assert len(axs) == len(case_keys), "axs should be the same length as case_keys"
 
         for count, key in enumerate(case_keys):
-            ax = axs[0, count]
+            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, alpha=0.5, label="detected")
-            ax.hist(data2, bins=bins, alpha=0.5, label="gt")
-            ax.set_title(self.cases[key]["label"])
+            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")
+            # ax.set_title(self.cases[key]["label"])
             ax.legend()
             if detect_threshold is not None:
                 noise_levels = get_noise_levels(self.benchmarks[key].recording, return_scaled=False).mean()
@@ -230,13 +205,62 @@ class PeakDetectionStudy(BenchmarkStudy):
             ax.set_ylabel("# frames")
             ax.set_xlabel("unit id")
 
-    def plot_template_similarities(self, case_keys=None, metric="l2", figsize=(15, 5), detect_threshold=None):
+    def plot_mean_deltas(self, case_keys=None, figsize=(15, 5), ax=None):
 
         if case_keys is None:
             case_keys = list(self.cases.keys())
         import matplotlib.pyplot as plt
 
-        fig, ax = plt.subplots(ncols=1, nrows=1, figsize=figsize, squeeze=True)
+        if ax is None:
+            fig, ax = plt.subplots(1, figsize=figsize)
+        else:
+            fig = ax.get_figure()
+
+        results = {}
+        labels = []
+        colors = []
+        for count, key in enumerate(case_keys):
+            gt_sorting = self.benchmarks[key].gt_sorting
+            results[key] = []
+            labels += [self.cases[key]["label"]]
+            data = self.get_result(key)["matches"]
+            for unit_ind, unit_id in enumerate(gt_sorting.unit_ids):
+                mask = data["labels"] == unit_id
+                results[key] += [np.mean(data["deltas"][mask])]
+
+            colors += [self.get_colors()[key]]
+        despine(ax)
+        plots = ax.violinplot(
+            results.values(),
+            range(len(case_keys)),
+            showmeans=True,
+            showmedians=False,
+            showextrema=False,
+        )
+
+        # Set the color of the violin patches
+        for pc, color in zip(plots["bodies"], colors):
+            pc.set_facecolor(color)
+            pc.set_edgecolor(color)
+
+        plots["cmeans"].set_colors(colors)
+
+        # ax.set_title(self.cases[key]["label"])
+        ax.set_xticks(range(len(case_keys)), labels, rotation=45)
+        ax.set_ylabel("# frames")
+        # ax.set_xlabel("unit id")
+
+    def plot_template_similarities(self, case_keys=None, metric="l2", figsize=(15, 5), detect_threshold=None, ax=None):
+
+        if case_keys is None:
+            case_keys = list(self.cases.keys())
+        import matplotlib.pyplot as plt
+
+        if ax is None:
+            fig, ax = plt.subplots(ncols=1, nrows=1, figsize=figsize, squeeze=True)
+        else:
+            fig = ax.get_figure()
+
         for key in case_keys:
 
             import sklearn.metrics
@@ -266,7 +290,7 @@ class PeakDetectionStudy(BenchmarkStudy):
             x = metrics["snr"].values
             y = distances
             ax.scatter(x, y, marker=".", label=label, color=color)
-
+            despine(ax)
             popt = fit_sigmoid(x, y, p0=None)
             xfit = np.linspace(0, max(metrics["snr"].values), 100)
             ax.plot(xfit, sigmoid(xfit, *popt), color=color)