junifer 0.0.8.dev284__tar.gz → 0.0.8.dev295__tar.gz

{junifer-0.0.8.dev284/junifer.egg-info → junifer-0.0.8.dev295}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: junifer
-Version: 0.0.8.dev284
+Version: 0.0.8.dev295
 Summary: JUelich NeuroImaging FEature extractoR
 Author-email: Fede Raimondo <f.raimondo@fz-juelich.de>, Synchon Mandal <s.mandal@fz-juelich.de>
 Maintainer-email: Fede Raimondo <f.raimondo@fz-juelich.de>, Synchon Mandal <s.mandal@fz-juelich.de>

junifer-0.0.8.dev295/docs/changes/newsfragments/521.bugfix

@@ -0,0 +1 @@
+Handle regions without voxels (e.g. lost when resampling or warping the parcellation) in parcel markers: functional connectivity and complexity markers are computed on the regions with data and give ``NaN`` for the others, instead of failing or returning values for the lost regions, and :class:`.RSSETSMarker` only uses the edges with data by `Fede Raimondo`_

junifer-0.0.8.dev295/docs/changes/newsfragments/522.bugfix

@@ -0,0 +1 @@
+Fix :class:`.TemporalSNRParcels`, :class:`.TemporalSNRSpheres` and :class:`.TemporalSNRMaps` replacing the BOLD data with the tSNR map, so the markers computed after them in a pipeline used the tSNR map instead of the BOLD data by `Fede Raimondo`_

junifer-0.0.8.dev295/docs/changes/newsfragments/522.enh

@@ -0,0 +1 @@
+Raise an error if a marker changes its input data (which is shared with the other markers of a pipeline), checking the values and their contents (arrays, data frames and images) by `Fede Raimondo`_

{junifer-0.0.8.dev284 → junifer-0.0.8.dev295}/junifer/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.0.8.dev284'
-__version_tuple__ = version_tuple = (0, 0, 8, 'dev284')
+__version__ = version = '0.0.8.dev295'
+__version_tuple__ = version_tuple = (0, 0, 8, 'dev295')
 
-__commit_id__ = commit_id = 'g3efb83df1'
+__commit_id__ = commit_id = 'g4eb842a09'

{junifer-0.0.8.dev284 → junifer-0.0.8.dev295}/junifer/markers/base.py

@@ -16,10 +16,12 @@ from ..pipeline import PipelineStepMixin, UpdateMetaMixin
 from ..storage import StorageType
 from ..typing import MarkerInOutMappings, StorageLike
 from ..utils import ensure_list_or_none, raise_error
+from .utils import _changed_paths, _fingerprint
 
 
 __all__ = ["BaseMarker"]
 
+
 _log = structlog.get_logger("junifer")
 logger = _log.bind(pkg="markers", step="marker")
 
@@ -257,8 +259,17 @@ class BaseMarker(BaseModel, ABC, PipelineStepMixin, UpdateMetaMixin):
                 # Copy metadata
                 t_meta = t_input["meta"].copy()
                 t_meta["type"] = t.value
-                # Compute marker
+                # Compute marker, checking it does not change the data, as
+                # it is shared with the markers computed afterwards
+                fingerprint = _fingerprint(input)
                 t_out = self.compute(input=t_input, extra_input=extra_input)
+                changed = _changed_paths(fingerprint, _fingerprint(input))
+                if changed:
+                    raise_error(
+                        f"Marker {self.name} changed its input data, which is "
+                        f"shared with the other markers: {', '.join(changed)}",
+                        klass=RuntimeError,
+                    )
                 # Initialize empty dictionary if no storage object is provided
                 if storage is None:
                     out[t] = {}

{junifer-0.0.8.dev284 → junifer-0.0.8.dev295}/junifer/markers/complexity/complexity_base.py

@@ -6,12 +6,12 @@
 
 from abc import abstractmethod
 from typing import (
-    TYPE_CHECKING,
     Annotated,
     Any,
     ClassVar,
 )
 
+import numpy as np
 from pydantic import BeforeValidator
 
 from ...datagrabber import DataType
@@ -20,10 +20,7 @@ from ...typing import Dependencies, MarkerInOutMappings
 from ...utils import ensure_list, ensure_list_or_none, raise_error
 from ..base import BaseMarker
 from ..parcel_aggregation import ParcelAggregation
-
-
-if TYPE_CHECKING:
-    import numpy as np
+from ..utils import _has_data
 
 
 __all__ = ["ComplexityBase"]
@@ -118,12 +115,15 @@ class ComplexityBase(BaseMarker):
             masks=self.masks,
             on=DataType.BOLD,
         ).compute(input=input, extra_input=extra_input)
-        # Compute complexity measure
+        # Compute complexity measure on the regions with data (e.g. regions
+        # lost in resampling have none) and set the others to NaN
+        data = parcel_aggregation["aggregation"]["data"]
+        has_data = _has_data(data)
+        complexity = np.full((1, data.shape[1]), np.nan)
+        complexity[:, has_data] = self.compute_complexity(data[:, has_data])
         return {
             "complexity": {
-                "data": self.compute_complexity(
-                    parcel_aggregation["aggregation"]["data"]
-                ),
+                "data": complexity,
                 "col_names": parcel_aggregation["aggregation"]["col_names"],
             }
         }

{junifer-0.0.8.dev284 → junifer-0.0.8.dev295}/junifer/markers/ets_rss.py

@@ -18,7 +18,7 @@ from ..typing import Dependencies, MarkerInOutMappings
 from ..utils import ensure_list, ensure_list_or_none
 from .base import BaseMarker, logger
 from .parcel_aggregation import ParcelAggregation
-from .utils import _ets
+from .utils import _ets, _has_data
 
 
 __all__ = ["RSSETSMarker"]
@@ -113,8 +113,13 @@ class RSSETSMarker(BaseMarker):
         ).compute(input=input, extra_input=extra_input)
         # Compute edgewise timeseries
         edge_ts, _ = _ets(aggregation["aggregation"]["data"])
-        # Compute the RSS of edgewise timeseries
-        rss = np.sum(edge_ts**2, 1) ** 0.5
+        # Compute the RSS of edgewise timeseries, only using the edges with
+        # data (e.g. regions lost in resampling have none)
+        edge_ts = edge_ts[:, _has_data(edge_ts)]
+        if edge_ts.shape[1] > 0:
+            rss = np.sum(edge_ts**2, 1) ** 0.5
+        else:
+            rss = np.full(edge_ts.shape[0], np.nan)
 
         return {
             "rss_ets": {

{junifer-0.0.8.dev284 → junifer-0.0.8.dev295}/junifer/markers/functional_connectivity/functional_connectivity_base.py

@@ -6,6 +6,7 @@
 from abc import abstractmethod
 from typing import Annotated, Any, ClassVar
 
+import numpy as np
 from pydantic import BeforeValidator
 from sklearn.covariance import EmpiricalCovariance, LedoitWolf
 
@@ -15,6 +16,7 @@ from ...storage import MatrixKind, StorageType
 from ...typing import Dependencies, MarkerInOutMappings
 from ...utils import ensure_list_or_none, raise_error
 from ..base import BaseMarker
+from ..utils import _has_data
 
 
 __all__ = ["FunctionalConnectivityBase"]
@@ -140,13 +142,20 @@ class FunctionalConnectivityBase(BaseMarker):
                 if k != "empirical"
             },
         )
+        # Compute on the columns with data (e.g. regions lost in
+        # resampling have none) and set the others to NaN
+        data = aggregation["aggregation"]["data"]
+        has_data = _has_data(data)
+        conn = np.full((data.shape[1], data.shape[1]), np.nan)
+        if has_data.any():
+            conn[np.ix_(has_data, has_data)] = connectivity.fit_transform(
+                [data[:, has_data]]
+            )[0]
         # Create dictionary for output
         labels = aggregation["aggregation"]["col_names"]
         return {
             "functional_connectivity": {
-                "data": connectivity.fit_transform(
-                    [aggregation["aggregation"]["data"]]
-                )[0],
+                "data": conn,
                 "row_names": labels,
                 "col_names": labels,
                 # xi correlation coefficient is not symmetric

{junifer-0.0.8.dev284 → junifer-0.0.8.dev295}/junifer/markers/temporal_snr/temporal_snr_base.py

@@ -104,7 +104,9 @@ class TemporalSNRBase(BaseMarker):
             "img.std(axis=-1).squeeze()", img=input["data"]
         )
         mask_img = nimg.math_img("(stdv_img != 0)", stdv_img=stdv_img)
-        input["data"] = nimg.math_img(
+        # Aggregate the tSNR image, without changing the input
+        aggregation_input = dict(input.items())
+        aggregation_input["data"] = nimg.math_img(
             "np.divide(mean_img, stdv_img, where=mask_img.astype(bool))",
             mean_img=mean_img,
             stdv_img=stdv_img,
@@ -113,8 +115,8 @@ class TemporalSNRBase(BaseMarker):
         # Perform necessary aggregation and return
         return {
             "tsnr": {
-                **self.aggregate(input=input, extra_input=extra_input)[
-                    "aggregation"
-                ]
+                **self.aggregate(
+                    input=aggregation_input, extra_input=extra_input
+                )["aggregation"]
             }
         }

{junifer-0.0.8.dev284 → junifer-0.0.8.dev295}/junifer/markers/temporal_snr/tests/test_temporal_snr_maps.py

@@ -28,7 +28,10 @@ def test_TemporalSNRMaps_computation() -> None:
             input_type=DataType.BOLD, output_feature="tsnr"
         )
         # Fit-transform the data
+        bold_img = element_data["BOLD"]["data"]
         tsnr_parcels = marker.fit_transform(element_data)
+        # The input is not changed
+        assert element_data["BOLD"]["data"] is bold_img
         tsnr_parcels_bold = tsnr_parcels["BOLD"]["tsnr"]
 
         assert "data" in tsnr_parcels_bold

{junifer-0.0.8.dev284 → junifer-0.0.8.dev295}/junifer/markers/temporal_snr/tests/test_temporal_snr_parcels.py

@@ -30,7 +30,10 @@ def test_TemporalSNRParcels_computation() -> None:
             input_type=DataType.BOLD, output_feature="tsnr"
         )
         # Fit-transform the data
+        bold_img = element_data["BOLD"]["data"]
         tsnr_parcels = marker.fit_transform(element_data)
+        # The input is not changed
+        assert element_data["BOLD"]["data"] is bold_img
         tsnr_parcels_bold = tsnr_parcels["BOLD"]["tsnr"]
 
         assert "data" in tsnr_parcels_bold

{junifer-0.0.8.dev284 → junifer-0.0.8.dev295}/junifer/markers/temporal_snr/tests/test_temporal_snr_spheres.py

@@ -28,7 +28,10 @@ def test_TemporalSNRSpheres_computation() -> None:
             input_type=DataType.BOLD, output_feature="tsnr"
         )
         # Fit-transform the data
+        bold_img = element_data["BOLD"]["data"]
         tsnr_spheres = marker.fit_transform(element_data)
+        # The input is not changed
+        assert element_data["BOLD"]["data"] is bold_img
         tsnr_spheres_bold = tsnr_spheres["BOLD"]["tsnr"]
 
         assert "data" in tsnr_spheres_bold

junifer-0.0.8.dev295/junifer/markers/tests/test_lost_regions.py

@@ -0,0 +1,279 @@
+"""Provide tests for markers on regions lost in resampling."""
+
+# Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
+# License: AGPL
+
+from collections.abc import Iterator
+from importlib.util import find_spec
+from pathlib import Path
+
+import nibabel as nib
+import numpy as np
+import pytest
+
+from junifer import markers
+from junifer.data import deregister_data, register_data
+from junifer.datareader import DefaultDataReader
+from junifer.pipeline import WorkDirManager
+
+
+COMPLEXITY_MARKERS = (
+    "HurstExponent",
+    "RangeEntropy",
+    "RangeEntropyAUC",
+    "MultiscaleEntropyAUC",
+    "PermEntropy",
+    "WeightedPermEntropy",
+    "SampleEntropy",
+)
+
+skip_no_neurokit2 = pytest.mark.skipif(
+    find_spec("neurokit2") is None, reason="requires neurokit2"
+)
+
+
+@pytest.fixture(scope="module")
+def element(tmp_path_factory: pytest.TempPathFactory) -> Iterator[dict]:
+    """Provide BOLD data where regions of the parcellations are lost.
+
+    The parcellations are on a 1mm grid and the BOLD data on a 3mm grid,
+    which does not sample their single-voxel regions:
+
+    * ``LostRegion`` (and ``LostRegion2``, the same): regions ``a``, ``b``,
+      ``lost``, ``c`` and ``d``.
+    * ``OneRegionLeft``: regions ``kept``, ``lost`` and ``lost_too``.
+
+    Parameters
+    ----------
+    tmp_path_factory : pytest.TempPathFactory
+        The pytest factory for temporary directories.
+
+    Yields
+    ------
+    dict
+        The element data.
+
+    """
+    tmp_path = tmp_path_factory.mktemp("lost_regions")
+    # Voxels 0, 3, 6, ... are sampled by the 3mm grid, 7 and 13 are not
+    lost_region = np.zeros((24, 24, 24), dtype=np.int16)
+    lost_region[0:12, 0:12] = 1
+    lost_region[12:24, 0:12] = 2
+    lost_region[7, 13, 7] = 3
+    lost_region[0:12, 15:24] = 4
+    lost_region[12:24, 15:24] = 5
+    one_region_left = np.zeros((24, 24, 24), dtype=np.int16)
+    one_region_left[0:12, 0:12] = 1
+    one_region_left[7, 13, 7] = 2
+    one_region_left[13, 7, 7] = 3
+    for name, data, labels in (
+        ("LostRegion", lost_region, ["a", "b", "lost", "c", "d"]),
+        ("LostRegion2", lost_region, ["a", "b", "lost", "c", "d"]),
+        ("OneRegionLeft", one_region_left, ["kept", "lost", "lost_too"]),
+    ):
+        path = tmp_path / f"{name}.nii.gz"
+        nib.save(nib.Nifti1Image(data, np.eye(4)), path)
+        register_data(
+            kind="parcellation",
+            name=name,
+            parcellation_path=path,
+            parcels_labels=labels,
+            space="MNI152NLin6Asym",
+        )
+    # Random walks, so all the measures are defined
+    rng = np.random.default_rng(0)
+    bold = rng.normal(size=(8, 8, 8, 120)).cumsum(axis=-1) + 1000
+    bold_img = nib.Nifti1Image(
+        bold.astype(np.float32), np.diag([3.0, 3.0, 3.0, 1.0])
+    )
+    bold_img.header.set_xyzt_units("mm", "sec")
+    bold_path = tmp_path / "bold.nii.gz"
+    nib.save(bold_img, bold_path)
+    yield DefaultDataReader().fit_transform(
+        {"BOLD": {"path": bold_path, "space": "MNI152NLin6Asym"}}
+    )
+    for name in ("LostRegion", "LostRegion2", "OneRegionLeft"):
+        deregister_data(kind="parcellation", name=name)
+
+
+def _case(name: str, params: dict, feature: str, nan: list) -> object:
+    """Get a test case.
+
+    Parameters
+    ----------
+    name : str
+        The name of the marker class.
+    params : dict
+        The parameters of the marker.
+    feature : str
+        The name of the feature to check.
+    nan : list
+        The values that are NaN.
+
+    Returns
+    -------
+    object
+        The test case, named after the parcellation, marker and feature.
+        Complexity markers are skipped if neurokit2 is not installed.
+
+    """
+    parcellation = params.get("parcellation", params.get("parcellation_one"))
+    return pytest.param(
+        name,
+        params,
+        feature,
+        nan,
+        marks=skip_no_neurokit2 if name in COMPLEXITY_MARKERS else (),
+        id=f"{parcellation}-{name}-{feature}",
+    )
+
+
+# Whether the values are NaN for LostRegion, whose 3rd region is lost
+REGIONS = [False, False, True, False, False]
+# For connectivity, a region pair is NaN if one of the regions is lost
+PAIRS = [[r or c for c in REGIONS] for r in REGIONS]
+# For edge-centric FC, the edges are the region pairs (lower triangle)
+EDGES = [r or c for i, r in enumerate(REGIONS) for c in REGIONS[:i]]
+EDGE_PAIRS = [[r or c for c in EDGES] for r in EDGES]
+
+
+@pytest.mark.parametrize(
+    "name, params, feature, nan",
+    [
+        _case(
+            "ParcelAggregation",
+            {"parcellation": "LostRegion", "method": "mean", "on": "BOLD"},
+            "aggregation",
+            [REGIONS] * 120,
+        ),
+        _case(
+            "FunctionalConnectivityParcels",
+            {"parcellation": "LostRegion"},
+            "functional_connectivity",
+            PAIRS,
+        ),
+        _case(
+            "EdgeCentricFCParcels",
+            {"parcellation": "LostRegion"},
+            "functional_connectivity",
+            EDGE_PAIRS,
+        ),
+        _case(
+            "CrossParcellationFC",
+            {
+                "parcellation_one": "LostRegion",
+                "parcellation_two": "LostRegion2",
+            },
+            "functional_connectivity",
+            PAIRS,
+        ),
+        _case(
+            "ReHoParcels",
+            {"parcellation": "LostRegion", "using": "junifer"},
+            "reho",
+            [REGIONS],
+        ),
+        _case(
+            "ALFFParcels",
+            {"parcellation": "LostRegion", "using": "junifer"},
+            "alff",
+            [REGIONS],
+        ),
+        _case(
+            "ALFFParcels",
+            {"parcellation": "LostRegion", "using": "junifer"},
+            "falff",
+            [REGIONS],
+        ),
+        _case(
+            "TemporalSNRParcels",
+            {"parcellation": "LostRegion"},
+            "tsnr",
+            [REGIONS],
+        ),
+        # Computed with the edges with data
+        _case(
+            "RSSETSMarker",
+            {"parcellation": "LostRegion"},
+            "rss_ets",
+            [[False]] * 120,
+        ),
+        *[
+            _case(
+                name, {"parcellation": "LostRegion"}, "complexity", [REGIONS]
+            )
+            for name in COMPLEXITY_MARKERS
+        ],
+        # Only the kept region with itself
+        _case(
+            "FunctionalConnectivityParcels",
+            {"parcellation": "OneRegionLeft"},
+            "functional_connectivity",
+            [[False, True, True], [True, True, True], [True, True, True]],
+        ),
+        # All the edges have a lost region
+        _case(
+            "EdgeCentricFCParcels",
+            {"parcellation": "OneRegionLeft"},
+            "functional_connectivity",
+            [[True] * 3] * 3,
+        ),
+        # No edges with data
+        _case(
+            "RSSETSMarker",
+            {"parcellation": "OneRegionLeft"},
+            "rss_ets",
+            [[True]] * 120,
+        ),
+        *[
+            _case(
+                name,
+                {"parcellation": "OneRegionLeft"},
+                "complexity",
+                [[False, True, True]],
+            )
+            for name in COMPLEXITY_MARKERS
+        ],
+    ],
+)
+def test_lost_regions(
+    tmp_path: Path,
+    element: dict,
+    name: str,
+    params: dict,
+    feature: str,
+    nan: list,
+) -> None:
+    """Test markers on regions lost in resampling.
+
+    The lost regions have no data (NaN), and the other regions are not
+    affected.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    element : dict
+        The element data.
+    name : str
+        The parametrized name of the marker class.
+    params : dict
+        The parametrized parameters of the marker.
+    feature : str
+        The parametrized name of the feature to check.
+    nan : list
+        The parametrized values that are NaN.
+
+    """
+    if name in COMPLEXITY_MARKERS:
+        from junifer.markers import complexity
+
+        marker = getattr(complexity, name)(**params)
+    else:
+        marker = getattr(markers, name)(**params)
+    WorkDirManager().workdir = tmp_path
+    with pytest.warns(RuntimeWarning, match=r"region\(s\) .* have no voxels"):
+        # Copy the data, as some markers change their input
+        out = marker.fit_transform({"BOLD": dict(element["BOLD"])})
+    data = np.asarray(out["BOLD"][feature]["data"], dtype=float)
+    assert np.array_equal(np.isnan(data), nan)