def test_repeated_dim_and_adjacent(self):
source_assembly = np.random.rand(5, 5)
source_assembly = NeuroidAssembly(
source_assembly,
coords={
'image_id':
('presentation', list(range(source_assembly.shape[0]))),
'image_meta':
('presentation', np.zeros(source_assembly.shape[0])),
'adjacent': 12
},
dims=['presentation', 'presentation'])
target_assembly = NeuroidAssembly(
np.zeros(3), coords={
'image_id': [0, 2, 3]
}, dims=['image_id']).stack(presentation=('image_id', ))
subset_assembly = subset(source_assembly,
target_assembly,
subset_dims=('presentation', ),
repeat=True)
np.testing.assert_array_equal(subset_assembly.shape, (3, 3))
assert set(subset_assembly['image_id'].values) == set(
target_assembly['image_id'].values)
assert subset_assembly['adjacent'] == 12
def test_smaller_last(self):
source_assembly = np.random.rand(100, 3)
source_assembly = NeuroidAssembly(
source_assembly,
coords={
'image_id': list(range(source_assembly.shape[0])),
'neuroid_id': list(range(source_assembly.shape[1]))
},
dims=['image_id', 'neuroid_id'])
source_assembly = source_assembly.stack(presentation=('image_id', ),
neuroid=('neuroid_id', ))
target_assembly = source_assembly.sel(
presentation=list(map(lambda x: (50 + x, ), range(50))),
neuroid=list(map(lambda x: (1 + x, ), range(2))))
subset_assembly = subset(source_assembly,
target_assembly,
subset_dims=('presentation', ))
np.testing.assert_array_equal(subset_assembly.coords.keys(),
target_assembly.coords.keys())
for coord_name in target_assembly.coords:
assert all(
subset_assembly[coord_name] == target_assembly[coord_name])
assert (subset_assembly == target_assembly).all()
def _package_prediction(self, predicted_values, source):
coords = {
coord: (dims, values)
for coord, dims, values in walk_coords(source)
if not array_is_element(dims, self._neuroid_dim)
}
# re-package neuroid coords
dims = source.dims
# if there is only one neuroid coordinate, it would get discarded and the dimension would be used as coordinate.
# to avoid this, we can build the assembly first and then stack on the neuroid dimension.
neuroid_level_dim = None
if len(
self._target_neuroid_values
) == 1: # extract single key: https://stackoverflow.com/a/20145927/2225200
(neuroid_level_dim, _), = self._target_neuroid_values.items()
dims = [
dim if dim != self._neuroid_dim else neuroid_level_dim
for dim in dims
]
for target_coord, target_value in self._target_neuroid_values.items():
# this might overwrite values which is okay
coords[target_coord] = (neuroid_level_dim
or self._neuroid_dim), target_value
prediction = NeuroidAssembly(predicted_values,
coords=coords,
dims=dims)
if neuroid_level_dim:
prediction = prediction.stack(
**{self._neuroid_dim: [neuroid_level_dim]})
return prediction
def look_at_cached(self, model_identifier, stimuli_identifier, stimuli):
responses = self.activations_model(stimuli,
layers=self.recording_layers)
# map time
regions = set(responses['region'].values)
if len(regions) > 1:
raise NotImplementedError(
"cannot handle more than one simultaneous region")
region = list(regions)[0]
time_bins = [
self.time_mapping[region][timestep]
if timestep in self.time_mapping[region] else (None, None)
for timestep in responses['time_step'].values
]
responses['time_bin_start'] = 'time_step', [
time_bin[0] for time_bin in time_bins
]
responses['time_bin_end'] = 'time_step', [
time_bin[1] for time_bin in time_bins
]
responses = NeuroidAssembly(responses.rename({'time_step':
'time_bin'}))
responses = responses[{
'time_bin': [
not np.isnan(time_start)
for time_start in responses['time_bin_start']
]
}]
# select time
time_responses = []
for time_bin in tqdm(self.recording_time_bins,
desc='CORnet-time to recording time'):
time_bin = time_bin if not isinstance(
time_bin, np.ndarray) else time_bin.tolist()
time_bin_start, time_bin_end = time_bin
nearest_start = find_nearest(responses['time_bin_start'].values,
time_bin_start)
bin_responses = responses.sel(time_bin_start=nearest_start)
bin_responses = NeuroidAssembly(
bin_responses.values,
coords={
**{
coord: (dims, values)
for coord, dims, values in walk_coords(bin_responses) if coord not in [
'time_bin_level_0', 'time_bin_end'
]
},
**{
'time_bin_start': ('time_bin', [time_bin_start]),
'time_bin_end': ('time_bin', [time_bin_end])
}
},
dims=bin_responses.dims)
time_responses.append(bin_responses)
responses = merge_data_arrays(time_responses)
return responses
def test_alignment(self):
jumbled_prediction = NeuroidAssembly(np.random.rand(500, 10),
coords={'image_id': ('presentation', list(reversed(range(500)))),
'image_meta': ('presentation', [0] * 500),
'neuroid_id': ('neuroid', list(reversed(range(10)))),
'neuroid_meta': ('neuroid', [0] * 10)},
dims=['presentation', 'neuroid'])
prediction = jumbled_prediction.sortby(['image_id', 'neuroid_id'])
correlation = XarrayCorrelation(scipy.stats.pearsonr)
score = correlation(jumbled_prediction, prediction)
assert all(score == approx(1))
def _load_assembly(self):
assembly = load_naturalStories()
stimulus_set = assembly.stimulus_set
# we're going to treat subjects as "neuroids" to make it easier for our metrics
assembly = assembly.mean('subjects')
assembly = assembly.expand_dims('neuroid')
assembly['neuroid_id'] = 'neuroid', [0]
assembly['subject_id'] = 'neuroid', ['all']
assembly = NeuroidAssembly(assembly)
assembly.attrs['stimulus_set'] = stimulus_set
return assembly
def test_neuroid_single_coord(self):
jumbled_source = NeuroidAssembly(np.random.rand(500, 10),
coords={'image_id': ('presentation', list(reversed(range(500)))),
'image_meta': ('presentation', [0] * 500),
'neuroid_id': ('neuroid_id', list(reversed(range(10))))},
dims=['presentation', 'neuroid_id']).stack(neuroid=['neuroid_id'])
target = jumbled_source.sortby(['image_id', 'neuroid_id'])
regression = XarrayRegression(LinearRegression())
regression.fit(jumbled_source, target)
prediction = regression.predict(jumbled_source)
assert set(prediction.dims) == {'presentation', 'neuroid'}
assert len(prediction['neuroid_id']) == 10
def test_misaligned(self):
jumbled_source = NeuroidAssembly(np.random.rand(500, 10),
coords={'image_id': ('presentation', list(reversed(range(500)))),
'image_meta': ('presentation', [0] * 500),
'neuroid_id': ('neuroid', list(reversed(range(10)))),
'neuroid_meta': ('neuroid', [0] * 10)},
dims=['presentation', 'neuroid'])
target = jumbled_source.sortby(['image_id', 'neuroid_id'])
cv = CrossValidation(splits=10, stratification_coord=None)
metric = self.MetricPlaceholder()
score = cv(jumbled_source, target, apply=metric)
assert len(metric.train_source_assemblies) == len(metric.test_source_assemblies) == \
len(metric.train_target_assemblies) == len(metric.test_target_assemblies) == 10
assert len(score.attrs['raw']) == 10
def test_one_division_similarity_dim_last(self):
assembly = np.random.rand(3, 100)
assembly = NeuroidAssembly(
assembly,
coords={'neuroid': list(range(assembly.shape[1])), 'division_coord': list(range(assembly.shape[0]))},
dims=['division_coord', 'neuroid'])
transformation = CartesianProduct(dividers=['division_coord'])
placeholder = self.MetricPlaceholder()
transformation(assembly, apply=placeholder)
assert len(assembly['division_coord']) == len(placeholder.assemblies)
targets = [assembly.sel(division_coord=i) for i in assembly['division_coord'].values]
for target in targets:
match = any([actual == target] for actual in placeholder.assemblies)
assert match, "expected divided assembly not found: {target}"
def test_fitpredict_alignment(self):
jumbled_source = NeuroidAssembly(np.random.rand(500, 10),
coords={'image_id': ('presentation', list(reversed(range(500)))),
'image_meta': ('presentation', [0] * 500),
'neuroid_id': ('neuroid', list(reversed(range(10)))),
'neuroid_meta': ('neuroid', [0] * 10)},
dims=['presentation', 'neuroid'])
target = jumbled_source.sortby(['image_id', 'neuroid_id'])
regression = XarrayRegression(LinearRegression())
regression.fit(jumbled_source, target)
prediction = regression.predict(jumbled_source)
# do not test for alignment of metadata - it is only important that the data is well-aligned with the metadata.
np.testing.assert_array_almost_equal(prediction.sortby(['image_id', 'neuroid_id']).values,
target.sortby(['image_id', 'neuroid_id']).values)
def test_average_label_trials():
assembly = NeuroidAssembly(
[
['a'],
['a'],
['a'],
['b'],
['b'],
['a'],
],
coords={
'image_id': ('presentation', ['a', 'a', 'a', 'b', 'b', 'b']),
'repetition': ('presentation', [0, 1, 2, 0, 1, 2]),
'presentation_dummy': ('presentation', ['x'] * 6),
'choice': ('choice', ['dummy'])
},
dims=['presentation', 'choice'])
averaged_assembly = average_trials(assembly)
assert len(averaged_assembly['choice']) == 1, "messed up dimension"
assert len(averaged_assembly['presentation']) == 2
assert set(averaged_assembly['image_id'].values) == {'a', 'b'}
np.testing.assert_array_equal(
averaged_assembly.sel(image_id='a').values, [['a']])
np.testing.assert_array_equal(
averaged_assembly.sel(image_id='b').values, [['b']])
def test_average_neural_trials():
assembly = NeuroidAssembly(
[[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8],
[7, 8, 9], [8, 9, 10]],
coords={
'image_id':
('presentation', ['a', 'a', 'b', 'b', 'c', 'c', 'd', 'd']),
'repetition': ('presentation', [0, 1, 0, 1, 0, 1, 0, 1]),
'presentation_dummy': ('presentation', ['x'] * 8),
'neuroid_id': ('neuroid', [0, 1, 2]),
'region': ('neuroid', ['IT', 'IT', 'IT'])
},
dims=['presentation', 'neuroid'])
averaged_assembly = average_trials(assembly)
assert len(averaged_assembly['neuroid']) == 3, "messed up neuroids"
assert len(averaged_assembly['presentation']) == 4
assert set(averaged_assembly['image_id'].values) == {'a', 'b', 'c', 'd'}
np.testing.assert_array_equal(averaged_assembly['neuroid_id'].values,
assembly['neuroid_id'].values)
np.testing.assert_array_equal(
averaged_assembly.sel(image_id='a').values, [[1.5, 2.5, 3.5]])
np.testing.assert_array_equal(
averaged_assembly.sel(image_id='b').values, [[3.5, 4.5, 5.5]])
np.testing.assert_array_equal(
averaged_assembly.sel(image_id='c').values, [[5.5, 6.5, 7.5]])
np.testing.assert_array_equal(
averaged_assembly.sel(image_id='d').values, [[7.5, 8.5, 9.5]])
def from_paths(self, *args, **kwargs):
raw_activations = super(TemporalExtractor, self).from_paths(*args, **kwargs)
# introduce time dimension
regions = defaultdict(list)
for layer in set(raw_activations['layer'].values):
match = re.match(r'(([^-]*)\..*|logits|avgpool)-t([0-9]+)', layer)
region, timestep = match.group(2) if match.group(2) else match.group(1), match.group(3)
stripped_layer = match.group(1)
regions[region].append((layer, stripped_layer, timestep))
activations = {}
for region, time_layers in regions.items():
for (full_layer, stripped_layer, timestep) in time_layers:
region_time_activations = raw_activations.sel(layer=full_layer)
region_time_activations['layer'] = 'neuroid', [stripped_layer] * len(region_time_activations['neuroid'])
activations[(region, timestep)] = region_time_activations
for key, key_activations in activations.items():
region, timestep = key
key_activations['region'] = 'neuroid', [region] * len(key_activations['neuroid'])
activations[key] = NeuroidAssembly([key_activations.values], coords={
**{coord: (dims, values) for coord, dims, values in walk_coords(activations[key])
if coord != 'neuroid_id'}, # otherwise, neuroid dim will be as large as before with nans
**{'time_step': [int(timestep)]}
}, dims=['time_step'] + list(key_activations.dims))
activations = list(activations.values())
activations = merge_data_arrays(activations)
# rebuild neuroid_id without timestep
neuroid_id = [".".join([f"{value}" for value in values]) for values in zip(*[
activations[coord].values for coord in ['model', 'region', 'neuroid_num']])]
activations['neuroid_id'] = 'neuroid', neuroid_id
return activations
def test_no_expand_raw_level(self):
assembly = np.random.rand(3, 100)
assembly = NeuroidAssembly(assembly,
coords={
'neuroid':
list(range(assembly.shape[1])),
'division_coord':
list(range(assembly.shape[0]))
},
dims=['division_coord', 'neuroid'])
transformation = CartesianProduct(dividers=['division_coord'])
class RawMetricPlaceholder(Metric):
def __call__(self, assembly, *args, **kwargs):
result = Score([assembly.values[0]], dims=['dim'])
raw = Score(result.copy(),
coords={
'dim_id': ('dim', [assembly.values[1]]),
'division_coord': ('dim', [assembly.values[2]])
})
result.attrs['raw'] = raw
return result
metric = RawMetricPlaceholder()
result = transformation(assembly, apply=metric)
assert result.dims == ("division_coord", "dim")
assert hasattr(result, 'raw')
assert result.raw.dims == ("dim", )
assert 'division_coord' not in result.raw.dims # no dimension
assert hasattr(result.raw, 'division_coord') # but a level
assert result.raw["dim"].variable.level_names == [
"dim_id", "division_coord"
]
def _package_layer(self, layer_activations, layer, stimuli_paths):
assert layer_activations.shape[0] == len(stimuli_paths)
activations, flatten_indices = flatten(layer_activations, return_index=True) # collapse for single neuroid dim
assert flatten_indices.shape[1] in [1, 2, 3]
# see comment in _package for an explanation why we cannot simply have 'channel' for the FC layer
if flatten_indices.shape[1] == 1: # FC
flatten_coord_names = ['channel', 'channel_x', 'channel_y']
elif flatten_indices.shape[1] == 2: # Transformer
flatten_coord_names = ['channel', 'embedding']
elif flatten_indices.shape[1] == 3: # 2DConv
flatten_coord_names = ['channel', 'channel_x', 'channel_y']
flatten_coords = {flatten_coord_names[i]: [sample_index[i] if i < flatten_indices.shape[1] else np.nan for sample_index in flatten_indices]
for i in range(len(flatten_coord_names))}
layer_assembly = NeuroidAssembly(
activations,
coords={**{'stimulus_path': stimuli_paths,
'neuroid_num': ('neuroid', list(range(activations.shape[1]))),
'model': ('neuroid', [self.identifier] * activations.shape[1]),
'layer': ('neuroid', [layer] * activations.shape[1]),
},
**{coord: ('neuroid', values) for coord, values in flatten_coords.items()}},
dims=['stimulus_path', 'neuroid']
)
neuroid_id = [".".join([f"{value}" for value in values]) for values in zip(*[
layer_assembly[coord].values for coord in ['model', 'layer', 'neuroid_num']])]
layer_assembly['neuroid_id'] = 'neuroid', neuroid_id
return layer_assembly
def test_equal(self):
assembly = np.random.rand(100, 3)
assembly = NeuroidAssembly(assembly,
coords={
'image_id':
list(range(assembly.shape[0])),
'neuroid_id':
list(range(assembly.shape[1]))
},
dims=['image_id', 'neuroid_id'])
assembly = assembly.stack(presentation=('image_id', ),
neuroid=('neuroid_id', ))
subset_assembly = subset(assembly,
assembly,
subset_dims=('presentation', ))
assert (subset_assembly == assembly).all()
def test_alignment(self):
assembly = NeuroidAssembly(
[[1, 2], [1, 2], [4, 3], [4, 3]],
coords={
'image_id': ('presentation', list(range(4))),
'image_meta': ('presentation', list(range(4))),
'neuroid_id': ('neuroid', list(range(2))),
'neuroid_meta': ('neuroid', list(range(2)))
},
dims=['presentation', 'neuroid'])
matrix = RSA()(assembly)
assert np.all(np.diag(matrix) == approx(1., abs=.001))
assert all(matrix.values[np.triu_indices(matrix.shape[0], k=1)] ==
matrix.values[np.tril_indices(matrix.shape[0], k=-1)]
), "upper and lower triangular need to be equal"
expected = DataAssembly(
[[1., 1., -1., -1.], [1., 1., -1., -1.], [-1., -1., 1., 1.],
[-1., -1., 1., 1.]],
coords={
'image_id': ('presentation', list(range(4))),
'image_meta': ('presentation', list(range(4)))
},
dims=['presentation', 'presentation'])
np.testing.assert_array_almost_equal(
matrix.values,
expected.values) # does not take ordering into account
def build_assembly(assembly, coord_list=['ty', 'tz']):
values = np.stack(
[getattr(assembly, coord).values for coord in coord_list],
axis=1)
coords = {
'neuroid_id': ('neuroid', list(range(len(coord_list)))),
'neuroid_meaning': ('neuroid', coord_list)}
for coord, dims, value in walk_coords(assembly):
if len(dims) == 0:
continue
if dims[0] == 'presentation':
coords[coord] = ('presentation', value)
new_assembly = NeuroidAssembly(
values,
coords=coords,
dims=['presentation', 'neuroid'])
new_assembly.attrs['stimulus_set'] = assembly.stimulus_set
return new_assembly
def test_neuroid_single_coord(self):
prediction = NeuroidAssembly(np.random.rand(500, 10),
coords={'image_id': ('presentation', list(range(500))),
'image_meta': ('presentation', [0] * 500),
'neuroid_id': ('neuroid_id', list(range(10)))},
dims=['presentation', 'neuroid_id']).stack(neuroid=['neuroid_id'])
correlation = XarrayCorrelation(lambda a, b: (1, 0))
score = correlation(prediction, prediction)
np.testing.assert_array_equal(score.dims, ['neuroid'])
assert len(score['neuroid']) == 10
def test_correlation(self):
prediction = NeuroidAssembly(np.random.rand(500, 10),
coords={'image_id': ('presentation', list(range(500))),
'image_meta': ('presentation', [0] * 500),
'neuroid_id': ('neuroid', list(range(10))),
'neuroid_meta': ('neuroid', [0] * 10)},
dims=['presentation', 'neuroid'])
correlation = XarrayCorrelation(lambda a, b: (1, 0))
score = correlation(prediction, prediction)
assert all(score == approx(1))
def test_small(self):
assembly = NeuroidAssembly((np.arange(30 * 25) + np.random.standard_normal(30 * 25)).reshape((30, 25)),
coords={'image_id': ('presentation', np.arange(30)),
'object_name': ('presentation', ['a', 'b', 'c'] * 10),
'neuroid_id': ('neuroid', np.arange(25)),
'region': ('neuroid', ['some_region'] * 25)},
dims=['presentation', 'neuroid'])
metric = CrossRegressedCorrelation(regression=pls_regression(), correlation=pearsonr_correlation())
score = metric(source=assembly, target=assembly)
assert score.sel(aggregation='center') == approx(1, abs=.00001)
def look_at(self, *args, **kwargs):
return NeuroidAssembly(
[[1, 2, 3], [1, 2, 3]],
coords={
'image_id': ('presentation', ['image1', 'image2']),
'object_name': ('presentation', ['number', 'number']),
'neuroid_id': ('neuroid', [1, 2, 3]),
'region': ('neuroid', ['IT'] * 3),
},
dims=['presentation', 'neuroid'])
def test_dummy_data(self):
data = NeuroidAssembly(np.tile(np.arange(10)[:, np.newaxis], [5, 10]),
coords={'image_id': ('presentation', np.tile(list(alphabet)[:10], 5)),
'image_meta': ('presentation', np.tile(list(alphabet)[:10], 5)),
'repetition': ('presentation', np.repeat(np.arange(5), 10)),
'neuroid_id': ('neuroid', np.arange(10)),
'neuroid_meta': ('neuroid', np.arange(10))},
dims=['presentation', 'neuroid'])
ceiler = InternalConsistency()
ceiling = ceiler(data)
assert ceiling.sel(aggregation='center') == 1
def test_dimensions(self):
prediction = NeuroidAssembly(np.random.rand(500, 10),
coords={'image_id': ('presentation', list(range(500))),
'image_meta': ('presentation', [0] * 500),
'neuroid_id': ('neuroid', list(range(10))),
'neuroid_meta': ('neuroid', [0] * 10)},
dims=['presentation', 'neuroid'])
correlation = XarrayCorrelation(lambda a, b: (1, 0))
score = correlation(prediction, prediction)
np.testing.assert_array_equal(score.dims, ['neuroid'])
np.testing.assert_array_equal(score.shape, [10])
def build_cate_assembly(assembly):
category_names = assembly.category_name.values
unique_cate_names = np.unique(category_names)
# Tricky solution for some weird requirements later
new_category_names = [
[curr_name, curr_name] \
for curr_name in category_names]
coords = {
'neuroid_id': ('neuroid', [0, 1]),
'neuroid_meaning': ('neuroid', ['category', 'category'])}
for coord, dims, value in walk_coords(assembly):
if len(dims) == 0:
continue
if dims[0] == 'presentation':
coords[coord] = ('presentation', value)
new_assembly = NeuroidAssembly(
new_category_names,
coords=coords,
dims=['presentation', 'neuroid'])
new_assembly.attrs['stimulus_set'] = assembly.stimulus_set
return new_assembly
def test_small(self, regression_ctr):
assembly = NeuroidAssembly((np.arange(30 * 25) + np.random.standard_normal(30 * 25)).reshape((30, 25)),
coords={'image_id': ('presentation', np.arange(30)),
'object_name': ('presentation', ['a', 'b', 'c'] * 10),
'neuroid_id': ('neuroid', np.arange(25)),
'region': ('neuroid', [None] * 25)},
dims=['presentation', 'neuroid'])
regression = regression_ctr()
regression.fit(source=assembly, target=assembly)
prediction = regression.predict(source=assembly)
assert all(prediction['image_id'] == assembly['image_id'])
assert all(prediction['neuroid_id'] == assembly['neuroid_id'])
def test_presentation_neuroid(self):
assembly = NeuroidAssembly(np.random.rand(500, 10),
coords={'image_id': ('presentation', list(range(500))),
'image_meta': ('presentation', [0] * 500),
'neuroid_id': ('neuroid', list(range(10))),
'neuroid_meta': ('neuroid', [0] * 10)},
dims=['presentation', 'neuroid'])
cv = CrossValidationSingle(splits=10, stratification_coord=None)
metric = self.MetricPlaceholder()
score = cv(assembly, apply=metric)
assert len(metric.train_assemblies) == len(metric.test_assemblies) == 10
assert len(score.attrs['raw']['split']) == 10
def get_assembly():
image_names = []
for i in range(1, 21):
image_names.append(f'images/{i}.png')
assembly = NeuroidAssembly(
(np.arange(40 * 5) + np.random.standard_normal(40 * 5)).reshape(
(5, 40, 1)),
coords={
'image_id': ('presentation', image_names * 2),
'object_name': ('presentation', ['a'] * 40),
'repetition': ('presentation', ([1] * 20 + [2] * 20)),
'neuroid_id': ('neuroid', np.arange(5)),
'region': ('neuroid', ['IT'] * 5),
'time_bin_start': ('time_bin', [70]),
'time_bin_end': ('time_bin', [170])
},
dims=['neuroid', 'presentation', 'time_bin'])
labels = ['a'] * 10 + ['b'] * 10
stimulus_set = StimulusSet([{
'image_id': image_names[i],
'object_name': 'a',
'image_label': labels[i]
} for i in range(20)])
stimulus_set.image_paths = {
image_name: os.path.join(os.path.dirname(__file__), image_name)
for image_name in image_names
}
stimulus_set.identifier = 'test'
assembly.attrs['stimulus_set'] = stimulus_set
assembly.attrs['stimulus_set_name'] = stimulus_set.identifier
assembly = assembly.squeeze("time_bin")
return assembly.transpose('presentation', 'neuroid')
def test_equal_shifted(self):
target_assembly = np.random.rand(100, 3)
target_assembly = NeuroidAssembly(
target_assembly,
coords={
'image_id': list(range(target_assembly.shape[0])),
'neuroid_id': list(range(target_assembly.shape[1]))
},
dims=['image_id', 'neuroid_id'])
target_assembly = target_assembly.stack(presentation=('image_id', ),
neuroid=('neuroid_id', ))
shifted_values = np.concatenate(
(target_assembly.values[1:], target_assembly.values[:1]))
shifed_ids = np.array(list(range(shifted_values.shape[0]))) + 1
shifed_ids[-1] = 0
source_assembly = NeuroidAssembly(
shifted_values,
coords={
'image_id': shifed_ids,
'neuroid_id': list(range(shifted_values.shape[1]))
},
dims=['image_id', 'neuroid_id'])
source_assembly = source_assembly.stack(presentation=('image_id', ),
neuroid=('neuroid_id', ))
subset_assembly = subset(source_assembly,
target_assembly,
subset_dims=('presentation', ))
np.testing.assert_array_equal(subset_assembly.coords.keys(),
target_assembly.coords.keys())
assert subset_assembly.shape == target_assembly.shape
def test_repeated_target(self):
source_assembly = np.random.rand(5, 3)
source_assembly = NeuroidAssembly(
source_assembly,
coords={
'image_id': list(range(source_assembly.shape[0])),
'neuroid_id': list(range(source_assembly.shape[1]))
},
dims=['image_id', 'neuroid_id'])
source_assembly = source_assembly.stack(presentation=('image_id', ),
neuroid=('neuroid_id', ))
target_assembly = NeuroidAssembly(
np.repeat(source_assembly, 2, axis=0),
coords={
'image_id':
np.repeat(list(range(source_assembly.shape[0])), 2, axis=0),
'neuroid_id':
list(range(source_assembly.shape[1]))
},
dims=['image_id', 'neuroid_id'])
target_assembly = target_assembly.stack(presentation=('image_id', ),
neuroid=('neuroid_id', ))
subset_assembly = subset(source_assembly,
target_assembly,
subset_dims=('presentation', ),
repeat=True)
np.testing.assert_array_equal(subset_assembly.coords.keys(),
target_assembly.coords.keys())
for coord_name in target_assembly.coords:
assert all(
subset_assembly[coord_name] == target_assembly[coord_name])
np.testing.assert_array_equal(subset_assembly, target_assembly)
assert (subset_assembly == target_assembly).all()
