nimare 0.4.2__py3-none-any.whl

nimare/tests/data/test_sleuth_file.txt

@@ -0,0 +1,18 @@
+// Reference = MNI
+// StudyName: ExperimentName
+// Subjects = 50
+-16	-58	-22
+26	-64	-50
+12	-70	-42
+-10	12	50
+
+// StudyName2: ExperimentName
+// Subjects = 46
+-9	-72	57
+-15	9	-3
+
+// StudyName3: ExperimentName
+// StudyName3: ExperimentName2
+// StudyName3: ExperimentName3
+// Subjects = 20
+-9	-72	57

nimare/tests/data/test_sleuth_file2.txt

@@ -0,0 +1,10 @@
+// Reference = Talairach
+// StudyName: ExperimentName2
+// Subjects = 25
+-18	-58	-24
+
+// StudyName4: ExperimentName2
+// Subjects = 20
+-18   -58     -24
+26	-64	-50
+12	-70	-42

nimare/tests/data/test_sleuth_file3.txt

@@ -0,0 +1,5 @@
+// Reference = Talairach
+// StudyName: ExperimentName
+// Subjects = 25
+-18	-58	-24
+10  20  dog

nimare/tests/data/test_sleuth_file4.txt

@@ -0,0 +1,5 @@
+// Reference = Talairach
+// StudyName: ExperimentName
+// Subjects = 25
+-18	-58	-24
+10  20

nimare/tests/data/test_sleuth_file5.txt

@@ -0,0 +1,5 @@
+// Reference = Dog
+// StudyName: ExperimentName
+// Subjects = 25
+-18	-58	-24
+10  20  10

nimare/tests/test_annotate_cogat.py

@@ -0,0 +1,32 @@
+"""Test nimare.annotate.cogat (Cognitive Atlas extraction methods)."""
+
+import pandas as pd
+
+from nimare import annotate, extract, utils
+
+
+def test_cogat(testdata_laird):
+    """A smoke test for CogAt-related functions."""
+    # A small test dataset with abstracts
+    ns_dset_laird = testdata_laird.copy()
+    cogat = extract.download_cognitive_atlas(data_dir=utils.get_resource_path(), overwrite=False)
+    id_df = pd.read_csv(cogat["ids"])
+    rel_df = pd.read_csv(cogat["relationships"])
+    weights = {"isKindOf": 1, "isPartOf": 1, "inCategory": 1}
+    counts_df, rep_text_df = annotate.cogat.extract_cogat(
+        ns_dset_laird.texts, id_df, text_column="abstract"
+    )
+    assert "id" in ns_dset_laird.texts.columns
+    expanded_df = annotate.cogat.expand_counts(counts_df, rel_df, weights)
+    assert isinstance(expanded_df, pd.DataFrame)
+
+
+def test_CogAtLemmatizer():
+    """A smoke test for CogAtLemmatizer."""
+    cogat = extract.download_cognitive_atlas(data_dir=utils.get_resource_path(), overwrite=False)
+    id_df = pd.read_csv(cogat["ids"])
+    id_df = id_df.loc[id_df["id"] == "trm_4aae62e4ad209"]
+    lem = annotate.cogat.CogAtLemmatizer(id_df)
+    true_text = "trm_4aae62e4ad209 is great"
+    test_text = "Cognitive control is great"
+    assert lem.transform(test_text) == true_text

nimare/tests/test_annotate_gclda.py

@@ -0,0 +1,86 @@
+"""Test nimare.annotate.gclda (GCLDA)."""
+
+import nibabel as nib
+import numpy as np
+import pandas as pd
+import pytest
+
+from nimare import annotate, decode
+
+
+def test_gclda_symmetric(testdata_laird):
+    """A smoke test for GCLDA with symmetric regions."""
+    counts_df = annotate.text.generate_counts(
+        testdata_laird.texts,
+        text_column="abstract",
+        tfidf=False,
+        min_df=1,
+        max_df=1.0,
+    )
+
+    with pytest.raises(ValueError):
+        annotate.gclda.GCLDAModel(
+            counts_df,
+            testdata_laird.coordinates,
+            mask=testdata_laird.masker.mask_img,
+            n_regions=3,
+            symmetric=True,
+        )
+
+    model = annotate.gclda.GCLDAModel(
+        counts_df,
+        testdata_laird.coordinates,
+        mask=testdata_laird.masker.mask_img,
+        n_regions=2,
+        symmetric=True,
+    )
+    model.fit(n_iters=5, loglikely_freq=5)
+
+    # Create ROI to decode
+    arr = np.zeros(testdata_laird.masker.mask_img.shape, np.int32)
+    arr[40:44, 45:49, 40:44] = 1
+    mask_img = nib.Nifti1Image(arr, testdata_laird.masker.mask_img.affine)
+    decoded_df, _ = decode.discrete.gclda_decode_roi(model, mask_img)
+    assert isinstance(decoded_df, pd.DataFrame)
+
+    # Decode the ROI as a continuous map
+    decoded_df, _ = decode.continuous.gclda_decode_map(model, mask_img)
+    assert isinstance(decoded_df, pd.DataFrame)
+
+    # Encode text
+    encoded_img, _ = decode.encode.gclda_encode(model, "fmri activation")
+    assert isinstance(encoded_img, nib.Nifti1Image)
+
+
+def test_gclda_asymmetric(testdata_laird):
+    """A smoke test for GCLDA with three asymmetric regions."""
+    counts_df = annotate.text.generate_counts(
+        testdata_laird.texts,
+        text_column="abstract",
+        tfidf=False,
+        min_df=1,
+        max_df=1.0,
+    )
+    model = annotate.gclda.GCLDAModel(
+        counts_df,
+        testdata_laird.coordinates,
+        mask=testdata_laird.masker.mask_img,
+        n_regions=3,
+        symmetric=False,
+    )
+    model.fit(n_iters=5, loglikely_freq=5)
+
+    # Create ROI to decode
+    arr = np.zeros(testdata_laird.masker.mask_img.shape, np.int32)
+    arr[40:44, 45:49, 40:44] = 1
+    mask_img = nib.Nifti1Image(arr, testdata_laird.masker.mask_img.affine)
+    decoded_df, _ = decode.discrete.gclda_decode_roi(model, mask_img)
+    assert isinstance(decoded_df, pd.DataFrame)
+
+    # Decode the ROI as a continuous map
+    decoded_df, _ = decode.continuous.gclda_decode_map(model, mask_img)
+    assert isinstance(decoded_df, pd.DataFrame)
+
+    # Encode text
+    encoded_img, _ = decode.encode.gclda_encode(model, "fmri activation")
+    assert isinstance(encoded_img, nib.Nifti1Image)

nimare/tests/test_annotate_lda.py

@@ -0,0 +1,27 @@
+"""Test nimare.annotate.lda (LDA)."""
+
+import numpy as np
+import pandas as pd
+
+from nimare import annotate
+
+
+def test_lda(testdata_laird):
+    """A smoke test for LDA."""
+    N_TOPICS = 5
+    model = annotate.lda.LDAModel(
+        n_topics=N_TOPICS,
+        max_iter=100,
+        text_column="abstract",
+    )
+    new_dset = model.fit(testdata_laird)
+    topic_columns = [c for c in new_dset.annotations.columns if c.startswith("LDA")]
+    assert len(topic_columns) == N_TOPICS
+
+    assert hasattr(model, "distributions_")
+    assert "p_topic_g_word" in model.distributions_.keys()
+    assert isinstance(model.distributions_["p_topic_g_word"], np.ndarray)
+    assert model.distributions_["p_topic_g_word"].shape[0] == N_TOPICS
+    assert "p_topic_g_word_df" in model.distributions_.keys()
+    assert isinstance(model.distributions_["p_topic_g_word_df"], pd.DataFrame)
+    assert model.distributions_["p_topic_g_word_df"].shape[0] == N_TOPICS

nimare/tests/test_dataset.py

@@ -0,0 +1,99 @@
+"""Test nimare.dataset (Dataset IO/transformations)."""
+
+import copy
+import json
+import os.path as op
+import warnings
+
+import nibabel as nib
+import numpy as np
+import pytest
+
+import nimare
+from nimare import dataset
+from nimare.tests.utils import get_test_data_path
+
+
+def test_dataset_smoke():
+    """Smoke test for nimare.dataset.Dataset initialization and get methods."""
+    db_file = op.join(get_test_data_path(), "neurosynth_dset.json")
+    dset = dataset.Dataset(db_file)
+    dset.update_path(get_test_data_path())
+    assert isinstance(dset, nimare.dataset.Dataset)
+    # Test that Dataset.masker is portable
+    assert not nib.is_proxy(dset.masker.mask_img_.dataobj)
+
+    methods = [dset.get_images, dset.get_labels, dset.get_metadata, dset.get_texts]
+    for method in methods:
+        assert isinstance(method(), list)
+        assert isinstance(method(ids=dset.ids[:5]), list)
+        assert isinstance(method(ids=dset.ids[0]), list)
+
+    assert isinstance(dset.get_images(imtype="beta"), list)
+    assert isinstance(dset.get_metadata(field="sample_sizes"), list)
+    assert isinstance(dset.get_studies_by_label("cogat_cognitive_control"), list)
+    assert isinstance(dset.get_studies_by_coordinate(np.array([[20, 20, 20]])), list)
+
+    # If label is not available, raise ValueError
+    with pytest.raises(ValueError):
+        dset.get_studies_by_label("dog")
+
+    mask_data = np.zeros(dset.masker.mask_img.shape, np.int32)
+    mask_data[40, 40, 40] = 1
+    mask_img = nib.Nifti1Image(mask_data, dset.masker.mask_img.affine)
+    assert isinstance(dset.get_studies_by_mask(mask_img), list)
+
+    dset1 = dset.slice(dset.ids[:5])
+    dset2 = dset.slice(dset.ids[5:])
+    assert isinstance(dset1, dataset.Dataset)
+    dset_merged = dset1.merge(dset2)
+    assert isinstance(dset_merged, dataset.Dataset)
+
+
+def test_empty_dset():
+    """Smoke test for initialization with an empty Dataset."""
+    # dictionary with no information
+    minimal_dict = {"study-0": {"contrasts": {"1": {}}}}
+    dataset.Dataset(minimal_dict)
+
+
+def test_posneg_warning():
+    """Smoke test for nimare.dataset.Dataset initialization with positive and negative z_stat."""
+    db_file = op.join(get_test_data_path(), "neurosynth_dset.json")
+    with open(db_file, "r") as f_obj:
+        data = json.load(f_obj)
+
+    data_pos_zstats = copy.deepcopy(data)
+    data_neg_zstats = copy.deepcopy(data)
+    for pid in data.keys():
+        for expid in data[pid]["contrasts"].keys():
+            exp = data[pid]["contrasts"][expid]
+
+            if "coords" not in exp.keys():
+                continue
+
+            if "z_stat" not in exp["coords"].keys():
+                continue
+
+            n_zstats = len(exp["coords"]["z_stat"])
+            rand_arr = np.random.randn(n_zstats)
+            rand_pos_arr = np.abs(rand_arr)
+            rand_neg_arr = np.abs(rand_arr) * -1
+
+            data[pid]["contrasts"][expid]["coords"]["z_stat"] = rand_arr.tolist()
+            data_neg_zstats[pid]["contrasts"][expid]["coords"]["z_stat"] = rand_neg_arr.tolist()
+            data_pos_zstats[pid]["contrasts"][expid]["coords"]["z_stat"] = rand_pos_arr.tolist()
+
+    # Test Warning is raised if there are positive and negative z-stat
+    with pytest.warns(UserWarning, match=r"positive and negative z_stats"):
+        dset_posneg = dataset.Dataset(data)
+
+    # Test Warning is not raised if there are only positive or negative z-stat
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        dset_pos = dataset.Dataset(data_pos_zstats)
+        dset_neg = dataset.Dataset(data_neg_zstats)
+
+    assert isinstance(dset_posneg, nimare.dataset.Dataset)
+    assert isinstance(dset_pos, nimare.dataset.Dataset)
+    assert isinstance(dset_neg, nimare.dataset.Dataset)

nimare/tests/test_decode_continuous.py

@@ -0,0 +1,132 @@
+"""Test nimare.decode.continuous.
+
+Tests for nimare.decode.continuous.gclda_decode_map are in test_annotate_gclda.
+"""
+
+import os
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from nimare.decode import continuous
+from nimare.meta import kernel, mkda
+
+
+def test_CorrelationDecoder_smoke(testdata_laird, tmp_path_factory):
+    """Smoke test for continuous.CorrelationDecoder."""
+    testdata_laird = testdata_laird.copy()
+    features = testdata_laird.get_labels(ids=testdata_laird.ids[0])[:5]
+
+    # Make an image to decode
+    meta = mkda.KDA(null_method="approximate")
+    res = meta.fit(testdata_laird)
+    img = res.get_map("stat")
+
+    # Test: train decoder with Dataset object
+    decoder = continuous.CorrelationDecoder(features=features)
+    decoder.fit(testdata_laird)
+    decoded_df = decoder.transform(img)
+
+    assert isinstance(decoded_df, pd.DataFrame)
+
+    # Get features and images to compare with other methods
+    features = list(decoder.results_.maps.keys())
+    images = np.array(list(decoder.results_.maps.values()))
+
+    # Save images to disk to test load_imgs method
+    tmpdir = tmp_path_factory.mktemp("test_CorrelationDecoder")
+    decoder.results_.save_maps(tmpdir)
+
+    # Test: load pregenerated maps using a dictionary of feature names and paths
+    img_dict = {feature: os.path.join(tmpdir, f"{feature}.nii.gz") for feature in features}
+    decoder2 = continuous.CorrelationDecoder()
+    decoder2.load_imgs(img_dict, mask=testdata_laird.masker)
+    decoded2_df = decoder2.transform(img)
+
+    features2 = list(decoder2.results_.maps.keys())
+    images2 = np.array(list(decoder2.results_.maps.values()))
+
+    assert isinstance(decoded2_df, pd.DataFrame)
+    assert np.array_equal(features, features2)
+    assert np.array_equal(images, images2)
+    assert decoded_df.equals(decoded2_df)
+
+    # Test: load pregenerated maps from a directory
+    decoder3 = continuous.CorrelationDecoder()
+    decoder3.load_imgs(tmpdir.as_posix(), mask=testdata_laird.masker)
+    decoded3_df = decoder3.transform(img)
+
+    features3 = list(decoder3.results_.maps.keys())
+    images3 = np.array(list(decoder3.results_.maps.values()))
+
+    assert isinstance(decoded3_df, pd.DataFrame)
+    assert np.array_equal(features, features3)
+    assert np.array_equal(images, images3)
+    assert decoded_df.equals(decoded3_df)
+
+    # Test: passing a dataset to load_imgs
+    decoder4 = continuous.CorrelationDecoder()
+    with pytest.raises(ValueError):
+        decoder4.load_imgs(testdata_laird, mask=testdata_laird.masker)
+
+    # Test: try loading pregenerated maps without a masker
+    decoder5 = continuous.CorrelationDecoder()
+    with pytest.raises(ValueError):
+        decoder5.load_imgs(img_dict)
+
+    # Test: try transforming an image without fitting the decoder
+    decoder6 = continuous.CorrelationDecoder()
+    with pytest.raises(AttributeError):
+        decoder6.transform(img)
+
+
+def test_CorrelationDistributionDecoder_smoke(testdata_laird, tmp_path_factory):
+    """Smoke test for continuous.CorrelationDistributionDecoder."""
+    tmpdir = tmp_path_factory.mktemp("test_CorrelationDistributionDecoder")
+
+    testdata_laird = testdata_laird.copy()
+    dset = testdata_laird.copy()
+    features = testdata_laird.get_labels(ids=testdata_laird.ids[0])[:5]
+
+    decoder = continuous.CorrelationDistributionDecoder(features=features)
+
+    # No images of the requested type
+    with pytest.raises(ValueError):
+        decoder.fit(testdata_laird)
+
+    # Let's add the path
+    testdata_laird.update_path(tmpdir)
+
+    # Then let's make some images to decode
+    kern = kernel.MKDAKernel(r=10, value=1)
+    kern._infer_names()  # Determine MA map filenames
+
+    imgs = kern.transform(testdata_laird, return_type="image")
+    for i_img, img in enumerate(imgs):
+        id_ = testdata_laird.ids[i_img]
+        out_file = os.path.join(testdata_laird.basepath, kern.filename_pattern.format(id=id_))
+
+        # Add file names to dset.images DataFrame
+        img.to_filename(out_file)
+        dset.images.loc[testdata_laird.images["id"] == id_, kern.image_type] = out_file
+
+    # And now we have images we can use for decoding!
+    decoder = continuous.CorrelationDistributionDecoder(
+        features=features,
+        target_image=kern.image_type,
+    )
+    decoder.fit(dset)
+
+    # Make an image to decode
+    meta = mkda.KDA(null_method="approximate")
+    res = meta.fit(testdata_laird)
+    img = res.get_map("stat")
+    decoded_df = decoder.transform(img)
+
+    assert isinstance(decoded_df, pd.DataFrame)
+
+    # Test: try transforming an image without fitting the decoder
+    decoder2 = decoder = continuous.CorrelationDistributionDecoder()
+    with pytest.raises(AttributeError):
+        decoder2.transform(img)

nimare/tests/test_decode_discrete.py

@@ -0,0 +1,92 @@
+"""Test nimare.decode.discrete.
+
+Tests for nimare.decode.discrete.gclda_decode_roi are in test_annotate_gclda.
+"""
+
+import pandas as pd
+import pytest
+
+from nimare.decode import discrete
+
+
+def test_neurosynth_decode(testdata_laird):
+    """Smoke test for discrete.neurosynth_decode."""
+    ids = testdata_laird.ids[:5]
+    features = testdata_laird.annotations.columns.tolist()[5:10]
+    decoded_df = discrete.neurosynth_decode(
+        testdata_laird.coordinates,
+        testdata_laird.annotations,
+        ids=ids,
+        features=features,
+        correction=None,
+    )
+    assert isinstance(decoded_df, pd.DataFrame)
+
+
+def test_brainmap_decode(testdata_laird):
+    """Smoke test for discrete.brainmap_decode."""
+    ids = testdata_laird.ids[:5]
+    features = testdata_laird.annotations.columns.tolist()[5:10]
+    decoded_df = discrete.brainmap_decode(
+        testdata_laird.coordinates,
+        testdata_laird.annotations,
+        ids=ids,
+        features=features,
+        correction=None,
+    )
+    assert isinstance(decoded_df, pd.DataFrame)
+
+
+def test_NeurosynthDecoder(testdata_laird):
+    """Smoke test for discrete.NeurosynthDecoder."""
+    ids = testdata_laird.ids[:5]
+    labels = testdata_laird.get_labels(ids=testdata_laird.ids)
+    decoder = discrete.NeurosynthDecoder(features=labels)
+    decoder.fit(testdata_laird)
+    decoded_df = decoder.transform(ids=ids)
+    assert isinstance(decoded_df, pd.DataFrame)
+    assert decoded_df.shape == (len(labels), 6)
+
+
+def test_NeurosynthDecoder_featuregroup(testdata_laird):
+    """Smoke test for discrete.NeurosynthDecoder with feature group selection."""
+    ids = testdata_laird.ids[:5]
+    decoder = discrete.NeurosynthDecoder(feature_group="Neurosynth_TFIDF")
+    decoder.fit(testdata_laird)
+    decoded_df = decoder.transform(ids=ids)
+    assert isinstance(decoded_df, pd.DataFrame)
+
+
+def test_NeurosynthDecoder_featuregroup_failure(testdata_laird):
+    """Smoke test for NeurosynthDecoder with feature group selection and no detected features."""
+    decoder = discrete.NeurosynthDecoder(feature_group="Neurosynth_TFIDF", features=["01", "05"])
+    with pytest.raises(Exception):
+        decoder.fit(testdata_laird)
+
+
+def test_BrainMapDecoder(testdata_laird):
+    """Smoke test for discrete.BrainMapDecoder."""
+    ids = testdata_laird.ids[:5]
+    labels = testdata_laird.get_labels(ids=testdata_laird.ids)
+    decoder = discrete.BrainMapDecoder(features=labels)
+    decoder.fit(testdata_laird)
+    decoded_df = decoder.transform(ids=ids)
+    assert isinstance(decoded_df, pd.DataFrame)
+    assert decoded_df.shape == (len(labels), 6)
+
+
+def test_BrainMapDecoder_failure(testdata_laird):
+    """Smoke test for discrete.BrainMapDecoder where there are no features left."""
+    decoder = discrete.BrainMapDecoder(features=["doggy"])
+    with pytest.raises(Exception):
+        decoder.fit(testdata_laird)
+
+
+def test_ROIAssociationDecoder(testdata_laird, roi_img):
+    """Smoke test for discrete.ROIAssociationDecoder."""
+    labels = testdata_laird.get_labels(ids=testdata_laird.ids)
+    decoder = discrete.ROIAssociationDecoder(masker=roi_img, features=labels)
+    decoder.fit(testdata_laird)
+    decoded_df = decoder.transform()
+    assert isinstance(decoded_df, pd.DataFrame)
+    assert decoded_df.shape == (len(labels), 1)