junifer 0.0.5__py3-none-any.whl → 0.0.5.dev11__py3-none-any.whl

junifer/markers/functional_connectivity/functional_connectivity_base.py

@@ -7,74 +7,60 @@
 from abc import abstractmethod
 from typing import Any, ClassVar, Dict, List, Optional, Set, Union
 
-from sklearn.covariance import EmpiricalCovariance, LedoitWolf
+from nilearn.connectome import ConnectivityMeasure
+from sklearn.covariance import EmpiricalCovariance
 
-from ...external.nilearn import JuniferConnectivityMeasure
 from ...utils import raise_error
 from ..base import BaseMarker
 
 
-__all__ = ["FunctionalConnectivityBase"]
-
-
 class FunctionalConnectivityBase(BaseMarker):
     """Abstract base class for functional connectivity markers.
 
     Parameters
     ----------
     agg_method : str, optional
-        The method to perform aggregation using.
-        Check valid options in :func:`.get_aggfunc_by_name`
-        (default "mean").
+        The method to perform aggregation using. Check valid options in
+        :func:`.get_aggfunc_by_name` (default "mean").
     agg_method_params : dict, optional
-        Parameters to pass to the aggregation function.
-        Check valid options in :func:`.get_aggfunc_by_name`
-        (default None).
-    conn_method : str, optional
-        The method to perform connectivity measure using.
-        Check valid options in :class:`.JuniferConnectivityMeasure`
-        (default "correlation").
-    conn_method_params : dict, optional
-        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
-        If None, ``{"empirical": True}`` will be used, which would mean
-        :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
-        covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
-        desired, ``{"empirical": False}`` should be passed
-        (default None).
+        Parameters to pass to the aggregation function. Check valid options in
+        :func:`.get_aggfunc_by_name` (default None).
+    cor_method : str, optional
+        The method to perform correlation using. Check valid options in
+        :class:`nilearn.connectome.ConnectivityMeasure`
+        (default "covariance").
+    cor_method_params : dict, optional
+        Parameters to pass to the correlation function. Check valid options in
+        :class:`nilearn.connectome.ConnectivityMeasure` (default None).
     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 ``BOLD_<class_name>``
-        (default None).
+        The name of the marker. If None, will use the class name (default
+        None).
 
     """
 
     _DEPENDENCIES: ClassVar[Set[str]] = {"nilearn", "scikit-learn"}
 
-    _MARKER_INOUT_MAPPINGS: ClassVar[Dict[str, Dict[str, str]]] = {
-        "BOLD": {
-            "functional_connectivity": "matrix",
-        },
-    }
-
     def __init__(
         self,
         agg_method: str = "mean",
         agg_method_params: Optional[Dict] = None,
-        conn_method: str = "correlation",
-        conn_method_params: Optional[Dict] = None,
+        cor_method: str = "covariance",
+        cor_method_params: Optional[Dict] = None,
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
         self.agg_method = agg_method
         self.agg_method_params = agg_method_params
-        self.conn_method = conn_method
-        self.conn_method_params = conn_method_params or {}
-        # Reverse of nilearn behavior
-        self.conn_method_params["empirical"] = self.conn_method_params.get(
-            "empirical", True
+        self.cor_method = cor_method
+        self.cor_method_params = cor_method_params or {}
+
+        # default to nilearn behavior
+        self.cor_method_params["empirical"] = self.cor_method_params.get(
+            "empirical", False
         )
         self.masks = masks
         super().__init__(on="BOLD", name=name)
@@ -91,6 +77,33 @@ class FunctionalConnectivityBase(BaseMarker):
             klass=NotImplementedError,
         )
 
+    def get_valid_inputs(self) -> List[str]:
+        """Get valid data types for input.
+
+        Returns
+        -------
+        list of str
+            The list of data types that can be used as input for this marker.
+
+        """
+        return ["BOLD"]
+
+    def get_output_type(self, input_type: str) -> str:
+        """Get output type.
+
+        Parameters
+        ----------
+        input_type : str
+            The data type input to the marker.
+
+        Returns
+        -------
+        str
+            The storage type output by the marker.
+
+        """
+        return "matrix"
+
     def compute(
         self,
         input: Dict[str, Any],
@@ -112,44 +125,30 @@ class FunctionalConnectivityBase(BaseMarker):
         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:
-
-            * ``functional_connectivity`` : dictionary with the following keys:
+            The computed result as dictionary. The following keys will be
+            included in the dictionary:
 
-              - ``data`` : functional connectivity matrix as ``numpy.ndarray``
-              - ``row_names`` : ROI labels as list of str
-              - ``col_names`` : ROI labels as list of str
-              - ``matrix_kind`` : the kind of matrix (tril, triu or full)
+            * ``data`` : functional connectivity matrix as a ``numpy.ndarray``.
+            * ``row_names`` : row names as a list
+            * ``col_names`` : column names as a list
+            * ``matrix_kind`` : the kind of matrix (tril, triu or full)
 
         """
         # Perform necessary aggregation
         aggregation = self.aggregate(input, extra_input=extra_input)
-        # Set covariance estimator
-        if self.conn_method_params["empirical"]:
-            cov_estimator = EmpiricalCovariance(store_precision=False)
-        else:
-            cov_estimator = LedoitWolf(store_precision=False)
         # Compute correlation
-        connectivity = JuniferConnectivityMeasure(
-            cov_estimator=cov_estimator,
-            kind=self.conn_method,
-            **{
-                k: v
-                for k, v in self.conn_method_params.items()
-                if k != "empirical"
-            },
-        )
+        if self.cor_method_params["empirical"]:
+            connectivity = ConnectivityMeasure(
+                cov_estimator=EmpiricalCovariance(),  # type: ignore
+                kind=self.cor_method,
+            )
+        else:
+            connectivity = ConnectivityMeasure(kind=self.cor_method)
         # Create dictionary for output
-        return {
-            "functional_connectivity": {
-                "data": connectivity.fit_transform(
-                    [aggregation["aggregation"]["data"]]
-                )[0],
-                # Create column names
-                "row_names": aggregation["aggregation"]["col_names"],
-                "col_names": aggregation["aggregation"]["col_names"],
-                "matrix_kind": "tril",
-            },
-        }
+        out = {}
+        out["data"] = connectivity.fit_transform([aggregation["data"]])[0]
+        # Create column names
+        out["row_names"] = aggregation["col_names"]
+        out["col_names"] = aggregation["col_names"]
+        out["matrix_kind"] = "tril"
+        return out

junifer/markers/functional_connectivity/functional_connectivity_parcels.py

@@ -12,9 +12,6 @@ from ..parcel_aggregation import ParcelAggregation
 from .functional_connectivity_base import FunctionalConnectivityBase
 
 
-__all__ = ["FunctionalConnectivityParcels"]
-
-
 @register_marker
 class FunctionalConnectivityParcels(FunctionalConnectivityBase):
     """Class for functional connectivity using parcellations.
@@ -22,34 +19,28 @@ class FunctionalConnectivityParcels(FunctionalConnectivityBase):
     Parameters
     ----------
     parcellation : str or list of str
-        The name(s) of the parcellation(s) to use.
-        See :func:`.list_parcellations` for options.
+        The name(s) of the parcellation(s). Check valid options by calling
+        :func:`.list_parcellations`.
     agg_method : str, optional
-        The method to perform aggregation using.
-        See :func:`.get_aggfunc_by_name` for options
-        (default "mean").
+        The method to perform aggregation using. Check valid options in
+        :func:`.get_aggfunc_by_name` (default "mean").
     agg_method_params : dict, optional
-        Parameters to pass to the aggregation function.
-        See :func:`.get_aggfunc_by_name` for options
-        (default None).
-    conn_method : str, optional
-        The method to perform connectivity measure using.
-        See :class:`.JuniferConnectivityMeasure` for options
-        (default "correlation").
-    conn_method_params : dict, optional
-        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
-        If None, ``{"empirical": True}`` will be used, which would mean
-        :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
-        covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
-        desired, ``{"empirical": False}`` should be passed
-        (default None).
+        Parameters to pass to the aggregation function. Check valid options in
+        :func:`.get_aggfunc_by_name` (default None).
+    cor_method : str, optional
+        The method to perform correlation using. Check valid options in
+        :class:`nilearn.connectome.ConnectivityMeasure`
+        (default "covariance").
+    cor_method_params : dict, optional
+        Parameters to pass to the correlation function. Check valid options in
+        :class:`nilearn.connectome.ConnectivityMeasure` (default None).
     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
-        ``BOLD_FunctionalConnectivityParcels`` (default None).
+        The name of the marker. If None, will use the class name (default
+        None).
 
     """
 
@@ -58,8 +49,8 @@ class FunctionalConnectivityParcels(FunctionalConnectivityBase):
         parcellation: Union[str, List[str]],
         agg_method: str = "mean",
         agg_method_params: Optional[Dict] = None,
-        conn_method: str = "correlation",
-        conn_method_params: Optional[Dict] = None,
+        cor_method: str = "covariance",
+        cor_method_params: Optional[Dict] = None,
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
@@ -67,8 +58,8 @@ class FunctionalConnectivityParcels(FunctionalConnectivityBase):
         super().__init__(
             agg_method=agg_method,
             agg_method_params=agg_method_params,
-            conn_method=conn_method,
-            conn_method_params=conn_method_params,
+            cor_method=cor_method,
+            cor_method_params=cor_method_params,
             masks=masks,
             name=name,
         )
@@ -96,16 +87,16 @@ class FunctionalConnectivityParcels(FunctionalConnectivityBase):
             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 values as ``numpy.ndarray``
-                - ``col_names`` : ROI labels as list of str
+            * ``data`` : the actual computed values as a numpy.ndarray
+            * ``col_names`` : the column labels for the computed values as list
 
         """
-        return ParcelAggregation(
+        parcel_aggregation = ParcelAggregation(
             parcellation=self.parcellation,
             method=self.agg_method,
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        ).compute(input=input, extra_input=extra_input)
+        )
+        # Return the 2D timeseries after parcel aggregation
+        return parcel_aggregation.compute(input, extra_input=extra_input)

junifer/markers/functional_connectivity/functional_connectivity_spheres.py

@@ -13,9 +13,6 @@ from ..utils import raise_error
 from .functional_connectivity_base import FunctionalConnectivityBase
 
 
-__all__ = ["FunctionalConnectivitySpheres"]
-
-
 @register_marker
 class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
     """Class for functional connectivity using coordinates (spheres).
@@ -23,42 +20,35 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
     Parameters
     ----------
     coords : str
-        The name of the coordinates list to use.
-        See :func:`.list_coordinates` for options.
-    radius : positive float, optional
-        The radius of the sphere around each coordinates in millimetres.
-        If None, the signal will be extracted from a single voxel.
-        See :class:`.JuniferNiftiSpheresMasker` for more information
-        (default None).
+        The name of the coordinates list to use. See
+        :func:`.list_coordinates` for options.
+    radius : float, optional
+        The radius of the sphere in mm. If None, the signal will be extracted
+        from a single voxel. See :class:`nilearn.maskers.NiftiSpheresMasker`
+        for more information (default None).
     allow_overlap : bool, optional
         Whether to allow overlapping spheres. If False, an error is raised if
-        the spheres overlap (default False).
+        the spheres overlap (default is False).
     agg_method : str, optional
-        The method to perform aggregation using.
-        See :func:`.get_aggfunc_by_name` for options
-        (default "mean").
-    agg_method_params : dict, optional
-        Parameters to pass to the aggregation function.
-        See :func:`.get_aggfunc_by_name` for options
-        (default None).
-    conn_method : str, optional
-        The method to perform connectivity measure using.
-        See :class:`.JuniferConnectivityMeasure` for options
-        (default "correlation").
-    conn_method_params : dict, optional
-        Parameters to pass to :class:`.JuniferConnectivityMeasure`.
-        If None, ``{"empirical": True}`` will be used, which would mean
-        :class:`sklearn.covariance.EmpiricalCovariance` is used to compute
-        covariance. If usage of :class:`sklearn.covariance.LedoitWolf` is
-        desired, ``{"empirical": False}`` should be passed
+        The aggregation method to use.
+        See :func:`.get_aggfunc_by_name` for more information
         (default None).
+    agg_method_params : dict, optional
+        The parameters to pass to the aggregation method (default None).
+    cor_method : str, optional
+        The method to perform correlation using. Check valid options in
+        :class:`nilearn.connectome.ConnectivityMeasure` (default "covariance").
+    cor_method_params : dict, optional
+        Parameters to pass to the correlation function. Check valid options in
+        :class:`nilearn.connectome.ConnectivityMeasure` (default None).
     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
-        ``BOLD_FunctionalConnectivitySpheres`` (default None).
+        The name of the marker. By default, it will use
+        KIND_FunctionalConnectivitySpheres where KIND is the kind of data it
+        was applied to (default None).
 
     """
 
@@ -69,8 +59,8 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
         allow_overlap: bool = False,
         agg_method: str = "mean",
         agg_method_params: Optional[Dict] = None,
-        conn_method: str = "correlation",
-        conn_method_params: Optional[Dict] = None,
+        cor_method: str = "covariance",
+        cor_method_params: Optional[Dict] = None,
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
@@ -82,8 +72,8 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
         super().__init__(
             agg_method=agg_method,
             agg_method_params=agg_method_params,
-            conn_method=conn_method,
-            conn_method_params=conn_method_params,
+            cor_method=cor_method,
+            cor_method_params=cor_method_params,
             masks=masks,
             name=name,
         )
@@ -111,13 +101,11 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
             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 values as ``numpy.ndarray``
-                - ``col_names`` : ROI labels as list of str
+            * ``data`` : the actual computed values as a numpy.ndarray
+            * ``col_names`` : the column labels for the computed values as list
 
         """
-        return SphereAggregation(
+        sphere_aggregation = SphereAggregation(
             coords=self.coords,
             radius=self.radius,
             allow_overlap=self.allow_overlap,
@@ -125,4 +113,6 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        ).compute(input=input, extra_input=extra_input)
+        )
+        # Return the 2D timeseries after sphere aggregation
+        return sphere_aggregation.compute(input, extra_input=extra_input)

junifer/markers/functional_connectivity/tests/test_crossparcellation_functional_connectivity.py

@@ -27,17 +27,16 @@ def test_init() -> None:
         CrossParcellationFC(
             parcellation_one="a",
             parcellation_two="a",
-            corr_method="pearson",
+            correlation_method="pearson",
         )
 
 
 def test_get_output_type() -> None:
     """Test CrossParcellationFC get_output_type()."""
-    assert "matrix" == CrossParcellationFC(
+    crossparcellation = CrossParcellationFC(
         parcellation_one=parcellation_one, parcellation_two=parcellation_two
-    ).get_output_type(
-        input_type="BOLD", output_feature="functional_connectivity"
     )
+    assert "matrix" == crossparcellation.get_output_type("BOLD")
 
 
 @pytest.mark.skipif(
@@ -58,11 +57,9 @@ def test_compute(tmp_path: Path) -> None:
         crossparcellation = CrossParcellationFC(
             parcellation_one=parcellation_one,
             parcellation_two=parcellation_two,
-            corr_method="spearman",
+            correlation_method="spearman",
         )
-        out = crossparcellation.compute(element_data["BOLD"])[
-            "functional_connectivity"
-        ]
+        out = crossparcellation.compute(element_data["BOLD"])
         assert out["data"].shape == (200, 100)
         assert len(out["col_names"]) == 100
         assert len(out["row_names"]) == 200
@@ -86,7 +83,7 @@ def test_store(tmp_path: Path) -> None:
         crossparcellation = CrossParcellationFC(
             parcellation_one=parcellation_one,
             parcellation_two=parcellation_two,
-            corr_method="spearman",
+            correlation_method="spearman",
         )
         storage = SQLiteFeatureStorage(
             uri=tmp_path / "test_crossparcellation.sqlite", upsert="ignore"
@@ -95,6 +92,5 @@ def test_store(tmp_path: Path) -> None:
         crossparcellation.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_CrossParcellationFC_functional_connectivity"
-            for x in features.values()
+            x["name"] == "BOLD_CrossParcellationFC" for x in features.values()
         )

junifer/markers/functional_connectivity/tests/test_edge_functional_connectivity_parcels.py

@@ -5,9 +5,6 @@
 # License: AGPL
 
 from pathlib import Path
-from typing import Dict
-
-import pytest
 
 from junifer.datareader import DefaultDataReader
 from junifer.markers.functional_connectivity import EdgeCentricFCParcels
@@ -15,51 +12,35 @@ from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 
 
-@pytest.mark.parametrize(
-    "conn_method_params",
-    [
-        {"empirical": False},
-        {"empirical": True},
-    ],
-)
-def test_EdgeCentricFCParcels(
-    tmp_path: Path,
-    conn_method_params: Dict[str, bool],
-) -> None:
+def test_EdgeCentricFCParcels(tmp_path: Path) -> None:
     """Test EdgeCentricFCParcels.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
-    conn_method_params : dict
-        The parametrized parameters to connectivity measure method.
 
     """
     with PartlyCloudyTestingDataGrabber() as dg:
-        # Get element data
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
-        # Setup marker
         marker = EdgeCentricFCParcels(
             parcellation="TianxS1x3TxMNInonlinear2009cAsym",
-            conn_method="correlation",
-            conn_method_params=conn_method_params,
+            cor_method_params={"empirical": True},
         )
         # Check correct output
-        assert "matrix" == marker.get_output_type(
-            input_type="BOLD", output_feature="functional_connectivity"
-        )
+        assert marker.get_output_type("BOLD") == "matrix"
 
         # Fit-transform the data
         edge_fc = marker.fit_transform(element_data)
-        edge_fc_bold = edge_fc["BOLD"]["functional_connectivity"]
+        edge_fc_bold = edge_fc["BOLD"]
 
         # For 16 ROIs we should get (16 * (16 -1) / 2) edges in the ETS
         n_edges = int(16 * (16 - 1) / 2)
         assert "data" in edge_fc_bold
         assert "row_names" in edge_fc_bold
         assert "col_names" in edge_fc_bold
-        assert edge_fc_bold["data"].shape == (n_edges, n_edges)
+        assert edge_fc_bold["data"].shape[0] == n_edges
+        assert edge_fc_bold["data"].shape[1] == n_edges
         assert len(set(edge_fc_bold["row_names"])) == n_edges
         assert len(set(edge_fc_bold["col_names"])) == n_edges
 
@@ -70,6 +51,5 @@ def test_EdgeCentricFCParcels(
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_EdgeCentricFCParcels_functional_connectivity"
-            for x in features.values()
+            x["name"] == "BOLD_EdgeCentricFCParcels" for x in features.values()
         )

junifer/markers/functional_connectivity/tests/test_edge_functional_connectivity_spheres.py

@@ -5,9 +5,6 @@
 # License: AGPL
 
 from pathlib import Path
-from typing import Dict
-
-import pytest
 
 from junifer.datareader import DefaultDataReader
 from junifer.markers.functional_connectivity import EdgeCentricFCSpheres
@@ -15,45 +12,26 @@ from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 
 
-@pytest.mark.parametrize(
-    "conn_method_params",
-    [
-        {"empirical": False},
-        {"empirical": True},
-    ],
-)
-def test_EdgeCentricFCSpheres(
-    tmp_path: Path,
-    conn_method_params: Dict[str, bool],
-) -> None:
+def test_EdgeCentricFCSpheres(tmp_path: Path) -> None:
     """Test EdgeCentricFCSpheres.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
-    conn_method_params : dict
-        The parametrized parameters to connectivity measure method.
 
     """
     with SPMAuditoryTestingDataGrabber() as dg:
-        # Get element data
         element_data = DefaultDataReader().fit_transform(dg["sub001"])
-        # Setup marker
         marker = EdgeCentricFCSpheres(
-            coords="DMNBuckner",
-            radius=5.0,
-            conn_method="correlation",
-            conn_method_params=conn_method_params,
+            coords="DMNBuckner", radius=5.0, cor_method="correlation"
         )
         # Check correct output
-        assert "matrix" == marker.get_output_type(
-            input_type="BOLD", output_feature="functional_connectivity"
-        )
+        assert marker.get_output_type("BOLD") == "matrix"
 
         # Fit-transform the data
         edge_fc = marker.fit_transform(element_data)
-        edge_fc_bold = edge_fc["BOLD"]["functional_connectivity"]
+        edge_fc_bold = edge_fc["BOLD"]
 
         # There are six DMNBuckner coordinates, so
         # for 6 ROIs we should get (6 * (6 -1) / 2) edges in the ETS
@@ -65,6 +43,13 @@ def test_EdgeCentricFCSpheres(
         assert len(set(edge_fc_bold["row_names"])) == n_edges
         assert len(set(edge_fc_bold["col_names"])) == n_edges
 
+        # Check empirical correlation method parameters
+        marker = EdgeCentricFCSpheres(
+            coords="DMNBuckner",
+            radius=5.0,
+            cor_method="correlation",
+            cor_method_params={"empirical": True},
+        )
         # Store
         storage = SQLiteFeatureStorage(
             uri=tmp_path / "test_edge_fc_spheres.sqlite", upsert="ignore"
@@ -72,6 +57,5 @@ def test_EdgeCentricFCSpheres(
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_EdgeCentricFCSpheres_functional_connectivity"
-            for x in features.values()
+            x["name"] == "BOLD_EdgeCentricFCSpheres" for x in features.values()
         )