def _DicarloMajaj2015RegionLowMidVar(region, identifier_metric_suffix, similarity_metric, ceiler):
assembly_repetition = LazyLoad(lambda region=region: load_var0var3_assembly(average_repetitions=False, region=region))
assembly = LazyLoad(lambda region=region: load_var0var3_assembly(average_repetitions=True, region=region))
return NeuralBenchmark(identifier=f'dicarlo.Majaj2015.lowmidvar.{region}-{identifier_metric_suffix}', version=3,
assembly=assembly, similarity_metric=similarity_metric,
ceiling_func=lambda: ceiler(assembly_repetition),
parent=region, paper_link='http://www.jneurosci.org/content/35/39/13402.short')
def _DicarloSanghaviMurty2020Region(region, identifier_metric_suffix, similarity_metric, ceiler):
assembly_repetition = LazyLoad(lambda region=region: load_assembly(average_repetitions=False, region=region))
assembly = LazyLoad(lambda region=region: load_assembly(average_repetitions=True, region=region))
return NeuralBenchmark(identifier=f'dicarlo.SanghaviMurty2020.{region}-{identifier_metric_suffix}', version=1,
assembly=assembly, similarity_metric=similarity_metric,
visual_degrees=VISUAL_DEGREES, number_of_trials=NUMBER_OF_TRIALS,
ceiling_func=lambda: ceiler(assembly_repetition),
parent=region,
bibtex=BIBTEX)
def _experimental_benchmark_pool():
"""
Benchmarks that can be used, but are not evaluated for the website.
"""
pool = {}
# neural benchmarks
from .majajhong2015 import DicarloMajajHong2015V4Mask, DicarloMajajHong2015ITMask, \
DicarloMajajHong2015V4RDM, DicarloMajajHong2015ITRDM
pool['dicarlo.MajajHong2015.V4-mask'] = LazyLoad(
DicarloMajajHong2015V4Mask)
pool['dicarlo.MajajHong2015.IT-mask'] = LazyLoad(
DicarloMajajHong2015ITMask)
pool['dicarlo.MajajHong2015.V4-rdm'] = LazyLoad(DicarloMajajHong2015V4RDM)
pool['dicarlo.MajajHong2015.IT-rdm'] = LazyLoad(DicarloMajajHong2015ITRDM)
from .freemanziemba2013 import MovshonFreemanZiemba2013V1RDM, MovshonFreemanZiemba2013V2RDM, \
MovshonFreemanZiemba2013V1Single
pool['movshon.FreemanZiemba2013.V1-rdm'] = LazyLoad(
MovshonFreemanZiemba2013V1RDM)
pool['movshon.FreemanZiemba2013.V2-rdm'] = LazyLoad(
MovshonFreemanZiemba2013V2RDM)
pool['movshon.FreemanZiemba2013.V1-single'] = LazyLoad(
MovshonFreemanZiemba2013V1Single)
from .cadena2017 import ToliasCadena2017PLS, ToliasCadena2017Mask
pool['tolias.Cadena2017-pls'] = LazyLoad(ToliasCadena2017PLS)
pool['tolias.Cadena2017-mask'] = LazyLoad(ToliasCadena2017Mask)
return pool
def _standard_benchmark(identifier, load_assembly, visual_degrees, number_of_trials, stratification_coord, bibtex):
assembly_repetition = LazyLoad(lambda: load_assembly(average_repetitions=False))
assembly = LazyLoad(lambda: load_assembly(average_repetitions=True))
similarity_metric = CrossRegressedCorrelation(
regression=pls_regression(), correlation=pearsonr_correlation(),
crossvalidation_kwargs=dict(stratification_coord=stratification_coord))
ceiler = InternalConsistency()
return NeuralBenchmark(identifier=f"{identifier}-pls", version=1,
assembly=assembly, similarity_metric=similarity_metric,
visual_degrees=visual_degrees, number_of_trials=number_of_trials,
ceiling_func=lambda: ceiler(assembly_repetition),
parent=None,
bibtex=bibtex)
def _MovshonFreemanZiemba2013Region(region, identifier_metric_suffix,
similarity_metric, ceiler):
assembly_repetition = LazyLoad(
lambda region=region: load_assembly(False, region=region))
assembly = LazyLoad(
lambda region=region: load_assembly(True, region=region))
return NeuralBenchmark(
identifier=
f'movshon.FreemanZiemba2013.{region}-{identifier_metric_suffix}',
version=2,
assembly=assembly,
similarity_metric=similarity_metric,
ceiling_func=lambda: ceiler(assembly_repetition),
parent=region,
paper_link='https://www.nature.com/articles/nn.3402')
def _DicarloMajajHong2015Region(region, identifier_metric_suffix,
similarity_metric, ceiler):
assembly_repetition = LazyLoad(lambda region=region: load_assembly(
average_repetitions=False, region=region))
assembly = LazyLoad(lambda region=region: load_assembly(
average_repetitions=True, region=region))
return NeuralBenchmark(
identifier=f'dicarlo.MajajHong2015.{region}-{identifier_metric_suffix}',
version=3,
assembly=assembly,
similarity_metric=similarity_metric,
visual_degrees=VISUAL_DEGREES,
number_of_trials=NUMBER_OF_TRIALS,
ceiling_func=lambda: ceiler(assembly_repetition),
parent=region,
paper_link='http://www.jneurosci.org/content/35/39/13402.short')
def __init__(self):
super(RajalinghamMatchtosamplePublicBenchmark,
self).__init__(metric=I2n(), metric_identifier='i2n')
self._assembly = LazyLoad(
lambda: load_rajalingham2018(access='public'))
self._ceiling_func = lambda: self._metric.ceiling(self._assembly,
skipna=True)
def __init__(self, base_model_pool, model_layers, reload=True):
super(MLBrainPool, self).__init__(reload)
self.reload = True
for basemodel_identifier, activations_model in base_model_pool.items():
if basemodel_identifier not in model_layers:
warnings.warn(
f"{basemodel_identifier} not found in model_layers")
continue
layers = model_layers[basemodel_identifier]
from model_tools.brain_transformation import ModelCommitment
# enforce early parameter binding: https://stackoverflow.com/a/3431699/2225200
def load(identifier=basemodel_identifier,
activations_model=activations_model,
layers=layers):
assert hasattr(activations_model, 'reload')
activations_model.reload()
brain_model = ModelCommitment(
identifier=identifier,
activations_model=activations_model,
layers=layers)
return brain_model
self[basemodel_identifier] = LazyLoad(load)
def __init__(self, identifier, metric, data_version='base'):
self._identifier = identifier
self._data_version = data_version
self._target_assembly = LazyLoad(lambda: self._load_assembly(version=self._data_version))
self._single_metric = metric
self._ceiler = self.PereiraExtrapolationCeiling(subject_column='subject', num_bootstraps=100)
self._cross = CartesianProduct(dividers=['experiment', 'atlas'])
def __init__(self,
identifier,
split_coord='word',
unique_split_values=False):
self._logger = logging.getLogger(fullname(self))
self._identifier = identifier
assembly = LazyLoad(self._load_assembly)
self._target_assembly = assembly
regression = linear_regression(xarray_kwargs=dict(
stimulus_coord='word_id',
neuroid_coord='subject_id')) # used for sorting -- keep at word_id
correlation = pearsonr_correlation(xarray_kwargs=dict(
correlation_coord='word_id',
neuroid_coord='subject_id')) # used for sorting -- keep at word_id
self._metric = CrossRegressedCorrelation(
regression=regression,
correlation=correlation,
crossvalidation_kwargs=dict(
splits=5,
kfold=True,
split_coord=split_coord,
stratification_coord='sentence_id',
unique_split_values=unique_split_values))
self._cross_subject = CartesianProduct(dividers=['subject_id'])
self._ceiler = self.ManySubjectExtrapolationCeiling(
subject_column='subject_id')
def _MovshonFreemanZiemba2013Region(region, identifier_metric_suffix,
similarity_metric, ceiler):
assembly_repetition = LazyLoad(
lambda region=region: load_assembly(False, region=region))
assembly = LazyLoad(
lambda region=region: load_assembly(True, region=region))
return NeuralBenchmark(
identifier=
f'movshon.FreemanZiemba2013.{region}-{identifier_metric_suffix}',
version=2,
assembly=assembly,
similarity_metric=similarity_metric,
parent=region,
ceiling_func=lambda: ceiler(assembly_repetition),
visual_degrees=VISUAL_DEGREES,
number_of_trials=NUMBER_OF_TRIALS,
bibtex=BIBTEX)
def __init__(self, identifier, metric):
self._identifier = identifier
assembly = LazyLoad(self.load_assembly)
self._target_assembly = assembly
self._metric = metric
self._average_sentence = False
self._ceiler = ExtrapolationCeiling(subject_column='subject_UID')
self._electrode_ceiler = self.ElectrodeExtrapolation(subject_column='subject_UID')
def _standard_benchmark(identifier, load_assembly, stratification_coord):
assembly_repetition = LazyLoad(
lambda: load_assembly(average_repetitions=False))
assembly = LazyLoad(lambda: load_assembly(average_repetitions=True))
similarity_metric = CrossRegressedCorrelation(
regression=pls_regression(),
correlation=pearsonr_correlation(),
crossvalidation_kwargs=dict(stratification_coord=stratification_coord))
ceiler = InternalConsistency()
return NeuralBenchmark(
identifier=f"{identifier}-pls",
version=1,
assembly=assembly,
similarity_metric=similarity_metric,
ceiling_func=lambda: ceiler(assembly_repetition),
parent=None,
paper_link='http://www.jneurosci.org/content/35/39/13402.short')
def _engineering_benchmark_pool():
"""
Additional engineering (ML) benchmarks. These benchmarks are public, but are also be evaluated for the website.
"""
pool = {}
from .imagenet import Imagenet2012
pool['fei-fei.Deng2009-top1'] = LazyLoad(Imagenet2012)
from .imagenet_c import Imagenet_C_Noise, Imagenet_C_Blur, Imagenet_C_Weather, Imagenet_C_Digital
pool['dietterich.Hendrycks2019-noise-top1'] = LazyLoad(Imagenet_C_Noise)
pool['dietterich.Hendrycks2019-blur-top1'] = LazyLoad(Imagenet_C_Blur)
pool['dietterich.Hendrycks2019-weather-top1'] = LazyLoad(
Imagenet_C_Weather)
pool['dietterich.Hendrycks2019-digital-top1'] = LazyLoad(
Imagenet_C_Digital)
return pool
def _engineering_benchmark_pool():
"""
Additional engineering (ML) benchmarks. These benchmarks are public, but are also be evaluated for the website.
"""
pool = {}
from .imagenet import Imagenet2012
pool['fei-fei.Deng2009-top1'] = LazyLoad(Imagenet2012)
return pool
def __init__(self):
super(VOneCORnetBrainPool, self).__init__(reload=True)
model_pool = {
'VOneCORnet-S': LazyLoad(vonecornet_s_brainmodel),
}
self._accessed_brain_models = []
for identifier, brain_model in model_pool.items():
self[identifier] = brain_model
def __init__(self):
self._metric = I2n()
self._fitting_stimuli = brainscore.get_stimulus_set('dicarlo.objectome.public')
self._assembly = LazyLoad(lambda: load_assembly('private'))
self._visual_degrees = 8
self._number_of_trials = 2
super(DicarloRajalingham2018I2n, self).__init__(
identifier='dicarlo.Rajalingham2018-i2n', version=2,
ceiling_func=lambda: self._metric.ceiling(self._assembly),
parent='behavior',
bibtex=BIBTEX)
def layer_candidate(self, model_name, layer, region, pca_components: Union[None, int] = 1000):
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
return LazyLoad(load) # lazy-load to avoid loading all models right away
def _public_benchmark_pool():
"""
Benchmarks that are publicly usable, but are not used for the website.
"""
pool = {}
# neural benchmarks
from .public_benchmarks import FreemanZiembaV1PublicBenchmark, FreemanZiembaV2PublicBenchmark, \
MajajV4PublicBenchmark, MajajITPublicBenchmark
pool['movshon.FreemanZiemba2013public.V1-pls'] = LazyLoad(
FreemanZiembaV1PublicBenchmark)
pool['movshon.FreemanZiemba2013public.V2-pls'] = LazyLoad(
FreemanZiembaV2PublicBenchmark)
pool['dicarlo.Majaj2015public.V4-pls'] = LazyLoad(MajajV4PublicBenchmark)
pool['dicarlo.Majaj2015public.IT-pls'] = LazyLoad(MajajITPublicBenchmark)
# behavioral benchmarks
from .public_benchmarks import RajalinghamMatchtosamplePublicBenchmark
pool['dicarlo.Rajalingham2018public-i2n'] = LazyLoad(
RajalinghamMatchtosamplePublicBenchmark)
return pool
def __init__(self):
super(VOneNetModelPool, self).__init__(reload=True)
_key_functions = {
'voneresnet-50': lambda: voneresnet(model_name='resnet50'),
'voneresnet-50-robust': lambda: voneresnet(model_name='resnet50_at'),
'voneresnet-50-non_stochastic': lambda: voneresnet(model_name='resnet50_ns'),
}
# instantiate models with LazyLoad wrapper
for identifier, function in _key_functions.items():
self[identifier] = LazyLoad(function)
def __init__(self):
self._metric = I2n()
self._fitting_stimuli = brainscore.get_stimulus_set(
'dicarlo.objectome.public')
self._assembly = LazyLoad(lambda: load_assembly('private'))
super(DicarloRajalingham2018I2n, self).__init__(
identifier='dicarlo.Rajalingham2018-i2n',
version=2,
ceiling_func=lambda: self._metric.ceiling(self._assembly),
parent='behavior',
paper_link='https://www.biorxiv.org/content/early/2018/02/12/240614'
)
def __init__(self, identifier, bold_shift=4):
self._identifier = identifier
assembly = LazyLoad(lambda: self._load_assembly(bold_shift))
self._target_assembly = assembly
regression = linear_regression(xarray_kwargs=dict(
stimulus_coord='stimulus_id', neuroid_coord='neuroid_id'))
correlation = pearsonr_correlation(xarray_kwargs=dict(
correlation_coord='stimulus_id', neuroid_coord='neuroid_id'))
self._metric = CrossRegressedCorrelation(
regression=regression, correlation=correlation,
crossvalidation_kwargs=dict(splits=5, kfold=True, split_coord='stimulus_id', stratification_coord='story'))
self._ceiler = ExtrapolationCeiling(subject_column='subject_UID', post_process=self.post_process_ceilings)
def load_single_layer_models():
model = cornet_s_brainmodel('base', True).activations_model._model
layer_number = 0
for name, m in model.named_modules():
if type(m) == nn.Conv2d:
layer_number = layer_number + 1
brain_models[f'CORnet-S_norm_dist_L{layer_number}'] = LazyLoad(
lambda layer_number=layer_number: cornet_s_brainmodel(f'norm_dist_L{layer_number}', True,
function=apply_norm_dist, config=[layer_number],
type='model'))
brain_models[f'CORnet-S_jumbler_L{layer_number}'] = LazyLoad(
lambda layer_number=layer_number: cornet_s_brainmodel(f'jumbler_L{layer_number}', True,
function=apply_all_jumbler, config=[layer_number],
type='model'))
brain_models[f'CORnet-S_fixed_value_L{layer_number}'] = LazyLoad(
lambda layer_number=layer_number: cornet_s_brainmodel(f'fixed_value_L{layer_number}', True,
function=apply_fixed_value, config=[layer_number],
type='model'))
brain_models[f'CORnet-S_fixed_value_small_L{layer_number}'] = LazyLoad(
lambda layer_number=layer_number: cornet_s_brainmodel(f'fixed_value_small_L{layer_number}', True,
function=apply_fixed_value_small,
config=[layer_number],
type='model'))
def __init__(self, identifier):
self._logger = logging.getLogger(fullname(self))
self._identifier = identifier
assembly = LazyLoad(self._load_assembly)
self._target_assembly = assembly
regression = linear_regression(xarray_kwargs=dict(
stimulus_coord='word_id', neuroid_coord='subject_id'))
correlation = pearsonr_correlation(xarray_kwargs=dict(
correlation_coord='word_id', neuroid_coord='subject_id'))
self._metric = CrossRegressedCorrelation(
regression=regression,
correlation=correlation,
crossvalidation_kwargs=dict(splits=5,
kfold=True,
split_coord='word_id',
stratification_coord='sentence_id'))
def get_ml_pool(test_models, module, submission):
ml_brain_pool = {}
if submission.model_type == 'BaseModel':
logger.info(f"Start working with base models")
layers = {}
base_model_pool = {}
for model in test_models:
function = lambda model_inst=model.name: module.get_model(model_inst)
base_model_pool[model.name] = LazyLoad(function)
try:
layers[model.name] = module.get_layers(model.name)
except Exception:
logging.warning(f'Could not retrieve layer for model {model} -- skipping model')
model_layers = ModelLayers(layers)
ml_brain_pool = MLBrainPool(base_model_pool, model_layers)
else:
logger.info(f"Start working with brain models")
for model in test_models:
ml_brain_pool[model.name] = module.get_model(model.name)
return ml_brain_pool
def AruCichy2019RDM():
assembly = LazyLoad(lambda: load_assembly(average_repetitions=False))
similarity_metric = RDMCrossValidated(crossvalidation_kwargs=dict(
stratification_coord=None))
ceiler = RDMConsistency()
ceiling = Score([1, np.nan],
coords={'aggregation': ['center', 'error']},
dims=['aggregation'])
return RDMBenchmark(identifier=f'aru.Cichy2019-rdm',
version=1,
assembly=assembly,
similarity_metric=similarity_metric,
visual_degrees=VISUAL_DEGREES,
ceiling_func=lambda: ceiling,
parent='Kamila',
number_of_trials=1,
region='IT',
time_bins=[(62.5, 156.2)])
def __init__(self):
super(BaseModelPool, self).__init__()
self._accessed_base_models = set()
self._key_functions = {}
for model in ['alexnet', 'densenet169', 'resnet101']:
model_func = getattr(model_file, model)
self.add_model_to_maps(
model, '', lambda bound_func=model_func: bound_func('', True))
self.add_model_to_maps(
model,
'_random',
lambda bound_func=model_func: bound_func('random', False))
self.add_model_to_maps(model,
'_norm_dist',
lambda bound_func=model_func: bound_func(
'norm_dist', True, apply_norm_dist))
self.add_model_to_maps(model,
'_jumbler',
lambda bound_func=model_func: bound_func(
'jumbler', True, apply_all_jumbler))
self.add_model_to_maps(
model,
'_kernel_jumbler',
lambda bound_func=model_func: bound_func(
'kernel_jumbler', True, apply_in_kernel_jumbler))
self.add_model_to_maps(
model,
'_channel_jumbler',
lambda bound_func=model_func: bound_func(
'channel_jumbler', True, apply_channel_jumbler))
self.add_model_to_maps(
model,
'_norm_dist_kernel',
lambda bound_func=model_func: bound_func(
'norm_dist_kernel', True, apply_norm_dist_kernel))
for identifier, function in self._key_functions.items():
self[identifier] = LazyLoad(function)
def __init__(self, base_model_pool, model_layers, reload=True):
super(VOneNetBrainPool, self).__init__(reload)
self.reload = True
for basemodel_identifier, activations_model in base_model_pool.items():
if basemodel_identifier not in model_layers:
warnings.warn(
f"{basemodel_identifier} not found in model_layers")
continue
model_layer = model_layers[basemodel_identifier]
def load(identifier=basemodel_identifier,
activations_model=activations_model,
layers=model_layer):
assert hasattr(activations_model, 'reload')
activations_model.reload()
brain_model = get_vonenet_commitment(
identifier=identifier,
activations_model=activations_model,
layers=layers,
stochastic=STOCHASTIC_MODELS[identifier])
return brain_model
self[basemodel_identifier] = LazyLoad(load)
def _evaluation_benchmark_pool():
""""
Standard benchmarks that are evaluated for the website.
"""
pool = {}
# neural benchmarks
from .majaj2015 import DicarloMajaj2015V4PLS, DicarloMajaj2015ITPLS
pool['dicarlo.Majaj2015.V4-pls'] = LazyLoad(DicarloMajaj2015V4PLS)
pool['dicarlo.Majaj2015.IT-pls'] = LazyLoad(DicarloMajaj2015ITPLS)
from .freemanziemba2013 import MovshonFreemanZiemba2013V1PLS, MovshonFreemanZiemba2013V2PLS
pool['movshon.FreemanZiemba2013.V1-pls'] = LazyLoad(
MovshonFreemanZiemba2013V1PLS)
pool['movshon.FreemanZiemba2013.V2-pls'] = LazyLoad(
MovshonFreemanZiemba2013V2PLS)
from .kar2019 import DicarloKar2019OST
pool['dicarlo.Kar2019-ost'] = LazyLoad(DicarloKar2019OST)
# behavioral benchmarks
from .rajalingham2018 import DicarloRajalingham2018I2n
pool['dicarlo.Rajalingham2018-i2n'] = LazyLoad(DicarloRajalingham2018I2n)
return pool
def __init__(self, input_size=None):
super(BaseModelPool, self).__init__(reload=True)
_key_functions = {
'alexnet':
lambda: pytorch_model('alexnet',
image_size=224
if input_size == None else input_size),
'squeezenet1_0':
lambda: pytorch_model('squeezenet1_0',
image_size=224
if input_size == None else input_size),
'squeezenet1_1':
lambda: pytorch_model('squeezenet1_1',
image_size=224
if input_size == None else input_size),
'resnet-18':
lambda: pytorch_model('resnet18',
image_size=224
if input_size == None else input_size),
'resnet-34':
lambda: pytorch_model('resnet34',
image_size=224
if input_size == None else input_size),
'resnet-50-pytorch':
lambda: pytorch_model('resnet50',
image_size=224
if input_size == None else input_size),
'resnet-50-robust':
lambda: robust_model('resnet50',
image_size=224
if input_size == None else input_size),
'vgg-16':
lambda: keras_model('vgg16',
'VGG16',
image_size=224
if input_size == None else input_size),
'vgg-19':
lambda: keras_model('vgg19',
'VGG19',
image_size=224
if input_size == None else input_size),
'vggface':
vggface,
'xception':
lambda: keras_model('xception',
'Xception',
image_size=299
if input_size == None else input_size),
'densenet-121':
lambda: keras_model('densenet',
'DenseNet121',
image_size=224
if input_size == None else input_size),
'densenet-169':
lambda: keras_model('densenet',
'DenseNet169',
image_size=224
if input_size == None else input_size),
'densenet-201':
lambda: keras_model('densenet',
'DenseNet201',
image_size=224
if input_size == None else input_size),
'inception_v1':
lambda: TFSlimModel.init('inception_v1',
preprocessing_type='inception',
image_size=224
if input_size == None else input_size),
'inception_v2':
lambda: TFSlimModel.init('inception_v2',
preprocessing_type='inception',
image_size=224
if input_size == None else input_size),
'inception_v3':
lambda: TFSlimModel.init('inception_v3',
preprocessing_type='inception',
image_size=299
if input_size == None else input_size),
'inception_v4':
lambda: TFSlimModel.init('inception_v4',
preprocessing_type='inception',
image_size=299
if input_size == None else input_size),
'inception_resnet_v2':
lambda: TFSlimModel.init('inception_resnet_v2',
preprocessing_type='inception',
image_size=299
if input_size == None else input_size),
'resnet-50_v1':
lambda: TFSlimModel.init('resnet-50_v1',
net_name='resnet_v1_50',
preprocessing_type='vgg',
image_size=224
if input_size == None else input_size,
labels_offset=0),
'resnet-101_v1':
lambda: TFSlimModel.init('resnet-101_v1',
net_name='resnet_v1_101',
preprocessing_type='vgg',
image_size=224
if input_size == None else input_size,
labels_offset=0),
'resnet-152_v1':
lambda: TFSlimModel.init('resnet-152_v1',
net_name='resnet_v1_152',
preprocessing_type='vgg',
image_size=224
if input_size == None else input_size,
labels_offset=0),
# image_size is 299 for resnet-v2, this is a bug in tf-slim.
# see https://github.com/tensorflow/models/tree/8b18491b26e4b8271db757a3245008882ea112b3/research/slim:
# "ResNet V2 models use Inception pre-processing and input image size of 299"
'resnet-50_v2':
lambda: TFSlimModel.init('resnet-50_v2',
net_name='resnet_v2_50',
preprocessing_type='inception',
image_size=299
if input_size == None else input_size),
'resnet-101_v2':
lambda: TFSlimModel.init('resnet-101_v2',
net_name='resnet_v2_101',
preprocessing_type='inception',
image_size=299
if input_size == None else input_size),
'resnet-152_v2':
lambda: TFSlimModel.init('resnet-152_v2',
net_name='resnet_v2_152',
preprocessing_type='inception',
image_size=299
if input_size == None else input_size),
'nasnet_mobile':
lambda: TFSlimModel.init('nasnet_mobile',
preprocessing_type='inception',
image_size=331
if input_size == None else input_size),
'nasnet_large':
lambda: TFSlimModel.init('nasnet_large',
preprocessing_type='inception',
image_size=331
if input_size == None else input_size),
'pnasnet_large':
lambda: TFSlimModel.init('pnasnet_large',
preprocessing_type='inception',
image_size=331
if input_size == None else input_size),
'bagnet9':
lambda: bagnet("bagnet9"),
'bagnet17':
lambda: bagnet("bagnet17"),
'bagnet33':
lambda: bagnet("bagnet33"),
'resnet50-SIN':
lambda: texture_vs_shape(model_identifier='resnet50-SIN',
model_name='resnet50_trained_on_SIN'),
'resnet50-SIN_IN':
lambda: texture_vs_shape(model_identifier='resnet50-SIN_IN',
model_name=
'resnet50_trained_on_SIN_and_IN'),
'resnet50-SIN_IN_IN':
lambda: texture_vs_shape(
model_identifier='resnet50-SIN_IN_IN',
model_name=
'resnet50_trained_on_SIN_and_IN_then_finetuned_on_IN'),
'resnext101_32x8d_wsl':
lambda: wsl(8),
'resnext101_32x16d_wsl':
lambda: wsl(16),
'resnext101_32x32d_wsl':
lambda: wsl(32),
'resnext101_32x48d_wsl':
lambda: wsl(48),
'fixres_resnext101_32x48d_wsl':
lambda: fixres(
'resnext101_32x48d_wsl',
'https://dl.fbaipublicfiles.com/FixRes_data/FixRes_Pretrained_Models/ResNeXt_101_32x48d.pth'
),
'dcgan':
lambda: dcgan("get_discriminator"),
'convrnn_224':
convrnn,
}
# MobileNets
for version, multiplier, image_size in [
# v1
(1, 1.0, 224),
(1, 1.0, 192),
(1, 1.0, 160),
(1, 1.0, 128),
(1, 0.75, 224),
(1, 0.75, 192),
(1, 0.75, 160),
(1, 0.75, 128),
(1, 0.5, 224),
(1, 0.5, 192),
(1, 0.5, 160),
(1, 0.5, 128),
(1, 0.25, 224),
(1, 0.25, 192),
(1, 0.25, 160),
(1, 0.25, 128),
# v2
(2, 1.4, 224),
(2, 1.3, 224),
(2, 1.0, 224),
(2, 1.0, 192),
(2, 1.0, 160),
(2, 1.0, 128),
(2, 1.0, 96),
(2, 0.75, 224),
(2, 0.75, 192),
(2, 0.75, 160),
(2, 0.75, 128),
(2, 0.75, 96),
(2, 0.5, 224),
(2, 0.5, 192),
(2, 0.5, 160),
(2, 0.5, 128),
(2, 0.5, 96),
(2, 0.35, 224),
(2, 0.35, 192),
(2, 0.35, 160),
(2, 0.35, 128),
(2, 0.35, 96),
]:
identifier = f"mobilenet_v{version}_{multiplier}_{image_size}"
if (version == 1 and multiplier
in [.75, .5, .25]) or (version == 2 and multiplier == 1.4):
net_name = f"mobilenet_v{version}_{multiplier * 100:03.0f}"
else:
net_name = f"mobilenet_v{version}"
# arg=arg default value enforces closure:
# https://docs.python.org/3/faq/programming.html#why-do-lambdas-defined-in-a-loop-with-different-values-all-return-the-same-result
_key_functions[identifier] = \
lambda identifier=identifier, image_size=image_size, net_name=net_name, \
multiplier=multiplier: TFSlimModel.init(
identifier, preprocessing_type='inception', image_size=image_size, net_name=net_name,
model_ctr_kwargs={'depth_multiplier': multiplier})
# instantiate models with LazyLoad wrapper
for identifier, function in _key_functions.items():
self[identifier] = LazyLoad(function)