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

junifer/markers/functional_connectivity/functional_connectivity_spheres.py

@@ -13,6 +13,9 @@ 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).
@@ -20,35 +23,42 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
     Parameters
     ----------
     coords : str
-        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).
+        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).
     allow_overlap : bool, optional
         Whether to allow overlapping spheres. If False, an error is raised if
-        the spheres overlap (default is False).
+        the spheres overlap (default False).
     agg_method : str, optional
-        The aggregation method to use.
-        See :func:`.get_aggfunc_by_name` for more information
-        (default None).
+        The method to perform aggregation using.
+        See :func:`.get_aggfunc_by_name` for options
+        (default "mean").
     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).
+        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).
     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. By default, it will use
-        KIND_FunctionalConnectivitySpheres where KIND is the kind of data it
-        was applied to (default None).
+        The name of the marker. If None, will use
+        ``BOLD_FunctionalConnectivitySpheres`` (default None).
 
     """
 
@@ -59,8 +69,8 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
         allow_overlap: bool = False,
         agg_method: str = "mean",
         agg_method_params: Optional[Dict] = None,
-        cor_method: str = "covariance",
-        cor_method_params: Optional[Dict] = None,
+        conn_method: str = "correlation",
+        conn_method_params: Optional[Dict] = None,
         masks: Union[str, Dict, List[Union[Dict, str]], None] = None,
         name: Optional[str] = None,
     ) -> None:
@@ -72,8 +82,8 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
         super().__init__(
             agg_method=agg_method,
             agg_method_params=agg_method_params,
-            cor_method=cor_method,
-            cor_method_params=cor_method_params,
+            conn_method=conn_method,
+            conn_method_params=conn_method_params,
             masks=masks,
             name=name,
         )
@@ -101,11 +111,13 @@ 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:
 
-            * ``data`` : the actual computed values as a numpy.ndarray
-            * ``col_names`` : the column labels for the computed values as list
+            * ``aggregation`` : dictionary with the following keys:
+
+                - ``data`` : ROI values as ``numpy.ndarray``
+                - ``col_names`` : ROI labels as list of str
 
         """
-        sphere_aggregation = SphereAggregation(
+        return SphereAggregation(
             coords=self.coords,
             radius=self.radius,
             allow_overlap=self.allow_overlap,
@@ -113,6 +125,4 @@ class FunctionalConnectivitySpheres(FunctionalConnectivityBase):
             method_params=self.agg_method_params,
             masks=self.masks,
             on="BOLD",
-        )
-        # Return the 2D timeseries after sphere aggregation
-        return sphere_aggregation.compute(input, extra_input=extra_input)
+        ).compute(input=input, extra_input=extra_input)

junifer/markers/functional_connectivity/tests/test_crossparcellation_functional_connectivity.py

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

junifer/markers/functional_connectivity/tests/test_edge_functional_connectivity_parcels.py

@@ -5,6 +5,9 @@
 # License: AGPL
 
 from pathlib import Path
+from typing import Dict
+
+import pytest
 
 from junifer.datareader import DefaultDataReader
 from junifer.markers.functional_connectivity import EdgeCentricFCParcels
@@ -12,35 +15,51 @@ from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 
 
-def test_EdgeCentricFCParcels(tmp_path: Path) -> None:
+@pytest.mark.parametrize(
+    "conn_method_params",
+    [
+        {"empirical": False},
+        {"empirical": True},
+    ],
+)
+def test_EdgeCentricFCParcels(
+    tmp_path: Path,
+    conn_method_params: Dict[str, bool],
+) -> 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",
-            cor_method_params={"empirical": True},
+            conn_method="correlation",
+            conn_method_params=conn_method_params,
         )
         # Check correct output
-        assert marker.get_output_type("BOLD") == "matrix"
+        assert "matrix" == marker.get_output_type(
+            input_type="BOLD", output_feature="functional_connectivity"
+        )
 
         # Fit-transform the data
         edge_fc = marker.fit_transform(element_data)
-        edge_fc_bold = edge_fc["BOLD"]
+        edge_fc_bold = edge_fc["BOLD"]["functional_connectivity"]
 
         # 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[0] == n_edges
-        assert edge_fc_bold["data"].shape[1] == n_edges
+        assert edge_fc_bold["data"].shape == (n_edges, n_edges)
         assert len(set(edge_fc_bold["row_names"])) == n_edges
         assert len(set(edge_fc_bold["col_names"])) == n_edges
 
@@ -51,5 +70,6 @@ def test_EdgeCentricFCParcels(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_EdgeCentricFCParcels" for x in features.values()
+            x["name"] == "BOLD_EdgeCentricFCParcels_functional_connectivity"
+            for x in features.values()
         )

junifer/markers/functional_connectivity/tests/test_edge_functional_connectivity_spheres.py

@@ -5,6 +5,9 @@
 # License: AGPL
 
 from pathlib import Path
+from typing import Dict
+
+import pytest
 
 from junifer.datareader import DefaultDataReader
 from junifer.markers.functional_connectivity import EdgeCentricFCSpheres
@@ -12,26 +15,45 @@ from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 
 
-def test_EdgeCentricFCSpheres(tmp_path: Path) -> None:
+@pytest.mark.parametrize(
+    "conn_method_params",
+    [
+        {"empirical": False},
+        {"empirical": True},
+    ],
+)
+def test_EdgeCentricFCSpheres(
+    tmp_path: Path,
+    conn_method_params: Dict[str, bool],
+) -> 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, cor_method="correlation"
+            coords="DMNBuckner",
+            radius=5.0,
+            conn_method="correlation",
+            conn_method_params=conn_method_params,
         )
         # Check correct output
-        assert marker.get_output_type("BOLD") == "matrix"
+        assert "matrix" == marker.get_output_type(
+            input_type="BOLD", output_feature="functional_connectivity"
+        )
 
         # Fit-transform the data
         edge_fc = marker.fit_transform(element_data)
-        edge_fc_bold = edge_fc["BOLD"]
+        edge_fc_bold = edge_fc["BOLD"]["functional_connectivity"]
 
         # There are six DMNBuckner coordinates, so
         # for 6 ROIs we should get (6 * (6 -1) / 2) edges in the ETS
@@ -43,13 +65,6 @@ def test_EdgeCentricFCSpheres(tmp_path: Path) -> None:
         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"
@@ -57,5 +72,6 @@ def test_EdgeCentricFCSpheres(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_EdgeCentricFCSpheres" for x in features.values()
+            x["name"] == "BOLD_EdgeCentricFCSpheres_functional_connectivity"
+            for x in features.values()
         )

junifer/markers/functional_connectivity/tests/test_functional_connectivity_parcels.py

@@ -6,10 +6,13 @@
 # License: AGPL
 
 from pathlib import Path
+from typing import TYPE_CHECKING, Dict, Type
 
+import pytest
 from nilearn.connectome import ConnectivityMeasure
 from nilearn.maskers import NiftiLabelsMasker
 from numpy.testing import assert_array_almost_equal
+from sklearn.covariance import EmpiricalCovariance, LedoitWolf
 
 from junifer.data import get_parcellation
 from junifer.datareader import DefaultDataReader
@@ -20,26 +23,51 @@ from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
 
 
-def test_FunctionalConnectivityParcels(tmp_path: Path) -> None:
+if TYPE_CHECKING:
+    from sklearn.base import BaseEstimator
+
+
+@pytest.mark.parametrize(
+    "conn_method_params, cov_estimator",
+    [
+        ({"empirical": False}, LedoitWolf(store_precision=False)),
+        ({"empirical": True}, EmpiricalCovariance(store_precision=False)),
+    ],
+)
+def test_FunctionalConnectivityParcels(
+    tmp_path: Path,
+    conn_method_params: Dict[str, bool],
+    cov_estimator: Type["BaseEstimator"],
+) -> None:
     """Test FunctionalConnectivityParcels.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
+    conn_method_params : dict
+        The parametrized parameters to connectivity measure method.
+    cov_estimator : estimator object
+        The parametrized covariance estimator.
 
     """
     with PartlyCloudyTestingDataGrabber() as dg:
+        # Get element data
         element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        # Setup marker
         marker = FunctionalConnectivityParcels(
-            parcellation="TianxS1x3TxMNInonlinear2009cAsym"
+            parcellation="TianxS1x3TxMNInonlinear2009cAsym",
+            conn_method="correlation",
+            conn_method_params=conn_method_params,
         )
         # Check correct output
-        assert marker.get_output_type("BOLD") == "matrix"
+        assert "matrix" == marker.get_output_type(
+            input_type="BOLD", output_feature="functional_connectivity"
+        )
 
         # Fit-transform the data
         fc = marker.fit_transform(element_data)
-        fc_bold = fc["BOLD"]
+        fc_bold = fc["BOLD"]["functional_connectivity"]
 
         assert "data" in fc_bold
         assert "row_names" in fc_bold
@@ -63,7 +91,7 @@ def test_FunctionalConnectivityParcels(tmp_path: Path) -> None:
         )
         # Compute the connectivity measure
         connectivity_measure = ConnectivityMeasure(
-            kind="covariance"
+            cov_estimator=cov_estimator, kind="correlation"  # type: ignore
         ).fit_transform([extracted_timeseries])[0]
 
         # Check that FC are almost equal
@@ -71,11 +99,6 @@ def test_FunctionalConnectivityParcels(tmp_path: Path) -> None:
             connectivity_measure, fc_bold["data"], decimal=3
         )
 
-        # Check empirical correlation method parameters
-        marker = FunctionalConnectivityParcels(
-            parcellation="TianxS1x3TxMNInonlinear2009cAsym",
-            cor_method_params={"empirical": True},
-        )
         # Store
         storage = SQLiteFeatureStorage(
             uri=tmp_path / "test_fc_parcels.sqlite", upsert="ignore"
@@ -83,6 +106,7 @@ def test_FunctionalConnectivityParcels(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_FunctionalConnectivityParcels"
+            x["name"]
+            == "BOLD_FunctionalConnectivityParcels_functional_connectivity"
             for x in features.values()
         )

junifer/markers/functional_connectivity/tests/test_functional_connectivity_spheres.py

@@ -7,12 +7,13 @@
 # License: AGPL
 
 from pathlib import Path
+from typing import TYPE_CHECKING, Dict, Type
 
 import pytest
 from nilearn.connectome import ConnectivityMeasure
 from nilearn.maskers import NiftiSpheresMasker
 from numpy.testing import assert_array_almost_equal
-from sklearn.covariance import EmpiricalCovariance
+from sklearn.covariance import EmpiricalCovariance, LedoitWolf
 
 from junifer.data import get_coordinates
 from junifer.datareader import DefaultDataReader
@@ -23,26 +24,52 @@ from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 
 
-def test_FunctionalConnectivitySpheres(tmp_path: Path) -> None:
+if TYPE_CHECKING:
+    from sklearn.base import BaseEstimator
+
+
+@pytest.mark.parametrize(
+    "conn_method_params, cov_estimator",
+    [
+        ({"empirical": False}, LedoitWolf(store_precision=False)),
+        ({"empirical": True}, EmpiricalCovariance(store_precision=False)),
+    ],
+)
+def test_FunctionalConnectivitySpheres(
+    tmp_path: Path,
+    conn_method_params: Dict[str, bool],
+    cov_estimator: Type["BaseEstimator"],
+) -> None:
     """Test FunctionalConnectivitySpheres.
 
     Parameters
     ----------
     tmp_path : pathlib.Path
         The path to the test directory.
+    conn_method_params : dict
+        The parametrized parameters to connectivity measure method.
+    cov_estimator : estimator object
+        The parametrized covariance estimator.
 
     """
     with SPMAuditoryTestingDataGrabber() as dg:
+        # Get element data
         element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        # Setup marker
         marker = FunctionalConnectivitySpheres(
-            coords="DMNBuckner", radius=5.0, cor_method="correlation"
+            coords="DMNBuckner",
+            radius=5.0,
+            conn_method="correlation",
+            conn_method_params=conn_method_params,
         )
         # Check correct output
-        assert marker.get_output_type("BOLD") == "matrix"
+        assert "matrix" == marker.get_output_type(
+            input_type="BOLD", output_feature="functional_connectivity"
+        )
 
         # Fit-transform the data
         fc = marker.fit_transform(element_data)
-        fc_bold = fc["BOLD"]
+        fc_bold = fc["BOLD"]["functional_connectivity"]
 
         assert "data" in fc_bold
         assert "row_names" in fc_bold
@@ -65,7 +92,7 @@ def test_FunctionalConnectivitySpheres(tmp_path: Path) -> None:
         )
         # Compute the connectivity measure
         connectivity_measure = ConnectivityMeasure(
-            kind="correlation"
+            cov_estimator=cov_estimator, kind="correlation"  # type: ignore
         ).fit_transform([extracted_timeseries])[0]
 
         # Check that FC are almost equal
@@ -80,68 +107,15 @@ def test_FunctionalConnectivitySpheres(tmp_path: Path) -> None:
         marker.fit_transform(input=element_data, storage=storage)
         features = storage.list_features()
         assert any(
-            x["name"] == "BOLD_FunctionalConnectivitySpheres"
+            x["name"]
+            == "BOLD_FunctionalConnectivitySpheres_functional_connectivity"
             for x in features.values()
         )
 
 
-def test_FunctionalConnectivitySpheres_empirical(tmp_path: Path) -> None:
-    """Test FunctionalConnectivitySpheres with empirical covariance.
-
-    Parameters
-    ----------
-    tmp_path : pathlib.Path
-        The path to the test directory.
-
-    """
-    with SPMAuditoryTestingDataGrabber() as dg:
-        element_data = DefaultDataReader().fit_transform(dg["sub001"])
-        marker = FunctionalConnectivitySpheres(
-            coords="DMNBuckner",
-            radius=5.0,
-            cor_method="correlation",
-            cor_method_params={"empirical": True},
-        )
-        # Check correct output
-        assert marker.get_output_type("BOLD") == "matrix"
-
-        # Fit-transform the data
-        fc = marker.fit_transform(element_data)
-        fc_bold = fc["BOLD"]
-
-        assert "data" in fc_bold
-        assert "row_names" in fc_bold
-        assert "col_names" in fc_bold
-        assert fc_bold["data"].shape == (6, 6)
-        assert len(set(fc_bold["row_names"])) == 6
-        assert len(set(fc_bold["col_names"])) == 6
-
-        # Compare with nilearn
-        # Load testing coordinates for the target data
-        testing_coords, _ = get_coordinates(
-            coords="DMNBuckner", target_data=element_data["BOLD"]
-        )
-        # Extract timeseries
-        nifti_spheres_masker = NiftiSpheresMasker(
-            seeds=testing_coords, radius=5.0
-        )
-        extracted_timeseries = nifti_spheres_masker.fit_transform(
-            element_data["BOLD"]["data"]
-        )
-        # Compute the connectivity measure
-        connectivity_measure = ConnectivityMeasure(
-            cov_estimator=EmpiricalCovariance(), kind="correlation"  # type: ignore
-        ).fit_transform([extracted_timeseries])[0]
-
-        # Check that FC are almost equal
-        assert_array_almost_equal(
-            connectivity_measure, fc_bold["data"], decimal=3
-        )
-
-
 def test_FunctionalConnectivitySpheres_error() -> None:
     """Test FunctionalConnectivitySpheres errors."""
     with pytest.raises(ValueError, match="radius should be > 0"):
         FunctionalConnectivitySpheres(
-            coords="DMNBuckner", radius=-0.1, cor_method="correlation"
+            coords="DMNBuckner", radius=-0.1, conn_method="correlation"
         )