wip

Author: samuelgarcia

src/spikeinterface/benchmark/benchmark_matching.py

@@ -91,14 +91,16 @@ def plot_performances_ordered(self, *args, **kwargs):
 
         return plot_performances_ordered(self, *args, **kwargs)
 
-    def plot_collisions(self, case_keys=None, axs=None, figsize=None):
+    def plot_collisions(self, case_keys=None, metric="l2", mode="lines", show_legend=True, axs=None, figsize=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), nrows=1, figsize=figsize, squeeze=False)
             axs = axs[0, :]
+        else:
+            fig = axs[0].figure
 
 
         for count, key in enumerate(case_keys):
@@ -108,10 +110,13 @@ def plot_collisions(self, case_keys=None, axs=None, figsize=None):
             plot_comparison_collision_by_similarity(
                 self.get_result(key)["gt_collision"],
                 templates_array,
+                metric=metric,
                 ax=ax,
-                show_legend=True,
-                mode="lines",
-                good_only=False,
+                show_legend=show_legend,
+                mode=mode,
+                # good_only=False,
+                # good_only=False,
+                good_only=True,
             )
 
             ax.set_title(label)

src/spikeinterface/comparison/collision.py

@@ -214,14 +214,23 @@ def compute_collision_by_similarity(self, similarity_matrix, unit_ids=None, good
 
                 tp1 = self.all_tp[ind1, ind2, :]
                 fn1 = self.all_fn[ind1, ind2, :]
-                recall1 = tp1 / (tp1 + fn1)
+                recall1 = np.zeros(tp1.size)
+                recall1[:] = np.nan
+                mask = (tp1 + fn1) > 0
+                if np.any(mask):
+                    recall1[mask] = tp1[mask] / (tp1[mask] + fn1[mask])
+
                 recall_scores.append(recall1)
                 similarities.append(similarity_matrix[r, c])
                 pair_names.append(f"{u1} {u2}")
 
                 tp2 = self.all_tp[ind2, ind1, :]
                 fn2 = self.all_fn[ind2, ind1, :]
-                recall2 = tp2 / (tp2 + fn2)
+                recall2 = np.zeros(tp2.size)
+                recall2[:] = np.nan
+                mask = (tp2 + fn2) > 0
+                if np.any(mask):
+                    recall2[mask] = tp2[mask] / (tp2[mask] + fn2[mask])
                 recall_scores.append(recall2)
                 similarities.append(similarity_matrix[r, c])
                 pair_names.append(f"{u2} {u1}")

src/spikeinterface/sorters/internal/spyking_circus2.py

@@ -35,13 +35,15 @@ class Spykingcircus2Sorter(ComponentsBasedSorter):
         "motion_correction": {"preset": "dredge_fast"},
         "merging": {"max_distance_um": 50},
         "clustering": {"method": "circus-clustering", "method_kwargs": dict()},
-        "matching": {"method": "circus-omp-svd", "method_kwargs": dict()},
+        # "matching": {"method": "circus-omp-svd", "method_kwargs": dict()},
+        "matching": {"method": "wobble", "method_kwargs": dict()},
         "apply_preprocessing": True,
         "templates_from_svd": True,
         "cache_preprocessing": {"mode": "memory", "memory_limit": 0.5, "delete_cache": True},
         "chunk_preprocessing": {"memory_limit": None},
         "multi_units_only": False,
-        "job_kwargs": {"n_jobs": 0.75},
+        # "job_kwargs": {"n_jobs": 0.75},
+        "job_kwargs": {"n_jobs": None},
         "seed": 42,
         "deterministic_peaks_detection": False,
         "debug": False,

src/spikeinterface/sortingcomponents/clustering/circus.py

@@ -54,7 +54,8 @@ class CircusClustering:
         "few_waveforms": None,
         "ms_before": 2.0,
         "ms_after": 2.0,
-        "remove_small_snr": False,
+        # "remove_small_snr": False,
+        "remove_small_snr": True,
         "seed": None,
         "noise_threshold": 4,
         "rank": 5,