junifer 0.0.7.dev153__py3-none-any.whl → 0.0.7.dev169__py3-none-any.whl

junifer/markers/temporal_snr/temporal_snr_maps.py

@@ -0,0 +1,80 @@
+"""Provide class for temporal SNR using maps."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from typing import Any, Optional, Union
+
+from ...api.decorators import register_marker
+from ..maps_aggregation import MapsAggregation
+from .temporal_snr_base import TemporalSNRBase
+
+
+__all__ = ["TemporalSNRMaps"]
+
+
+@register_marker
+class TemporalSNRMaps(TemporalSNRBase):
+    """Class for temporal signal-to-noise ratio using maps.
+
+    Parameters
+    ----------
+    maps : str
+        The name of the map(s) to use.
+        See :func:`.list_data` for options.
+    masks : str, dict or list of dict or str, optional
+        The specification of the masks to apply to regions before extracting
+        signals. Check :ref:`Using Masks <using_masks>` for more details.
+        If None, will not apply any mask (default None).
+    name : str, optional
+        The name of the marker. If None, will use the class name (default
+        None).
+
+    """
+
+    def __init__(
+        self,
+        maps: str,
+        masks: Union[str, dict, list[Union[dict, str]], None] = None,
+        name: Optional[str] = None,
+    ) -> None:
+        self.maps = maps
+        super().__init__(
+            masks=masks,
+            name=name,
+        )
+
+    def aggregate(
+        self, input: dict[str, Any], extra_input: Optional[dict] = None
+    ) -> dict:
+        """Perform maps aggregation.
+
+        Parameters
+        ----------
+        input : dict
+            A single input from the pipeline data object in which the data
+            is the voxelwise temporal SNR map.
+        extra_input : dict, optional
+            The other fields in the pipeline data object. Useful for accessing
+            other data kind that needs to be used in the computation. For
+            example, the functional connectivity markers can make use of the
+            confounds if available (default None).
+
+        Returns
+        -------
+        dict
+            The computed result as dictionary. This will be either returned
+            to the user or stored in the storage by calling the store method
+            with this as a parameter. The dictionary has the following keys:
+
+            * ``aggregation`` : dictionary with the following keys:
+
+                - ``data`` : ROI-wise tSNR values as ``numpy.ndarray``
+                - ``col_names`` : ROI labels as list of str
+
+        """
+        return MapsAggregation(
+            maps=self.maps,
+            masks=self.masks,
+            on="BOLD",
+        ).compute(input=input, extra_input=extra_input)

junifer/markers/temporal_snr/tests/test_temporal_snr_maps.py

@@ -0,0 +1,67 @@
+"""Provide tests for temporal signal-to-noise ratio using maps."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from pathlib import Path
+
+from junifer.datagrabber import PatternDataladDataGrabber
+from junifer.datareader import DefaultDataReader
+from junifer.markers import TemporalSNRMaps
+from junifer.storage import HDF5FeatureStorage
+
+
+def test_TemporalSNRMaps_computation(
+    maps_datagrabber: PatternDataladDataGrabber,
+) -> None:
+    """Test TemporalSNRMaps fit-transform.
+
+    Parameters
+    ----------
+    maps_datagrabber : PatternDataladDataGrabber
+        The testing PatternDataladDataGrabber, as fixture.
+
+    """
+    with maps_datagrabber as dg:
+        element = dg[("sub-01", "sub-001", "rest", "1")]
+        element_data = DefaultDataReader().fit_transform(element)
+        marker = TemporalSNRMaps(maps="Smith_rsn_10")
+        # Check correct output
+        assert "vector" == marker.get_output_type(
+            input_type="BOLD", output_feature="tsnr"
+        )
+
+        # Fit-transform the data
+        tsnr_parcels = marker.fit_transform(element_data)
+        tsnr_parcels_bold = tsnr_parcels["BOLD"]["tsnr"]
+
+        assert "data" in tsnr_parcels_bold
+        assert "col_names" in tsnr_parcels_bold
+        assert tsnr_parcels_bold["data"].shape == (1, 10)
+        assert len(set(tsnr_parcels_bold["col_names"])) == 10
+
+
+def test_TemporalSNRMaps_storage(
+    tmp_path: Path, maps_datagrabber: PatternDataladDataGrabber
+) -> None:
+    """Test TemporalSNRMaps store.
+
+    Parameters
+    ----------
+    tmp_path : pathlib.Path
+        The path to the test directory.
+    maps_datagrabber : PatternDataladDataGrabber
+        The testing PatternDataladDataGrabber, as fixture.
+
+    """
+    with maps_datagrabber as dg:
+        element = dg[("sub-01", "sub-001", "rest", "1")]
+        element_data = DefaultDataReader().fit_transform(element)
+        marker = TemporalSNRMaps(maps="Smith_rsn_10")
+        # Store
+        storage = HDF5FeatureStorage(tmp_path / "test_tsnr_maps.hdf5")
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "BOLD_TemporalSNRMaps_tsnr" for x in features.values()
+        )

junifer/markers/tests/test_maps_aggregation.py

@@ -0,0 +1,430 @@
+"""Provide test for maps aggregation."""
+
+# Authors: Synchon Mandal <s.mandal@fz-juelich.de>
+# License: AGPL
+
+from copy import deepcopy
+from pathlib import Path
+
+import pytest
+from nilearn.maskers import NiftiMapsMasker
+from numpy.testing import assert_array_almost_equal, assert_array_equal
+
+from junifer.data import MapsRegistry, MaskRegistry
+from junifer.data.masks import compute_brain_mask
+from junifer.datagrabber import PatternDataladDataGrabber
+from junifer.datareader import DefaultDataReader
+from junifer.markers import MapsAggregation
+from junifer.storage import HDF5FeatureStorage
+
+
+@pytest.mark.parametrize(
+    "input_type, storage_type",
+    [
+        (
+            "T1w",
+            "vector",
+        ),
+        (
+            "T2w",
+            "vector",
+        ),
+        (
+            "BOLD",
+            "timeseries",
+        ),
+        (
+            "VBM_GM",
+            "vector",
+        ),
+        (
+            "VBM_WM",
+            "vector",
+        ),
+        (
+            "VBM_CSF",
+            "vector",
+        ),
+        (
+            "fALFF",
+            "vector",
+        ),
+        (
+            "GCOR",
+            "vector",
+        ),
+        (
+            "LCOR",
+            "vector",
+        ),
+    ],
+)
+def test_MapsAggregation_input_output(
+    input_type: str, storage_type: str
+) -> None:
+    """Test MapsAggregation input and output types.
+
+    Parameters
+    ----------
+    input_type : str
+        The parametrized input type.
+    storage_type : str
+        The parametrized storage type.
+
+    """
+    assert storage_type == MapsAggregation(
+        maps="Smith_rsn_10", on=input_type
+    ).get_output_type(input_type=input_type, output_feature="aggregation")
+
+
+def test_MapsAggregation_3D(
+    maps_datagrabber: PatternDataladDataGrabber,
+) -> None:
+    """Test MapsAggregation on 3D data.
+
+    Parameters
+    ----------
+    maps_datagrabber : PatternDataladDataGrabber
+        The testing PatternDataladDataGrabber, as fixture.
+
+    """
+    with maps_datagrabber as dg:
+        element = dg[("sub-01", "sub-001", "rest", "1")]
+        element_data = DefaultDataReader().fit_transform(element)
+        # Deepcopy data for later use
+        input_data = deepcopy(element_data)
+        # Modify for junifer
+        element_data["BOLD"]["data"] = element_data["BOLD"]["data"].slicer[
+            ...,
+            0:1,
+        ]
+        marker = MapsAggregation(maps="Smith_rsn_10")
+        maps_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
+            "aggregation"
+        ]["data"]
+        assert maps_agg_bold_data.ndim == 2
+
+        # Compare with nilearn
+        # Load testing maps
+        maps, _ = MapsRegistry().get(
+            maps="Smith_rsn_10",
+            target_data=element_data["BOLD"],
+        )
+        # Extract data
+        masker = NiftiMapsMasker(maps_img=maps)
+        nifti_maps_masked_bold = masker.fit_transform(
+            input_data["BOLD"]["data"].slicer[..., 0:1]
+        )
+
+        assert_array_equal(
+            nifti_maps_masked_bold.shape, maps_agg_bold_data.shape
+        )
+        assert_array_equal(nifti_maps_masked_bold, maps_agg_bold_data)
+
+
+def test_MapsAggregation_4D(
+    maps_datagrabber: PatternDataladDataGrabber,
+) -> None:
+    """Test MapsAggregation on 4D data.
+
+    Parameters
+    ----------
+    maps_datagrabber : PatternDataladDataGrabber
+        The testing PatternDataladDataGrabber, as fixture.
+
+    """
+    with maps_datagrabber as dg:
+        element = dg[("sub-01", "sub-001", "rest", "1")]
+        element_data = DefaultDataReader().fit_transform(element)
+        # Deepcopy data for later use
+        input_data = deepcopy(element_data)
+        marker = MapsAggregation(maps="Smith_rsn_10")
+        maps_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
+            "aggregation"
+        ]["data"]
+        assert maps_agg_bold_data.ndim == 2
+
+        # Compare with nilearn
+        # Load testing maps
+        maps, _ = MapsRegistry().get(
+            maps="Smith_rsn_10",
+            target_data=element_data["BOLD"],
+        )
+        # Extract data
+        masker = NiftiMapsMasker(maps_img=maps)
+        nifti_maps_masked_bold = masker.fit_transform(
+            input_data["BOLD"]["data"]
+        )
+
+        assert_array_equal(
+            nifti_maps_masked_bold.shape, maps_agg_bold_data.shape
+        )
+        assert_array_equal(nifti_maps_masked_bold, maps_agg_bold_data)
+
+
+def test_MapsAggregation_storage(
+    maps_datagrabber: PatternDataladDataGrabber, tmp_path: Path
+) -> None:
+    """Test MapsAggregation storage.
+
+    Parameters
+    ----------
+    maps_datagrabber : PatternDataladDataGrabber
+        The testing PatternDataladDataGrabber, as fixture.
+    tmp_path : pathlib.Path
+        The path to the test directory.
+
+    """
+    # Store 3D
+    with maps_datagrabber as dg:
+        element = dg[("sub-01", "sub-001", "rest", "1")]
+        element_data = DefaultDataReader().fit_transform(element)
+        storage = HDF5FeatureStorage(
+            uri=tmp_path / "test_maps_storage_3D.hdf5"
+        )
+        marker = MapsAggregation(
+            maps="Smith_rsn_10",
+            on="BOLD",
+        )
+        element_data["BOLD"]["data"] = element_data["BOLD"]["data"].slicer[
+            ..., 0:1
+        ]
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "BOLD_MapsAggregation_aggregation"
+            for x in features.values()
+        )
+
+    # Store 4D
+    with maps_datagrabber as dg:
+        element = dg[("sub-01", "sub-001", "rest", "1")]
+        element_data = DefaultDataReader().fit_transform(element)
+        storage = HDF5FeatureStorage(
+            uri=tmp_path / "test_maps_storage_4D.sqlite"
+        )
+        marker = MapsAggregation(
+            maps="Smith_rsn_10",
+            on="BOLD",
+        )
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "BOLD_MapsAggregation_aggregation"
+            for x in features.values()
+        )
+
+
+def test_MapsAggregation_3D_mask(
+    maps_datagrabber: PatternDataladDataGrabber,
+) -> None:
+    """Test MapsAggregation on 3D data with mask.
+
+    Parameters
+    ----------
+    maps_datagrabber : PatternDataladDataGrabber
+        The testing PatternDataladDataGrabber, as fixture.
+
+    """
+    with maps_datagrabber as dg:
+        element = dg[("sub-01", "sub-001", "rest", "1")]
+        element_data = DefaultDataReader().fit_transform(element)
+        # Deepcopy data for later use
+        input_data = deepcopy(element_data)
+        # Modify for junifer
+        element_data["BOLD"]["data"] = element_data["BOLD"]["data"].slicer[
+            ...,
+            0:1,
+        ]
+        marker = MapsAggregation(
+            maps="Smith_rsn_10",
+            on="BOLD",
+            masks="compute_brain_mask",
+        )
+        maps_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
+            "aggregation"
+        ]["data"]
+        assert maps_agg_bold_data.ndim == 2
+
+        # Compare with nilearn
+        # Load testing maps
+        maps, _ = MapsRegistry().get(
+            maps="Smith_rsn_10",
+            target_data=element_data["BOLD"],
+        )
+        # Load mask
+        mask_img = MaskRegistry().get(
+            "compute_brain_mask", target_data=element_data["BOLD"]
+        )
+        # Extract data
+        masker = NiftiMapsMasker(maps_img=maps, mask_img=mask_img)
+        nifti_maps_masked_bold = masker.fit_transform(
+            input_data["BOLD"]["data"].slicer[..., 0:1]
+        )
+
+        assert_array_equal(
+            nifti_maps_masked_bold.shape, maps_agg_bold_data.shape
+        )
+        assert_array_equal(nifti_maps_masked_bold, maps_agg_bold_data)
+
+
+def test_MapsAggregation_3D_mask_computed(
+    maps_datagrabber: PatternDataladDataGrabber,
+) -> None:
+    """Test MapsAggregation on 3D data with computed masks.
+
+    Parameters
+    ----------
+    maps_datagrabber : PatternDataladDataGrabber
+        The testing PatternDataladDataGrabber, as fixture.
+
+    """
+    with maps_datagrabber as dg:
+        element = dg[("sub-01", "sub-001", "rest", "1")]
+        element_data = DefaultDataReader().fit_transform(element)
+
+        # Compare with nilearn
+        # Load testing maps
+        maps, _ = MapsRegistry().get(
+            maps="Smith_rsn_10",
+            target_data=element_data["BOLD"],
+        )
+        # Get a mask
+        mask_img = compute_brain_mask(element_data["BOLD"], threshold=0.2)
+        # Create NiftiMapsMasker
+        masker = NiftiMapsMasker(maps_img=maps, mask_img=mask_img)
+        nifti_maps_masked_bold_good = masker.fit_transform(
+            element_data["BOLD"]["data"]
+        )
+
+        # Get another mask
+        mask_img = compute_brain_mask(element_data["BOLD"], threshold=0.5)
+        # Create NiftiMapsMasker
+        masker = NiftiMapsMasker(maps_img=maps, mask_img=mask_img)
+        nifti_maps_masked_bold_bad = masker.fit_transform(mask_img)
+
+        # Use the MapsAggregation object
+        marker = MapsAggregation(
+            maps="Smith_rsn_10",
+            masks={"compute_brain_mask": {"threshold": 0.2}},
+            on="BOLD",
+        )
+        maps_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
+            "aggregation"
+        ]["data"]
+
+        assert maps_agg_bold_data.ndim == 2
+        assert_array_almost_equal(
+            nifti_maps_masked_bold_good, maps_agg_bold_data
+        )
+
+        with pytest.raises(AssertionError):
+            assert_array_almost_equal(
+                maps_agg_bold_data, nifti_maps_masked_bold_bad
+            )
+
+
+def test_MapsAggregation_4D_agg_time(
+    maps_datagrabber: PatternDataladDataGrabber,
+):
+    """Test MapsAggregation on 4D data, aggregating time.
+
+    Parameters
+    ----------
+    maps_datagrabber : PatternDataladDataGrabber
+        The testing PatternDataladDataGrabber, as fixture.
+
+    """
+    with maps_datagrabber as dg:
+        element = dg[("sub-01", "sub-001", "rest", "1")]
+        element_data = DefaultDataReader().fit_transform(element)
+        # Create MapsAggregation object
+        marker = MapsAggregation(
+            maps="Smith_rsn_10",
+            time_method="mean",
+            on="BOLD",
+        )
+        maps_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
+            "aggregation"
+        ]["data"]
+
+        # Compare with nilearn
+        # Loading testing maps
+        maps, _ = MapsRegistry().get(
+            maps="Smith_rsn_10",
+            target_data=element_data["BOLD"],
+        )
+        # Extract data
+        masker = NiftiMapsMasker(maps_img=maps)
+        nifti_maps_masked_bold = masker.fit_transform(
+            element_data["BOLD"]["data"]
+        )
+        nifti_maps_masked_bold_mean = nifti_maps_masked_bold.mean(axis=0)
+
+        assert maps_agg_bold_data.ndim == 1
+        assert_array_equal(
+            nifti_maps_masked_bold_mean.shape, maps_agg_bold_data.shape
+        )
+        assert_array_almost_equal(
+            nifti_maps_masked_bold_mean, maps_agg_bold_data, decimal=2
+        )
+
+        # Test picking first time point
+        nifti_maps_masked_bold_pick_0 = nifti_maps_masked_bold[:1, :]
+        marker = MapsAggregation(
+            maps="Smith_rsn_10",
+            time_method="select",
+            time_method_params={"pick": [0]},
+            on="BOLD",
+        )
+        maps_agg_bold_data = marker.fit_transform(element_data)["BOLD"][
+            "aggregation"
+        ]["data"]
+
+        assert maps_agg_bold_data.ndim == 2
+        assert_array_equal(
+            nifti_maps_masked_bold_pick_0.shape, maps_agg_bold_data.shape
+        )
+        assert_array_equal(nifti_maps_masked_bold_pick_0, maps_agg_bold_data)
+
+
+def test_MapsAggregation_errors() -> None:
+    """Test errors for MapsAggregation."""
+    with pytest.raises(ValueError, match="can only be used with BOLD data"):
+        MapsAggregation(
+            maps="Smith_rsn_10",
+            time_method="select",
+            time_method_params={"pick": [0]},
+            on="VBM_GM",
+        )
+
+    with pytest.raises(
+        ValueError, match="can only be used with `time_method`"
+    ):
+        MapsAggregation(
+            maps="Smith_rsn_10",
+            time_method_params={"pick": [0]},
+            on="VBM_GM",
+        )
+
+
+def test_MapsAggregation_warning(
+    maps_datagrabber: PatternDataladDataGrabber,
+) -> None:
+    """Test warning for MapsAggregation."""
+    with maps_datagrabber as dg:
+        element = dg[("sub-01", "sub-001", "rest", "1")]
+        element_data = DefaultDataReader().fit_transform(element)
+        with pytest.warns(
+            RuntimeWarning, match="No time dimension to aggregate"
+        ):
+            marker = MapsAggregation(
+                maps="Smith_rsn_10",
+                time_method="select",
+                time_method_params={"pick": [0]},
+                on="BOLD",
+            )
+            element_data["BOLD"]["data"] = element_data["BOLD"]["data"].slicer[
+                ..., 0:1
+            ]
+            marker.fit_transform(element_data)

junifer/typing/_typing.py

@@ -65,9 +65,7 @@ ConditionalDependencies = Sequence[
 ]
 ExternalDependencies = Sequence[MutableMapping[str, Union[str, Sequence[str]]]]
 MarkerInOutMappings = MutableMapping[str, MutableMapping[str, str]]
-DataGrabberPatterns = dict[
-    str, Union[dict[str, str], list[dict[str, str]]]
-]
+DataGrabberPatterns = dict[str, Union[dict[str, str], list[dict[str, str]]]]
 ConfigVal = Union[bool, int, float, str]
 Element = Union[str, tuple[str, ...]]
 Elements = Sequence[Element]

{junifer-0.0.7.dev153.dist-info → junifer-0.0.7.dev169.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: junifer
-Version: 0.0.7.dev153
+Version: 0.0.7.dev169
 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>