def test_searchlight_errors_per_trial():
# To make sure that searchlight can return error/accuracy per trial
from mvpa2.clfs.gnb import GNB
from mvpa2.generators.partition import OddEvenPartitioner
from mvpa2.measures.base import CrossValidation
from mvpa2.measures.searchlight import sphere_searchlight
from mvpa2.measures.gnbsearchlight import sphere_gnbsearchlight
from mvpa2.testing.datasets import datasets
from mvpa2.misc.errorfx import prediction_target_matches
dataset = datasets['3dsmall'].copy()
# randomly permute samples so we break any random correspondence
# to strengthen tests below
sample_idx = np.arange(len(dataset))
dataset = dataset[np.random.permutation(sample_idx)]
dataset.sa.targets = ['L%d' % l for l in dataset.sa.targets]
dataset.fa['voxel_indices'] = dataset.fa.myspace
sample_clf = GNB() # fast and deterministic
part = OddEvenPartitioner()
# only do partial to save time
cv = CrossValidation(sample_clf, part, errorfx=None) #prediction_target_matches)
# Just to compare error
cv_error = CrossValidation(sample_clf, part)
# Large searchlight radius so we get entire ROI, 2 centers just to make sure
# that all stacking works correctly
sl = sphere_searchlight(cv, radius=10, center_ids=[0, 1])
results = sl(dataset)
sl_gnb = sphere_gnbsearchlight(sample_clf, part, radius=10, errorfx=None,
center_ids=[0, 1])
results_gnbsl = sl_gnb(dataset)
# inspect both results
# verify that partitioning was done correctly
partitions = list(part.generate(dataset))
for res in (results, results_gnbsl):
assert('targets' in res.sa.keys()) # should carry targets
assert('cvfolds' in res.sa.keys()) # should carry cvfolds
for ipart in xrange(len(partitions)):
assert_array_equal(dataset[partitions[ipart].sa.partitions == 2].targets,
res.sa.targets[res.sa.cvfolds == ipart])
assert_datasets_equal(results, results_gnbsl)
# one "accuracy" per each trial
assert_equal(results.shape, (len(dataset), 2))
# with accuracies the same in both searchlights since the same
# features were to be selected in both cases due too large radii
errors_dataset = cv(dataset)
assert_array_equal(errors_dataset.samples[:, 0], results.samples[:, 0])
assert_array_equal(errors_dataset.samples[:, 0], results.samples[:, 1])
# and error matching (up to precision) the one if we run with default error function
assert_array_almost_equal(np.mean(results.targets[:, None] != results.samples, axis=0)[0],
np.mean(cv_error(dataset)))
def test_gifti_dataset_h5py(fn, include_nodes):
if not externals.exists('h5py'):
raise SkipTest
from mvpa2.base.hdf5 import h5save, h5load
ds = _get_test_dataset(include_nodes)
h5save(fn, ds)
ds2 = h5load(fn)
assert_datasets_equal(ds, ds2)
def test_gifti_dataset_h5py(fn, include_nodes):
if not externals.exists('h5py'):
raise SkipTest
from mvpa2.base.hdf5 import h5save, h5load
ds = _get_test_dataset(include_nodes)
h5save(fn, ds)
ds2 = h5load(fn)
assert_datasets_equal(ds, ds2)
def test_generate_testing_fmri_dataset(tempfile):
skip_if_no_external('nibabel')
skip_if_no_external('h5py')
from mvpa2.base.hdf5 import h5load
from mvpa2.testing.regress import generate_testing_fmri_dataset
ds, filename = generate_testing_fmri_dataset(tempfile)
assert_equal(tempfile, filename)
assert_true(exists(tempfile))
ds_reloaded = h5load(tempfile)
assert_datasets_equal(ds, ds_reloaded, ignore_a={'wtf'})
def test_generate_testing_fmri_dataset(tempfile):
skip_if_no_external('nibabel')
skip_if_no_external('h5py')
from mvpa2.base.hdf5 import h5load
from mvpa2.testing.regress import generate_testing_fmri_dataset
ds, filename = generate_testing_fmri_dataset(tempfile)
try:
import IPython
assert_true(externals.exists('ipython'))
except:
assert_false(externals.exists('ipython'))
assert ('ipython' not in ds.a.versions)
assert_equal(tempfile, filename)
assert_true(exists(tempfile))
ds_reloaded = h5load(tempfile)
assert_datasets_equal(ds, ds_reloaded, ignore_a={'wtf'})
def test_generate_testing_fmri_dataset(tempfile):
skip_if_no_external('nibabel')
skip_if_no_external('h5py')
from mvpa2.base.hdf5 import h5load
from mvpa2.testing.regress import generate_testing_fmri_dataset
ds, filename = generate_testing_fmri_dataset(tempfile)
try:
import IPython
assert_true(externals.exists('ipython'))
except:
assert_false(externals.exists('ipython'))
assert('ipython' not in ds.a.versions)
assert_equal(tempfile, filename)
assert_true(exists(tempfile))
ds_reloaded = h5load(tempfile)
assert_datasets_equal(ds, ds_reloaded, ignore_a={'wtf'})
def test_balancer():
ds = give_data()
ds.sa['ids'] = np.arange(len(ds)) # some sa to ease tracking of samples
# only mark the selection in an attribute
bal = Balancer()
res = bal(ds)
# we get a new dataset, with shared samples
assert_false(ds is res)
assert_true(ds.samples is res.samples.base)
# should kick out 2 samples in each chunk of 10
assert_almost_equal(np.mean(res.sa.balanced_set), 0.8)
# same as above, but actually apply the selection
bal = Balancer(apply_selection=True, count=5)
# just run it once
res = bal(ds)
# we get a new dataset, with shared samples
assert_false(ds is res)
# should kick out 2 samples in each chunk of 10
assert_equal(len(res), int(0.8 * len(ds)))
# now use it as a generator
dses = list(bal.generate(ds))
assert_equal(len(dses), 5)
# if we rerun again, it would be a different selection
res2 = bal(ds)
assert_true(np.any(res.sa.ids != bal(ds).sa.ids))
# but if we create a balancer providing seed rng int,
# should be identical results
bal = Balancer(apply_selection=True, count=5, rng=1)
assert_false(np.any(bal(ds).sa.ids != bal(ds).sa.ids))
# But results should differ if we use .generate to produce those multiple
# balanced datasets
b = Balancer(apply_selection=True, count=3, rng=1)
balanced = list(b.generate(ds))
assert_false(all(balanced[0].sa.ids == balanced[1].sa.ids))
assert_false(all(balanced[0].sa.ids == balanced[2].sa.ids))
assert_false(all(balanced[1].sa.ids == balanced[2].sa.ids))
# And should be exactly the same
for ds_a, ds_b in zip(balanced, b.generate(ds)):
assert_datasets_equal(ds_a, ds_b)
# Contribution by Chris Markiewicz
# And interleaving __call__ and generator fetches
gen1 = b.generate(ds)
gen2 = b.generate(ds)
seq1, seq2, seq3 = [], [], []
for i in xrange(3):
seq1.append(gen1.next())
seq2.append(gen2.next())
seq3.append(b(ds))
# Produces expected sequences
for i in xrange(3):
assert_datasets_equal(balanced[i], seq1[i])
assert_datasets_equal(balanced[i], seq2[i])
# And all __call__s return the same result
ds_a = seq3[0]
for ds_b in seq3[1:]:
assert_array_equal(ds_a.sa.ids, ds_b.sa.ids)
# with limit
bal = Balancer(limit={'chunks': 3}, apply_selection=True)
res = bal(ds)
assert_equal(res.sa['chunks'].unique, (3, ))
assert_equal(get_nelements_per_value(res.sa.targets).values(), [2] * 4)
# same but include all offlimit samples
bal = Balancer(limit={'chunks': 3},
include_offlimit=True,
apply_selection=True)
res = bal(ds)
assert_array_equal(res.sa['chunks'].unique, range(10))
# chunk three still balanced, but the rest is not, i.e. all samples included
assert_equal(
get_nelements_per_value(res[res.sa.chunks == 3].sa.targets).values(),
[2] * 4)
assert_equal(
get_nelements_per_value(res.sa.chunks).values(),
[10, 10, 10, 8, 10, 10, 10, 10, 10, 10])
# fixed amount
bal = Balancer(amount=1, limit={'chunks': 3}, apply_selection=True)
res = bal(ds)
assert_equal(get_nelements_per_value(res.sa.targets).values(), [1] * 4)
# fraction
bal = Balancer(amount=0.499, limit=None, apply_selection=True)
res = bal(ds)
assert_array_equal(
np.round(
np.array(get_nelements_per_value(ds.sa.targets).values()) * 0.5),
np.array(get_nelements_per_value(res.sa.targets).values()))
# check on feature attribute
ds.fa['one'] = np.tile([1, 2], 5)
ds.fa['chk'] = np.repeat([1, 2], 5)
bal = Balancer(attr='one', amount=2, limit='chk', apply_selection=True)
res = bal(ds)
assert_equal(get_nelements_per_value(res.fa.one).values(), [4] * 2)
def test_attrpermute():
# Was about to use borrowkwargs but didn't work out . Test doesn't hurt
doc = AttributePermutator.__init__.__doc__
assert_in('limit : ', doc)
assert_not_in('collection : ', doc)
ds = give_data()
ds.sa['ids'] = range(len(ds))
pristine_data = ds.samples.copy()
permutation = AttributePermutator(['targets', 'ids'], assure=True)
pds = permutation(ds)
# should not touch the data
assert_array_equal(pristine_data, pds.samples)
# even keep the very same array
assert_true(pds.samples.base is ds.samples)
# there is no way that it can be the same attribute
assert_false(np.all(pds.sa.ids == ds.sa.ids))
# ids should reflect permutation setup
assert_array_equal(pds.sa.targets, ds.sa.targets[pds.sa.ids])
# other attribute should remain intact
assert_array_equal(pds.sa.chunks, ds.sa.chunks)
# now chunk-wise permutation
permutation = AttributePermutator('ids', limit='chunks')
pds = permutation(ds)
# first ten should remain first ten
assert_false(np.any(pds.sa.ids[:10] > 9))
# verify that implausible assure=True would not work
permutation = AttributePermutator('targets', limit='ids', assure=True)
assert_raises(RuntimeError, permutation, ds)
# same thing, but only permute single chunk
permutation = AttributePermutator('ids', limit={'chunks': 3})
pds = permutation(ds)
# one chunk should change
assert_false(np.any(pds.sa.ids[30:40] > 39))
assert_false(np.any(pds.sa.ids[30:40] < 30))
# the rest not
assert_array_equal(pds.sa.ids[:30], range(30))
# or a list of chunks
permutation = AttributePermutator('ids', limit={'chunks': [3, 4]})
pds = permutation(ds)
# two chunks should change
assert_false(np.any(pds.sa.ids[30:50] > 49))
assert_false(np.any(pds.sa.ids[30:50] < 30))
# the rest not
assert_array_equal(pds.sa.ids[:30], range(30))
# and now try generating more permutations
nruns = 2
def assert_all_different_permutations(pds):
assert_equal(len(pds), nruns)
for i, p in enumerate(pds):
assert_false(np.all(p.sa.ids == ds.sa.ids))
for p_ in pds[i + 1:]:
assert_false(np.all(p.sa.ids == p_.sa.ids))
permutation = AttributePermutator(['targets', 'ids'],
assure=True,
count=nruns)
pds = list(permutation.generate(ds))
assert_all_different_permutations(pds)
# if we provide seeding, and generate, it should also return different datasets
permutation = AttributePermutator(['targets', 'ids'], count=nruns, rng=1)
pds1 = list(permutation.generate(ds))
assert_all_different_permutations(pds)
# but if we regenerate -- should all be the same to before
pds2 = list(permutation.generate(ds))
assert_equal(len(pds1), len(pds2))
for p1, p2 in zip(pds1, pds2):
assert_datasets_equal(p1, p2)
# permute feature attrs
ds.fa['ids'] = range(ds.shape[1])
permutation = AttributePermutator('fa.ids', assure=True)
pds = permutation(ds)
assert_false(np.all(pds.fa.ids == ds.fa.ids))
# now chunk-wise uattrs strategy (reassignment)
permutation = AttributePermutator('targets',
limit='chunks',
strategy='uattrs',
assure=True)
pds = permutation(ds)
# Due to assure above -- we should have changed things
assert_not_equal(zip(ds.targets), zip(pds.targets))
# in each chunk we should have unique remappings
for c in ds.UC:
chunk_idx = ds.C == c
otargets, ptargets = ds.targets[chunk_idx], pds.sa.targets[chunk_idx]
# we still have the same targets
assert_equal(set(ptargets), set(otargets))
# we have only 1-to-1 mappings
assert_true(len(set(zip(otargets, ptargets))), len(set(otargets)))
ds.sa['odds'] = ds.sa.ids % 2
# test combinations
permutation = AttributePermutator(['targets', 'odds'],
limit='chunks',
strategy='uattrs',
assure=True)
pds = permutation(ds)
# Due to assure above -- we should have changed things
assert_not_equal(zip(ds.targets, ds.sa.odds), zip(pds.targets,
pds.sa.odds))
# In each chunk we should have unique remappings
for c in ds.UC:
chunk_idx = ds.C == c
otargets, ptargets = ds.targets[chunk_idx], pds.sa.targets[chunk_idx]
oodds, podds = ds.sa.odds[chunk_idx], pds.sa.odds[chunk_idx]
# we still have the same targets
assert_equal(set(ptargets), set(otargets))
assert_equal(set(oodds), set(podds))
# at the end we have the same mapping
assert_equal(set(zip(otargets, oodds)), set(zip(ptargets, podds)))
def test_assert_datasets_almost_equal(digits, attribute):
samples = np.random.standard_normal((2, 5))
args = dict(sa=dict(targets=np.asarray([1., 2])),
fa=dict(ids=np.asarray([0., 1, 2, 3, 4])),
a=dict(a_value=[66]))
ds = Dataset(samples=samples, **args)
def negate_assert(f):
def raiser(*args, **kwargs):
assert_raises(AssertionError, f, *args, **kwargs)
return raiser
assert_datasets_not_almost_equal = negate_assert(
assert_datasets_almost_equal)
assert_datasets_not_equal = negate_assert(assert_datasets_equal)
def change_attribute(name, how_much):
# change a single attribute in samples, a, fa, or sa.
ds2 = ds.copy(deep=True)
attr = ds2.__dict__[name]
if name == 'samples':
value = attr
else:
for key in attr:
break
value = attr[key].value
value[0] += how_much
return ds2
def remove_attribute(name):
ds2 = ds.copy(deep=True)
attr = ds2.__dict__[name]
for key in list(attr.keys()):
attr.pop(key)
return ds2
if digits is None:
ds2 = change_attribute(attribute, 0)
assert_datasets_equal(ds, ds2)
else:
ds2 = change_attribute(attribute, .5 * 10**-digits)
assert_datasets_not_equal(ds, ds2)
assert_datasets_not_almost_equal(ds, ds2, decimal=digits + 1)
if attribute == 'samples':
assert_datasets_almost_equal(ds, ds2, decimal=digits)
else:
assert_datasets_not_almost_equal(ds, ds2, decimal=digits - 1)
# test ignore_ options
args = {('ignore_' + attribute): list(args[attribute].keys())}
assert_datasets_equal(ds, ds2, **args)
assert_datasets_almost_equal(ds, ds2, **args)
ds3 = remove_attribute(attribute)
assert_datasets_not_equal(ds, ds3)
assert_datasets_not_almost_equal(ds, ds3)
def test_assert_datasets_almost_equal(digits, attribute):
samples = np.random.standard_normal((2, 5))
args = dict(sa=dict(targets=np.asarray([1., 2])),
fa=dict(ids=np.asarray([0., 1, 2, 3, 4])),
a=dict(a_value=[66]))
ds = Dataset(samples=samples, **args)
def negate_assert(f):
def raiser(*args, **kwargs):
assert_raises(AssertionError, f, *args, **kwargs)
return raiser
assert_datasets_not_almost_equal = negate_assert(assert_datasets_almost_equal)
assert_datasets_not_equal = negate_assert(assert_datasets_equal)
def change_attribute(name, how_much):
# change a single attribute in samples, a, fa, or sa.
ds2 = ds.copy(deep=True)
attr = ds2.__dict__[name]
if name == 'samples':
value = attr
else:
for key in attr:
break
value = attr[key].value
value[0] += how_much
return ds2
def remove_attribute(name):
ds2 = ds.copy(deep=True)
attr = ds2.__dict__[name]
for key in attr.keys():
attr.pop(key)
return ds2
if digits is None:
ds2 = change_attribute(attribute, 0)
assert_datasets_equal(ds, ds2)
else:
ds2 = change_attribute(attribute, .5 * 10 ** -digits)
assert_datasets_not_equal(ds, ds2)
assert_datasets_not_almost_equal(ds, ds2, decimal=digits + 1)
if attribute == 'samples':
assert_datasets_almost_equal(ds, ds2, decimal=digits)
else:
assert_datasets_not_almost_equal(ds, ds2, decimal=digits - 1)
# test ignore_ options
args = {('ignore_' + attribute): args[attribute].keys()}
assert_datasets_equal(ds, ds2, **args)
assert_datasets_almost_equal(ds, ds2, **args)
ds3 = remove_attribute(attribute)
assert_datasets_not_equal(ds, ds3)
assert_datasets_not_almost_equal(ds, ds3)
def test_balancer():
ds = give_data()
ds.sa['ids'] = np.arange(len(ds)) # some sa to ease tracking of samples
# only mark the selection in an attribute
bal = Balancer()
res = bal(ds)
# we get a new dataset, with shared samples
assert_false(ds is res)
assert_true(ds.samples is res.samples.base)
# should kick out 2 samples in each chunk of 10
assert_almost_equal(np.mean(res.sa.balanced_set), 0.8)
# same as above, but actually apply the selection
bal = Balancer(apply_selection=True, count=5)
# just run it once
res = bal(ds)
# we get a new dataset, with shared samples
assert_false(ds is res)
# should kick out 2 samples in each chunk of 10
assert_equal(len(res), int(0.8 * len(ds)))
# now use it as a generator
dses = list(bal.generate(ds))
assert_equal(len(dses), 5)
# if we rerun again, it would be a different selection
res2 = bal(ds)
assert_true(np.any(res.sa.ids != bal(ds).sa.ids))
# but if we create a balancer providing seed rng int,
# should be identical results
bal = Balancer(apply_selection=True, count=5, rng=1)
assert_false(np.any(bal(ds).sa.ids != bal(ds).sa.ids))
# But results should differ if we use .generate to produce those multiple
# balanced datasets
b = Balancer(apply_selection=True, count=3, rng=1)
balanced = list(b.generate(ds))
assert_false(all(balanced[0].sa.ids == balanced[1].sa.ids))
assert_false(all(balanced[0].sa.ids == balanced[2].sa.ids))
assert_false(all(balanced[1].sa.ids == balanced[2].sa.ids))
# And should be exactly the same
for ds_a, ds_b in zip(balanced, b.generate(ds)):
assert_datasets_equal(ds_a, ds_b)
# Contribution by Chris Markiewicz
# And interleaving __call__ and generator fetches
gen1 = b.generate(ds)
gen2 = b.generate(ds)
seq1, seq2, seq3 = [], [], []
for i in xrange(3):
seq1.append(gen1.next())
seq2.append(gen2.next())
seq3.append(b(ds))
# Produces expected sequences
for i in xrange(3):
assert_datasets_equal(balanced[i], seq1[i])
assert_datasets_equal(balanced[i], seq2[i])
# And all __call__s return the same result
ds_a = seq3[0]
for ds_b in seq3[1:]:
assert_array_equal(ds_a.sa.ids, ds_b.sa.ids)
# with limit
bal = Balancer(limit={'chunks': 3}, apply_selection=True)
res = bal(ds)
assert_equal(res.sa['chunks'].unique, (3,))
assert_equal(get_nelements_per_value(res.sa.targets).values(),
[2] * 4)
# same but include all offlimit samples
bal = Balancer(limit={'chunks': 3}, include_offlimit=True,
apply_selection=True)
res = bal(ds)
assert_array_equal(res.sa['chunks'].unique, range(10))
# chunk three still balanced, but the rest is not, i.e. all samples included
assert_equal(get_nelements_per_value(res[res.sa.chunks == 3].sa.targets).values(),
[2] * 4)
assert_equal(get_nelements_per_value(res.sa.chunks).values(),
[10, 10, 10, 8, 10, 10, 10, 10, 10, 10])
# fixed amount
bal = Balancer(amount=1, limit={'chunks': 3}, apply_selection=True)
res = bal(ds)
assert_equal(get_nelements_per_value(res.sa.targets).values(),
[1] * 4)
# fraction
bal = Balancer(amount=0.499, limit=None, apply_selection=True)
res = bal(ds)
assert_array_equal(
np.round(np.array(get_nelements_per_value(ds.sa.targets).values()) * 0.5),
np.array(get_nelements_per_value(res.sa.targets).values()))
# check on feature attribute
ds.fa['one'] = np.tile([1, 2], 5)
ds.fa['chk'] = np.repeat([1, 2], 5)
bal = Balancer(attr='one', amount=2, limit='chk', apply_selection=True)
res = bal(ds)
assert_equal(get_nelements_per_value(res.fa.one).values(),
[4] * 2)
def test_attrpermute():
# Was about to use borrowkwargs but didn't work out . Test doesn't hurt
doc = AttributePermutator.__init__.__doc__
assert_in('limit : ', doc)
assert_not_in('collection : ', doc)
ds = give_data()
ds.sa['ids'] = range(len(ds))
pristine_data = ds.samples.copy()
permutation = AttributePermutator(['targets', 'ids'], assure=True)
pds = permutation(ds)
# should not touch the data
assert_array_equal(pristine_data, pds.samples)
# even keep the very same array
assert_true(pds.samples.base is ds.samples)
# there is no way that it can be the same attribute
assert_false(np.all(pds.sa.ids == ds.sa.ids))
# ids should reflect permutation setup
assert_array_equal(pds.sa.targets, ds.sa.targets[pds.sa.ids])
# other attribute should remain intact
assert_array_equal(pds.sa.chunks, ds.sa.chunks)
# now chunk-wise permutation
permutation = AttributePermutator('ids', limit='chunks')
pds = permutation(ds)
# first ten should remain first ten
assert_false(np.any(pds.sa.ids[:10] > 9))
# verify that implausible assure=True would not work
permutation = AttributePermutator('targets', limit='ids', assure=True)
assert_raises(RuntimeError, permutation, ds)
# same thing, but only permute single chunk
permutation = AttributePermutator('ids', limit={'chunks': 3})
pds = permutation(ds)
# one chunk should change
assert_false(np.any(pds.sa.ids[30:40] > 39))
assert_false(np.any(pds.sa.ids[30:40] < 30))
# the rest not
assert_array_equal(pds.sa.ids[:30], range(30))
# or a list of chunks
permutation = AttributePermutator('ids', limit={'chunks': [3,4]})
pds = permutation(ds)
# two chunks should change
assert_false(np.any(pds.sa.ids[30:50] > 49))
assert_false(np.any(pds.sa.ids[30:50] < 30))
# the rest not
assert_array_equal(pds.sa.ids[:30], range(30))
# and now try generating more permutations
nruns = 2
def assert_all_different_permutations(pds):
assert_equal(len(pds), nruns)
for i, p in enumerate(pds):
assert_false(np.all(p.sa.ids == ds.sa.ids))
for p_ in pds[i+1:]:
assert_false(np.all(p.sa.ids == p_.sa.ids))
permutation = AttributePermutator(['targets', 'ids'],
assure=True, count=nruns)
pds = list(permutation.generate(ds))
assert_all_different_permutations(pds)
# if we provide seeding, and generate, it should also return different datasets
permutation = AttributePermutator(['targets', 'ids'],
count=nruns, rng=1)
pds1 = list(permutation.generate(ds))
assert_all_different_permutations(pds)
# but if we regenerate -- should all be the same to before
pds2 = list(permutation.generate(ds))
assert_equal(len(pds1), len(pds2))
for p1, p2 in zip(pds1, pds2):
assert_datasets_equal(p1, p2)
# permute feature attrs
ds.fa['ids'] = range(ds.shape[1])
permutation = AttributePermutator('fa.ids', assure=True)
pds = permutation(ds)
assert_false(np.all(pds.fa.ids == ds.fa.ids))
# now chunk-wise uattrs strategy (reassignment)
permutation = AttributePermutator('targets', limit='chunks',
strategy='uattrs', assure=True)
pds = permutation(ds)
# Due to assure above -- we should have changed things
assert_not_equal(zip(ds.targets), zip(pds.targets))
# in each chunk we should have unique remappings
for c in ds.UC:
chunk_idx = ds.C == c
otargets, ptargets = ds.targets[chunk_idx], pds.sa.targets[chunk_idx]
# we still have the same targets
assert_equal(set(ptargets), set(otargets))
# we have only 1-to-1 mappings
assert_true(len(set(zip(otargets, ptargets))), len(set(otargets)))
ds.sa['odds'] = ds.sa.ids % 2
# test combinations
permutation = AttributePermutator(['targets', 'odds'], limit='chunks',
strategy='uattrs', assure=True)
pds = permutation(ds)
# Due to assure above -- we should have changed things
assert_not_equal(zip(ds.targets, ds.sa.odds),
zip(pds.targets, pds.sa.odds))
# In each chunk we should have unique remappings
for c in ds.UC:
chunk_idx = ds.C == c
otargets, ptargets = ds.targets[chunk_idx], pds.sa.targets[chunk_idx]
oodds, podds = ds.sa.odds[chunk_idx], pds.sa.odds[chunk_idx]
# we still have the same targets
assert_equal(set(ptargets), set(otargets))
assert_equal(set(oodds), set(podds))
# at the end we have the same mapping
assert_equal(set(zip(otargets, oodds)), set(zip(ptargets, podds)))
