def get_model(cfg): """Get PyTorch model.""" # model = getattr(models, cfg.modelname)(pretrained=False) if cfg.modelname.startswith("/timm/"): model = timm.create_model(cfg.modelname[6:], pretrained=False) elif cfg.modelname.startswith("/torch/"): model = getattr(models, cfg.modelname[7:])(pretrained=False) else: raise RuntimeError("Unknown model source. Use /timm/ or /torch/.") # Changing the last layer according the number of classes lastlayer = list(model._modules)[-1] try: setattr(model, lastlayer, nn.Linear(in_features=getattr(model, lastlayer).in_features, out_features=cfg.NUMCLASSES, bias=True)) except torch.nn.modules.module.ModuleAttributeError: setattr(model, lastlayer, nn.Linear(in_features=getattr(model, lastlayer)[1].in_features, out_features=cfg.NUMCLASSES, bias=True)) cp = torch.load(cfg.chk) if 'model' in cp: model.load_state_dict(cp['model']) else: model.load_state_dict(cp) return model.to(cfg.device)
def __init__(self, num_layers=5, pretrained=True): super().__init__() self.base = timm.create_model( model_name='tf_efficientnet_b{}'.format(num_layers), pretrained=pretrained, in_chans=1, drop_connect_rate=0.2) self.model_name = 'efficientnet-b{}'.format(num_layers) self.in_features = self.base.num_features self.conv_stem = self.base.conv_stem self.bn1 = self.base.bn1 self.act1 = self.base.act1 self.blocks = self.base.blocks self.conv_head = self.base.conv_head self.bn2 = self.base.bn2 self.act2 = self.base.act2 self.global_pool = self.base.global_pool self.fc1 = nn.Linear(self.in_features, 168) ## consonant_diacritic->7 self.fc2 = nn.Linear(self.in_features, 11) ## grapheme_root->168 self.fc3 = nn.Linear(self.in_features, 7) ## vowel_diacritic ->11
def __init__(self, model_name: str, pretrained: bool = True) -> None: super(SETIModel, self).__init__() self.model_name = model_name self.model = timm.create_model(model_name=self.model_name, pretrained=pretrained, in_chans=1) if config.MODEL_NAME.startswith("rexnet"): self.input_fc = self.model.head.fc.in_features self.model.head.fc = nn.Linear(in_features=self.input_fc, out_features=1, bias=True) elif config.MODEL_NAME.startswith("efficientnet"): self.input_fc = self.model.classifier.in_features self.model.classifier = nn.Linear(in_features=self.input_fc, out_features=1, bias=True) elif config.MODEL_NAME.startswith("resnet"): self.input_fc = self.model.fc.in_features self.model.fc = nn.Linear(in_features=self.input_fc, out_features=1, bias=True) else: raise NotImplementedError("Model head has not been modified.")
def createTimmBackbone(model_name, pretrained=True, trainable=False): print('Building Model Backbone for {} model'.format(model_name)) model = timm.create_model(model_name, pretrained=pretrained) final_in_features = 0 if 'efficientnet' in model_name: final_in_features = model.classifier.in_features model.classifier = nn.Identity() model.global_pool = nn.Identity() elif 'nfnet' in model_name: final_in_features = model.head.fc.in_features model.head.fc = nn.Identity() model.head.global_pool = nn.Identity() elif 'swin' in model_name: final_in_features = model.head.in_features model.head = nn.Identity() model.global_pool = nn.Identity() if not trainable: for param in model.parameters(): param.requires_grad = False return model, final_in_features
def model_builder(architecture_name, output=6): if architecture_name.startswith("resnet"): net = eval("models." + architecture_name)(pretrained=True) net.fc = torch.nn.Linear(net.fc.in_features, output) return net elif architecture_name.startswith("efficientnet"): n = int(architecture_name[-1]) net = EfficientNet.from_pretrained(f'efficientnet-b{n}') net._fc = torch.nn.Linear(net._fc.in_features, output) return net elif architecture_name.startswith("densenet"): net = eval("models." + architecture_name)(pretrained=True) net.classifier = torch.nn.Linear(net.classifier.in_features, output) return net elif architecture_name == "vgg19": net = models.vgg19_bn(pretrained=True) net.classifier[6] = torch.nn.Linear(net.classifier[6].in_features, output) return net elif architecture_name == "seresnext": net = timm.create_model('gluon_seresnext101_32x4d', pretrained=True) net.fc = torch.nn.Linear(net.fc.in_features, 6) return net
def __init__(self, name): super(EfficientNet, self).__init__() backbone = timm.create_model( model_name=name, pretrained=False, in_chans=3, ) self.conv_stem = backbone.conv_stem self.bn1 = backbone.bn1 self.act1 = backbone.act1 ### Original blocks ### for i in range(len((backbone.blocks))): setattr(self, "block{}".format(str(i)), backbone.blocks[i]) self.conv_head = backbone.conv_head self.bn2 = backbone.bn2 self.act2 = backbone.act2 self.global_pool = SelectAdaptivePool2d(pool_type="avg") self.num_features = backbone.num_features ### Baseline head ### self.fc = nn.Linear(self.num_features, 7) del backbone
def __init__(self, model_name='resnet200d_320', pretrained=False): super().__init__() self.model = timm.create_model(model_name, pretrained=False) n_features = self.model.fc.in_features self.model.fc = nn.Linear(n_features, CFG.target_size) if pretrained: pretrained_path = '/home/yuki/RANZCR/input/startingpointschestx/resnet200d_320_chestx.pth' # self.model.load_state_dict(torch.load(pretrained_path, map_location=torch.device('cpu'))['model']) checkpoint = torch.load(pretrained_path, map_location='cpu')['model'] for key in list(checkpoint.keys()): if 'model.' in key: checkpoint[key.replace('model.', '')] = checkpoint[key] del checkpoint[key] self.model.load_state_dict(checkpoint) print(f'load {model_name} pretrained model') n_features = self.model.fc.in_features self.model.global_pool = nn.Identity() self.model.fc = nn.Identity() self.pooling = nn.AdaptiveAvgPool2d(1) self.fc = nn.Linear(n_features, CFG.target_size)
def __init__(self, config, pretrained_backbone=True, alternate_init=False): super(EfficientDet, self).__init__() self.config = config set_config_readonly(self.config) self.backbone = create_model( config.backbone_name, features_only=True, out_indices=(2, 3, 4), pretrained=pretrained_backbone, exportable=True, **config.backbone_args) #erase scriptable=True feature_info = get_feature_info(self.backbone) self.fpn = BiFpn(self.config, feature_info) self.class_net = HeadNet(self.config, num_outputs=self.config.num_classes) self.box_net = HeadNet(self.config, num_outputs=4) for n, m in self.named_modules(): if 'backbone' not in n: if alternate_init: _init_weight_alt(m, n) else: _init_weight(m, n)
def test_model_backward(model_name, batch_size): """Run a single forward pass with each model""" input_size = _get_input_size(model_name=model_name, target=TARGET_BWD_SIZE) if max(input_size) > MAX_BWD_SIZE: pytest.skip("Fixed input size model > limit.") model = create_model(model_name, pretrained=False, num_classes=42) num_params = sum([x.numel() for x in model.parameters()]) model.train() inputs = torch.randn((batch_size, *input_size)) outputs = model(inputs) if isinstance(outputs, tuple): outputs = torch.cat(outputs) outputs.mean().backward() for n, x in model.named_parameters(): assert x.grad is not None, f'No gradient for {n}' num_grad = sum( [x.grad.numel() for x in model.parameters() if x.grad is not None]) assert outputs.shape[-1] == 42 assert num_params == num_grad, 'Some parameters are missing gradients' assert not torch.isnan(outputs).any(), 'Output included NaNs'
def __init__(self): super(ResNestMaskClassifier, self).__init__() # get number of backbone feature map feature backbone_pre = timm.create_model('resnest200e', pretrained=True) self.in_features = backbone_pre.fc.in_features # set backbone except original classifier backbone = torch.nn.Sequential(*(list(backbone_pre.children())[:-1])) self.backbone = backbone # set 3heads for mask, gender, age self.mask_layer = self.get_classifier(3) self.gender_layer = self.get_classifier(2) self.age_layer = self.get_classifier(3) # initialize weights with kaiming_normalization in classifier heads self.classifier_layers = [self.mask_layer, self.gender_layer, self.age_layer] for layer in self.classifier_layers: for m in layer.modules(): if isinstance(m, nn.Linear): # lnit dense nn.init.kaiming_normal_(m.weight) nn.init.zeros_(m.bias)
def __init__(self): super(Net, self).__init__() try: # The model is a Vision transformer self.model = timm.create_model('vit_large_patch16_384', pretrained=True) except: print("Failed to load models") raise SystemExit(0) for param in self.model.parameters(): param.requires_grad = False for i in [-1, -2, -3]: for param in self.model.blocks[i].parameters(): param.requires_grad = True self.in_features = self.model.head.in_features self.model.head = nn.Linear(self.in_features, self.in_features // 5) self.dropout = nn.Dropout(0.5) self.relu = nn.ReLU() self.fc = nn.Linear(self.in_features // 5, n_classes)
def __init__(self, name='resnet18', pretrained=True): super(Backbone, self).__init__() self.net = timm.create_model(name, pretrained=pretrained) if 'regnet' in name: self.out_features = self.net.head.fc.in_features elif 'csp' in name: self.out_features = self.net.head.fc.in_features elif 'dm_nfnet' in name: self.out_features = self.net.head.fc.in_features elif 'res' in name: #works also for resnest self.out_features = self.net.fc.in_features elif 'efficientnet' in name: self.out_features = self.net.classifier.in_features elif 'densenet' in name: self.out_features = self.net.classifier.in_features elif 'senet' in name: self.out_features = self.net.fc.in_features elif 'inception' in name: self.out_features = self.net.last_linear.in_features # self.out_features = self.net.fc.in_features else: self.out_features = self.net.classifier.in_features
def test_model_forward_fx_torchscript(model_name, batch_size): """Symbolically trace each model, script it, and run single forward pass""" if not has_fx_feature_extraction: pytest.skip( "Can't test FX. Torch >= 1.10 and Torchvision >= 0.11 are required." ) input_size = _get_input_size(model_name=model_name, target=TARGET_JIT_SIZE) if max(input_size) > MAX_JIT_SIZE: pytest.skip("Fixed input size model > limit.") with set_scriptable(True): model = create_model(model_name, pretrained=False) model.eval() model = torch.jit.script(_create_fx_model(model)) with torch.no_grad(): outputs = tuple(model(torch.randn((batch_size, *input_size))).values()) if isinstance(outputs, tuple): outputs = torch.cat(outputs) assert outputs.shape[0] == batch_size assert not torch.isnan(outputs).any(), 'Output included NaNs'
def build_backbone_from_cfg(config) -> Tuple[torch.nn.Module, int]: args = config.copy() backbone_type_name = args.pop('type') if hasattr(Backbones, backbone_type_name): backbone = getattr(Backbones, backbone_type_name)(**args) output_channels = backbone.output_channels elif backbone_type_name in pretrainedmodels.__dict__: backbone = pretrainedmodels.__dict__[backbone_type_name](**args) if 'squeezenet' in backbone_type_name: backbone = backbone.features output_channels = 512 else: backbone.forward = backbone.features output_channels = backbone.last_linear.in_features elif backbone_type_name in timm.list_models(): backbone = timm.create_model(backbone_type_name, **args) backbone.forward = backbone.forward_features output_channels = backbone.classifier.in_features else: assert False, f'{backbone_type_name} not found in backbones factory' return backbone, output_channels
def vit16(pretrained: bool = False, num_classes: int = 1000) -> nn.Module: """ViT-Base (ViT-B/16) from original paper. This function just call function in timm repo https://github.com/rwightman/pytorch-image-models (Apache License 2.0). Note: The main params to create Vision Transformer is shown in below. - patch_size = 16 - embed_dim = 768 - depth = 12 - num_heads = 12 Args: pretrained (bool, optional): If pretrained is True, this function downloads and loads pretrained model of ImageNet-1k. num_classes (int, optional): The number of class. Returns: nn.Module: Vision Transformer model. """ return timm.create_model("vit_base_patch16_224", pretrained=pretrained, num_classes=num_classes)
def __init__(self, config, norm_kwargs=None, pretrained_backbone=True, alternate_init=False): super(EfficientDet, self).__init__() norm_kwargs = norm_kwargs or dict(eps=.001, momentum=.01) self.backbone = create_model(config.backbone_name, features_only=True, out_indices=(2, 3, 4), pretrained=pretrained_backbone, **config.backbone_args) feature_info = [ dict(num_chs=f['num_chs'], reduction=f['reduction']) for i, f in enumerate(self.backbone.feature_info()) ] act_layer = get_act_layer(config.act_type) self.fpn = BiFpn(config, feature_info, norm_kwargs=norm_kwargs, act_layer=act_layer) self.class_net = HeadNet(config, num_outputs=config.num_classes, norm_kwargs=norm_kwargs, act_layer=act_layer) self.box_net = HeadNet(config, num_outputs=4, norm_kwargs=norm_kwargs, act_layer=act_layer) for n, m in self.named_modules(): if 'backbone' not in n: if alternate_init: _init_weight_alt(m, n) else: _init_weight(m, n)
def __init__(self, model_name="tf_efficientnet_b5", num_classes=1108, n_channels=6, weight=None): super(MixNet, self).__init__() self.model = timm.create_model(model_name=model_name, pretrained=True, num_classes=31) conv1 = self.model.conv_stem self.model.conv_stem = nn.Conv2d(in_channels=n_channels, out_channels=conv1.out_channels, kernel_size=conv1.kernel_size, stride=conv1.stride, padding=conv1.padding, bias=conv1.bias) # copy pretrained weights self.model.conv_stem.weight.data[:, :3, :, :] = conv1.weight.data self.model.conv_stem.weight.data[:, 3: n_channels, :, :] = conv1.weight.data[:, :int( n_channels - 3), :, :] if weight: model_state_dict = torch.load(weight)['model_state_dict'] new_model_state_dict = {} for k, v in model_state_dict.items(): new_model_state_dict[k[6:]] = v self.model.load_state_dict(new_model_state_dict) print( f"\n\n******************************* Loaded checkpoint {weight}" ) in_features = self.model.classifier.in_features self.model.classifier = nn.Linear(in_features=in_features, out_features=num_classes)
def __init__(self, n_classes=CFG.classes, model_name=CFG.model_name, fc_dim=CFG.fc_dim, margin=CFG.margin, scale=CFG.scale, pooling='GeM', args_pooling: dict = {}, use_fc=True, pretrained=True): super(ShopeeModel, self).__init__() print('Building Model Backbone for {} model'.format(model_name)) self.backbone = timm.create_model(model_name, pretrained=pretrained) in_features = self.backbone.classifier.in_features self.backbone.classifier = nn.Identity() self.backbone.global_pool = nn.Identity() #self.pooling = nn.AdaptiveAvgPool2d(1) #---------- self.pooling = getattr(cirtorch.pooling, pooling)(**args_pooling) #----------- self.use_fc = use_fc if use_fc: self.dropout = nn.Dropout(p=0.1) self.classifier = nn.Linear(in_features, fc_dim) self.bn = nn.BatchNorm1d(fc_dim) self._init_params() in_features = fc_dim self.final = ArcMarginProduct(in_features, n_classes, scale=scale, margin=margin, easy_margin=False, ls_eps=0.0)
def __init__( self, arch: str, pretrained: bool, lr: float, weight_decay: int, data_path: str, batch_size: int, workers: int, **kwargs, ): super().__init__() self.save_hyperparameters() self.arch = arch self.pretrained = pretrained self.lr = lr self.weight_decay = weight_decay self.data_path = data_path self.batch_size = batch_size self.workers = workers if self.arch == "tiny": # Tiny empty model for development purposes. img_size = [32, 32] self.model_cfg = _cfg(input_size=[3] + img_size) self.model = VisionTransformer(img_size=img_size, patch_size=4, in_chans=3, num_classes=1000, embed_dim=16, depth=2, num_heads=1) else: self.model: VisionTransformer = timm.create_model( self.arch, pretrained=self.pretrained) self.model_cfg = vision_transformer.default_cfgs[self.arch] # TODO: delete me. Hack so that auto_lr_find works self.model.reset_classifier(10)
def __init__(self, args): super(CNN_Image_Encoder, self).__init__() self.cnn = timm.create_model('resnet152', pretrained=args.image_enc_pre_trained, num_classes=0) self.transform = torchvision.transforms.Compose( [ torchvision.transforms.Resize(256), torchvision.transforms.CenterCrop(224), torchvision.transforms.ToTensor(), torchvision.transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ] ) if args.image_enc_pre_trained is True else torchvision.transforms.Compose( [ torchvision.transforms.Resize(256), torchvision.transforms.CenterCrop(224), torchvision.transforms.ToTensor(), torchvision.transforms.Normalize([0.500, 0.500, 0.500], [0.500, 0.500, 0.500]) ]) for para in self.cnn.parameters(): assert para.requires_grad is True
def __init__(self, args): super().__init__() model_list = list() model_list.append(nn.Conv2d(1, 3, 1)) model = timm.create_model(args.model, pretrained=args.pretrained, num_classes=512) model_list.append(model) model = nn.Sequential(*model_list) self.dropout = nn.Dropout(0.5) self.dropouts = nn.ModuleList([nn.Dropout(0.5) for _ in range(5)]) self.model = model str_model = nn.Sequential( nn.Linear(4, 512), nn.BatchNorm1d(512), nn.ReLU(), Swish_module(), nn.Dropout(p=0.3), nn.Linear(512, 128), nn.BatchNorm1d(128), Swish_module(), ) self.str_model = str_model self.output_layer = nn.Linear(512 + 128, args.num_classes)
def test_model_default_cfgs(model_name, batch_size): """Run a single forward pass with each model""" model = create_model(model_name, pretrained=False) model.eval() state_dict = model.state_dict() cfg = model.default_cfg classifier = cfg['classifier'] first_conv = cfg['first_conv'] pool_size = cfg['pool_size'] input_size = model.default_cfg['input_size'] if all([x <= MAX_FWD_FEAT_SIZE for x in input_size]) and \ not any([fnmatch.fnmatch(model_name, x) for x in EXCLUDE_FILTERS]): # pool size only checked if default res <= 448 * 448 to keep resource down input_size = tuple([min(x, MAX_FWD_FEAT_SIZE) for x in input_size]) outputs = model.forward_features(torch.randn( (batch_size, *input_size))) assert outputs.shape[-1] == pool_size[-1] and outputs.shape[ -2] == pool_size[-2] assert any([k.startswith(classifier) for k in state_dict.keys() ]), f'{classifier} not in model params' assert any([k.startswith(first_conv) for k in state_dict.keys() ]), f'{first_conv} not in model params'
def test_model_forward_features(model_name, batch_size): """Run a single forward pass with each model in feature extraction mode""" model = create_model(model_name, pretrained=False, features_only=True) model.eval() expected_channels = model.feature_info.channels() assert len( expected_channels ) >= 4 # all models here should have at least 4 feature levels by default, some 5 or 6 if has_model_default_key(model_name, 'fixed_input_size'): input_size = get_model_default_value(model_name, 'input_size') elif has_model_default_key(model_name, 'min_input_size'): input_size = get_model_default_value(model_name, 'min_input_size') else: input_size = ( 3, 96, 96 ) # jit compile is already a bit slow and we've tested normal res already... outputs = model(torch.randn((batch_size, *input_size))) assert len(expected_channels) == len(outputs) for e, o in zip(expected_channels, outputs): assert e == o.shape[1] assert o.shape[0] == batch_size assert not torch.isnan(o).any()
def __init__(self): super(backboneNet_efficient, self).__init__() net = timm.create_model('tf_efficientnet_b4', pretrained=True) layers_to_train = ['conv_head', 'block6', 'block5', 'block4', 'block3', 'block2' 'block1', 'block0', 'conv_stem'][:4] for name, parameter in net.named_parameters(): if all([not name.startswith(layer) for layer in layers_to_train]): parameter.requires_grad_(False) self.conv_stem = net.conv_stem self.bn1 = net.bn1 self.act1 = net.act1 self.block0 = net.blocks[0] self.block1 = net.blocks[1] self.block2 = net.blocks[2] self.block3 = net.blocks[3] self.block4 = net.blocks[4] self.block5 = net.blocks[5] self.block6 = net.blocks[6] self.conv_head = net.conv_head self.bn2 = net.bn2 self.act2 = net.act2
def __init__(self, model_name, pretrained=False, dropout_cls = None, pooling_type='avg', **kwargs): super().__init__(**kwargs) assert self.is_classification(), f"{model_name} model is adapted for classification tasks only" self.pretrained = pretrained self.is_mobilenet = True if model_name in ["mobilenetv3_large_100_miil_in21k", "mobilenetv3_large_100_miil"] else False self.model = timm.create_model(model_name, pretrained=pretrained, num_classes=self.num_classes) self.num_head_features = self.model.num_features self.num_features = (self.model.conv_head.in_channels if self.is_mobilenet else self.model.num_features) self.dropout = Dropout(**dropout_cls) self.pooling_type = pooling_type if self.loss in ["am_softmax", "am_binary"]: self.model.act2 = nn.PReLU() self.classifier = AngleSimpleLinear(self.num_head_features, self.num_classes) else: assert self.loss in ["softmax", "asl", "bce"] self.classifier = self.model.get_classifier()
def __init__(self, normalize_attn=False): super().__init__() # self.backbone = timm.create_model(model_name, pretrained=True) self.resnest = torch.hub.load('zhanghang1989/ResNeSt', 'resnest50_fast_1s1x64d', pretrained=True) self.effnet = timm.create_model('tf_efficientnet_b4', pretrained=True) self.in_features = 2048 self.eff_conv = nn.Conv2d(1792, 2048, (1, 1)) self.head_res = Head(self.in_features, 2, activation='mish', use_meta=False) self.head_eff = Head(self.in_features, 2, activation='mish', use_meta=False) self.relu = Mish() self.maxpool = GeM() self.res_attn1 = AttentionBlock(256, 1024, 512, 4, normalize_attn=normalize_attn) self.res_attn2 = AttentionBlock(512, 1024, 512, 2, normalize_attn=normalize_attn) self.eff_attn = AttentionBlock(2048, 2048, 512, 1, normalize_attn=normalize_attn) self.output1 = nn.Linear(2820, 128) self.output = nn.Linear(128, 2)
def __init__( self, out_features: int, model_config: ModelConfig, met_config: MetricLearningConfig, pooling_config: PoolingConfig, ): super(ShopeeImgNet3, self).__init__() self.model_config = model_config channel_size = model_config.channel_size self.backbone = timm.create_model(model_config.model_arch, pretrained=model_config.pretrained) if "resnext" in model_config.model_arch or "resnet" in model_config.model_arch: final_in_features = self.backbone.fc.in_features elif "vit" in model_config.model_arch: final_in_features = self.backbone.head.in_features else: final_in_features = self.backbone.classifier.in_features self.backbone = nn.Sequential(*list(self.backbone.children())[:-2]) self.pooling = PoolingFactory.get_pooling(pooling_config) self.dropout = nn.Dropout(p=model_config.dropout) if "vit" in model_config.model_arch: self.bn1 = nn.BatchNorm1d(final_in_features) else: self.bn1 = nn.BatchNorm2d(final_in_features) self.fc = nn.Linear(final_in_features, channel_size) self.bn2 = nn.BatchNorm1d(channel_size) self.margin = MetricLearningFactory.get_metric_learning_product( met_config, in_features=channel_size, out_features=out_features, ) self._init_params()
def __init__(self, name="mobilenetv2_100",num_classes=21,pretrained="", pretrained_backbone=True,sc=False,filter_multiplier=1.0): super(Deeplab3P,self).__init__() output_stride = 16 num_filters = int(256*filter_multiplier) num_low_filters = int(48*filter_multiplier) try: self.backbone=timm.create_model(name, features_only=True, output_stride=output_stride, out_indices=(1, 4),pretrained=pretrained_backbone and pretrained =="") except RuntimeError: print("no model") print(timm.list_models()) raise RuntimeError() channels=self.backbone.feature_info.channels() self.head16=get_ASSP(channels[1], output_stride,num_filters) self.head4=torch.nn.Sequential( nn.Conv2d(channels[0], num_low_filters, 1, bias=False), nn.BatchNorm2d(num_low_filters), nn.ReLU(inplace=True)) self.decoder= nn.Sequential( nn.Conv2d(num_low_filters+num_filters, num_filters, 3, padding=1, bias=False), nn.BatchNorm2d(num_filters), nn.ReLU(inplace=True), nn.Conv2d(num_filters, num_filters, 3, padding=1, bias=False), nn.BatchNorm2d(num_filters), nn.ReLU(inplace=True), nn.Conv2d(num_filters, num_classes, 1) ) if sc: self.decoder = convert_to_separable_conv(self.decoder) if pretrained != "": dic = torch.load(pretrained, map_location='cpu') if type(dic)==dict: self.load_state_dict(dic['model']) else: self.load_state_dict(dic)
def __init__(self, pretrained_image_embedor='resnet50', pretrained_text_embedor='bert-base-uncased', output_dim=512): super(EmbedorNN, self).__init__() self.image_embedor = timm.create_model(pretrained_image_embedor, pretrained=True) self.image_pool = nn.AdaptiveAvgPool2d((1, 1)) self.text_embedor = BertModel.from_pretrained(pretrained_text_embedor) self.head = nn.Sequential(nn.Linear(2048 + 768, output_dim), #nn.ReLU(), #nn.Linear(1024, output_dim) ) for m in self.head.modules(): if isinstance(m, nn.Linear): sz = m.weight.data.size(-1) m.weight.data.normal_(mean=0.0, std=1 / np.sqrt(sz)) elif isinstance(m, (nn.LayerNorm, nn.BatchNorm1d)): m.bias.data.zero_() m.weight.data.fill_(1.0) m.bias.data.zero_() if isinstance(m, nn.Linear) and m.bias is not None: m.bias.data.zero_()
def __init__(self): super(backboneNet_efficient, self).__init__() net = timm.create_model( "tf_efficientnet_b7_ns", pretrained=True, norm_layer=FrozenBatchNorm2d, ) layers_to_train = ["blocks"] for name, parameter in net.named_parameters(): if all([not name.startswith(layer) for layer in layers_to_train]): parameter.requires_grad_(False) self.conv_stem = net.conv_stem self.bn1 = net.bn1 self.act1 = net.act1 self.block0 = net.blocks[0].requires_grad_(False) self.block1 = net.blocks[1].requires_grad_(False) self.block2 = net.blocks[2].requires_grad_(False) self.block3 = net.blocks[3] self.block4 = net.blocks[4] self.block5 = net.blocks[5] self.block6 = net.blocks[6] self.conv_head = net.conv_head self.bn2 = net.bn2 self.act2 = net.act2