def test_eval_fixed(self):
from rsatoolbox.inference import eval_fixed
from rsatoolbox.rdm import RDMs
from rsatoolbox.model import ModelFixed
rdms = RDMs(np.random.rand(11, 10)) # 11 5x5 rdms
m = ModelFixed('test', rdms.get_vectors()[0])
eval_fixed(m, rdms)
def test_eval_bootstrap_rdm(self):
from rsatoolbox.inference import eval_bootstrap_rdm
from rsatoolbox.rdm import RDMs
from rsatoolbox.model import ModelFixed
rdms = RDMs(np.random.rand(11, 10)) # 11 5x5 rdms
m = ModelFixed('test', rdms.get_vectors()[0])
m2 = ModelFixed('test2', rdms.get_vectors()[1])
value = eval_bootstrap_rdm([m, m2], rdms, N=10)
def test_eval_bootstrap_rdm(self):
from rsatoolbox.inference import eval_bootstrap_rdm
from rsatoolbox.rdm import RDMs
from rsatoolbox.model import ModelFixed
rdms = RDMs(np.random.rand(11, 10)) # 11 5x5 rdms
m = ModelFixed('test', rdms.get_vectors()[0])
eval_bootstrap_rdm(m, rdms, N=10)
eval_bootstrap_rdm(m, rdms, N=10, boot_noise_ceil=True)
def test_eval_bootstrap(self):
from rsatoolbox.inference import eval_bootstrap
from rsatoolbox.rdm import RDMs
from rsatoolbox.model import ModelFixed
rdms = RDMs(np.random.rand(11, 10)) # 11 5x5 rdms
m = ModelFixed('test', rdms.get_vectors()[0])
m2 = ModelFixed('test2', rdms.get_vectors()[1])
result = eval_bootstrap([m, m2], rdms, N=10)
assert result.evaluations.shape[1] == 2
assert result.evaluations.shape[0] == 10
def test_fit(self):
from rsatoolbox.rdm import RDMs
rdm = np.random.rand(2, 6)
pattern_descriptors = {'test': ['a', 'b', 'c', 'd']}
rdm_descriptors = {'ind': np.array([1, 2])}
rdm_obj = RDMs(rdm,
dissimilarity_measure='euclid',
pattern_descriptors=pattern_descriptors,
rdm_descriptors=rdm_descriptors)
m = model.ModelWeighted('Test Model', rdm_obj)
train = rdm_obj.subset('ind', 2)
theta = m.fit(train)
def test_bootstrap_testset_rdm(self):
from rsatoolbox.inference import bootstrap_testset_rdm
from rsatoolbox.rdm import RDMs
from rsatoolbox.model import ModelFixed
rdms = RDMs(np.random.rand(11, 10)) # 11 5x5 rdms
m = ModelFixed('test', rdms.get_vectors()[0])
_, _ = bootstrap_testset_rdm(m,
rdms,
method='cosine',
fitter=None,
N=100,
rdm_descriptor=None)
def test_fit(self):
from rsatoolbox.rdm import RDMs
rdm = np.random.rand(5, 15)
pattern_descriptors = {'test': ['a', 'b', 'c', 'd', 'e', 'f']}
rdm_descriptors = {'ind': np.array([1, 2, 3, 1, 2])}
rdm_obj = RDMs(rdm,
dissimilarity_measure='euclid',
pattern_descriptors=pattern_descriptors,
rdm_descriptors=rdm_descriptors)
m = model.ModelInterpolate('Test Model', rdm_obj)
train = rdm_obj.subset('ind', 2)
theta = m.fit(train)
_ = m.predict(theta)
def test_bootstrap_testset_pattern(self):
from rsatoolbox.inference import bootstrap_testset_pattern
from rsatoolbox.rdm import RDMs
from rsatoolbox.model import ModelFixed
rdms = RDMs(np.random.rand(11, 10)) # 11 5x5 rdms
m = ModelFixed('test', rdms.get_vectors()[0])
m2 = ModelFixed('test2', rdms.get_vectors()[1])
evaluations, n_cond = bootstrap_testset_pattern(
[m, m2],
rdms,
method='cosine',
fitter=None,
N=100,
pattern_descriptor=None)
def test_t_scipy(self):
from rsatoolbox.util.inference_util import t_tests
from rsatoolbox.inference import eval_fixed
from rsatoolbox.rdm import RDMs
from rsatoolbox.model import ModelFixed
import scipy.stats
rdms = RDMs(np.random.rand(11, 10)) # 11 5x5 rdms
m = ModelFixed('test', rdms.get_vectors()[0])
m2 = ModelFixed('test', rdms.get_vectors()[2])
value = eval_fixed([m, m2], rdms)
ps = t_tests(value.evaluations, value.diff_var, dof=value.dof)
scipy_t = scipy.stats.ttest_rel(value.evaluations[0, 0],
value.evaluations[0, 1])
self.assertAlmostEqual(scipy_t.pvalue, ps[0, 1])
def test_reorder(self):
from rsatoolbox.rdm import RDMs
rdm = np.array([[0., 1., 2., 3.], [1., 0., 1., 2.], [2., 1., 0., 1.],
[3., 2., 1., 0.]])
conds = ['a', 'b', 'c', 'd']
rdms = RDMs(np.atleast_2d(squareform(rdm)),
pattern_descriptors=dict(conds=conds))
conds_ordered = ['b', 'a', 'c', 'd']
new_order = [conds.index(cond_idx) for cond_idx in conds_ordered]
rdm_reordered = rdm[np.ix_(new_order, new_order)]
rdms.reorder(new_order)
assert_array_equal(np.atleast_2d(squareform(rdm_reordered)),
rdms.dissimilarities)
assert_array_equal(conds_ordered,
rdms.pattern_descriptors.get('conds'))
def test_bootstrap_crossval(self):
from rsatoolbox.inference import bootstrap_crossval
from rsatoolbox.rdm import RDMs
from rsatoolbox.model import ModelFixed
dis = np.random.rand(11, 190) # 11 10x10 rdms
mes = "Euclidean"
des = {'subj': 0}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7, 7, 7, 7])}
pattern_des = {
'type':
np.array([
0, 1, 2, 2, 4, 5, 5, 5, 6, 7, 10, 11, 12, 12, 14, 15, 15, 15,
16, 17
])
}
rdms = RDMs(dissimilarities=dis,
rdm_descriptors=rdm_des,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des)
m = ModelFixed('test', rdms[0])
bootstrap_crossval(m,
rdms,
N=10,
k_rdm=2,
k_pattern=2,
pattern_descriptor='type',
rdm_descriptor='session')
def test_bootstrap_cv_random(self):
from rsatoolbox.inference import bootstrap_cv_random
from rsatoolbox.rdm import RDMs
from rsatoolbox.model import ModelFixed
dis = np.random.rand(11, 190) # 11 10x10 rdms
mes = "Euclidean"
des = {'subj': 0}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7, 7, 7, 7])}
pattern_des = {
'type':
np.array([
0, 1, 2, 2, 4, 5, 5, 5, 6, 7, 10, 11, 12, 12, 14, 15, 15, 15,
16, 17
])
}
rdms = RDMs(dissimilarities=dis,
rdm_descriptors=rdm_des,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des)
m = ModelFixed('test', rdms[0])
res = bootstrap_cv_random(m,
rdms,
N=10,
n_rdm=2,
n_pattern=4,
pattern_descriptor='type',
rdm_descriptor='session')
self.assertEqual(res.evaluations.shape[0], 10)
def test_bootstrap_sample_pattern(self):
from rsatoolbox.inference import bootstrap_sample_pattern
from rsatoolbox.rdm import RDMs
rdms = RDMs(np.random.rand(11, 10)) # 11 5x5 rdms
rdm_sample = bootstrap_sample_pattern(rdms)
assert rdm_sample[0].n_cond == 5
assert rdm_sample[0].n_rdm == 11
def pool_rdm(rdms, method='cosine'):
"""pools multiple RDMs into the one with maximal performance under a given
evaluation metric
rdm_descriptors of the generated rdms are empty
Args:
rdms (rsatoolbox.rdm.RDMs):
RDMs to be pooled
method : String, optional
Which comparison method to optimize for. The default is 'cosine'.
Returns:
rsatoolbox.rdm.RDMs: the pooled RDM, i.e. a RDM with maximal performance
under the chosen method
"""
rdm_vec = rdms.get_vectors()
if method == 'euclid':
rdm_vec = _nan_mean(rdm_vec)
elif method == 'neg_riem_dist':
rdm_vec = _nan_mean(rdm_vec)
elif method == 'cosine':
rdm_vec = rdm_vec / np.sqrt(
np.nanmean(rdm_vec**2, axis=1, keepdims=True))
rdm_vec = _nan_mean(rdm_vec)
elif method == 'corr':
rdm_vec = rdm_vec - np.nanmean(rdm_vec, axis=1, keepdims=True)
rdm_vec = rdm_vec / np.nanstd(rdm_vec, axis=1, keepdims=True)
rdm_vec = _nan_mean(rdm_vec)
rdm_vec = rdm_vec - np.nanmin(rdm_vec)
elif method == 'cosine_cov':
rdm_vec = rdm_vec / np.sqrt(
np.nanmean(rdm_vec**2, axis=1, keepdims=True))
rdm_vec = _nan_mean(rdm_vec)
elif method == 'corr_cov':
rdm_vec = rdm_vec - np.nanmean(rdm_vec, axis=1, keepdims=True)
rdm_vec = rdm_vec / np.nanstd(rdm_vec, axis=1, keepdims=True)
rdm_vec = _nan_mean(rdm_vec)
rdm_vec = rdm_vec - np.nanmin(rdm_vec)
elif method == 'spearman' or method == 'rho-a':
rdm_vec = np.array([_nan_rank_data(v) for v in rdm_vec])
rdm_vec = _nan_mean(rdm_vec)
elif method == 'rho-a':
rdm_vec = np.array([_nan_rank_data(v) for v in rdm_vec])
rdm_vec = _nan_mean(rdm_vec)
elif method == 'kendall' or method == 'tau-b':
Warning('Noise ceiling for tau based on averaged ranks!')
rdm_vec = np.array([_nan_rank_data(v) for v in rdm_vec])
rdm_vec = _nan_mean(rdm_vec)
elif method == 'tau-a':
Warning('Noise ceiling for tau based on averaged ranks!')
rdm_vec = np.array([_nan_rank_data(v) for v in rdm_vec])
rdm_vec = _nan_mean(rdm_vec)
else:
raise ValueError('Unknown RDM comparison method requested!')
return RDMs(rdm_vec,
dissimilarity_measure=rdms.dissimilarity_measure,
descriptors=rdms.descriptors,
rdm_descriptors=None,
pattern_descriptors=rdms.pattern_descriptors)
def test_Icon_from_rdm(self):
from rsatoolbox.vis import Icon
from rsatoolbox.rdm import RDMs
rdm = RDMs(np.random.rand(1, 190))
ic = Icon(rdm)
self.assertEqual(ic.final_image.size[0], 100)
def test_sort_by_alpha(self):
from rsatoolbox.rdm import RDMs
rdm = np.array([[0., 1., 2., 3.], [1., 0., 1., 2.], [2., 1., 0., 1.],
[3., 2., 1., 0.]])
conds = ['b', 'a', 'c', 'd']
rdms = RDMs(np.atleast_2d(squareform(rdm)),
pattern_descriptors=dict(conds=conds))
rdms.sort_by(conds='alpha')
new_order = np.argsort(conds)
rdm_reordered = rdm[np.ix_(new_order, new_order)]
self.assertIsNone(
assert_array_equal(np.atleast_2d(squareform(rdm_reordered)),
rdms.dissimilarities))
self.assertIsNone(
assert_array_equal(sorted(conds),
rdms.pattern_descriptors.get('conds')))
def test_demo_rdm_scatterplot(self):
import os
from scipy.io import loadmat
import numpy as np
from rsatoolbox.rdm import concat, RDMs
from rsatoolbox.vis import rdm_comparison_scatterplot
path = os.path.dirname(os.path.abspath(__file__))
condition_descriptors = {
'type': (["A"] * 23) + (["B"] * 23) + (["C"] * 46)
}
matlab_data = loadmat(
os.path.join(path, '..', 'demos',
'92imageData/92_brainRDMs.mat'))['RDMs']
n_rdms = len(matlab_data[0])
rdms_ = RDMs(
np.array([matlab_data[0][i][0][0] for i in range(n_rdms)]),
pattern_descriptors=condition_descriptors,
rdm_descriptors={'name': np.array([f"RDM{i}" for i in range(4)])})
rdms_a = concat([rdms_[0], rdms_[1]])
rdms_b = concat([rdms_[2], rdms_[3]])
rdm_comparison_scatterplot((rdms_a, rdms_b),
show_marginal_distributions=True,
show_identity_line=True,
show_legend=False,
highlight_selector='type',
highlight_categories=["A", "B", "C"],
colors={
"A": (1, 0, 0),
"B": (0, 1, 0),
"C": (0, 0, 1),
})
def test_creation_rdm(self):
from rsatoolbox.rdm import RDMs
rdm = np.array(np.ones(6))
rdm_obj = RDMs(np.array([rdm]))
m = model.ModelFixed('Test Model', rdm_obj)
m.fit(rdm_obj)
pred = m.predict()
assert np.all(pred == rdm)
pred_obj = m.predict_rdm()
assert isinstance(pred_obj, RDMs)
def test_pool_standard(self):
from rsatoolbox.rdm import RDMs
from rsatoolbox.util.pooling import pool_rdm
dissimilarities = np.random.rand(5, 10)
rdms = RDMs(dissimilarities)
for method in [
'euclid', 'cosine', 'corr', 'cosine_cov', 'corr_cov',
'spearman', 'rho-a', 'tau-b', 'tau-a'
]:
pooled_rdm = pool_rdm(rdms, method=method)
self.assertEqual(pooled_rdm.n_cond, rdms.n_cond)
self.assertEqual(pooled_rdm.n_rdm, 1)
def test_creation_rdm(self):
from rsatoolbox.rdm import RDMs
rdm = np.random.rand(2, 6)
pattern_descriptors = {'test': ['a', 'b', 'c', 'd']}
rdm_obj = RDMs(rdm,
dissimilarity_measure='euclid',
pattern_descriptors=pattern_descriptors)
m = model.ModelWeighted('Test Model', rdm_obj)
pred = m.predict(np.array([1, 0]))
assert np.all(pred == rdm[0])
pred_obj = m.predict_rdm()
assert isinstance(pred_obj, RDMs)
assert pred_obj.n_rdm == 1
assert pred_obj.pattern_descriptors == pattern_descriptors
def test_category_condition_idxs_2_categories_by_ints(self):
from rsatoolbox.util.rdm_utils import category_condition_idxs
from rsatoolbox.rdm.rdms import RDMs
n_rdm, n_cond = 4, 8
dis = np.zeros((n_rdm, n_cond, n_cond))
rdms = RDMs(dissimilarities=dis,
dissimilarity_measure='Euclidean',
descriptors={'subj': range(n_rdm)})
categories = category_condition_idxs(rdms, [1, 2, 1, 2, 1, 2, 1, 2])
self.assertEqual(categories, {
'Category 1': [0, 2, 4, 6],
'Category 2': [1, 3, 5, 7],
})
def test_bootstrap_sample_rdm_descriptors(self):
from rsatoolbox.inference import bootstrap_sample_rdm
from rsatoolbox.rdm import RDMs
dis = np.random.rand(11, 10) # 11 5x5 rdms
mes = "Euclidean"
des = {'subj': 0}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7, 7, 7, 7])}
pattern_des = {'type': np.array([0, 1, 2, 2, 4])}
rdms = RDMs(dissimilarities=dis,
rdm_descriptors=rdm_des,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des)
rdm_sample = bootstrap_sample_rdm(rdms, 'session')
assert rdm_sample[0].n_cond == 5
def test_boot_noise_ceiling_runs_for_method(self, method):
from rsatoolbox.inference import boot_noise_ceiling
from rsatoolbox.rdm import RDMs
dis = np.random.rand(11, 10) # 11 5x5 rdms
mes = "Euclidean"
des = {'subj': 0}
rdm_des = {'session': np.array([1, 1, 2, 2, 4, 5, 6, 7, 7, 7, 7])}
pattern_des = {'type': np.array([0, 1, 2, 2, 4])}
rdms = RDMs(
dissimilarities=dis,
rdm_descriptors=rdm_des,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des
)
_, _ = boot_noise_ceiling(rdms, method=method)
def show_2d(rdms: RDMs,
method: str,
weights: Optional[NDArray] = None,
rdm_descriptor: Optional[str] = None,
pattern_descriptor: Optional[str] = None,
icon_size: float = 0.1) -> Figure:
"""Draw a scatter plot of the RDMs reduced to two dimensions
Args:
rdms (RDMs): The RDMs object to display
method (str): One of 'MDS', 't-SNE', 'Isomap'.
weights: Optional array of weights (vector per RDM)
rdm_descriptor: (Optional[str]): If provided, this will be used as
title for each individual RDM.
pattern_descriptor (Optional[str]): If provided, the chosen pattern
descriptor will be printed adjacent to each point in the plot
icon_size: relative size of icons if the pattern descriptor chosen
is of type Icon
Returns:
Figure: A matplotlib figure in which the plot is drawn
"""
if method == 'MDS':
MDS = sklearn.manifold.MDS if weights is None else Weighted_MDS
embedding = MDS(n_components=2,
random_state=seed,
dissimilarity='precomputed')
elif method == 't-SNE':
embedding = sklearn.manifold.TSNE(n_components=2)
elif method == 'Isomap':
embedding = sklearn.manifold.Isomap(n_components=2)
else:
raise NotImplementedError('Unknown method: ' + str(method))
rdm_mats = rdms.get_matrices()
coords = numpy.full((rdms.n_rdm, rdms.n_cond, 2), numpy.nan)
for r in range(rdms.n_rdm):
fitKwargs = dict()
if weights is not None:
fitKwargs['weight'] = weight_to_matrices(weights)[r, :, :]
coords[r, :, :] = embedding.fit_transform(rdm_mats[r, :, :],
**fitKwargs)
return show_scatter(rdms,
coords,
rdm_descriptor=rdm_descriptor,
pattern_descriptor=pattern_descriptor,
icon_size=icon_size)
def test_pool_nan(self):
from rsatoolbox.rdm import RDMs
from rsatoolbox.util.pooling import pool_rdm
dissimilarities = np.random.rand(5, 10)
dissimilarities[:, 3] = np.nan
rdms = RDMs(dissimilarities)
for method in [
'euclid', 'cosine', 'corr', 'cosine_cov', 'corr_cov',
'spearman', 'rho-a', 'tau-b', 'tau-a'
]:
pooled_rdm = pool_rdm(rdms, method=method)
self.assertEqual(pooled_rdm.n_cond, rdms.n_cond)
self.assertEqual(pooled_rdm.n_rdm, 1)
self.assertTrue(np.isnan(pooled_rdm.dissimilarities[0, 3]),
'nan got removed while pooling for %s' % method)
self.assertFalse(np.isnan(pooled_rdm.dissimilarities[0, 4]),
'too many nans while pooling for %s' % method)
def test_cv_noise_ceiling(self):
from rsatoolbox.inference import cv_noise_ceiling
from rsatoolbox.inference import sets_k_fold_rdm
from rsatoolbox.rdm import RDMs
dis = np.random.rand(11, 10) # 11 5x5 rdms
mes = "Euclidean"
des = {'subj': 0}
rdm_des = {'session': np.array([1, 1, 2, 2, 4, 5, 6, 7, 7, 7, 7])}
pattern_des = {'type': np.array([0, 1, 2, 2, 4])}
rdms = RDMs(
dissimilarities=dis,
rdm_descriptors=rdm_des,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des
)
_, test_set, ceil_set = sets_k_fold_rdm(rdms, k_rdm=3, random=False)
_, _ = cv_noise_ceiling(rdms, ceil_set, test_set, method='cosine')
def test_category_condition_idxs_2_categories_by_name(self):
from rsatoolbox.util.rdm_utils import category_condition_idxs
from rsatoolbox.rdm.rdms import RDMs
n_rdm, n_cond = 4, 8
dis = np.zeros((n_rdm, n_cond, n_cond))
rdms = RDMs(
dissimilarities=dis,
# 2 categories, P and Q
pattern_descriptors={'type': list('PPPPQQQQ')},
dissimilarity_measure='Euclidean',
descriptors={'subj': range(n_rdm)})
categories = category_condition_idxs(rdms, 'type')
self.assertEqual(categories, {
'P': [0, 1, 2, 3],
'Q': [4, 5, 6, 7],
})
def setUp(self):
from rsatoolbox.rdm import RDMs
from rsatoolbox.model import ModelFixed
dis = np.random.rand(11, 190) # 11 20x20 rdms
mes = "Euclidean"
des = {'subj': 0}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7, 7, 7, 7])}
pattern_des = {
'type':
np.array([
0, 1, 2, 2, 4, 5, 5, 5, 6, 7, 10, 11, 12, 12, 14, 15, 15, 15,
16, 17
])
}
rdms = RDMs(dissimilarities=dis,
rdm_descriptors=rdm_des,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des)
m = ModelFixed('test', rdms[0])
self.rdms = rdms
self.m = m
def test_save_load_result(self):
from rsatoolbox.rdm import RDMs
from rsatoolbox.inference import Result
from rsatoolbox.inference import load_results
from rsatoolbox.model import ModelFixed
import io
rdm = RDMs(np.random.rand(10),
pattern_descriptors={
'test': ['test1', 'test1', 'test1', 'test3', 'test']
})
m1 = ModelFixed('test1', rdm)
m2 = ModelFixed('test2', np.random.rand(10))
models = [m1, m2]
evaluations = np.random.rand(100, 2)
method = 'test_method'
cv_method = 'test_cv_method'
noise_ceiling = np.array([0.5, 0.2])
res = Result(models, evaluations, method, cv_method, noise_ceiling)
f = io.BytesIO() # Essentially a Mock file
res.save(f, file_type='hdf5')
res_loaded = load_results(f, file_type='hdf5')
assert res_loaded.method == method
assert res_loaded.cv_method == cv_method
assert np.all(res_loaded.evaluations == evaluations)
def get_searchlight_RDMs(data_2d, centers, neighbors, events,
method='correlation', verbose=True):
"""Iterates over all the searchlight centers and calculates the RDM
Args:
data_2d (2D numpy array): brain data,
shape n_observations x n_channels (i.e. voxels/vertices)
centers (1D numpy array): center indices for all searchlights as provided
by rsatoolbox.util.searchlight.get_volume_searchlight
neighbors (list): list of lists with neighbor voxel indices for all searchlights
as provided by rsatoolbox.util.searchlight.get_volume_searchlight
events (1D numpy array): 1D array of length n_observations
method (str, optional): distance metric,
see rsatoolbox.rdm.calc for options. Defaults to 'correlation'.
verbose (bool, optional): Defaults to True.
Returns:
RDM [rsatoolbox.rdm.RDMs]: RDMs object with the RDM for each searchlight
the RDM.rdm_descriptors['voxel_index']
describes the center voxel index each RDM is associated with
"""
data_2d, centers = np.array(data_2d), np.array(centers)
n_centers = centers.shape[0]
# For memory reasons, we chunk the data if we have more than 1000 RDMs
if n_centers > 1000:
# we can't run all centers at once, that will take too much memory
# so lets to some chunking
chunked_center = np.split(np.arange(n_centers),
np.linspace(0, n_centers,
101, dtype=int)[1:-1])
# loop over chunks
n_conds = len(np.unique(events))
RDM = np.zeros((n_centers, n_conds * (n_conds - 1) // 2))
for chunks in tqdm(chunked_center, desc='Calculating RDMs...'):
center_data = []
for c in chunks:
# grab this center and neighbors
center = centers[c]
center_neighbors = neighbors[c]
# create a database object with this data
ds = Dataset(data_2d[:, center_neighbors],
descriptors={'center': center},
obs_descriptors={'events': events},
channel_descriptors={'voxels': center_neighbors})
center_data.append(ds)
RDM_corr = calc_rdm(center_data, method=method,
descriptor='events')
RDM[chunks, :] = RDM_corr.dissimilarities
else:
center_data = []
for c in range(n_centers):
# grab this center and neighbors
center = centers[c]
nb = neighbors[c]
# create a database object with this data
ds = Dataset(data_2d[:, nb],
descriptors={'center': c},
obs_descriptors={'events': events},
channel_descriptors={'voxels': nb})
center_data.append(ds)
# calculate RDMs for each database object
RDM = calc_rdm(center_data, method=method,
descriptor='events').dissimilarities
SL_rdms = RDMs(RDM,
rdm_descriptors={'voxel_index': centers},
dissimilarity_measure=method)
return SL_rdms
