Merge pull request #4036 from samuelgarcia/templates_scaled

Templates.is_scaled > Templates.is_in_uV

Author: samuelgarcia

src/spikeinterface/benchmark/tests/common_benchmark_testing.py

@@ -74,7 +74,7 @@ def compute_gt_templates(recording, gt_sorting, ms_before=2.0, ms_after=3.0, ret
         channel_ids=recording.channel_ids,
         unit_ids=gt_sorting.unit_ids,
         probe=recording.get_probe(),
-        is_scaled=return_scaled,
+        is_in_uV=return_scaled,
     )
     return gt_templates
 

src/spikeinterface/core/analyzer_extension_core.py

@@ -698,7 +698,7 @@ def get_templates(self, unit_ids=None, operator="average", percentile=None, save
                 channel_ids=self.sorting_analyzer.channel_ids,
                 unit_ids=unit_ids,
                 probe=self.sorting_analyzer.get_probe(),
-                is_scaled=self.sorting_analyzer.return_in_uV,
+                is_in_uV=self.sorting_analyzer.return_in_uV,
             )
         else:
             raise ValueError("`outputs` must be 'numpy' or 'Templates'")

src/spikeinterface/core/sparsity.py

@@ -439,7 +439,7 @@ def from_snr(
             return_scaled = templates_or_sorting_analyzer.return_scaled
         elif isinstance(templates_or_sorting_analyzer, Templates):
             assert noise_levels is not None, "To compute sparsity from snr you need to provide noise_levels"
-            return_scaled = templates_or_sorting_analyzer.is_scaled
+            return_scaled = templates_or_sorting_analyzer.is_in_uV
 
         mask = np.zeros((unit_ids.size, channel_ids.size), dtype="bool")
 
@@ -491,9 +491,9 @@ def from_amplitude(cls, templates_or_sorting_analyzer, threshold, amplitude_mode
                 "You can set `return_scaled=True` when computing the templates."
             )
         elif isinstance(templates_or_sorting_analyzer, Templates):
-            assert templates_or_sorting_analyzer.is_scaled, (
+            assert templates_or_sorting_analyzer.is_in_uV, (
                 "To compute sparsity from amplitude you need to have scaled templates. "
-                "You can set `is_scaled=True` when creating the Templates object."
+                "You can set `is_in_uV=True` when creating the Templates object."
             )
 
         mask = np.zeros((unit_ids.size, channel_ids.size), dtype="bool")

src/spikeinterface/core/template.py

@@ -31,7 +31,7 @@ class Templates:
         Array of unit IDs. If `None`, defaults to an array of increasing integers.
     probe: Probe, default: None
         A `probeinterface.Probe` object
-    is_scaled : bool, optional default: True
+    is_in_uV : bool, optional default: True
         If True, it means that the templates are in uV, otherwise they are in raw ADC values.
     check_for_consistent_sparsity : bool, optional default: None
         When passing a sparsity_mask, this checks that the templates array is also sparse and that it matches the
@@ -61,7 +61,7 @@ class Templates:
     templates_array: np.ndarray
     sampling_frequency: float
     nbefore: int
-    is_scaled: bool = True
+    is_in_uV: bool = True
 
     sparsity_mask: np.ndarray = None
     channel_ids: np.ndarray = None
@@ -206,7 +206,7 @@ def to_sparse(self, sparsity):
             unit_ids=self.unit_ids,
             probe=self.probe,
             check_for_consistent_sparsity=self.check_for_consistent_sparsity,
-            is_scaled=self.is_scaled,
+            is_in_uV=self.is_in_uV,
         )
 
     def get_one_template_dense(self, unit_index):
@@ -257,7 +257,7 @@ def to_dict(self):
             "unit_ids": self.unit_ids,
             "sampling_frequency": self.sampling_frequency,
             "nbefore": self.nbefore,
-            "is_scaled": self.is_scaled,
+            "is_in_uV": self.is_in_uV,
             "probe": self.probe.to_dict() if self.probe is not None else None,
         }
 
@@ -270,7 +270,7 @@ def from_dict(cls, data):
             unit_ids=np.asarray(data["unit_ids"]),
             sampling_frequency=data["sampling_frequency"],
             nbefore=data["nbefore"],
-            is_scaled=data["is_scaled"],
+            is_in_uV=data["is_in_uV"],
             probe=data["probe"] if data["probe"] is None else Probe.from_dict(data["probe"]),
         )
 
@@ -304,7 +304,7 @@ def add_templates_to_zarr_group(self, zarr_group: "zarr.Group") -> None:
 
         zarr_group.attrs["sampling_frequency"] = self.sampling_frequency
         zarr_group.attrs["nbefore"] = self.nbefore
-        zarr_group.attrs["is_scaled"] = self.is_scaled
+        zarr_group.attrs["is_in_uV"] = self.is_in_uV
 
         if self.sparsity_mask is not None:
             zarr_group.create_dataset("sparsity_mask", data=self.sparsity_mask)
@@ -361,8 +361,12 @@ def from_zarr_group(cls, zarr_group: "zarr.Group") -> "Templates":
         sampling_frequency = zarr_group.attrs["sampling_frequency"]
         nbefore = zarr_group.attrs["nbefore"]
 
-        # TODO: Consider eliminating the True and make it required
-        is_scaled = zarr_group.attrs.get("is_scaled", True)
+        if "is_scaled" in zarr_group.attrs:
+            # prior to 0.103.0 "is_in_uV" was named "is_scaled", so for backward compatibility:
+            is_in_uV = zarr_group.attrs["is_scaled"]
+        else:
+            # TODO: Consider eliminating the True and make it required
+            is_in_uV = zarr_group.attrs.get("is_in_uV", True)
 
         sparsity_mask = None
         if "sparsity_mask" in zarr_group:
@@ -380,7 +384,7 @@ def from_zarr_group(cls, zarr_group: "zarr.Group") -> "Templates":
             channel_ids=channel_ids,
             unit_ids=unit_ids,
             probe=probe,
-            is_scaled=is_scaled,
+            is_in_uV=is_in_uV,
         )
 
     @staticmethod

src/spikeinterface/core/template_tools.py

@@ -22,7 +22,7 @@ def get_dense_templates_array(one_object: Templates | SortingAnalyzer, return_sc
         The dense templates (num_units, num_samples, num_channels)
     """
     if isinstance(one_object, Templates):
-        if return_scaled != one_object.is_scaled:
+        if return_scaled != one_object.is_in_uV:
             raise ValueError(
                 f"get_dense_templates_array: return_scaled={return_scaled} is not possible Templates has the reverse"
             )
@@ -165,15 +165,15 @@ def get_template_extremum_channel(
     channel_ids = templates_or_sorting_analyzer.channel_ids
 
     # if SortingAnalyzer need to use global SortingAnalyzer return_scaled otherwise
-    # we use the Templates is_scaled
+    # we use the Templates is_in_uV
     if isinstance(templates_or_sorting_analyzer, SortingAnalyzer):
         # For backward compatibility
         if hasattr(templates_or_sorting_analyzer, "return_scaled"):
             return_scaled = templates_or_sorting_analyzer.return_scaled
         else:
             return_scaled = templates_or_sorting_analyzer.return_in_uV
     else:
-        return_scaled = templates_or_sorting_analyzer.is_scaled
+        return_scaled = templates_or_sorting_analyzer.is_in_uV
 
     peak_values = get_template_amplitudes(
         templates_or_sorting_analyzer, peak_sign=peak_sign, mode=mode, return_scaled=return_scaled
@@ -218,15 +218,15 @@ def get_template_extremum_channel_peak_shift(templates_or_sorting_analyzer, peak
     shifts = {}
 
     # We need to use the SortingAnalyzer return_scaled
-    # We need to use the Templates is_scaled
+    # We need to use the Templates is_in_uV
     if isinstance(templates_or_sorting_analyzer, SortingAnalyzer):
         # For backward compatibility
         if hasattr(templates_or_sorting_analyzer, "return_scaled"):
             return_scaled = templates_or_sorting_analyzer.return_scaled
         else:
             return_scaled = templates_or_sorting_analyzer.return_in_uV
     else:
-        return_scaled = templates_or_sorting_analyzer.is_scaled
+        return_scaled = templates_or_sorting_analyzer.is_in_uV
 
     templates_array = get_dense_templates_array(templates_or_sorting_analyzer, return_scaled=return_scaled)
 
@@ -291,7 +291,7 @@ def get_template_extremum_amplitude(
         else:
             return_scaled = templates_or_sorting_analyzer.return_in_uV
     else:
-        return_scaled = templates_or_sorting_analyzer.is_scaled
+        return_scaled = templates_or_sorting_analyzer.is_in_uV
 
     extremum_amplitudes = get_template_amplitudes(
         templates_or_sorting_analyzer, peak_sign=peak_sign, mode=mode, return_scaled=return_scaled, abs_value=abs_value

src/spikeinterface/core/tests/test_template_class.py

@@ -7,7 +7,7 @@
 from probeinterface import generate_multi_columns_probe
 
 
-def generate_test_template(template_type, is_scaled=True) -> Templates:
+def generate_test_template(template_type, is_in_uV=True) -> Templates:
     num_units = 3
     num_samples = 5
     num_channels = 4
@@ -28,7 +28,7 @@ def generate_test_template(template_type, is_scaled=True) -> Templates:
             probe=probe,
             unit_ids=unit_ids,
             channel_ids=channel_ids,
-            is_scaled=is_scaled,
+            is_in_uV=is_in_uV,
         )
     elif template_type == "sparse":  # sparse with sparse templates
         sparsity_mask = np.array(
@@ -53,7 +53,7 @@ def generate_test_template(template_type, is_scaled=True) -> Templates:
             sampling_frequency=sampling_frequency,
             nbefore=nbefore,
             probe=probe,
-            is_scaled=is_scaled,
+            is_in_uV=is_in_uV,
             unit_ids=unit_ids,
             channel_ids=channel_ids,
         )
@@ -68,16 +68,16 @@ def generate_test_template(template_type, is_scaled=True) -> Templates:
             sampling_frequency=sampling_frequency,
             nbefore=nbefore,
             probe=probe,
-            is_scaled=is_scaled,
+            is_in_uV=is_in_uV,
             unit_ids=unit_ids,
             channel_ids=channel_ids,
         )
 
 
-@pytest.mark.parametrize("is_scaled", [True, False])
+@pytest.mark.parametrize("is_in_uV", [True, False])
 @pytest.mark.parametrize("template_type", ["dense", "sparse"])
-def test_pickle_serialization(template_type, is_scaled, tmp_path):
-    template = generate_test_template(template_type, is_scaled)
+def test_pickle_serialization(template_type, is_in_uV, tmp_path):
+    template = generate_test_template(template_type, is_in_uV)
 
     # Dump to pickle
     pkl_path = tmp_path / "templates.pkl"
@@ -91,21 +91,21 @@ def test_pickle_serialization(template_type, is_scaled, tmp_path):
     assert template == template_reloaded
 
 
-@pytest.mark.parametrize("is_scaled", [True, False])
+@pytest.mark.parametrize("is_in_uV", [True, False])
 @pytest.mark.parametrize("template_type", ["dense", "sparse"])
-def test_json_serialization(template_type, is_scaled):
-    template = generate_test_template(template_type, is_scaled)
+def test_json_serialization(template_type, is_in_uV):
+    template = generate_test_template(template_type, is_in_uV)
 
     json_str = template.to_json()
     template_reloaded_from_json = Templates.from_json(json_str)
 
     assert template == template_reloaded_from_json
 
 
-@pytest.mark.parametrize("is_scaled", [True, False])
+@pytest.mark.parametrize("is_in_uV", [True, False])
 @pytest.mark.parametrize("template_type", ["dense", "sparse"])
-def test_get_dense_templates(template_type, is_scaled):
-    template = generate_test_template(template_type, is_scaled)
+def test_get_dense_templates(template_type, is_in_uV):
+    template = generate_test_template(template_type, is_in_uV)
     dense_templates = template.get_dense_templates()
     assert dense_templates.shape == (template.num_units, template.num_samples, template.num_channels)
 
@@ -115,10 +115,10 @@ def test_initialization_fail_with_dense_templates():
         template = generate_test_template(template_type="sparse_with_dense_templates")
 
 
-@pytest.mark.parametrize("is_scaled", [True, False])
+@pytest.mark.parametrize("is_in_uV", [True, False])
 @pytest.mark.parametrize("template_type", ["dense", "sparse"])
-def test_save_and_load_zarr(template_type, is_scaled, tmp_path):
-    original_template = generate_test_template(template_type, is_scaled)
+def test_save_and_load_zarr(template_type, is_in_uV, tmp_path):
+    original_template = generate_test_template(template_type, is_in_uV)
 
     zarr_path = tmp_path / "templates.zarr"
     original_template.to_zarr(str(zarr_path))
@@ -129,10 +129,10 @@ def test_save_and_load_zarr(template_type, is_scaled, tmp_path):
     assert original_template == loaded_template
 
 
-@pytest.mark.parametrize("is_scaled", [True, False])
+@pytest.mark.parametrize("is_in_uV", [True, False])
 @pytest.mark.parametrize("template_type", ["dense", "sparse"])
-def test_select_units(template_type, is_scaled):
-    template = generate_test_template(template_type, is_scaled)
+def test_select_units(template_type, is_in_uV):
+    template = generate_test_template(template_type, is_in_uV)
     selected_unit_ids = ["unit_a", "unit_c"]
     selected_unit_ids_indices = [0, 2]
 
@@ -149,10 +149,10 @@ def test_select_units(template_type, is_scaled):
         assert np.array_equal(selected_template.sparsity_mask, template.sparsity_mask[selected_unit_ids_indices])
 
 
-@pytest.mark.parametrize("is_scaled", [True, False])
+@pytest.mark.parametrize("is_in_uV", [True, False])
 @pytest.mark.parametrize("template_type", ["dense"])
-def test_select_channels(template_type, is_scaled):
-    template = generate_test_template(template_type, is_scaled)
+def test_select_channels(template_type, is_in_uV):
+    template = generate_test_template(template_type, is_in_uV)
     selected_channel_ids = ["channel1", "channel3"]
     selected_channel_ids_indices = [0, 2]
 

src/spikeinterface/core/tests/test_template_tools.py

@@ -48,7 +48,7 @@ def _get_templates_object_from_sorting_analyzer(sorting_analyzer):
         sparsity_mask=None,
         channel_ids=sorting_analyzer.channel_ids,
         unit_ids=sorting_analyzer.unit_ids,
-        is_scaled=sorting_analyzer.return_in_uV,
+        is_in_uV=sorting_analyzer.return_in_uV,
     )
     return templates
 

src/spikeinterface/generation/drift_tools.py

@@ -166,7 +166,7 @@ def from_static_templates(cls, templates: Templates):
             nbefore=templates.nbefore,
             probe=templates.probe,
             sparsity_mask=templates.sparsity_mask,
-            is_scaled=templates.is_scaled,
+            is_in_uV=templates.is_in_uV,
             unit_ids=templates.unit_ids,
             channel_ids=templates.channel_ids,
         )

src/spikeinterface/generation/drifting_generator.py

@@ -459,7 +459,7 @@ def generate_drifting_recording(
         sampling_frequency=sampling_frequency,
         nbefore=nbefore,
         probe=probe,
-        is_scaled=True,
+        is_in_uV=True,
     )
 
     drifting_templates = DriftingTemplates.from_static_templates(templates)

src/spikeinterface/generation/tests/test_drift_tools.py

@@ -65,7 +65,7 @@ def make_some_templates():
         sampling_frequency=sampling_frequency,
         nbefore=nbefore,
         probe=probe,
-        is_scaled=True,
+        is_in_uV=True,
     )
 
     return templates