class NeurosynthMerge:
def __init__(self, thesaurus, npath, outdir, test_mode=False):
"""
Generates a new set of images using the neurosynth repository combining
across terms in a thesarus.
Args:
- thesaurus: A list of tuples where:[('term that will be the name
of the file', 'the other term', 'expression combining the
terms')]
- the last expression is alphanumeric and separated by:
(& for and) (&~ for andnot) (| for or)
- npath: directory where the neurosynth git repository is locally
on your machine (https://github.com/neurosynth/neurosynth)
- outdir: directory where the generated images will be saved
- test_mode: when true, the code will run an abridged version for
test purposes (as implemented by test.Neurosynth.py)
"""
self.thesaurus = thesaurus
self.npath = npath
self.outdir = outdir
self.import_neurosynth_git()
from neurosynth.analysis import meta
# Take out first two terms from the feature_list and insert the third
# term from the tuple.
for triplet in thesaurus:
self.feature_list = [feature for feature in self.feature_list \
if feature not in triplet]
self.feature_list.append(triplet[-1])
# This makes an abridged version of feature_list for testing purposes.
if test_mode:
self.feature_list = [triplet[-1] for triplet in thesaurus]
# Run metanalyses on the new features set and save the results to the
#outdir.
for feature in self.feature_list:
self.ids = self.dataset.get_ids_by_expression(feature,
threshold=0.001)
ma = meta.MetaAnalysis(self.dataset, self.ids)
# Parse the feature name (to avoid conflicts with illegal
#characters as file names)
regex = re.compile('\W+')
split = re.split(regex, feature)
feat_fname = split[0]
# Save the results (many different types of files)
ma.save_results(self.outdir+os.sep+feat_fname)
def import_neurosynth_git(self):
# Add the appropriate neurosynth git folder to the python path.
sys.path.append(self.npath)
from neurosynth.base.dataset import Dataset
from neurosynth.analysis import meta
# Try to load a pickle if it exists. Create a new dataset instance
# if it doesn't.
try:
self.dataset = cPickle.load(
open(self.npath+os.sep+'data/dataset.pkl', 'rb'))
except IOError:
# Create Dataset instance from a database file.
self.dataset = Dataset(self.npath+os.sep+'data/database.txt')
# Load features from file
self.dataset.add_features(self.npath+os.sep+'data/features.txt')
# Get names of features.
self.feature_list = self.dataset.get_feature_names()
from neurosynth.base.dataset import Dataset
from neurosynth.analysis import meta
import os
dataset = Dataset('database.txt')
dataset.add_features('features.txt')
print dataset.get_feature_names()
ids = dataset.get_ids_by_features('emo*', threshold=0.001)
print len(ids)
ma = meta.MetaAnalysis(dataset, ids)
ma.save_results('emotion')
# <codecell>
dataset = Dataset.load('dataset.pkl') # Note the capital D in the second Dataset--load() is a class method
# <markdowncell>
# ## Doing stuff with Neurosynth
# Now that our Dataset has both activation data and some features, we're ready to start doing some analyses! By design, Neurosynth focuses on facilitating simple, fast, and modestly useful analyses. This means you probably won't break any new ground using Neurosynth, but you should be able to supplement results you've generated using other approaches with a bunch of nifty analyses that take just 2 - 3 lines of code.
#
# ### Simple feature-based meta-analyses
# The most straightforward thing you can do with Neurosynth is use the features we just loaded above to perform automated large-scale meta-analyses of the literature. Let's see what features we have:
# <codecell>
dataset.get_feature_names()
# <markdowncell>
# If the loading process went smoothly, this should return a list of about 500 terms. We can use these terms--either in isolation or in combination--to select articles for inclusion in a meta-analysis. For example, suppose we want to run a meta-analysis of emotion studies. We could operationally define a study of emotion as one in which the authors used words starting with 'emo' with high frequency:
# <codecell>
ids = dataset.get_ids_by_features('emo*', threshold=0.001)
# <markdowncell>
# Here we're asking for a list of IDs of all studies that use words starting with 'emo' (e.g.,'emotion', 'emotional', 'emotionally', etc.) at a frequency of 1 in 1,000 words or greater (in other words, if an article has 5,000 words of text, it will only be included in our set if it uses words starting with 'emo' at least 5 times). Let's find out how many studies are in our list:
# <codecell>
resource_dir = path.join(path.pardir, 'resources')
# make sure we have the data
dataset_dir = path.join(path.expanduser('~'), 'Documents', 'neurosynth-data')
database_path = path.join(dataset_dir, 'database_bregma.txt')
neurosynth_data_url = 'https://github.com/wmpauli/neurosynth-data'
if not path.exists(database_path):
print("Please download dataset from %s and store it in %s" % (neurosynth_data_url, dataset_dir))
# load dataset, both image table and feature table
r = 1.0 # 1mm smoothing kernel
transform = {'BREGMA': transformations.bregma_to_whs()}
target = 'WHS'
masker_filename = path.join(resource_dir, 'WHS_SD_rat_brainmask_sm_v2.nii.gz')
dataset = Dataset(path.join(dataset_dir, 'database_bregma.txt'), masker=masker_filename, r=r, transform=transform, target=target)
dataset.feature_table = FeatureTable(dataset)
dataset.add_features(path.join(dataset_dir, "features_bregma.txt")) # add features
fn = dataset.get_feature_names()
# get the ids of studies where this feature occurs
ids = dataset.get_ids_by_features(('%s*' % feature), threshold=0.1)
ma = meta.MetaAnalysis(dataset, ids)
results_path = path.join('results', 'meta', feature)
if not path.exists(results_path):
makedirs(results_path)
print("saving results to: %s" % results_path)
ma.save_results(results_path)
# note, figure 2 of manuscript was used by plotting the z-score statistical maps for forward inference (pAgF_z.nii.gz) and reverse inference (pFgA_z.nii.gz)
# Create Dataset instance from a database file.
dataset = Dataset(op.join(neurosynth_data_dir, "database.txt"))
# Load features from file
dataset.add_features(op.join(neurosynth_data_dir, "features.txt"))
# Pickle the Dataset to file so we can use Dataset.load() next time
# instead of having to sit through the generation process again.
dataset.save(op.join(neurosynth_data_dir, "dataset.pkl"))
# Load pickled Dataset--assumes you've previously saved it. If not,
# follow the create_a_new_dataset_and_load_features example.
dataset = Dataset.load(op.join(neurosynth_data_dir, "dataset.pkl"))
# Get the full list of feature names
feature_list = dataset.get_feature_names()
# Run a meta-analysis on each feature, and save all the results to
# a directory called results. Note that the directory will not be
# created for you, so make sure it exists.
# Here we use the default frequency threshold of 0.001 (i.e., a
# study is said to have a feature if more than 1 in every 1,000
# words is the target word), and an FDR correction level of 0.05.
out_dir = "/home/data/nbc/misc-projects/meta-gradients/code/feature_maps"
for tmp_feature in feature_list:
print(tmp_feature)
meta.analyze_features(
dataset,
[tmp_feature],
threshold=0.001,
