brainscore-vision 2.1__py3-none-any.whl

brainscore_vision/model_helpers/brain_transformation/neural.py

@@ -0,0 +1,159 @@
+import logging
+
+from result_caching import store_xarray, store
+from tqdm import tqdm
+
+from brainscore_vision.metrics import Score
+from brainscore_vision.model_helpers.activations.pca import LayerPCA
+from brainscore_vision.model_helpers.brain_transformation import TemporalAligned
+from brainscore_vision.model_helpers.utils import make_list
+from brainscore_vision.model_interface import BrainModel
+from brainscore_vision.utils import fullname
+
+
+class LayerMappedModel(BrainModel):
+    def __init__(self, identifier, activations_model, region_layer_map, visual_degrees=None):
+        self._identifier = identifier
+        self.activations_model = activations_model
+        self._visual_degrees = visual_degrees
+        self.region_layer_map = region_layer_map
+        self.recorded_regions = []
+
+    @property
+    def identifier(self):
+        return self._identifier
+
+    def look_at(self, stimuli, number_of_trials=1, require_variance: bool = False):
+        """
+        :param number_of_trials: An integer that determines how many repetitions of the same image the model performs.
+        :param require_variance: Whether to require models to return different activations for the same stimuli or not.
+                                  For detailed information, see
+                                  :meth:`~brainscore_vision.model_helpers.activations.ActivationsExtractorHelper.__call__`,
+        """
+        layer_regions = {}
+        for region in self.recorded_regions:
+            layers = self.region_layer_map[region]
+            layers = make_list(layers)
+            for layer in layers:
+                assert layer not in layer_regions, f"layer {layer} has already been assigned for {layer_regions[layer]}"
+                layer_regions[layer] = region
+        activations = self.run_activations(stimuli,
+                                           layers=list(layer_regions.keys()),
+                                           number_of_trials=number_of_trials,
+                                           require_variance=require_variance)
+        activations['region'] = 'neuroid', [layer_regions[layer] for layer in activations['layer'].values]
+        return activations
+
+    def run_activations(self, stimuli, layers, number_of_trials=1, require_variance=None):
+        activations = self.activations_model(stimuli, layers=layers, number_of_trials=number_of_trials,
+                                             require_variance=require_variance)
+        return activations
+
+    def start_task(self, task):
+        if task != BrainModel.Task.passive:
+            raise NotImplementedError()
+
+    def start_recording(self, recording_target: BrainModel.RecordingTarget):
+        self.recorded_regions = [recording_target]
+
+    def visual_degrees(self) -> int:
+        return self._visual_degrees
+
+
+class LayerSelection:
+    def __init__(self, model_identifier, activations_model, layers, visual_degrees):
+        """
+        :param model_identifier: this is separate from the container name because it only refers to
+            the combination of (model, preprocessing), i.e. no mapping.
+        """
+        self.model_identifier = model_identifier
+        self._layer_scoring = LayerScores(model_identifier=model_identifier, activations_model=activations_model,
+                                          visual_degrees=visual_degrees)
+        self.layers = layers
+        self._logger = logging.getLogger(fullname(self))
+
+    def __call__(self, selection_identifier, benchmark):
+        # for layer-mapping, attach LayerPCA so that we can cache activations
+        model_identifier = self.model_identifier
+        pca_hooked = LayerPCA.is_hooked(self._layer_scoring._activations_model)
+        if not pca_hooked:
+            pca_handle = LayerPCA.hook(self._layer_scoring._activations_model, n_components=1000)
+            identifier = self._layer_scoring._activations_model.identifier
+            self._layer_scoring._activations_model.identifier = identifier + "-pca_1000"
+            model_identifier += "-pca_1000"
+
+        result = self._call(model_identifier=model_identifier, selection_identifier=selection_identifier,
+                            benchmark=benchmark)
+
+        if not pca_hooked:
+            pca_handle.remove()
+            self._layer_scoring._activations_model.identifier = identifier
+        return result
+
+    @store(identifier_ignore=['benchmark', 'benchmark'])
+    def _call(self, model_identifier, selection_identifier, benchmark):
+        self._logger.debug("Finding best layer")
+        layer_scores = self._layer_scoring(benchmark=benchmark, benchmark_identifier=selection_identifier,
+                                           layers=self.layers, prerun=True)
+
+        self._logger.debug("Layer scores (unceiled): " + ", ".join([
+            f"{layer} -> {layer_scores.raw.sel(layer=layer).item():.3f}"
+            f"+-{layer_scores.raw.sel(layer=layer).attrs['error'].item():.3f}"
+            for layer in layer_scores['layer'].values]))
+        best_layer = layer_scores['layer'].values[layer_scores.argmax()]
+        return best_layer
+
+
+class LayerScores:
+    def __init__(self, model_identifier, activations_model, visual_degrees):
+        self.model_identifier = model_identifier
+        self._activations_model = activations_model
+        self._visual_degrees = visual_degrees
+        self._logger = logging.getLogger(fullname(self))
+
+    def __call__(self, benchmark, layers, benchmark_identifier=None, prerun=False):
+        return self._call(model_identifier=self.model_identifier,
+                          benchmark_identifier=benchmark_identifier or benchmark.identifier,
+                          visual_degrees=self._visual_degrees,
+                          model=self._activations_model, benchmark=benchmark, layers=layers, prerun=prerun)
+
+    @store_xarray(identifier_ignore=['model', 'benchmark', 'layers', 'prerun'], combine_fields={'layers': 'layer'})
+    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 = self._create_mapped_model(region=benchmark.region, layer=layer, model=model,
+                                                    model_identifier=model_identifier, visual_degrees=visual_degrees)
+            layer_model = TemporalAligned(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 _create_mapped_model(self, region, layer, model, model_identifier, visual_degrees):
+        return LayerMappedModel(identifier=f"{model_identifier}-{layer}", visual_degrees=visual_degrees,
+                                # per-layer identifier to avoid overlap
+                                activations_model=model, region_layer_map={region: layer})
+
+
+class PreRunLayers:
+    def __init__(self, model, layers, forward):
+        self._model = model
+        self._layers = layers
+        self._forward = forward
+
+    def look_at(self, stimuli, number_of_trials=1):
+        self._model(layers=self._layers, stimuli=stimuli)
+        return self._forward.look_at(stimuli, number_of_trials=number_of_trials)
+
+    def __getattr__(self, item):
+        if item in ['look_at']:
+            return super(PreRunLayers, self).__getattr__(item)
+        return getattr(self._forward, item)

brainscore_vision/model_helpers/brain_transformation/temporal.py

@@ -0,0 +1,199 @@
+import logging
+import numpy as np
+from typing import List, Tuple
+
+from brainio.assemblies import merge_data_arrays, walk_coords, DataAssembly
+from brainscore_vision.model_helpers.utils import fullname
+from brainscore_vision.model_interface import BrainModel
+
+
+def iterable_to_list(arr):
+    """ recursively converts a list, tuple, or numpy array into a python list. """
+    if isinstance(arr, (list, tuple)):
+        return [iterable_to_list(a) for a in arr]
+    if isinstance(arr, np.ndarray):
+        if arr.dtype == object:
+            arr = arr.tolist()
+        return [iterable_to_list(a) for a in arr]
+    else:
+        return arr
+
+
+def time_align(
+        source_time_bins: List[Tuple[int, int]], 
+        target_time_bins: List[Tuple[int, int]], 
+        mode: str = "portion"
+    ) -> np.ndarray:
+    """ return the aligned binary indicator in the source.
+        belong_to matrix: (target_time_bin, source_time_bin)
+          1 if the target time bin covers the source time bin
+          0 otherwise
+          can be a portion if mode=="portion"
+
+        NOTE: here we assume the source time bins are contiguous, i.e. no gap between them.
+
+        Example:
+        source_time_bins = [(0, 100), (100, 200), (200, 300)]
+        target_time_bins = [(0, 50), (250, 300)]
+
+        mode = "center"
+        belong_to = [[1, 0, 0], [0, 0, 1]]
+
+        mode = "portion"
+        belong_to = [[0.5, 0, 0], [0, 0, 0.5]]
+    """
+    
+    source_time_bins = np.array(iterable_to_list(source_time_bins))  # otherwise object array [(a,b), (c,d)...]
+    target_time_bins = np.array(iterable_to_list(target_time_bins))    
+    assert (source_time_bins[:, 0] <= source_time_bins[:, 1]).all()
+    assert (target_time_bins[:, 0] <= target_time_bins[:, 1]).all()
+
+    target_time_starts = target_time_bins[:, 0]
+    target_time_ends = target_time_bins[:, 1]
+
+    source_time_starts = source_time_bins[:, 0]
+    source_time_ends = source_time_bins[:, 1]
+
+    if mode == "center":
+
+        target_time_mids = target_time_bins.mean(-1)
+        belong_to = (target_time_mids.reshape(-1, 1) >= source_time_starts) & (target_time_mids.reshape(-1, 1) < source_time_ends)
+        belong_to = belong_to.astype(int)
+
+    elif mode == "portion":
+
+        target_time_starts = target_time_starts.reshape(-1, 1)
+        target_time_ends = target_time_ends.reshape(-1, 1)
+        source_time_starts = source_time_starts.reshape(1, -1)
+        source_time_ends = source_time_ends.reshape(1, -1)
+
+        # overlap
+        overlap_starts = np.maximum(target_time_starts, source_time_starts)
+        overlap_ends = np.minimum(target_time_ends, source_time_ends)
+        overlap = np.maximum(overlap_ends - overlap_starts, 0)
+
+        # target time bin size
+        source_time_size = source_time_ends - source_time_starts
+
+        # portion
+        belong_to = overlap / source_time_size
+
+        # get target time bin whose range is not covered completely
+        not_completed_covered = (overlap_ends.max(1) < target_time_ends.T) | (overlap_starts.min(1) > target_time_starts.T)
+        not_completed_covered = not_completed_covered[0]
+        belong_to[not_completed_covered] = 0
+
+    else:
+        raise NotImplementedError("Temporal alignment mode should be either 'center' or 'portion'.")
+
+    return belong_to
+
+
+def assembly_time_align(
+        source : DataAssembly, 
+        target_time_bins : List[Tuple[int]], 
+        mode : str = "portion"
+    ) -> DataAssembly:
+    """ Align the time bins of the source assembly to the target time bins."""
+
+    assert hasattr(source, "time_bin")
+    assert source.time_bin.variable.level_names == ['time_bin_start', 'time_bin_end']
+    source_time_bins = np.array(iterable_to_list(source.time_bin.values))  # otherwise object array [(a,b), (c,d)...]
+    target_time_bins = np.array(iterable_to_list(target_time_bins)) 
+    assert len(target_time_bins[0]) == 2
+
+    belong_to = time_align(source_time_bins, target_time_bins, mode)
+    invalid = np.where(belong_to.sum(1)==0)[0]
+    assert len(invalid)==0, f"Target time bin(s):\n{target_time_bins[invalid]} invalid. The source time bins are:\n{source_time_bins}."
+    source = source.transpose(..., "time_bin")
+    source_data = source.values
+    source_dtype = source_data.dtype
+    ret_data = []
+    for source_belong_to in belong_to:
+        relevant = source_belong_to>0
+        data = source_data[..., relevant]
+        weights = source_belong_to[relevant]
+        data = (data * weights).sum(-1) / weights.sum()  # weighted average
+        ret_data.append(data.astype(source_dtype))
+    ret_data = np.stack(ret_data, -1)  # can be memory-intensive
+
+    # create assembly
+    coords = {k: v for k, v in source.coords.items() if k != "time_bin"}
+    ret = type(source)(
+        ret_data,
+        dims=source.dims,
+        coords={
+            "time_bin_start": ("time_bin", target_time_bins[:, 0]),
+            "time_bin_end": ("time_bin", target_time_bins[:, 1]),
+            **coords
+        },
+    )
+    return ret
+
+
+class TemporalAligned(BrainModel):
+    """
+    Deals with the alignment of time-bins.
+    
+    If the underlying model does not provide a time dimension in its predictions, this always outputs the same prediction for all requested recording time-bins. More specifically, this duplicates the LayerMappedModel prediction across time.
+    
+    If the underlying model does provide a time dimension in its predictions, align those time points to the requested recording time-bins.
+    """
+
+    def __init__(self, layer_model):
+        self._logger = logging.getLogger(fullname(self))
+        self._layer_model = layer_model
+        self.region_layer_map = self._layer_model.region_layer_map
+        self.activations_model = self._layer_model.activations_model
+        self.start_task = self._layer_model.start_task
+        self._time_bins = None
+
+    def start_recording(self, recording_target: BrainModel.RecordingTarget, time_bins=List[Tuple[int]]):
+        self._layer_model.start_recording(recording_target)
+        self._time_bins = time_bins
+
+    def visual_degrees(self) -> int:
+        return self._layer_model.visual_degrees()
+
+    def look_at(self, stimuli, number_of_trials=1):
+        responses = self._layer_model.look_at(stimuli, number_of_trials=number_of_trials)
+        if "time_bin" not in responses.dims:
+            # if the model does not support temporal output, assume the output is the same across time
+            time_responses = []
+            self._logger.debug(f'Repeating single assembly across time bins {self._time_bins}')
+            for time_bin in self._time_bins:
+                time_bin = time_bin if not isinstance(time_bin, np.ndarray) else time_bin.tolist()
+                time_bin_start, time_bin_end = time_bin
+                bin_responses = responses.expand_dims('time_bin_start').expand_dims('time_bin_end')
+                bin_responses['time_bin_start'] = [time_bin_start]
+                bin_responses['time_bin_end'] = [time_bin_end]
+                bin_responses = bin_responses.stack(time_bin=['time_bin_start', 'time_bin_end'])
+                time_responses.append(bin_responses)
+            responses = merge_data_arrays(time_responses)
+            responses = fix_timebin_naming(responses)
+        else:
+            # for temporal models, align the time bins
+            responses = assembly_time_align(responses, self._time_bins)
+            
+        if len(self._time_bins) == 1:
+            responses = responses.squeeze('time_bin')
+        return responses
+
+    @property
+    def identifier(self):
+        return self._layer_model.identifier
+
+
+def fix_timebin_naming(assembly):
+    """
+    renames coordinate time_bin_level_0 to time_bin_start and time_bin_level_1 to time_bin_end
+    to work around bug introduced in xarray 0.16.2 (and still present in 0.17.0).
+    """
+    # jjpr had found that xarray 0.16.2 introduced a bug where xarray.core.alignment._get_joiner assumes Index when the
+    # object is a MultiIndex.
+    # xarray.rename for some reason does not work for some reason, it cannot find the coords
+    rename = dict(time_bin_level_0='time_bin_start', time_bin_level_1='time_bin_end')
+    assembly = type(assembly)(assembly.values, coords={
+        rename[coord] if coord in rename else coord: (dims, values)
+        for coord, dims, values in walk_coords(assembly)}, dims=assembly.dims)
+    return assembly

brainscore_vision/model_helpers/check_submission/check_models.py

@@ -0,0 +1,87 @@
+import numpy as np
+import os
+from brainio.assemblies import NeuroidAssembly
+from brainio.stimuli import StimulusSet
+from brainscore_vision import load_ceiling, load_metric, load_dataset
+from brainscore_vision.benchmark_helpers.neural_common import average_repetition, timebins_from_assembly
+from brainscore_vision.benchmark_helpers.screen import place_on_screen
+from brainscore_vision.benchmarks import BenchmarkBase, ceil_score
+from brainscore_vision.metrics.internal_consistency import InternalConsistency
+from brainscore_vision.model_helpers.brain_transformation import ModelCommitment, LayerSelection, RegionLayerMap
+from brainscore_vision.model_interface import BrainModel
+
+
+def check_brain_models(module):
+    module = __import__(module)
+    for model in module.get_model_list():
+        model = module.get_model(model)
+        assert model is not None
+        assert isinstance(model, BrainModel)
+        check_brain_model_processing(model)
+    print('Test successful, you are ready to submit!')
+
+
+def check_brain_model_processing(model):
+    benchmark = _MockBenchmark()
+    score = benchmark(model, do_behavior=True)
+    assert score is not None
+
+
+def check_base_models(module):
+    module = __import__(module)
+    for model in module.get_model_list():
+        layers = module.get_layers(model)
+        assert layers is not None
+        assert isinstance(layers, list)
+        assert len(layers) > 0
+        assert module.get_model(model) is not None
+        check_processing(model, module)
+        print('Test successful, you are ready to submit!')
+
+
+def check_processing(model_identifier, module):
+    os.environ['RESULTCACHING_DISABLE'] = '1'
+    model_instance = module.get_model(model_identifier)
+    layers = module.get_layers(model_identifier)
+    benchmark = _MockBenchmark()
+    layer_selection = LayerSelection(model_identifier=model_identifier,
+                                     activations_model=model_instance, layers=layers,
+                                     visual_degrees=8)
+    region_layer_map = RegionLayerMap(layer_selection=layer_selection,
+                                      region_benchmarks={'IT': benchmark})
+
+    brain_model = ModelCommitment(identifier=model_identifier, activations_model=model_instance,
+                                  layers=layers, region_layer_map=region_layer_map)
+    score = benchmark(brain_model, do_behavior=True)
+    assert score is not None
+
+
+class _MockBenchmark(BenchmarkBase):
+    def __init__(self):
+        assembly_repetition = load_dataset("MajajHong2015.public").sel(region="IT").squeeze("time_bin")
+        assert hasattr(assembly_repetition, 'repetition')
+        self.region = 'IT'
+        self.assembly = average_repetition(assembly_repetition)
+        self._assembly = self.assembly
+        self.timebins = timebins_from_assembly(self.assembly)
+        self._similarity_metric = load_metric('pls', crossvalidation_kwargs=dict(stratification_coord='object_name'))
+        identifier = f'{assembly_repetition.name}-layer_selection'
+        ceiler = load_ceiling('internal_consistency')
+        super(_MockBenchmark, self).__init__(identifier=identifier,
+                                             ceiling_func=lambda: ceiler(assembly_repetition),
+                                             version='1.0')
+
+    def __call__(self, candidate: BrainModel, do_behavior=False):
+        # adapt stimuli to visual degrees
+        stimuli = place_on_screen(self.assembly.stimulus_set, target_visual_degrees=candidate.visual_degrees(),
+                                  source_visual_degrees=8)  # arbitrary choice for source degrees
+        # Check neural recordings
+        candidate.start_recording(self.region, time_bins=self.timebins)
+        source_assembly = candidate.look_at(stimuli)
+        # Check behavioral tasks
+        if do_behavior:
+            candidate.start_task(BrainModel.Task.probabilities, self.assembly.stimulus_set)
+            candidate.look_at(stimuli)
+        raw_score = self._similarity_metric(source_assembly, self.assembly)
+        return ceil_score(raw_score, self.ceiling)
+

brainscore_vision/model_helpers/conftest.py

@@ -0,0 +1,3 @@
+# the following import is needed to configure pytest for `generic_plugin_tests`
+# noinspection PyUnresolvedReferences
+from brainscore_core.plugin_management.generic_plugin_tests_helper import pytest_addoption

brainscore_vision/model_helpers/generic_plugin_tests.py

@@ -0,0 +1,119 @@
+from pathlib import Path
+
+from brainio.stimuli import StimulusSet
+# the following import is needed to configure pytest
+# noinspection PyUnresolvedReferences
+from brainscore_core.plugin_management.generic_plugin_tests_helper import pytest_generate_tests
+from brainscore_vision import BrainModel, load_model
+import pytest
+
+
+def test_identifier(identifier: str):
+    model = load_model(identifier)
+    assert model.identifier is not None
+
+
+def test_visual_degrees(identifier: str):
+    model = load_model(identifier)
+    assert 0 < model.visual_degrees() < 9000
+
+
+def test_start_task_or_recording(identifier: str):
+    model = load_model(identifier)
+    can_do = ProbeModel()
+    assert can_do.can_start_task(model) or can_do.can_start_recording(model)
+
+
+def test_look_at_behavior_probabilities(identifier: str):
+    model = load_model(identifier)
+    stimuli = fitting_stimuli = _make_stimulus_set()
+    if not ProbeModel().can_start_task_specific(model,
+                                                task=BrainModel.Task.probabilities, fitting_stimuli=fitting_stimuli):
+        # model cannot do this task, ignore. We're testing for behavior or neural in `test_supports_behavior_or_neural`
+        return
+
+    model.start_task(BrainModel.Task.probabilities, fitting_stimuli=stimuli)
+    predictions = model.look_at(stimuli=stimuli, number_of_trials=1)
+    assert set(predictions.dims) == {'presentation', 'choice'}
+    assert set(predictions['stimulus_id'].values) == {'stimid1', 'stimid2', 'stimid3'}
+    assert all(predictions['object_name'] == 'rgb')
+    assert set(predictions['choice'].values) == set(fitting_stimuli['image_label'].values)
+    assert (0 <= predictions.values).all()
+    assert (predictions.values <= 1).all()
+
+@pytest.mark.memory_intense
+def test_look_at_neural_V1(identifier: str):
+    model = load_model(identifier)
+    if not ProbeModel().can_start_recording_region(model, recording_target=BrainModel.RecordingTarget.V1):
+        # model cannot do this task, ignore. We're testing for behavior or neural in `test_supports_behavior_or_neural`
+        return
+
+    stimuli = _make_stimulus_set()
+    model.start_recording(recording_target=BrainModel.RecordingTarget.V1, time_bins=[(50, 100)])
+    predictions = model.look_at(stimuli=stimuli, number_of_trials=1)
+
+    assert set(predictions['stimulus_id'].values) == {'stimid1', 'stimid2', 'stimid3'}
+    assert all(predictions['object_name'] == 'rgb')
+    assert len(predictions['neuroid']) >= 1, "expected at least one neuroid"
+    assert len(set(predictions['neuroid_id'].values)) == len(predictions['neuroid']), "expected unique neuroid_ids"
+    assert len(predictions.dims) <= 3
+    assert 'presentation' in predictions.dims
+    assert 'neuroid' in predictions.dims
+    if len(predictions.dims) == 3:
+        assert 'time_bin' in predictions.dims
+
+
+def _make_stimulus_set() -> StimulusSet:
+    stimuli = StimulusSet({
+        'stimulus_id': ['stimid1', 'stimid2', 'stimid3'],
+        'object_name': ['rgb', 'rgb', 'rgb'],
+        'image_label': ['label1', 'label1', 'label2'],
+        'filename': ['rgb1', 'rgb2', 'rgb3'],
+    })
+    stimuli.stimulus_paths = {'stimid1': Path(__file__).parent / 'generic_plugin_tests_resources' / 'rgb1.jpg',
+                              'stimid2': Path(__file__).parent / 'generic_plugin_tests_resources' / 'rgb2.jpg',
+                              'stimid3': Path(__file__).parent / 'generic_plugin_tests_resources' / 'rgb3.png',
+                              }
+    stimuli.identifier = 'test_look_at_neural_V1.rgb_1_2'
+    return stimuli
+
+
+class ProbeModel:
+    def can_start_task(self, model: BrainModel) -> bool:
+        tasks = [BrainModel.Task.label,
+                 BrainModel.Task.probabilities,
+                 BrainModel.Task.odd_one_out]
+        for task in tasks:
+            if self.can_start_task_specific(model, task=task):
+                return True
+        # no task worked
+        return False
+
+    def can_start_task_specific(self, model, task: BrainModel.Task, fitting_stimuli=None) -> bool:
+        try:  # start task without fitting stimuli
+            model.start_task(task=task)
+            return True
+        except Exception:
+            try:  # start task with fitting stimuli
+                model.start_task(task=task, fitting_stimuli=fitting_stimuli)
+                return True
+            except Exception:
+                return False
+
+    def can_start_recording(self, model: BrainModel) -> bool:
+        regions = [BrainModel.RecordingTarget.V1,
+                   BrainModel.RecordingTarget.V2,
+                   BrainModel.RecordingTarget.V4,
+                   BrainModel.RecordingTarget.IT]
+        for region in regions:
+            if self.can_start_recording_region(model, recording_target=region):
+                return True
+        # no region worked
+        return False
+
+    def can_start_recording_region(self, model: BrainModel, recording_target: BrainModel.RecordingTarget) -> bool:
+        try:
+            model.start_recording(recording_target=recording_target, time_bins=[(100, 200)])
+            return True
+        except Exception:
+            return False