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_commit(self, model_ctr, layers, region): activations_model = model_ctr() layer_model = LayerMappedModel(identifier=activations_model.identifier, activations_model=activations_model, region_layer_map={region: layers}) layer_model.start_recording(region) stimulus_set = StimulusSet([{'image_id': 'test'}]) stimulus_set.image_paths = {'test': os.path.join(os.path.dirname(__file__), 'rgb1.jpg')} stimulus_set.identifier = self.__class__.__name__ predictions = layer_model.look_at(stimulus_set) assert set(predictions['region'].values) == {region} assert set(predictions['layer'].values) == {layers} if isinstance(layers, str) else set(layers)
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 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) 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)