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
