junifer 0.0.4.dev733__py3-none-any.whl → 0.0.4.dev782__py3-none-any.whl

junifer/markers/functional_connectivity/tests/test_functional_connectivity_spheres.py

@@ -3,21 +3,24 @@
 # Authors: Amir Omidvarnia <a.omidvarnia@fz-juelich.de>
 #          Kaustubh R. Patil <k.patil@fz-juelich.de>
 #          Federico Raimondo <f.raimondo@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
 from pathlib import Path
 
 import pytest
-from nilearn import datasets, image
 from nilearn.connectome import ConnectivityMeasure
+from nilearn.maskers import NiftiSpheresMasker
 from numpy.testing import assert_array_almost_equal
 from sklearn.covariance import EmpiricalCovariance
 
+from junifer.data import get_coordinates
+from junifer.datareader import DefaultDataReader
 from junifer.markers.functional_connectivity import (
     FunctionalConnectivitySpheres,
 )
-from junifer.markers.sphere_aggregation import SphereAggregation
 from junifer.storage import SQLiteFeatureStorage
+from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 
 
 def test_FunctionalConnectivitySpheres(tmp_path: Path) -> None:
@@ -29,56 +32,57 @@ def test_FunctionalConnectivitySpheres(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-    # get a dataset
-    ni_data = datasets.fetch_spm_auditory(subject_id="sub001")
-    fmri_img = image.concat_imgs(ni_data.func)  # type: ignore
-
-    fc = FunctionalConnectivitySpheres(
-        coords="DMNBuckner", radius=5.0, cor_method="correlation"
-    )
-    all_out = fc.fit_transform(
-        {"BOLD": {"data": fmri_img, "meta": {}, "space": "MNI"}}
-    )
-
-    out = all_out["BOLD"]
-
-    assert "data" in out
-    assert "row_names" in out
-    assert "col_names" in out
-    assert out["data"].shape[0] == 6
-    assert out["data"].shape[1] == 6
-    assert len(set(out["row_names"])) == 6
-    assert len(set(out["col_names"])) == 6
-
-    # get the timeseries using sa
-    sa = SphereAggregation(
-        coords="DMNBuckner", radius=5.0, method="mean", on="BOLD"
-    )
-    ts = sa.compute({"data": fmri_img, "meta": {}, "space": "MNI"})
-
-    # Check that FC are almost equal when using nileran
-    cm = ConnectivityMeasure(kind="correlation")
-    out_ni = cm.fit_transform([ts["data"]])[0]
-    assert_array_almost_equal(out_ni, out["data"], decimal=3)
-
-    # check correct output
-    assert fc.get_output_type("BOLD") == "matrix"
-
-    uri = tmp_path / "test_fc_parcel.sqlite"
-    # Single storage, must be the uri
-    storage = SQLiteFeatureStorage(uri=uri, upsert="ignore")
-    meta = {
-        "element": {"subject": "test"},
-        "dependencies": {"numpy", "nilearn"},
-    }
-    input = {"BOLD": {"data": fmri_img, "meta": meta, "space": "MNI"}}
-    all_out = fc.fit_transform(input, storage=storage)
-
-    features = storage.list_features()
-    assert any(
-        x["name"] == "BOLD_FunctionalConnectivitySpheres"
-        for x in features.values()
-    )
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        marker = FunctionalConnectivitySpheres(
+            coords="DMNBuckner", radius=5.0, cor_method="correlation"
+        )
+        # 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(
+            kind="correlation"
+        ).fit_transform([extracted_timeseries])[0]
+
+        # Check that FC are almost equal
+        assert_array_almost_equal(
+            connectivity_measure, fc_bold["data"], decimal=3
+        )
+
+        # Store
+        storage = SQLiteFeatureStorage(
+            uri=tmp_path / "test_fc_spheres.sqlite", upsert="ignore"
+        )
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "BOLD_FunctionalConnectivitySpheres"
+            for x in features.values()
+        )
 
 
 def test_FunctionalConnectivitySpheres_empirical(tmp_path: Path) -> None:
@@ -90,43 +94,49 @@ def test_FunctionalConnectivitySpheres_empirical(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-
-    # get a dataset
-    ni_data = datasets.fetch_spm_auditory(subject_id="sub001")
-    fmri_img = image.concat_imgs(ni_data.func)  # type: ignore
-
-    fc = FunctionalConnectivitySpheres(
-        coords="DMNBuckner",
-        radius=5.0,
-        cor_method="correlation",
-        cor_method_params={"empirical": True},
-    )
-    all_out = fc.fit_transform(
-        {"BOLD": {"data": fmri_img, "meta": {}, "space": "MNI"}}
-    )
-
-    out = all_out["BOLD"]
-
-    assert "data" in out
-    assert "row_names" in out
-    assert "col_names" in out
-    assert out["data"].shape[0] == 6
-    assert out["data"].shape[1] == 6
-    assert len(set(out["row_names"])) == 6
-    assert len(set(out["col_names"])) == 6
-
-    # get the timeseries using sa
-    sa = SphereAggregation(
-        coords="DMNBuckner", radius=5.0, method="mean", on="BOLD"
-    )
-    ts = sa.compute({"data": fmri_img, "space": "MNI"})
-
-    # Check that FC are almost equal when using nileran
-    cm = ConnectivityMeasure(
-        cov_estimator=EmpiricalCovariance(), kind="correlation"  # type: ignore
-    )
-    out_ni = cm.fit_transform([ts["data"]])[0]
-    assert_array_almost_equal(out_ni, out["data"], decimal=3)
+    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:

junifer/markers/reho/tests/test_reho_parcels.py

@@ -12,12 +12,12 @@ import scipy as sp
 from junifer.datareader import DefaultDataReader
 from junifer.markers import ReHoParcels
 from junifer.pipeline import WorkDirManager
-from junifer.pipeline.utils import _check_afni
+from junifer.pipeline.utils import _check_afni, _check_ants
 from junifer.storage import SQLiteFeatureStorage
-from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
-
-
-PARCELLATION = "Schaefer100x7"
+from junifer.testing.datagrabbers import (
+    PartlyCloudyTestingDataGrabber,
+    SPMAuditoryTestingDataGrabber,
+)
 
 
 def test_ReHoParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
@@ -32,13 +32,16 @@ def test_ReHoParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
 
     """
     with caplog.at_level(logging.DEBUG):
-        with SPMAuditoryTestingDataGrabber() as dg:
-            element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        with PartlyCloudyTestingDataGrabber() as dg:
+            element_data = DefaultDataReader().fit_transform(dg["sub-01"])
             # Update workdir to current test's tmp_path
             WorkDirManager().workdir = tmp_path
 
             # Initialize marker
-            marker = ReHoParcels(parcellation=PARCELLATION, using="junifer")
+            marker = ReHoParcels(
+                parcellation="TianxS1x3TxMNInonlinear2009cAsym",
+                using="junifer",
+            )
             # Fit transform marker on data
             output = marker.fit_transform(element_data)
 
@@ -72,6 +75,9 @@ def test_ReHoParcels(caplog: pytest.LogCaptureFixture, tmp_path: Path) -> None:
             assert "Creating cache" not in caplog.text
 
 
+@pytest.mark.skipif(
+    _check_ants() is False, reason="requires ANTs to be in PATH"
+)
 @pytest.mark.skipif(
     _check_afni() is False, reason="requires AFNI to be in PATH"
 )
@@ -91,7 +97,7 @@ def test_ReHoParcels_comparison(tmp_path: Path) -> None:
 
         # Initialize marker
         junifer_marker = ReHoParcels(
-            parcellation=PARCELLATION, using="junifer"
+            parcellation="Schaefer100x7", using="junifer"
         )
         # Fit transform marker on data
         junifer_output = junifer_marker.fit_transform(element_data)
@@ -99,7 +105,7 @@ def test_ReHoParcels_comparison(tmp_path: Path) -> None:
         junifer_output_bold = junifer_output["BOLD"]
 
         # Initialize marker
-        afni_marker = ReHoParcels(parcellation=PARCELLATION, using="afni")
+        afni_marker = ReHoParcels(parcellation="Schaefer100x7", using="afni")
         # Fit transform marker on data
         afni_output = afni_marker.fit_transform(element_data)
         # Get BOLD output
@@ -110,4 +116,4 @@ def test_ReHoParcels_comparison(tmp_path: Path) -> None:
             junifer_output_bold["data"].flatten(),
             afni_output_bold["data"].flatten(),
         )
-        assert r >= 0.3  # this is very bad, but they differ...
+        assert r >= 0.2  # this is very bad, but they differ...

junifer/markers/temporal_snr/tests/test_temporal_snr_parcels.py

@@ -1,18 +1,39 @@
 """Provide tests for temporal signal-to-noise ratio using parcellation."""
 
 # Authors: Leonard Sasse <l.sasse@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
 from pathlib import Path
 
-from nilearn import datasets, image
-
+from junifer.datareader import DefaultDataReader
 from junifer.markers.temporal_snr import TemporalSNRParcels
-from junifer.storage import SQLiteFeatureStorage
+from junifer.storage import HDF5FeatureStorage
+from junifer.testing.datagrabbers import PartlyCloudyTestingDataGrabber
+
+
+def test_TemporalSNRParcels_computation() -> None:
+    """Test TemporalSNRParcels fit-transform."""
+    with PartlyCloudyTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        marker = TemporalSNRParcels(
+            parcellation="TianxS1x3TxMNInonlinear2009cAsym"
+        )
+        # Check correct output
+        assert marker.get_output_type("BOLD") == "vector"
+
+        # Fit-transform the data
+        tsnr_parcels = marker.fit_transform(element_data)
+        tsnr_parcels_bold = tsnr_parcels["BOLD"]
+
+        assert "data" in tsnr_parcels_bold
+        assert "col_names" in tsnr_parcels_bold
+        assert tsnr_parcels_bold["data"].shape == (1, 16)
+        assert len(set(tsnr_parcels_bold["col_names"])) == 16
 
 
-def test_TemporalSNRParcels(tmp_path: Path) -> None:
-    """Test TemporalSNRParcels.
+def test_TemporalSNRParcels_storage(tmp_path: Path) -> None:
+    """Test TemporalSNRParcels store.
 
     Parameters
     ----------
@@ -20,35 +41,15 @@ def test_TemporalSNRParcels(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-    # get a dataset
-    ni_data = datasets.fetch_spm_auditory(subject_id="sub001")
-    fmri_img = image.concat_imgs(ni_data.func)  # type: ignore
-
-    tsnr_parcels = TemporalSNRParcels(parcellation="Schaefer100x7")
-    all_out = tsnr_parcels.fit_transform(
-        {"BOLD": {"data": fmri_img, "meta": {}, "space": "MNI"}}
-    )
-
-    out = all_out["BOLD"]
-
-    assert "data" in out
-    assert "col_names" in out
-
-    assert out["data"].shape[0] == 1
-    assert out["data"].shape[1] == 100
-    assert len(set(out["col_names"])) == 100
-
-    # check correct output
-    assert tsnr_parcels.get_output_type("BOLD") == "vector"
-
-    uri = tmp_path / "test_tsnr_parcellation.sqlite"
-    # Single storage, must be the uri
-    storage = SQLiteFeatureStorage(uri=uri, upsert="ignore")
-    meta = {"element": {"subject": "test"}, "dependencies": {"numpy"}}
-    input = {"BOLD": {"data": fmri_img, "meta": meta, "space": "MNI"}}
-    all_out = tsnr_parcels.fit_transform(input, storage=storage)
-
-    features = storage.list_features()
-    assert any(
-        x["name"] == "BOLD_TemporalSNRParcels" for x in features.values()
-    )
+    with PartlyCloudyTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        marker = TemporalSNRParcels(
+            parcellation="TianxS1x3TxMNInonlinear2009cAsym"
+        )
+        # Store
+        storage = HDF5FeatureStorage(tmp_path / "test_tsnr_parcels.hdf5")
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "BOLD_TemporalSNRParcels" for x in features.values()
+        )

junifer/markers/temporal_snr/tests/test_temporal_snr_spheres.py

@@ -1,19 +1,39 @@
 """Provide tests for temporal signal-to-noise spheres."""
 
 # Authors: Leonard Sasse <l.sasse@fz-juelich.de>
+#          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
 from pathlib import Path
 
 import pytest
-from nilearn import datasets, image
 
+from junifer.datareader import DefaultDataReader
 from junifer.markers.temporal_snr import TemporalSNRSpheres
-from junifer.storage import SQLiteFeatureStorage
+from junifer.storage import HDF5FeatureStorage
+from junifer.testing.datagrabbers import SPMAuditoryTestingDataGrabber
 
 
-def test_TemporalSNRSpheres(tmp_path: Path) -> None:
-    """Test TemporalSNRSpheres.
+def test_TemporalSNRSpheres_computation() -> None:
+    """Test TemporalSNRSpheres fit-transform."""
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        marker = TemporalSNRSpheres(coords="DMNBuckner", radius=5.0)
+        # Check correct output
+        assert marker.get_output_type("BOLD") == "vector"
+
+        # Fit-transform the data
+        tsnr_spheres = marker.fit_transform(element_data)
+        tsnr_spheres_bold = tsnr_spheres["BOLD"]
+
+        assert "data" in tsnr_spheres_bold
+        assert "col_names" in tsnr_spheres_bold
+        assert tsnr_spheres_bold["data"].shape == (1, 6)
+        assert len(set(tsnr_spheres_bold["col_names"])) == 6
+
+
+def test_TemporalSNRSpheres_storage(tmp_path: Path) -> None:
+    """Test TemporalSNRSpheres store.
 
     Parameters
     ----------
@@ -21,40 +41,16 @@ def test_TemporalSNRSpheres(tmp_path: Path) -> None:
         The path to the test directory.
 
     """
-    # get a dataset
-    ni_data = datasets.fetch_spm_auditory(subject_id="sub001")
-    fmri_img = image.concat_imgs(ni_data.func)  # type: ignore
-
-    tsnr_spheres = TemporalSNRSpheres(coords="DMNBuckner", radius=5.0)
-    all_out = tsnr_spheres.fit_transform(
-        {"BOLD": {"data": fmri_img, "meta": {}, "space": "MNI"}}
-    )
-
-    out = all_out["BOLD"]
-
-    assert "data" in out
-    assert "col_names" in out
-    assert out["data"].shape[0] == 1
-    assert out["data"].shape[1] == 6
-    assert len(set(out["col_names"])) == 6
-
-    # check correct output
-    assert tsnr_spheres.get_output_type("BOLD") == "vector"
-
-    uri = tmp_path / "test_tsnr_coords.sqlite"
-    # Single storage, must be the uri
-    storage = SQLiteFeatureStorage(uri=uri, upsert="ignore")
-    meta = {
-        "element": {"subject": "test"},
-        "dependencies": {"numpy", "nilearn"},
-    }
-    input = {"BOLD": {"data": fmri_img, "meta": meta, "space": "MNI"}}
-    all_out = tsnr_spheres.fit_transform(input, storage=storage)
-
-    features = storage.list_features()
-    assert any(
-        x["name"] == "BOLD_TemporalSNRSpheres" for x in features.values()
-    )
+    with SPMAuditoryTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        marker = TemporalSNRSpheres(coords="DMNBuckner", radius=5.0)
+        # Store
+        storage = HDF5FeatureStorage(tmp_path / "test_tsnr_spheres.hdf5")
+        marker.fit_transform(input=element_data, storage=storage)
+        features = storage.list_features()
+        assert any(
+            x["name"] == "BOLD_TemporalSNRSpheres" for x in features.values()
+        )
 
 
 def test_TemporalSNRSpheres_error() -> None:

junifer/markers/tests/test_collection.py

@@ -19,7 +19,6 @@ from junifer.pipeline import PipelineStepMixin
 from junifer.preprocess import fMRIPrepConfoundRemover
 from junifer.storage import SQLiteFeatureStorage
 from junifer.testing.datagrabbers import (
-    OasisVBMTestingDataGrabber,
     PartlyCloudyTestingDataGrabber,
 )
 
@@ -46,20 +45,20 @@ def test_marker_collection() -> None:
     """Test MarkerCollection."""
     markers = [
         ParcelAggregation(
-            parcellation="Schaefer100x7",
+            parcellation="TianxS2x3TxMNInonlinear2009cAsym",
             method="mean",
-            name="gmd_schaefer100x7_mean",
+            name="tian_mean",
         ),
         ParcelAggregation(
-            parcellation="Schaefer100x7",
+            parcellation="TianxS2x3TxMNInonlinear2009cAsym",
             method="std",
-            name="gmd_schaefer100x7_std",
+            name="tian_std",
         ),
         ParcelAggregation(
-            parcellation="Schaefer100x7",
+            parcellation="TianxS2x3TxMNInonlinear2009cAsym",
             method="trim_mean",
             method_params={"proportiontocut": 0.1},
-            name="gmd_schaefer100x7_trim_mean90",
+            name="tian_trim_mean90",
         ),
     ]
     mc = MarkerCollection(markers=markers)  # type: ignore
@@ -69,7 +68,7 @@ def test_marker_collection() -> None:
     assert isinstance(mc._datareader, DefaultDataReader)
 
     # Create testing datagrabber
-    dg = OasisVBMTestingDataGrabber()
+    dg = PartlyCloudyTestingDataGrabber()
     mc.validate(dg)
 
     with dg:
@@ -78,17 +77,17 @@ def test_marker_collection() -> None:
         assert out is not None
         assert isinstance(out, dict)
         assert len(out) == 3
-        assert "gmd_schaefer100x7_mean" in out
-        assert "gmd_schaefer100x7_std" in out
-        assert "gmd_schaefer100x7_trim_mean90" in out
+        assert "tian_mean" in out
+        assert "tian_std" in out
+        assert "tian_trim_mean90" in out
 
         for t_marker in markers:
             t_name = t_marker.name
-            assert "VBM_GM" in out[t_name]
-            t_vbm = out[t_name]["VBM_GM"]
-            assert "data" in t_vbm
-            assert "col_names" in t_vbm
-            assert "meta" in t_vbm
+            assert "BOLD" in out[t_name]
+            t_bold = out[t_name]["BOLD"]
+            assert "data" in t_bold
+            assert "col_names" in t_bold
+            assert "meta" in t_bold
 
     # Test preprocessing
     class BypassPreprocessing(PipelineStepMixin):
@@ -108,7 +107,7 @@ def test_marker_collection() -> None:
         for t_marker in markers:
             t_name = t_marker.name
             assert_array_equal(
-                out[t_name]["VBM_GM"]["data"], out2[t_name]["VBM_GM"]["data"]
+                out[t_name]["BOLD"]["data"], out2[t_name]["BOLD"]["data"]
             )
 
 
@@ -151,27 +150,28 @@ def test_marker_collection_storage(tmp_path: Path) -> None:
     """
     markers = [
         ParcelAggregation(
-            parcellation="Schaefer100x7",
+            parcellation="TianxS2x3TxMNInonlinear2009cAsym",
             method="mean",
-            name="gmd_schaefer100x7_mean",
+            name="tian_mean",
         ),
         ParcelAggregation(
-            parcellation="Schaefer100x7",
+            parcellation="TianxS2x3TxMNInonlinear2009cAsym",
             method="std",
-            name="gmd_schaefer100x7_std",
+            name="tian_std",
         ),
         ParcelAggregation(
-            parcellation="Schaefer100x7",
+            parcellation="TianxS2x3TxMNInonlinear2009cAsym",
             method="trim_mean",
             method_params={"proportiontocut": 0.1},
-            name="gmd_schaefer100x7_trim_mean90",
+            name="tian_trim_mean90",
         ),
     ]
-    # Test storage
-    dg = OasisVBMTestingDataGrabber()
-
-    uri = tmp_path / "test_marker_collection_storage.sqlite"
-    storage = SQLiteFeatureStorage(uri=uri)
+    # Setup datagrabber
+    dg = PartlyCloudyTestingDataGrabber()
+    # Setup storage
+    storage = SQLiteFeatureStorage(
+        tmp_path / "test_marker_collection_storage.sqlite"
+    )
     mc = MarkerCollection(
         markers=markers,  # type: ignore
         storage=storage,
@@ -197,23 +197,24 @@ def test_marker_collection_storage(tmp_path: Path) -> None:
 
     features = storage.list_features()
     assert len(features) == 3
+
     feature_md5 = next(iter(features.keys()))
     t_feature = storage.read_df(feature_md5=feature_md5)
-    fname = "gmd_schaefer100x7_mean"
-    t_data = out[fname]["VBM_GM"]["data"]  # type: ignore
-    cols = out[fname]["VBM_GM"]["col_names"]  # type: ignore
+    fname = "tian_mean"
+    t_data = out[fname]["BOLD"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["col_names"]  # type: ignore
     assert_array_equal(t_feature[cols].values, t_data)  # type: ignore
 
     feature_md5 = list(features.keys())[1]
     t_feature = storage.read_df(feature_md5=feature_md5)
-    fname = "gmd_schaefer100x7_std"
-    t_data = out[fname]["VBM_GM"]["data"]  # type: ignore
-    cols = out[fname]["VBM_GM"]["col_names"]  # type: ignore
+    fname = "tian_std"
+    t_data = out[fname]["BOLD"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["col_names"]  # type: ignore
     assert_array_equal(t_feature[cols].values, t_data)  # type: ignore
 
     feature_md5 = list(features.keys())[2]
     t_feature = storage.read_df(feature_md5=feature_md5)
-    fname = "gmd_schaefer100x7_trim_mean90"
-    t_data = out[fname]["VBM_GM"]["data"]  # type: ignore
-    cols = out[fname]["VBM_GM"]["col_names"]  # type: ignore
+    fname = "tian_trim_mean90"
+    t_data = out[fname]["BOLD"]["data"]  # type: ignore
+    cols = out[fname]["BOLD"]["col_names"]  # type: ignore
     assert_array_equal(t_feature[cols].values, t_data)  # type: ignore