def _dummy_rdm():
import PIL
import matplotlib.markers
from collections import defaultdict
markers = list(matplotlib.markers.MarkerStyle().markers.keys())
images = np.meshgrid(np.linspace(0.5, 1.0, 50), np.linspace(0.5, 1.0, 30),
np.linspace(0.5, 1.0, 3))
images = [
this_image * this_ind / 4.0 for this_ind in range(4)
for this_image in images
]
images = [
PIL.Image.fromarray(255 * this_image, "RGB") for this_image in images
]
names = [
this_class + this_ex for this_class in ("a", "b", "c", "d")
for this_ex in ("1", "2", "3")
]
n_con = len(names)
icons = defaultdict(list)
for this_marker, this_image, this_name in zip(markers, images, names):
icons["image"].append(rsv.Icon(image=this_image))
icons["marker"].append(rsv.Icon(marker=this_marker, color=[0, 0, 0]))
icons["string"].append(rsv.Icon(string=this_name))
icons["text"].append(this_name)
ROIs = ["X", "Y", "Z"]
return rsr.concat([
rsr.RDMs(
dissimilarities=np.random.rand(1, int((n_con - 1) * n_con / 2)),
dissimilarity_measure="1-rho",
rdm_descriptors=dict(ROI=this_roi),
pattern_descriptors=icons,
) for this_roi in ROIs
])
def test_k_fold_rdm(self):
from rsatoolbox.inference import sets_k_fold_rdm
import rsatoolbox.rdm as rsr
dis = np.zeros((8, 10))
mes = "Euclidean"
des = {'subj': 0}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7])}
pattern_des = {'category': np.array([0, 1, 2, 2, 3])}
rdms = rsr.RDMs(dissimilarities=dis,
rdm_descriptors=rdm_des,
dissimilarity_measure=mes,
pattern_descriptors=pattern_des,
descriptors=des)
train_set, test_set, ceil_set = sets_k_fold_rdm(
rdms, k_rdm=3, rdm_descriptor='session', random=False)
assert len(test_set) == 3
assert len(train_set) == 3
assert len(test_set[0]) == 2
assert len(train_set[0]) == 2
assert test_set[0][0].n_cond == 5
assert test_set[1][0].n_cond == 5
assert test_set[0][0].n_rdm == 3
assert test_set[1][0].n_rdm == 3
assert test_set[2][0].n_rdm == 2
train_set, test_set, ceil_set = sets_k_fold_rdm(rdms,
k_rdm=3,
random=False)
def test_rdm2d_init(self):
dis = np.zeros((8, 10))
mes = "Euclidean"
des = {'session': 0, 'subj': 0}
rdms = rsr.RDMs(dissimilarities=dis,
dissimilarity_measure=mes,
descriptors=des)
self.assertEqual(rdms.n_rdm, 8)
self.assertEqual(rdms.n_cond, 5)
def test_rdm_idx_len_is_1(self):
n_rdm, n_cond = 7, 10
dis = np.zeros((n_rdm, n_cond, n_cond))
rdms = rsr.RDMs(
dissimilarities=dis,
pattern_descriptors={'type': np.array(list(range(n_cond)))},
dissimilarity_measure='Euclidean',
descriptors={'subj': range(n_rdm)})
self.assertEqual(len(rdms[0]), 1)
def test_rdm2d_get_vectors(self):
dis = np.zeros((8, 10))
mes = "Euclidean"
des = {'session': 0, 'subj': 0}
rdms = rsr.RDMs(dissimilarities=dis,
dissimilarity_measure=mes,
descriptors=des)
v_rdms = rdms.get_vectors()
self.assertEqual(v_rdms.shape[0], 8)
self.assertEqual(v_rdms.shape[1], 10)
def test_rdm3d_get_matrices(self):
dis = np.zeros((8, 5, 5))
mes = "Euclidean"
des = {'session': 0, 'subj': 0}
rdms = rsr.RDMs(dissimilarities=dis,
dissimilarity_measure=mes,
descriptors=des)
m_rdms = rdms.get_matrices()
self.assertEqual(m_rdms.shape[0], 8)
self.assertEqual(m_rdms.shape[1], 5)
self.assertEqual(m_rdms.shape[2], 5)
def test_vis_mds_output_shape_corresponds_to_inputs(self, show_scatter):
from rsatoolbox.vis.scatter_plot import show_MDS
dis = np.random.rand(8, 10)
mes = "Euclidean"
des = {"session": 0, "subj": 0}
rdms = rsr.RDMs(dissimilarities=dis,
dissimilarity_measure=mes,
descriptors=des)
show_MDS(rdms)
coords = show_scatter.call_args[0][1]
self.assertEqual(coords.shape, (8, 5, 2))
def test_concat(self):
from rsatoolbox.rdm import concat
dis = np.zeros((8, 10))
dis2 = np.random.rand(8, 10)
mes = "Euclidean"
des = {'subj': 0}
pattern_des = {'type': np.array([0, 1, 2, 2, 4])}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7])}
rdms1 = rsr.RDMs(dissimilarities=dis,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des,
rdm_descriptors=rdm_des)
rdms2 = rsr.RDMs(dissimilarities=dis2,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des,
rdm_descriptors=rdm_des)
rdms = concat((rdms1, rdms2))
self.assertEqual(rdms.n_rdm, 16)
assert len(rdms.rdm_descriptors['session']) == 16
def test_rdm_subset_len(self):
subset_idxs = [0, 1, 2]
dis = np.zeros((8, 10))
mes = "Euclidean"
des = {'subj': 0}
rdm_des = {'session': np.array([0, 1, 2, 3, 4, 5, 6, 7])}
rdms = rsr.RDMs(dissimilarities=dis,
rdm_descriptors=rdm_des,
dissimilarity_measure=mes,
descriptors=des)
rdms_subset = rdms.subset('session', np.array(subset_idxs))
self.assertEqual(len(rdms_subset), len(subset_idxs))
def test_rdm_append(self):
dis = np.zeros((8, 10))
mes = "Euclidean"
des = {'subj': 0}
pattern_des = {'type': np.array([0, 1, 2, 2, 4])}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7])}
rdms = rsr.RDMs(dissimilarities=dis,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des,
rdm_descriptors=rdm_des)
rdms.append(rdms)
self.assertEqual(rdms.n_rdm, 16)
def test_rdm_subset_pattern(self):
dis = np.zeros((8, 10))
mes = "Euclidean"
des = {'subj': 0}
pattern_des = {'type': np.array([0, 1, 2, 2, 4])}
rdms = rsr.RDMs(dissimilarities=dis,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des)
rdms_subset = rdms.subset_pattern('type', np.array([0, 1, 2]))
self.assertEqual(rdms_subset.n_rdm, 8)
self.assertEqual(rdms_subset.n_cond, 4)
assert_array_equal(rdms_subset.pattern_descriptors['type'],
[0, 1, 2, 2])
def test_rdm_subset(self):
dis = np.zeros((8, 10))
mes = "Euclidean"
des = {'subj': 0}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7])}
rdms = rsr.RDMs(dissimilarities=dis,
rdm_descriptors=rdm_des,
dissimilarity_measure=mes,
descriptors=des)
rdms_subset = rdms.subset('session', np.array([0, 1, 2]))
self.assertEqual(rdms_subset.n_rdm, 4)
self.assertEqual(rdms_subset.n_cond, 5)
assert_array_equal(rdms_subset.rdm_descriptors['session'],
[0, 1, 2, 2])
def test_concat_varargs_multiple_rdms(self):
from rsatoolbox.rdm import concat
dis = np.zeros((8, 10))
dis2 = np.random.rand(8, 10)
mes = "Euclidean"
des = {'subj': 0}
pattern_des = {'type': np.array([0, 1, 2, 2, 4])}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7])}
rdms1 = rsr.RDMs(dissimilarities=dis,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des,
rdm_descriptors=rdm_des)
rdms2 = rsr.RDMs(dissimilarities=dis2,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des,
rdm_descriptors=rdm_des)
rdm_c1 = concat((rdms1, rdms2))
rdm_c2 = concat(rdms1, rdms2)
self.assertEqual(rdm_c1.n_rdm, 16)
self.assertEqual(rdm_c2.n_rdm, 16)
assert_array_equal(rdm_c1.dissimilarities, rdm_c2.dissimilarities)
def test_concat_varargs_one_rdm(self):
from rsatoolbox.rdm import concat
dis = np.zeros((8, 10))
mes = "Euclidean"
des = {'subj': 0}
pattern_des = {'type': np.array([0, 1, 2, 2, 4])}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7])}
rdms = rsr.RDMs(dissimilarities=dis,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des,
rdm_descriptors=rdm_des)
rdm_c1 = concat(rdms)
self.assertEqual(rdm_c1.n_rdm, 8)
assert_array_equal(rdm_c1.dissimilarities, rdms.dissimilarities)
def test_sqrt_transform(self):
from rsatoolbox.rdm import sqrt_transform
dis = np.zeros((8, 10))
mes = "Euclidean"
des = {'subj': 0}
pattern_des = {'type': np.array([0, 1, 2, 2, 4])}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7])}
rdms = rsr.RDMs(dissimilarities=dis,
rdm_descriptors=rdm_des,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des)
sqrt_rdm = sqrt_transform(rdms)
self.assertEqual(sqrt_rdm.n_rdm, rdms.n_rdm)
self.assertEqual(sqrt_rdm.n_cond, rdms.n_cond)
def test_rdm_idx(self):
dis = np.zeros((8, 10))
mes = "Euclidean"
des = {'subj': 0}
pattern_des = {'type': np.array([0, 1, 2, 2, 4])}
rdms = rsr.RDMs(dissimilarities=dis,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des)
rdms_sample = rdms[2]
self.assertEqual(rdms_sample.n_rdm, 1)
assert_array_equal(rdms_sample.dissimilarities[0], dis[2])
rdms_sample = rdms[3, 4, 5]
self.assertEqual(rdms_sample.n_rdm, 3)
assert_array_equal(rdms_sample.dissimilarities[0], dis[3])
def test_calc_correlation(self, _parse_input):
from rsatoolbox.rdm import calc_rdm
data = Mock()
data.descriptors = {'session': 0, 'subj': 0}
data.measurements = np.random.rand(6, 5)
desc = [0, 1, 2, 3, 4, 5]
_parse_input.return_value = (data.measurements, desc, 'conds')
rdm_expected = 1 - np.corrcoef(data.measurements)
rdme = rsr.RDMs(dissimilarities=np.array([rdm_expected]),
dissimilarity_measure='correlation',
descriptors=data.descriptors)
rdm = calc_rdm(data, descriptor='conds', method='correlation')
self.assertIsNone(
assert_array_almost_equal(rdme.dissimilarities.flatten(),
rdm.dissimilarities.flatten()))
def test_rdm_iter(self):
dis = np.zeros((8, 10))
mes = "Euclidean"
des = {'subj': 0}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7])}
rdms = rsr.RDMs(dissimilarities=dis,
rdm_descriptors=rdm_des,
dissimilarity_measure=mes,
descriptors=des)
i = 0
for rdm in rdms:
self.assertIsInstance(rdm, rsr.RDMs)
self.assertEqual(len(rdm), 1)
assert_array_equal(rdm.dissimilarities, rdms[i].dissimilarities)
i += 1
self.assertEqual(i, rdms.n_rdm)
def test_vis_weighted_mds_output_behaves_like_mds(self, show_scatter):
from rsatoolbox.vis.scatter_plot import show_MDS
dis = np.random.rand(8, 10)
wes = np.ones((8, 10))
mes = "Euclidean"
des = {"session": 0, "subj": 0}
rdms = rsr.RDMs(dissimilarities=dis,
dissimilarity_measure=mes,
descriptors=des)
show_MDS(rdms)
mds_coords = show_scatter.call_args[0][1]
show_MDS(rdms, weights=wes)
wmds_coords = show_scatter.call_args[0][1]
np.testing.assert_allclose(pdist(mds_coords[0]),
pdist(wmds_coords[0]),
atol=3e-1)
def test_positive_transform(self):
from rsatoolbox.rdm import positive_transform
dis = np.random.rand(8, 10) - 0.5
mes = "Euclidean"
des = {'subj': 0}
pattern_des = {'type': np.array([0, 1, 2, 2, 4])}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7])}
rdms = rsr.RDMs(dissimilarities=dis,
rdm_descriptors=rdm_des,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des)
pos_rdm = positive_transform(rdms)
self.assertEqual(pos_rdm.n_rdm, rdms.n_rdm)
self.assertEqual(pos_rdm.n_cond, rdms.n_cond)
assert np.all(pos_rdm.dissimilarities >= 0)
def test_leave_one_out_rdm(self):
from rsatoolbox.inference import sets_leave_one_out_rdm
import rsatoolbox.rdm as rsr
dis = np.zeros((8, 10))
mes = "Euclidean"
des = {'subj': 0}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7])}
pattern_des = {'category': np.array([0, 1, 2, 2, 3])}
rdms = rsr.RDMs(dissimilarities=dis,
rdm_descriptors=rdm_des,
dissimilarity_measure=mes,
pattern_descriptors=pattern_des,
descriptors=des)
train_set, test_set, ceil_set = sets_leave_one_out_rdm(rdms)
for i_test in test_set:
assert i_test[0].n_rdm == 1
def test_transform(self):
from rsatoolbox.rdm import transform
dis = np.random.rand(8, 10)
mes = "Euclidean"
des = {'subj': 0}
pattern_des = {'type': np.array([0, 1, 2, 2, 4])}
rdm_des = {'session': np.array([0, 1, 2, 2, 4, 5, 6, 7])}
rdms = rsr.RDMs(dissimilarities=dis,
rdm_descriptors=rdm_des,
pattern_descriptors=pattern_des,
dissimilarity_measure=mes,
descriptors=des)
def square(x):
return x**2
transformed_rdm = transform(rdms, square)
self.assertEqual(transformed_rdm.n_rdm, rdms.n_rdm)
self.assertEqual(transformed_rdm.n_cond, rdms.n_cond)
def test_example_dissimilarities(self):
# relevant imports
import numpy as np
from scipy import io
import rsatoolbox
import rsatoolbox.data as rsd # abbreviation to deal with dataset
import rsatoolbox.rdm as rsr
# create a dataset object
measurements = {'simTruePatterns': np.random.randn(92, 100)}
measurements = measurements['simTruePatterns']
nCond = measurements.shape[0]
nVox = measurements.shape[1]
# now create a dataset object
des = {'session': 1, 'subj': 1}
obs_des = {
'conds': np.array(['cond_' + str(x) for x in np.arange(nCond)])
}
chn_des = {
'voxels': np.array(['voxel_' + str(x) for x in np.arange(nVox)])
}
data = rsd.Dataset(measurements=measurements,
descriptors=des,
obs_descriptors=obs_des,
channel_descriptors=chn_des)
# calculate an RDM
RDM_euc = rsr.calc_rdm(data)
RDM_corr = rsr.calc_rdm(data, method='correlation', descriptor='conds')
# create an RDM object
rdm_des = {'RDM': np.array(['RDM_1'])}
RDM_euc2 = rsr.RDMs(
RDM_euc.dissimilarities,
dissimilarity_measure=RDM_euc.dissimilarity_measure,
descriptors=RDM_euc.descriptors,
rdm_descriptors=rdm_des,
pattern_descriptors=obs_des)
print(RDM_euc.dissimilarities) # here a vector
dist_matrix = RDM_euc.get_matrices()
print(dist_matrix)
def test_calc_correlation(self, _parse_input):
from rsatoolbox.rdm import calc_rdm_unbalanced
data = rsa.data.Dataset(
np.random.rand(6, 5),
descriptors={'session': 0, 'subj': 0},
obs_descriptors={'conds': [0, 1, 2, 3, 4, 5]}
)
rdm_expected = 1 - np.corrcoef(data.measurements)
rdme = rsr.RDMs(
dissimilarities=np.array([rdm_expected]),
dissimilarity_measure='correlation',
descriptors=data.descriptors)
rdm = calc_rdm_unbalanced(
data,
descriptor='conds',
method='correlation'
)
self.assertIsNone(
assert_array_almost_equal(
rdme.dissimilarities.flatten(),
rdm.dissimilarities.flatten()
)
)
