def test_18_timebins(self):
model = TemporalIgnore(layer_model=LayerMappedModelMock())
time_bins = [(70 + i * 10, 80 + i * 10) for i in range(18)]
model.start_recording(recording_target='IT', time_bins=time_bins)
recordings = model.look_at('dummy')
assert set(recordings.dims) == {'presentation', 'neuroid', 'time_bin'}
np.testing.assert_array_equal(recordings['time_bin_start'].values,
[start for start, end in time_bins])
np.testing.assert_array_equal(recordings['time_bin_end'].values,
[end for start, end in time_bins])
def test_two_timebins(self):
layer_model = LayerMappedModelMock()
model = TemporalIgnore(layer_model=layer_model)
model.start_recording(recording_target='IT',
time_bins=[(70, 170), (170, 270)])
recordings = model.look_at('dummy')
assert set(recordings.dims) == {'presentation', 'neuroid', 'time_bin'}
np.testing.assert_array_equal(recordings['time_bin_start'].values,
[70, 170])
np.testing.assert_array_equal(recordings['time_bin_end'].values,
[170, 270])
def _call(
self,
model_identifier,
benchmark_identifier,
visual_degrees, # storage fields
model,
benchmark,
layers,
prerun=False):
layer_scores = []
for i, layer in enumerate(tqdm(layers, desc="layers")):
layer_model = LayerMappedModel(
identifier=f"{model_identifier}-{layer}",
visual_degrees=visual_degrees,
# per-layer identifier to avoid overlap
activations_model=model,
region_layer_map={benchmark.region: layer})
layer_model = TemporalIgnore(layer_model)
if i == 0 and prerun: # pre-run activations together to avoid running every layer separately
# we can only pre-run stimuli in response to the benchmark, since we might otherwise be missing
# visual_degrees resizing.
layer_model = PreRunLayers(model=model,
layers=layers,
forward=layer_model)
score = benchmark(layer_model)
score = score.expand_dims('layer')
score['layer'] = [layer]
layer_scores.append(score)
layer_scores = Score.merge(*layer_scores)
layer_scores = layer_scores.sel(
layer=layers) # preserve layer ordering
return layer_scores
def build_layer_model(self, identifier, model, benchmark, layer):
layer_model = LayerMappedModel(
identifier=identifier,
activations_model=model,
region_layer_map={benchmark.region: layer})
layer_model = TemporalIgnore(layer_model)
return layer_model
def _call(
self,
model_identifier,
benchmark_identifier, # storage fields
model,
benchmark,
layers,
prerun=False):
if prerun:
# pre-run activations together to avoid running every layer separately
model(layers=layers, stimuli=benchmark._assembly.stimulus_set)
layer_scores = []
for layer in tqdm(layers, desc="layers"):
layer_model = LayerMappedModel(
identifier=f"{model_identifier}-{layer}",
# per-layer identifier to avoid overlap
activations_model=model,
region_layer_map={benchmark.region: layer})
layer_model = TemporalIgnore(layer_model)
score = benchmark(layer_model)
score = score.expand_dims('layer')
score['layer'] = [layer]
layer_scores.append(score)
layer_scores = Score.merge(*layer_scores)
layer_scores = layer_scores.sel(
layer=layers) # preserve layer ordering
return layer_scores
def load(model_name=model_name, layer=layer, region=region, pca_components=pca_components):
activations_model = base_model_pool[model_name]
if pca_components:
LayerPCA.hook(activations_model, n_components=pca_components)
activations_model.identifier += "-pca_1000"
model = LayerMappedModel(f"{model_name}-{layer}", activations_model=activations_model, visual_degrees=8)
model.commit(region, layer)
model = TemporalIgnore(model)
return model
def test_newmodel_pytorch(self):
import torch
from torch import nn
from model_tools.activations.pytorch import load_preprocess_images
class MyModel(nn.Module):
def __init__(self):
super(MyModel, self).__init__()
self.conv1 = torch.nn.Conv2d(in_channels=3,
out_channels=2,
kernel_size=3)
self.relu1 = torch.nn.ReLU()
linear_input_size = np.power((224 - 3 + 2 * 0) / 1 + 1, 2) * 2
self.linear = torch.nn.Linear(int(linear_input_size), 1000)
self.relu2 = torch.nn.ReLU(
) # can't get named ReLU output otherwise
# init weights for reproducibility
self.conv1.weight.data.fill_(0.01)
self.conv1.bias.data.fill_(0.01)
self.linear.weight.data.fill_(0.01)
self.linear.bias.data.fill_(0.01)
def forward(self, x):
x = self.conv1(x)
x = self.relu1(x)
x = x.view(x.size(0), -1)
x = self.linear(x)
x = self.relu2(x)
return x
preprocessing = functools.partial(load_preprocess_images,
image_size=224)
model_id = 'new_pytorch'
activations_model = PytorchWrapper(model=MyModel(),
preprocessing=preprocessing,
identifier=model_id)
layer = 'relu2'
candidate = LayerMappedModel(f"{model_id}-{layer}",
activations_model=activations_model,
visual_degrees=8)
candidate.commit('IT', layer)
candidate = TemporalIgnore(candidate)
ceiled_score = score_model(
model_identifier=model_id,
model=candidate,
benchmark_identifier='dicarlo.MajajHong2015.IT-pls')
score = ceiled_score.raw
assert score.sel(aggregation='center') == approx(.0820823, abs=.01)
def _call(
self,
model_identifier,
benchmark_identifier, # storage fields
model,
benchmark,
layers,
prerun=False):
if prerun:
# pre-run activations together to avoid running every layer separately
model(layers=layers, stimuli=benchmark._assembly.stimulus_set)
for layer in tqdm(layers, desc="layers"):
layer_model = LayerMappedModel(
identifier=f"{model_identifier}-{layer}",
activations_model=model,
region_layer_map={benchmark.region: layer})
layer_model = TemporalIgnore(layer_model)
layer_model.start_recording(benchmark.region,
time_bins=benchmark.timebins)
layer_model.look_at(benchmark._assembly.stimulus_set)
def test_single_timebin(self):
model = TemporalIgnore(layer_model=LayerMappedModelMock())
model.start_recording(recording_target='IT', time_bins=[(70, 170)])
recordings = model.look_at('dummy')
assert set(recordings.dims) == {'presentation',
'neuroid'} # squeezed time-bin
