nimare 0.4.2__py3-none-any.whl

nimare/tests/test_meta_ale.py

@@ -0,0 +1,298 @@
+"""Test nimare.meta.ale (ALE/SCALE meta-analytic algorithms)."""
+
+import os
+import pickle
+
+import nibabel as nib
+import numpy as np
+import pytest
+from nilearn.input_data import NiftiLabelsMasker
+
+import nimare
+from nimare.correct import FDRCorrector, FWECorrector
+from nimare.meta import ale
+from nimare.results import MetaResult
+from nimare.tests.utils import get_test_data_path
+from nimare.utils import vox2mm
+
+
+def test_ALE_approximate_null_unit(testdata_cbma, tmp_path_factory):
+    """Unit test for ALE with approximate null_method."""
+    tmpdir = tmp_path_factory.mktemp("test_ALE_approximate_null_unit")
+    est_out_file = os.path.join(tmpdir, "est_file.pkl.gz")
+    res_out_file = os.path.join(tmpdir, "res_file.pkl.gz")
+
+    meta = ale.ALE(null_method="approximate")
+    results = meta.fit(testdata_cbma)
+    assert "stat" in results.maps.keys()
+    assert "p" in results.maps.keys()
+    assert "z" in results.maps.keys()
+    assert isinstance(results, nimare.results.MetaResult)
+    assert isinstance(results.get_map("z", return_type="image"), nib.Nifti1Image)
+    assert isinstance(results.get_map("z", return_type="array"), np.ndarray)
+    results_copy = results.copy()
+    assert results_copy != results
+    assert isinstance(results, nimare.results.MetaResult)
+
+    # Test saving/loading estimator
+    for compress in [True, False]:
+        meta.save(est_out_file, compress=compress)
+        assert os.path.isfile(est_out_file)
+        meta2 = ale.ALE.load(est_out_file, compressed=compress)
+        assert isinstance(meta2, ale.ALE)
+        if compress:
+            with pytest.raises(pickle.UnpicklingError):
+                ale.ALE.load(est_out_file, compressed=(not compress))
+        else:
+            with pytest.raises(OSError):
+                ale.ALE.load(est_out_file, compressed=(not compress))
+
+    # Test saving/loading MetaResult object
+    for compress in [True, False]:
+        results.save(res_out_file, compress=compress)
+        assert os.path.isfile(res_out_file)
+        res2 = MetaResult.load(res_out_file, compressed=compress)
+        assert isinstance(res2, MetaResult)
+        if compress:
+            with pytest.raises(pickle.UnpicklingError):
+                MetaResult.load(res_out_file, compressed=(not compress))
+        else:
+            with pytest.raises(OSError):
+                MetaResult.load(res_out_file, compressed=(not compress))
+
+    # Test MCC methods
+    # Monte Carlo FWE
+    corr = FWECorrector(method="montecarlo", voxel_thresh=0.001, n_iters=5, n_cores=-1)
+    corr_results = corr.transform(results)
+    assert isinstance(corr_results, nimare.results.MetaResult)
+    assert isinstance(corr_results.description_, str)
+    assert "z_desc-size_level-cluster_corr-FWE_method-montecarlo" in corr_results.maps.keys()
+    assert "z_desc-mass_level-cluster_corr-FWE_method-montecarlo" in corr_results.maps.keys()
+    assert "z_level-voxel_corr-FWE_method-montecarlo" in corr_results.maps.keys()
+    assert "logp_desc-size_level-cluster_corr-FWE_method-montecarlo" in corr_results.maps.keys()
+    assert "logp_desc-mass_level-cluster_corr-FWE_method-montecarlo" in corr_results.maps.keys()
+    assert "logp_level-voxel_corr-FWE_method-montecarlo" in corr_results.maps.keys()
+    assert isinstance(
+        corr_results.get_map(
+            "z_desc-size_level-cluster_corr-FWE_method-montecarlo", return_type="image"
+        ),
+        nib.Nifti1Image,
+    )
+    assert isinstance(
+        corr_results.get_map(
+            "z_desc-size_level-cluster_corr-FWE_method-montecarlo", return_type="array"
+        ),
+        np.ndarray,
+    )
+    assert isinstance(
+        corr_results.get_map(
+            "z_desc-mass_level-cluster_corr-FWE_method-montecarlo", return_type="image"
+        ),
+        nib.Nifti1Image,
+    )
+    assert isinstance(
+        corr_results.get_map(
+            "z_desc-mass_level-cluster_corr-FWE_method-montecarlo", return_type="array"
+        ),
+        np.ndarray,
+    )
+
+    # Bonferroni FWE
+    corr = FWECorrector(method="bonferroni")
+    corr_results = corr.transform(results)
+    assert isinstance(corr_results, nimare.results.MetaResult)
+    assert isinstance(corr_results.description_, str)
+    assert isinstance(
+        corr_results.get_map("z_corr-FWE_method-bonferroni", return_type="image"), nib.Nifti1Image
+    )
+    assert isinstance(
+        corr_results.get_map("z_corr-FWE_method-bonferroni", return_type="array"), np.ndarray
+    )
+
+    # FDR
+    corr = FDRCorrector(method="indep", alpha=0.05)
+    corr_results = corr.transform(results)
+    assert isinstance(corr_results, nimare.results.MetaResult)
+    assert isinstance(corr_results.description_, str)
+    assert isinstance(
+        corr_results.get_map("z_corr-FDR_method-indep", return_type="image"), nib.Nifti1Image
+    )
+    assert isinstance(
+        corr_results.get_map("z_corr-FDR_method-indep", return_type="array"), np.ndarray
+    )
+
+
+def test_ALE_montecarlo_null_unit(testdata_cbma, tmp_path_factory):
+    """Unit test for ALE with an montecarlo null_method.
+
+    This test is run with low-memory kernel transformation as well.
+    """
+    tmpdir = tmp_path_factory.mktemp("test_ALE_montecarlo_null_unit")
+    out_file = os.path.join(tmpdir, "file.pkl.gz")
+
+    meta = ale.ALE(null_method="montecarlo", n_iters=10)
+    results = meta.fit(testdata_cbma)
+    assert isinstance(results.description_, str)
+    assert "stat" in results.maps.keys()
+    assert "p" in results.maps.keys()
+    assert "z" in results.maps.keys()
+    assert isinstance(results, nimare.results.MetaResult)
+    assert isinstance(results.get_map("z", return_type="image"), nib.Nifti1Image)
+    assert isinstance(results.get_map("z", return_type="array"), np.ndarray)
+    results_copy = results.copy()
+    assert results_copy != results
+    assert isinstance(results, nimare.results.MetaResult)
+
+    # Test saving/loading
+    meta.save(out_file, compress=True)
+    assert os.path.isfile(out_file)
+    meta2 = ale.ALE.load(out_file, compressed=True)
+    assert isinstance(meta2, ale.ALE)
+    with pytest.raises(pickle.UnpicklingError):
+        ale.ALE.load(out_file, compressed=False)
+
+    meta.save(out_file, compress=False)
+    assert os.path.isfile(out_file)
+    meta2 = ale.ALE.load(out_file, compressed=False)
+    assert isinstance(meta2, ale.ALE)
+    with pytest.raises(OSError):
+        ale.ALE.load(out_file, compressed=True)
+
+    # Test MCC methods
+    # Monte Carlo FWE
+    corr = FWECorrector(method="montecarlo", voxel_thresh=0.001, n_iters=5, n_cores=-1)
+    corr_results = corr.transform(results)
+    assert isinstance(corr_results, nimare.results.MetaResult)
+    assert isinstance(corr_results.description_, str)
+    assert "z_desc-size_level-cluster_corr-FWE_method-montecarlo" in corr_results.maps.keys()
+    assert "z_desc-mass_level-cluster_corr-FWE_method-montecarlo" in corr_results.maps.keys()
+    assert "z_level-voxel_corr-FWE_method-montecarlo" in corr_results.maps.keys()
+    assert "logp_desc-size_level-cluster_corr-FWE_method-montecarlo" in corr_results.maps.keys()
+    assert "logp_desc-mass_level-cluster_corr-FWE_method-montecarlo" in corr_results.maps.keys()
+    assert "logp_level-voxel_corr-FWE_method-montecarlo" in corr_results.maps.keys()
+    assert isinstance(
+        corr_results.get_map(
+            "z_desc-size_level-cluster_corr-FWE_method-montecarlo", return_type="image"
+        ),
+        nib.Nifti1Image,
+    )
+    assert isinstance(
+        corr_results.get_map(
+            "z_desc-size_level-cluster_corr-FWE_method-montecarlo", return_type="array"
+        ),
+        np.ndarray,
+    )
+    assert isinstance(
+        corr_results.get_map(
+            "z_desc-mass_level-cluster_corr-FWE_method-montecarlo", return_type="image"
+        ),
+        nib.Nifti1Image,
+    )
+    assert isinstance(
+        corr_results.get_map(
+            "z_desc-mass_level-cluster_corr-FWE_method-montecarlo", return_type="array"
+        ),
+        np.ndarray,
+    )
+
+    # Check that the updated null distribution is in the corrected MetaResult's Estimator.
+    assert (
+        "values_desc-mass_level-cluster_corr-fwe_method-montecarlo"
+        in corr_results.estimator.null_distributions_.keys()
+    )
+    # The updated null distribution should *not* be in the original Estimator, nor in the
+    # uncorrected MetaResult's Estimator.
+    assert (
+        "values_desc-mass_level-cluster_corr-fwe_method-montecarlo"
+        not in meta.null_distributions_.keys()
+    )
+    assert (
+        "values_desc-mass_level-cluster_corr-fwe_method-montecarlo"
+        not in results.estimator.null_distributions_.keys()
+    )
+
+    # Bonferroni FWE
+    corr = FWECorrector(method="bonferroni")
+    corr_results = corr.transform(results)
+    assert isinstance(corr_results, nimare.results.MetaResult)
+    assert isinstance(
+        corr_results.get_map("z_corr-FWE_method-bonferroni", return_type="image"), nib.Nifti1Image
+    )
+    assert isinstance(
+        corr_results.get_map("z_corr-FWE_method-bonferroni", return_type="array"), np.ndarray
+    )
+
+    # FDR
+    corr = FDRCorrector(method="indep", alpha=0.05)
+    corr_results = corr.transform(results)
+    assert isinstance(corr_results, nimare.results.MetaResult)
+    assert isinstance(
+        corr_results.get_map("z_corr-FDR_method-indep", return_type="image"), nib.Nifti1Image
+    )
+    assert isinstance(
+        corr_results.get_map("z_corr-FDR_method-indep", return_type="array"), np.ndarray
+    )
+
+
+def test_ALESubtraction_smoke(testdata_cbma, tmp_path_factory):
+    """Smoke test for ALESubtraction."""
+    tmpdir = tmp_path_factory.mktemp("test_ALESubtraction_smoke")
+    out_file = os.path.join(tmpdir, "file.pkl.gz")
+
+    sub_meta = ale.ALESubtraction(n_iters=10, n_cores=2)
+    results = sub_meta.fit(testdata_cbma, testdata_cbma)
+    assert isinstance(results, nimare.results.MetaResult)
+    assert isinstance(results.description_, str)
+    assert "z_desc-group1MinusGroup2" in results.maps.keys()
+    assert isinstance(
+        results.get_map("z_desc-group1MinusGroup2", return_type="image"), nib.Nifti1Image
+    )
+    assert isinstance(results.get_map("z_desc-group1MinusGroup2", return_type="array"), np.ndarray)
+
+    sub_meta.save(out_file)
+    assert os.path.isfile(out_file)
+
+
+def test_SCALE_smoke(testdata_cbma, tmp_path_factory):
+    """Smoke test for SCALE."""
+    tmpdir = tmp_path_factory.mktemp("test_SCALE_smoke")
+    out_file = os.path.join(tmpdir, "file.pkl.gz")
+    dset = testdata_cbma.slice(testdata_cbma.ids[:3])
+
+    with pytest.raises(TypeError):
+        ale.SCALE(xyz="dog", n_iters=5, n_cores=1)
+
+    with pytest.raises(ValueError):
+        ale.SCALE(xyz=np.random.random((5, 3, 1)), n_iters=5, n_cores=1)
+
+    with pytest.raises(ValueError):
+        ale.SCALE(xyz=np.random.random((3, 10)), n_iters=5, n_cores=1)
+
+    xyz = vox2mm(
+        np.vstack(np.where(testdata_cbma.masker.mask_img.get_fdata())).T,
+        testdata_cbma.masker.mask_img.affine,
+    )
+    xyz = xyz[:20, :]
+    meta = ale.SCALE(xyz, n_iters=5, n_cores=1)
+    results = meta.fit(dset)
+    assert isinstance(results, nimare.results.MetaResult)
+    assert isinstance(results.description_, str)
+    assert "z" in results.maps.keys()
+    assert isinstance(results.get_map("z", return_type="image"), nib.Nifti1Image)
+    assert isinstance(results.get_map("z", return_type="array"), np.ndarray)
+
+    meta.save(out_file)
+    assert os.path.isfile(out_file)
+
+
+def test_ALE_non_nifti_masker(testdata_cbma):
+    """Unit test for ALE with non-NiftiMasker.
+
+    CBMA estimators don't work with non-NiftiMasker (e.g., a NiftiLabelsMasker).
+    """
+    atlas = os.path.join(get_test_data_path(), "test_pain_dataset", "atlas.nii.gz")
+    masker = NiftiLabelsMasker(atlas)
+    meta = ale.ALE(mask=masker, n_iters=10)
+
+    with pytest.raises(ValueError):
+        meta.fit(testdata_cbma)

nimare/tests/test_meta_cbmr.py

@@ -0,0 +1,295 @@
+"""Tests for CBMR meta-analytic methods."""
+
+import logging
+import warnings
+
+import pytest
+
+try:
+    import torch
+except ImportError:
+    warnings.warn("Torch not installed. CBMR tests will be skipped.")
+    TORCH_INSTALLED = False
+else:
+    TORCH_INSTALLED = True
+    from nimare.meta import models
+    from nimare.meta.cbmr import CBMREstimator, CBMRInference
+
+import nimare
+from nimare.correct import FDRCorrector, FWECorrector
+from nimare.transforms import StandardizeField
+
+# numba has a lot of debug messages that are not useful for testing
+logging.getLogger("numba").setLevel(logging.WARNING)
+# indexed_gzip has a few debug messages that are not useful for testing
+logging.getLogger("indexed_gzip").setLevel(logging.WARNING)
+
+
+if TORCH_INSTALLED:
+
+    @pytest.fixture(
+        scope="session",
+        params=[
+            pytest.param(models.PoissonEstimator, id="Poisson"),
+            pytest.param(models.NegativeBinomialEstimator, id="NegativeBinomial"),
+            pytest.param(
+                models.ClusteredNegativeBinomialEstimator, id="ClusteredNegativeBinomial"
+            ),
+        ],
+    )
+    def model(request):
+        """CBMR models."""
+        return request.param
+
+else:
+    model = None
+
+
+@pytest.fixture(scope="session")
+def cbmr_result(testdata_cbmr_simulated, model):
+    """Test CBMR estimator."""
+    dset = StandardizeField(fields=["sample_sizes", "avg_age", "schizophrenia_subtype"]).transform(
+        testdata_cbmr_simulated
+    )
+
+    cbmr = CBMREstimator(
+        group_categories=["diagnosis", "drug_status"],
+        moderators=["standardized_sample_sizes", "standardized_avg_age", "schizophrenia_subtype"],
+        spline_spacing=100,
+        model=model,
+        penalty=False,
+        n_iter=1000,
+        lr=1,
+        tol=1e4,
+        device="cpu",
+    )
+    res = cbmr.fit(dataset=dset)
+    assert isinstance(res, nimare.results.MetaResult)
+    assert isinstance(res.description_, str)
+
+    return res
+
+
+@pytest.fixture(scope="session")
+def inference_results(testdata_cbmr_simulated, cbmr_result):
+    """Test inference results for CBMR estimator."""
+    inference = CBMRInference(device="cpu")
+    inference.fit(cbmr_result)
+    t_con_groups = inference.create_contrast(
+        [
+            "DepressionYes-DepressionNo",
+        ],
+        source="groups",
+    )
+    t_con_moderators = inference.create_contrast(
+        ["standardized_sample_sizes-standardized_avg_age"],
+        source="moderators",
+    )
+    contrast_result = inference.transform(
+        t_con_groups=t_con_groups, t_con_moderators=t_con_moderators
+    )
+
+    return contrast_result
+
+
+@pytest.fixture(
+    scope="session",
+    params=[
+        pytest.param(FWECorrector(method="bonferroni"), id="bonferroni"),
+        pytest.param(FDRCorrector(method="indep"), id="indep"),
+        pytest.param(FDRCorrector(method="negcorr"), id="negcorr"),
+    ],
+)
+def corrector(request):
+    """Corrector classes."""
+    return request.param
+
+
+def test_cbmr_estimator(cbmr_result):
+    """Unit test for CBMR estimator."""
+    assert isinstance(cbmr_result, nimare.results.MetaResult)
+
+
+def test_cbmr_inference(inference_results):
+    """Unit test for CBMR inference."""
+    assert isinstance(inference_results, nimare.results.MetaResult)
+
+
+def test_cbmr_correctors(inference_results, corrector):
+    """Unit test for Correctors that work with CBMR."""
+    corrected_results = corrector.transform(inference_results)
+    assert isinstance(corrected_results, nimare.results.MetaResult)
+
+
+def test_firth_penalty(testdata_cbmr_simulated):
+    """Unit test for Firth penalty."""
+    dset = StandardizeField(fields=["sample_sizes", "avg_age", "schizophrenia_subtype"]).transform(
+        testdata_cbmr_simulated
+    )
+    cbmr = CBMREstimator(
+        group_categories=["diagnosis", "drug_status"],
+        moderators=["standardized_sample_sizes", "standardized_avg_age", "schizophrenia_subtype"],
+        spline_spacing=100,
+        model=models.PoissonEstimator,
+        penalty=True,
+        lr=1,
+        tol=1e4,
+        device="cpu",
+    )
+    res = cbmr.fit(dataset=dset)
+    assert isinstance(res, nimare.results.MetaResult)
+
+
+def test_moderators_none(testdata_cbmr_simulated):
+    """Unit test for Firth penalty."""
+    dset = StandardizeField(fields=["sample_sizes", "avg_age", "schizophrenia_subtype"]).transform(
+        testdata_cbmr_simulated
+    )
+    cbmr = CBMREstimator(
+        group_categories=["diagnosis", "drug_status"],
+        moderators=None,
+        spline_spacing=100,
+        model=models.PoissonEstimator,
+        penalty=False,
+        lr=1,
+        tol=1e4,
+        device="cpu",
+    )
+    res = cbmr.fit(dataset=dset)
+    assert isinstance(res, nimare.results.MetaResult)
+    inference = CBMRInference(device="cpu")
+    inference.fit(res)
+
+    t_con_groups = inference.create_contrast(
+        [
+            "DepressionYes",
+        ],
+        source="groups",
+    )
+    inference_results = inference.transform(t_con_groups=t_con_groups)
+
+    assert isinstance(inference_results, nimare.results.MetaResult)
+
+
+def test_CBMREstimator_update(testdata_cbmr_simulated):
+    """Unit test for CBMR estimator update function."""
+    testdata_cbmr_simulated = StandardizeField(
+        fields=["sample_sizes", "avg_age", "schizophrenia_subtype"]
+    ).transform(testdata_cbmr_simulated)
+    cbmr = CBMREstimator(
+        moderators=["standardized_sample_sizes", "standardized_avg_age", "schizophrenia_subtype"],
+        model=models.PoissonEstimator,
+        lr=1,
+    )
+
+    cbmr._collect_inputs(testdata_cbmr_simulated, drop_invalid=True)
+    cbmr._preprocess_input(testdata_cbmr_simulated)
+
+    # fit the model
+    init_weight_kwargs = {
+        "groups": cbmr.groups,
+        "moderators": cbmr.moderators,
+        "spatial_coef_dim": cbmr.inputs_["coef_spline_bases"].shape[1],
+        "moderators_coef_dim": len(cbmr.moderators) if cbmr.moderators else None,
+    }
+
+    cbmr.model.init_weights(**init_weight_kwargs)
+    optimizer = torch.optim.LBFGS(cbmr.model.parameters(), cbmr.lr)
+    # load dataset info to torch.tensor
+    if cbmr.moderators:
+        moderators_by_group_tensor = dict()
+        for group in cbmr.model.groups:
+            moderators_tensor = torch.tensor(
+                cbmr.inputs_["moderators_by_group"][group],
+                dtype=torch.float64,
+                device=cbmr.device,
+            )
+            moderators_by_group_tensor[group] = moderators_tensor
+    else:
+        moderators_by_group_tensor = None
+    foci_per_voxel_tensor, foci_per_study_tensor = dict(), dict()
+    for group in cbmr.model.groups:
+        group_foci_per_voxel_tensor = torch.tensor(
+            cbmr.inputs_["foci_per_voxel"][group], dtype=torch.float64, device=cbmr.device
+        )
+        group_foci_per_study_tensor = torch.tensor(
+            cbmr.inputs_["foci_per_study"][group], dtype=torch.float64, device=cbmr.device
+        )
+        foci_per_voxel_tensor[group] = group_foci_per_voxel_tensor
+        foci_per_study_tensor[group] = group_foci_per_study_tensor
+
+    if cbmr.iter == 0:
+        prev_loss = torch.tensor(float("inf"))  # initialization loss difference
+
+    cbmr.model._update(
+        optimizer,
+        torch.tensor(cbmr.inputs_["coef_spline_bases"], dtype=torch.float64, device=cbmr.device),
+        moderators_by_group_tensor,
+        foci_per_voxel_tensor,
+        foci_per_study_tensor,
+        prev_loss,
+    )
+    # deliberately set the first spatial coefficient to nan
+    for group in cbmr.model.groups:
+        nan_coef = torch.tensor(cbmr.model.spatial_coef_linears[group].weight)
+        nan_coef[:, 0] = float("nan")
+        cbmr.model.spatial_coef_linears[group].weight = torch.nn.Parameter(nan_coef)
+
+    # Expect exceptions when one of the spatial coefficients is nan.
+    with pytest.raises(ValueError):
+        cbmr.model._update(
+            optimizer,
+            torch.tensor(
+                cbmr.inputs_["coef_spline_bases"], dtype=torch.float64, device=cbmr.device
+            ),
+            moderators_by_group_tensor,
+            foci_per_voxel_tensor,
+            foci_per_study_tensor,
+            prev_loss,
+        )
+
+
+def test_StandardizeField(testdata_cbmr_simulated):
+    """Unit test for StandardizeField."""
+    dset = StandardizeField(fields=["sample_sizes", "avg_age"]).transform(testdata_cbmr_simulated)
+    assert isinstance(dset, nimare.dataset.Dataset)
+    assert "standardized_sample_sizes" in dset.annotations
+    assert "standardized_avg_age" in dset.annotations
+    assert dset.annotations["standardized_sample_sizes"].mean() == pytest.approx(0.0, abs=1e-3)
+    assert dset.annotations["standardized_sample_sizes"].std() == pytest.approx(1.0, abs=1e-3)
+    assert dset.annotations["standardized_avg_age"].mean() == pytest.approx(0.0, abs=1e-3)
+    assert dset.annotations["standardized_avg_age"].std() == pytest.approx(1.0, abs=1e-3)
+
+
+@pytest.mark.cbmr_importerror
+def test_cbmr_importerror():
+    """Test that ImportErrors are raised when torch is not installed."""
+    with pytest.raises(ImportError):
+        from nimare.meta.cbmr import CBMREstimator
+
+        CBMREstimator()
+
+    with pytest.raises(ImportError):
+        from nimare.meta.cbmr import CBMRInference
+
+        CBMRInference()
+
+    with pytest.raises(ImportError):
+        from nimare.meta.models import GeneralLinearModelEstimator
+
+        GeneralLinearModelEstimator()
+
+    with pytest.raises(ImportError):
+        from nimare.meta.models import PoissonEstimator
+
+        PoissonEstimator()
+
+    with pytest.raises(ImportError):
+        from nimare.meta.models import NegativeBinomialEstimator
+
+        NegativeBinomialEstimator()
+
+    with pytest.raises(ImportError):
+        from nimare.meta.models import ClusteredNegativeBinomialEstimator
+
+        ClusteredNegativeBinomialEstimator()