junifer 0.0.4.dev829__py3-none-any.whl → 0.0.5__py3-none-any.whl

junifer/external/nilearn/tests/test_junifer_nifti_spheres_masker.py

@@ -4,12 +4,14 @@
 # License: AGPL
 
 import warnings
+from typing import List, Tuple
 
 import nibabel
 import numpy as np
 import pytest
 from nilearn._utils import data_gen
 from nilearn.image import get_data
+from nilearn.maskers import NiftiSpheresMasker
 from numpy.testing import assert_array_equal
 
 from junifer.external.nilearn import JuniferNiftiSpheresMasker
@@ -17,7 +19,7 @@ from junifer.external.nilearn import JuniferNiftiSpheresMasker
 
 # New BSD License
 
-# Copyright (c) 2007 - 2022 The nilearn developers.
+# Copyright (c) The nilearn developers.
 # All rights reserved.
 
 
@@ -331,3 +333,76 @@ def test_nifti_spheres_masker_io_shapes() -> None:
         )
         test_data = masker.transform(img_4d)
         assert test_data.shape == (n_volumes, n_regions)
+
+
+@pytest.mark.parametrize(
+    "shape",
+    [
+        (10, 11, 12),
+        (10, 11, 12, 5),
+    ],
+)
+@pytest.mark.parametrize(
+    "radius, allow_overlap",
+    [
+        (2.0, True),
+        (2.0, False),
+        (3.0, True),
+        (4.0, True),
+        (5.0, True),
+    ],
+)
+@pytest.mark.parametrize(
+    "coords",
+    [
+        [(1, 1, 1)],
+        [(1, 1, 1), (4, 4, 4)],
+        [(1, 1, 1), (4, 4, 4), (10, 10, 10)],
+    ],
+)
+def test_junifer_and_nilearn_mean_agg_are_equal(
+    shape: Tuple[int, ...],
+    radius: float,
+    allow_overlap: bool,
+    coords: List[Tuple[int, int, int]],
+) -> None:
+    """Test junifer's masker behaves same as nilearn's when agg is mean.
+
+    Parameters
+    ----------
+    shape : tuple of int
+        The parametrized shape of the input image.
+    radius : float
+        The parametrized radius of the spheres.
+    allow_overlap : bool
+        The parametrized option to overlap spheres or not.
+    coords : list of tuple of int, int and int
+        The parametrized seeds.
+
+    """
+    # Set affine
+    affine = np.eye(4)
+    # Generate random image
+    input_img, mask_img = data_gen.generate_random_img(
+        shape=shape,
+        affine=affine,
+    )
+    # Compute junifer's version
+    junifer_masker = JuniferNiftiSpheresMasker(
+        seeds=coords,
+        radius=radius,
+        allow_overlap=allow_overlap,
+        mask_img=mask_img,
+    )
+    junifer_output = junifer_masker.fit_transform(input_img)
+    # Compute nilearn's version
+    nilearn_masker = NiftiSpheresMasker(
+        seeds=coords,
+        radius=radius,
+        allow_overlap=allow_overlap,
+        mask_img=mask_img,
+    )
+    nilearn_output = nilearn_masker.fit_transform(input_img)
+    # Checks
+    assert junifer_output.shape == nilearn_output.shape
+    np.testing.assert_almost_equal(junifer_output, nilearn_output)

junifer/markers/__init__.py

@@ -1,4 +1,4 @@
-"""Provide imports for markers sub-package."""
+"""Markers for feature extraction."""
 
 # Authors: Federico Raimondo <f.raimondo@fz-juelich.de>
 #          Leonard Sasse <l.sasse@fz-juelich.de>
@@ -23,3 +23,25 @@ from .temporal_snr import (
     TemporalSNRParcels,
     TemporalSNRSpheres,
 )
+from .brainprint import BrainPrint
+
+
+__all__ = [
+    "BaseMarker",
+    "MarkerCollection",
+    "RSSETSMarker",
+    "ParcelAggregation",
+    "SphereAggregation",
+    "FunctionalConnectivityParcels",
+    "FunctionalConnectivitySpheres",
+    "CrossParcellationFC",
+    "EdgeCentricFCParcels",
+    "EdgeCentricFCSpheres",
+    "ReHoParcels",
+    "ReHoSpheres",
+    "ALFFParcels",
+    "ALFFSpheres",
+    "TemporalSNRParcels",
+    "TemporalSNRSpheres",
+    "BrainPrint",
+]

junifer/markers/base.py

@@ -5,6 +5,7 @@
 # License: AGPL
 
 from abc import ABC, abstractmethod
+from copy import deepcopy
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 from ..pipeline import PipelineStepMixin, UpdateMetaMixin
@@ -15,20 +16,28 @@ if TYPE_CHECKING:
     from junifer.storage import BaseFeatureStorage
 
 
+__all__ = ["BaseMarker"]
+
+
 class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
     """Abstract base class for all markers.
 
+    For every interface that is required, one needs to provide a concrete
+    implementation of this abstract class.
+
     Parameters
     ----------
-    on : str or list of str
-        The kind of data to apply the marker to. By default, will work on all
-        available data.
+    on : str or list of str or None, optional
+        The data type to apply the marker on. If None,
+        will work on all available data types (default None).
     name : str, optional
-        The name of the marker. By default, it will use the class name as the
+        The name of the marker. If None, will use the class name as the
         name of the marker (default None).
 
     Raises
     ------
+    AttributeError
+        If the marker does not have `_MARKER_INOUT_MAPPINGS` attribute.
     ValueError
         If required input data type(s) is(are) not found.
 
@@ -39,6 +48,12 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
         on: Optional[Union[List[str], str]] = None,
         name: Optional[str] = None,
     ) -> None:
+        # Check for missing mapping attribute
+        if not hasattr(self, "_MARKER_INOUT_MAPPINGS"):
+            raise_error(
+                msg=("Missing `_MARKER_INOUT_MAPPINGS` for the marker"),
+                klass=AttributeError,
+            )
         # Use all data types if not provided
         if on is None:
             on = self.get_valid_inputs()
@@ -82,7 +97,6 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
             )
         return [x for x in self._on if x in input]
 
-    @abstractmethod
     def get_valid_inputs(self) -> List[str]:
         """Get valid data types for input.
 
@@ -92,30 +106,25 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
             The list of data types that can be used as input for this marker.
 
         """
-        raise_error(
-            msg="Concrete classes need to implement get_valid_inputs().",
-            klass=NotImplementedError,
-        )
+        return list(self._MARKER_INOUT_MAPPINGS.keys())
 
-    @abstractmethod
-    def get_output_type(self, input_type: str) -> str:
+    def get_output_type(self, input_type: str, output_feature: str) -> str:
         """Get output type.
 
         Parameters
         ----------
         input_type : str
             The data type input to the marker.
+        output_feature : str
+            The feature output of the marker.
 
         Returns
         -------
         str
-            The storage type output by the marker.
+            The storage type output of the marker.
 
         """
-        raise_error(
-            msg="Concrete classes need to implement get_output_type().",
-            klass=NotImplementedError,
-        )
+        return self._MARKER_INOUT_MAPPINGS[input_type][output_feature]
 
     @abstractmethod
     def compute(self, input: Dict, extra_input: Optional[Dict] = None) -> Dict:
@@ -148,6 +157,7 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
     def store(
         self,
         type_: str,
+        feature: str,
         out: Dict[str, Any],
         storage: "BaseFeatureStorage",
     ) -> None:
@@ -157,13 +167,15 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
         ----------
         type_ : str
             The data type to store.
+        feature : str
+            The feature to store.
         out : dict
             The computed result as a dictionary to store.
         storage : storage-like
             The storage class, for example, SQLiteFeatureStorage.
 
         """
-        output_type_ = self.get_output_type(type_)
+        output_type_ = self.get_output_type(type_, feature)
         logger.debug(f"Storing {output_type_} in {storage}")
         storage.store(kind=output_type_, **out)
 
@@ -192,22 +204,50 @@ class BaseMarker(ABC, PipelineStepMixin, UpdateMetaMixin):
         for type_ in self._on:
             if type_ in input.keys():
                 logger.info(f"Computing {type_}")
+                # Get data dict for data type
                 t_input = input[type_]
+                # Pass the other data types as extra input, removing
+                # the current type
                 extra_input = input.copy()
                 extra_input.pop(type_)
+                logger.debug(
+                    f"Extra data type for feature extraction: "
+                    f"{extra_input.keys()}"
+                )
+                # Copy metadata
                 t_meta = t_input["meta"].copy()
                 t_meta["type"] = type_
-
+                # Compute marker
                 t_out = self.compute(input=t_input, extra_input=extra_input)
-                t_out["meta"] = t_meta
-
-                self.update_meta(t_out, "marker")
-
-                if storage is not None:
-                    logger.info(f"Storing in {storage}")
-                    self.store(type_=type_, out=t_out, storage=storage)
-                else:
-                    logger.info("No storage specified, returning dictionary")
-                    out[type_] = t_out
+                # Initialize empty dictionary if no storage object is provided
+                if storage is None:
+                    out[type_] = {}
+                # Store individual features
+                for feature_name, feature_data in t_out.items():
+                    # Make deep copy of the feature data for manipulation
+                    feature_data_copy = deepcopy(feature_data)
+                    # Make deep copy of metadata and add to feature data
+                    feature_data_copy["meta"] = deepcopy(t_meta)
+                    # Update metadata for the feature,
+                    # feature data is not manipulated, only meta
+                    self.update_meta(feature_data_copy, "marker")
+                    # Update marker feature's metadata name
+                    feature_data_copy["meta"]["marker"][
+                        "name"
+                    ] += f"_{feature_name}"
+
+                    if storage is not None:
+                        logger.info(f"Storing in {storage}")
+                        self.store(
+                            type_=type_,
+                            feature=feature_name,
+                            out=feature_data_copy,
+                            storage=storage,
+                        )
+                    else:
+                        logger.info(
+                            "No storage specified, returning dictionary"
+                        )
+                        out[type_][feature_name] = feature_data_copy
 
         return out