def __init__(self):
super().__init__()
base_net = resnet.resnet34(pretrained=True)
self.in_block = nn.Sequential(base_net.conv1, base_net.bn1,
base_net.relu, base_net.maxpool)
self.encoder = nn.ModuleList([
base_net.layer1, base_net.layer2, base_net.layer3, base_net.layer4
])
enc_channels = list(reversed([64, 128, 256, 512]))
self.decoder = nn.ModuleList([])
self.lateral = nn.ModuleList([])
for in_channel, out_channel in zip(enc_channels[:-1],
enc_channels[1:]):
d = DecoderBlock(in_channel, out_channel, 3, 2)
l = nn.Sequential(nn.Conv2d(out_channel, 256, 3, padding=1),
nn.BatchNorm2d(256), nn.ReLU(inplace=True))
self.decoder.append(d)
self.lateral.append(l)
self.classifier = nn.ModuleList([
nn.Sequential(nn.Conv2d(256, 256, 3, padding=1),
nn.BatchNorm2d(256), nn.ReLU(inplace=True)),
nn.Sequential(nn.Conv2d(256, 256, 3, padding=1),
nn.BatchNorm2d(256), nn.ReLU(inplace=True)),
nn.Sequential(nn.Conv2d(256, 256, 3, padding=1),
nn.BatchNorm2d(256), nn.ReLU(inplace=True)),
nn.Sequential(nn.Conv2d(256, 256, 3, padding=1),
nn.BatchNorm2d(256), nn.ReLU(inplace=True)),
nn.Conv2d(256, 68, 3, padding=1)
])
def __init__(
self,
num_claasses=28,
pretrained_resnet=True,
sng_args=SNG_ARGS,
qsdf_args=QSDF_ARGS,
):
super().__init__()
self.sng_args = sng_args
self.qsdf_args = qsdf_args
self.num_classes = num_claasses
self.resnet = resnet.resnet34(pretrained=pretrained_resnet)
self.resnet.layer4 = nn.Identity()
self.resnet.avgpool = nn.Identity()
self.resnet.fc = nn.Identity()
self.scene_graph = SceneGraph(**sng_args)
self.reasoning = qs.DifferentiableReasoning(
self._make_vse_concepts(qsdf_args.vse_large_scale,
qsdf_args.vse_known_belong),
self.scene_graph.output_dims,
qsdf_args.vse_hidden_dims,
)
def __init__(self, resnet_layer, pretrained=None):
super(ResNetFPN, self).__init__()
self.lateral_conv1 = nn.Conv2d(2048, 256, kernel_size=1)
self.lateral_conv2 = nn.Conv2d(1024, 256, kernel_size=1)
self.lateral_conv3 = nn.Conv2d(512, 256, kernel_size=1)
self.lateral_conv4 = nn.Conv2d(256, 256, kernel_size=1)
self.anti_aliasing_conv1 = nn.Conv2d(256,
256,
kernel_size=3,
padding=1)
self.anti_aliasing_conv2 = nn.Conv2d(256,
256,
kernel_size=3,
padding=1)
self.anti_aliasing_conv3 = nn.Conv2d(256,
256,
kernel_size=3,
padding=1)
self._init_parameters()
assert resnet_layer in [18, 34, 50, 101, 152]
pretrained = True if pretrained is not None else False
if resnet_layer == 18:
self.resnet = resnet.resnet18(pretrained)
elif resnet_layer == 34:
self.resnet = resnet.resnet34(pretrained)
elif resnet_layer == 50:
self.resnet = resnet.resnet50(pretrained)
elif resnet_layer == 101:
self.resnet = resnet.resnet101(pretrained)
elif resnet_layer == 152:
self.resnet = resnet.resnet152(pretrained)
def __init__(self, backbone='resnet50'):
super().__init__()
if backbone == 'resnet18':
backbone = resnet18(pretrained=True)
self.out_channels = [256, 512, 512, 256, 256, 128]
elif backbone == 'resnet34':
backbone = resnet34(pretrained=True)
self.out_channels = [256, 512, 512, 256, 256, 256]
elif backbone == 'resnet50':
backbone = resnet50(pretrained=True)
self.out_channels = [1024, 512, 512, 256, 256, 256]
elif backbone == 'resnet101':
backbone = resnet101(pretrained=True)
self.out_channels = [1024, 512, 512, 256, 256, 256]
else: # backbone == 'resnet152':
backbone = resnet152(pretrained=True)
self.out_channels = [1024, 512, 512, 256, 256, 256]
self.feature_extractor = nn.Sequential(*list(backbone.children())[:7])
conv4_block1 = self.feature_extractor[-1][0]
conv4_block1.conv1.stride = (1, 1)
conv4_block1.conv2.stride = (1, 1)
conv4_block1.downsample[0].stride = (1, 1)
def __init__(self, name="resnet34", pretrain=True):
super().__init__()
if name == "resnet50":
base_net = resnet.resnet50(pretrained=False)
if pretrain:
print("load the {} weight from ./cache".format(name))
base_net.load_state_dict(model_zoo.load_url(model_urls["resnet50"], model_dir="./cache"))
if name == "resnet34":
base_net = resnet.resnet34(pretrained=False)
if pretrain:
print("load the {} weight from ./cache".format(name))
base_net.load_state_dict(model_zoo.load_url(model_urls["resnet34"], model_dir="./cache"))
self.stage1 = nn.Sequential(
base_net.conv1,
base_net.bn1,
base_net.relu,
base_net.maxpool
)
self.stage2 = base_net.layer1
self.stage3 = base_net.layer2
self.stage4 = base_net.layer3
self.stage5 = base_net.layer4
def __init__(self, mode_name='wide_resnet50_2'):
super(Backbone, self).__init__()
assert mode_name in ('resnet18', 'resnet34', 'resnet50', 'resnet101',
'resnet152', 'resnext50_32x4d',
'resnext101_32x8d', 'wide_resnet50_2',
'wide_resnet101_2')
if mode_name == 'resnet18':
self.res_back_bone = resnet.resnet18()
elif mode_name == 'resnet34':
self.res_back_bone = resnet.resnet34()
elif mode_name == 'resnet50':
self.res_back_bone = resnet.resnet50()
elif mode_name == 'resnet101':
self.res_back_bone = resnet.resnet101()
elif mode_name == 'resnet152':
self.res_back_bone = resnet.resnet152()
elif mode_name == 'resnext50_32x4d':
self.res_back_bone = resnet.resnext50_32x4d()
elif mode_name == 'resnext101_32x8d':
self.res_back_bone = resnet.resnext101_32x8d()
elif mode_name == 'wide_resnet50_2':
self.res_back_bone = resnet.wide_resnet50_2()
else:
self.res_back_bone = resnet.wide_resnet101_2()
self.backbone = nn.Module()
layer0 = nn.Sequential(*list(self.res_back_bone.children())[:4])
self.backbone.add_module('layer0', layer0)
self.backbone.add_module('layer1', self.res_back_bone.layer1)
self.backbone.add_module('layer2', self.res_back_bone.layer2)
self.backbone.add_module('layer3', self.res_back_bone.layer3)
self.backbone.add_module('layer4', self.res_back_bone.layer4)
def __init__(self):
self.resnet = resnet34(pretrained=True)
self.linear = nn.Linear(1000, 3)
self.optimiser = torch.optim.Adam(list(self.resnet.parameters()) +
list(self.linear.parameters()),
lr=.0003,
eps=1e-6)
def resnet34_reid(features=128, classes=1502):
resnet = resnet34(pretrained=True)
resnet.layer4[0].downsample[0].stride = (1, 1)
resnet.layer4[0].conv1.stride = (1, 1)
resnet.fc = None
model = ReIDResnet(resnet, 512, features, classes)
return model
def __init__(
self,
voxel_dimension=(9, 180,
240), # dimension of voxel will be C x 2 x H x W
crop_dimension=(
224, 224), # dimension of crop before it goes into classifier
num_classes=101,
mlp_layers=[1, 30, 30, 1],
activation=nn.LeakyReLU(negative_slope=0.1),
pretrained=True):
nn.Module.__init__(self)
self.quantization_layer = QuantizationLayer(voxel_dimension,
mlp_layers, activation)
self.classifier = resnet34(pretrained=pretrained)
self.crop_dimension = crop_dimension
# replace fc layer and first convolutional layer
input_channels = 2 * voxel_dimension[0]
self.classifier.conv1 = nn.Conv2d(input_channels,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.classifier.fc = nn.Linear(self.classifier.fc.in_features,
num_classes)
def __init__(self, out_channels=64, pretrained=True):
super(UNetResNet34, self).__init__()
self.out_channels = out_channels
# ----------------------------------------------------------------------------- #
# Encoder
# ----------------------------------------------------------------------------- #
net = resnet34(pretrained)
# Note that we do not downsample for conv1
# self.conv1 = net.conv1
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=1, padding=3, bias=False)
self.conv1.weight.data = net.conv1.weight.data
self.bn1 = net.bn1
self.relu = net.relu
self.maxpool = net.maxpool
self.layer1 = net.layer1
self.layer2 = net.layer2
self.layer3 = net.layer3
self.layer4 = net.layer4
# ----------------------------------------------------------------------------- #
# Decoder
# ----------------------------------------------------------------------------- #
_, self.dec_t_conv_stage5 = self.dec_stage(self.layer4, num_concat=1)
self.dec_conv_stage4, self.dec_t_conv_stage4 = self.dec_stage(self.layer3, num_concat=2)
self.dec_conv_stage3, self.dec_t_conv_stage3 = self.dec_stage(self.layer2, num_concat=2)
self.dec_conv_stage2, self.dec_t_conv_stage2 = self.dec_stage(self.layer1, num_concat=2)
self.dec_conv_stage1 = nn.Conv2d(2 * 64, out_channels, kernel_size=3, padding=1)
# dropout
self.dropout = nn.Dropout(p=0.4)
def __init__(self, backbone='resnet50', pretrained_path=None):
super().__init__()
if backbone == 'resnet18':
backbone = resnet18(pretrained=not pretrained_path)
self.final_out_channels = 256
self.low_level_inplanes = 64
elif backbone == 'resnet34':
backbone = resnet34(pretrained=not pretrained_path)
self.final_out_channels = 256
self.low_level_inplanes = 64
elif backbone == 'resnet50':
backbone = resnet50(pretrained=not pretrained_path)
self.final_out_channels = 1024
self.low_level_inplanes = 256
elif backbone == 'resnet101':
backbone = resnet101(pretrained=not pretrained_path)
self.final_out_channels = 1024
self.low_level_inplanes = 256
else: # backbone == 'resnet152':
backbone = resnet152(pretrained=not pretrained_path)
self.final_out_channels = 1024
self.low_level_inplanes = 256
if pretrained_path:
backbone.load_state_dict(torch.load(pretrained_path))
self.early_extractor = nn.Sequential(*list(backbone.children())[:5])
self.later_extractor = nn.Sequential(*list(backbone.children())[5:7])
conv4_block1 = self.later_extractor[-1][0]
conv4_block1.conv1.stride = (1, 1)
conv4_block1.conv2.stride = (1, 1)
conv4_block1.downsample[0].stride = (1, 1)
def __init__(self, backbone="resnet50", backbone_path=None):
super().__init__()
if backbone == "resnet18":
backbone = resnet18(pretrained=not backbone_path)
self.out_channels = [256, 512, 512, 256, 256, 128]
elif backbone == "resnet34":
backbone = resnet34(pretrained=not backbone_path)
self.out_channels = [256, 512, 512, 256, 256, 256]
elif backbone == "resnet50":
backbone = resnet50(pretrained=not backbone_path)
self.out_channels = [1024, 512, 512, 256, 256, 256]
elif backbone == "resnet101":
backbone = resnet101(pretrained=not backbone_path)
self.out_channels = [1024, 512, 512, 256, 256, 256]
else:
backbone = resnet152(pretrained=not backbone_path)
self.out_channels = [1024, 512, 512, 256, 256, 256]
if backbone_path:
backbone.load_state_dict(torch.load(backbone_path))
self.feature_extractor = nn.Sequential(*list(backbone.children())[:7])
conv4_block1 = self.feature_extractor[-1][0]
conv4_block1.conv1.stride = (1, 1)
conv4_block1.conv2.stride = (1, 1)
conv4_block1.downsample[0].stride = (1, 1)
def __init__(self, resnet_layer, pretrained=None):
super(ResNet, self).__init__()
assert resnet_layer in [18, 34, 50, 101, 152]
pretrained = True if pretrained is not None else False
if resnet_layer == 18:
self.resnet = resnet.resnet18(pretrained)
elif resnet_layer == 34:
self.resnet = resnet.resnet34(pretrained)
elif resnet_layer == 50:
self.resnet = resnet.resnet50(pretrained)
elif resnet_layer == 101:
self.resnet = resnet.resnet101(pretrained)
else:
self.resnet = resnet.resnet152(pretrained)
# fix layer grad
for p in self.resnet.conv1.parameters():
p.requires_grad = False
for p in self.resnet.layer1.parameters():
p.requires_grad = False
for p in self.resnet.layer2.parameters():
p.requires_grad = True
for p in self.resnet.layer3.parameters():
p.requires_grad = True
# fix batch norm layer
for m in self.resnet.modules():
if isinstance(m, nn.BatchNorm2d):
for p in m.parameters():
p.requires_grad = False
def __init__(self, backbone='resnet50', backbone_path=None):
super().__init__()
if backbone == 'resnet18':
backbone = resnet18(pretrained=not backbone_path)
self.out_channels = [256, 512, 512, 256, 256, 128]
elif backbone == 'resnet34':
backbone = resnet34(pretrained=not backbone_path)
self.out_channels = [256, 512, 512, 256, 256, 256]
elif backbone == 'resnet50':
backbone = resnet50(pretrained=not backbone_path)
self.out_channels = [1024, 512, 512, 256, 256, 256]
elif backbone == 'resnet101':
backbone = resnet101(pretrained=not backbone_path)
self.out_channels = [1024, 512, 512, 256, 256, 256]
else: # backbone == 'resnet152':
backbone = resnet152(pretrained=not backbone_path)
self.out_channels = [1024, 512, 512, 256, 256, 256]
if backbone_path:
backbone.load_state_dict(torch.load(backbone_path))
for name, parameter in backbone.named_parameters():
if 'layer2' not in name and 'layer3' not in name and 'layer4' not in name:
parameter.requires_grad_(False)
self.feature_extractor = nn.Sequential(*list(backbone.children())[:7])
conv4_block1 = self.feature_extractor[-1][0]
conv4_block1.conv1.stride = (1, 1)
conv4_block1.conv2.stride = (1, 1)
conv4_block1.downsample[0].stride = (1, 1)
def load_model():
'''Download the pretrained model'''
model = resnet34(pretrained=True).to('cuda')
# summary(model, input_size=(3, 224, 224))
#print('Number of Residual blocks: ', len(list(model.children())))
# print('\n', list(model.children())[:-4])
return model
def __init__(self, cfg: Namespace, **kwargs):
super(BaseModel, self).__init__()
pretrained_base = getattr(cfg, "pretrained_base", False)
in_channels = getattr(cfg, "in_channels", 3)
# Spatial transformer localization-network
self.image_conv = resnet34(pretrained=pretrained_base)
self.localization_2 = nn.Sequential(nn.Conv2d(3, 8, kernel_size=7),
nn.MaxPool2d(2, stride=2),
nn.ReLU(True),
nn.Conv2d(8, 10, kernel_size=5),
nn.MaxPool2d(2, stride=2),
nn.ReLU(True))
self.localization = nn.Sequential(nn.Conv2d(10, 8, kernel_size=7),
nn.MaxPool2d(2, stride=2),
nn.ReLU(True),
nn.Conv2d(8, 10, kernel_size=5),
nn.MaxPool2d(2, stride=2),
nn.ReLU(True))
# Regressor for the 3 * 2 affine matrix
self.fc_loc = nn.Sequential(nn.Linear(10 * 3 * 3, 32), nn.ReLU(True),
nn.Linear(32, 3 * 2))
# Initialize the weights/bias with identity transformation
self.fc_loc[2].weight.data.zero_()
self.fc_loc[2].bias.data.copy_(
torch.tensor([1, 0, 0, 0, 1, 0], dtype=torch.float))
self.layer = make_layer(3, BasicBlock, 6, 3)
def __init__(self, n_styles=18, opts=None):
super(ResNetBackboneEncoder, self).__init__()
self.conv1 = nn.Conv2d(opts.input_nc,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.bn1 = BatchNorm2d(64)
self.relu = PReLU(64)
resnet_basenet = resnet34(pretrained=True)
blocks = [
resnet_basenet.layer1, resnet_basenet.layer2,
resnet_basenet.layer3, resnet_basenet.layer4
]
modules = []
for block in blocks:
for bottleneck in block:
modules.append(bottleneck)
self.body = Sequential(*modules)
self.styles = nn.ModuleList()
self.style_count = n_styles
for i in range(self.style_count):
style = GradualStyleBlock(512, 512, 16)
self.styles.append(style)
def __init__(self, n_classes):
"""The definition of our network
Arguments:
n_classes {int} -- The number of classes in the dataset
"""
super(Model, self).__init__()
self.n_features = 512 # The dimension of features before the classification layer
self.feature_size = 8 # The size of feature map extracted from self.features
self.resnet = resnet34(pretrained=True)
self.features = nn.Sequential(
self.resnet.conv1,
self.resnet.bn1,
self.resnet.relu,
self.resnet.maxpool,
self.resnet.layer1,
self.resnet.layer2,
self.resnet.layer3,
self.resnet.layer4,
# nn.AvgPool2d(7, stride=1) # We replace this layer by nn.AdaptiveAvgPool2d
nn.AdaptiveAvgPool2d((self.feature_size, self.feature_size)))
# Adaptation layer
self.fc = nn.Sequential(
nn.Linear(self.n_features * self.feature_size**2, self.n_features),
# nn.ReLU(True) # ReLU will lead to feature disappearance, while Sigmoid will not.
nn.Sigmoid())
self.fc[0].weight.data.normal_(0, 0.5)
# Classfication layer
self.classifier = nn.Linear(self.n_features, n_classes)
def __init__(self, pretrained=None):
super(HeadCommon, self).__init__()
self.config = ConfigParser()
config_path = os.path.abspath(
os.path.join(__file__, "../../", "config.ini"))
assert os.path.exists(config_path), "config.ini not exists!"
self.config.read(config_path)
self.backbone_type = self.config['BACKBONE']['BACKBONE_TYPE']
_pretrained = True if pretrained is not None else False
assert self.backbone_type in ['resnet', 'vgg16']
if self.backbone_type == 'resnet':
resnet_layer = int(self.config['BACKBONE']['RESNET_LAYER'])
assert resnet_layer in [18, 34, 50, 101, 152]
if resnet_layer == 18:
_resnet = resnet.resnet18(_pretrained)
elif resnet_layer == 34:
_resnet = resnet.resnet34(_pretrained)
elif resnet_layer == 50:
_resnet = resnet.resnet50(_pretrained)
elif resnet_layer == 101:
_resnet = resnet.resnet101(_pretrained)
else:
_resnet = resnet.resnet152(_pretrained)
# using resnet_c5 the last bottle neck of resnet
_resnet.layer4[0].conv2.stride = (1, 1)
_resnet.layer4[0].downsample[0].stride = (1, 1)
self.resnet_c5 = _resnet.layer4
self.resnet_c5_avg = _resnet.avgpool
elif self.backbone_type == 'vgg16':
assert not bool(int(self.config['HEAD']['MASK_HEAD_ON'])), (
"When mask head on, not support vgg16 backbone.")
vgg = vgg16(pretrained=True)
self.vgg_fc = nn.Sequential(
*list(vgg.classifier._modules.values())[:-1])
def __init__(self, feature_dim=128, resnet_depth=18):
super(Model, self).__init__()
self.f = []
if resnet_depth == 18:
my_resnet = resnet18()
resnet_output_dim = 512
elif resnet_depth == 34:
my_resnet = resnet34()
resnet_output_dim = 512
elif resnet_depth == 50:
my_resnet = resnet50()
resnet_output_dim = 2048
for name, module in my_resnet.named_children():
if name == 'conv1':
module = nn.Conv2d(3,
64,
kernel_size=3,
stride=1,
padding=1,
bias=False)
if not isinstance(module, nn.Linear) and not isinstance(
module, nn.MaxPool2d):
self.f.append(module)
# encoder
self.f = nn.Sequential(*self.f)
# projection head
self.g = nn.Sequential(nn.Linear(resnet_output_dim, 512, bias=False),
nn.BatchNorm1d(512), nn.ReLU(inplace=True),
nn.Linear(512, feature_dim, bias=True))
def __init__(self, backbone, num_classes=21):
super().__init__()
if backbone == 'resnet-18':
self.backbone = resnet18()
self.in_channel = [512, 128, 64, 64]
self.out_channel = [256, 64, 64, 64]
elif backbone == 'resnet-34':
self.backbone = resnet34()
self.in_channel = [512, 128, 64, 64]
self.out_channel = [256, 64, 64, 64]
elif backbone == 'resnet-50':
self.backbone = resnet50()
self.in_channel = [2048, 512, 256, 64]
self.out_channel = [1024, 256, 64, 64]
elif backbone == 'resnet-101':
self.backbone = resnet101()
self.in_channel = [2048, 512, 256, 64]
self.out_channel = [1024, 256, 64, 64]
elif backbone == 'resnet-152':
self.backbone = resnet152()
self.in_channel = [2048, 512, 256, 64]
self.out_channel = [1024, 256, 64, 64]
else:
raise NotImplementedError
self.encoder = Encoder(self.backbone)
self.decoder = Decoder(self.in_channel, self.out_channel)
self.out = nn.Conv2d(64, num_classes, 1)
self._init_weight()
def get_classification_model(classifier_name='resnet18',
num_classes=1000,
pretrained=True):
"""
Get the detection model
:param pretrained:
:param classifier_name:
:param num_classes:
:return:
"""
if classifier_name == 'resnet18':
model = resnet18(pretrained, num_classes=num_classes)
elif classifier_name == 'resnet34':
model = resnet34(pretrained, num_classes=num_classes)
elif classifier_name == 'resnet50':
model = resnet50(pretrained, num_classes=num_classes)
elif classifier_name == 'resnet101':
model = resnet101(pretrained, num_classes=num_classes)
elif classifier_name == 'resnet152':
model = resnet152(pretrained, num_classes=num_classes)
else:
raise ValueError('Unsupported resnet type.')
return model
def __init__(self, num_classes: int = 250):
super(ResNet34, self).__init__()
self.backbone = resnet34(pretrained=True)
self.backbone.fc = nn.Linear(self.backbone.fc.in_features, num_classes)
self._fc2 = None
self._fc3 = None
self._bn1d = None
self._relu = nn.ReLU()
def main():
# set the random seeds
# torch.manual_seed(42)
# random.seed(42)
resnet = resnet34()
dataset = Cifar10Dataset()
kubenet = KubeResnet34(resnet, dataset)
return kubenet.start()
def initModel(self, model, preTrain):
if model == "18":
return resnet.resnet18(
preTrain, num_classes=config.frontend["resnet"]["size"])
elif model == "34":
return resnet.resnet34(
preTrain, num_classes=config.frontend["resnet"]["size"])
elif model == "50":
return resnet.resnet50(
preTrain, num_classes=config.frontend["resnet"]["size"])
def initModel(self, model, preTrain):
if model == "18":
return resnet.resnet18(preTrain,
num_classes=ENCODER_REPRESENTATION_SIZE)
elif model == "34":
return resnet.resnet34(preTrain,
num_classes=ENCODER_REPRESENTATION_SIZE)
elif model == "50":
return resnet.resnet50(preTrain,
num_classes=ENCODER_REPRESENTATION_SIZE)
def resnet34(pretrained=False, **kwargs):
"""Constructs a ResNet-34 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet_C5(BasicBlock, [3, 4, 6, 3], **kwargs)
model_full = resnet.resnet34(pretrained=True)
if pretrained:
model.load_pretrained(model_full)
return model
def get_backbone(self, name, pretrained):
if name == "resne34":
return resnet34(pretrained=pretrained)
elif name == "resnet50":
return resnet50(pretrained=pretrained)
elif name == "resnet101":
return resnet101(pretrained=pretrained)
elif name == "resnet152":
return resnet152(pretrained=pretrained)
else:
return resnet18(pretrained=pretrained) #default
def resnet34(pretrained=False, fixed_feature=True):
""" "ResNet-34 model from torchvision's resnet model.
:param pretrained: if true, return a model pretrained on ImageNet
:param fixed_feature: if true and pretrained is true, model features are fixed while training.
"""
from torchvision.models.resnet import resnet34
model = resnet34(pretrained)
ff = True if pretrained and fixed_feature else False
return _ResNet(model, ff)
def __init__(self):
super().__init__()
rn34 = resnet34(pretrained=True)
# discard last Resnet block, avrpooling and classification FC
self.layer1 = nn.Sequential(*list(rn34.children())[:6])
self.layer2 = nn.Sequential(*list(rn34.children())[6:7])
# modify conv4 if necessary
# Always deal with stride in first block
modulelist = list(self.layer2.children())
_ModifyBlock(modulelist[0], stride=(1, 1))
def create_model(model_name, num_classes=1000, pretrained=False, **kwargs):
if 'test_time_pool' in kwargs:
test_time_pool = kwargs.pop('test_time_pool')
else:
test_time_pool = True
if 'extra' in kwargs:
extra = kwargs.pop('extra')
else:
extra = True
if model_name == 'dpn68':
model = dpn68(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn68b':
model = dpn68b(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn92':
model = dpn92(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool, extra=extra)
elif model_name == 'dpn98':
model = dpn98(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn131':
model = dpn131(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn107':
model = dpn107(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'resnet18':
model = resnet18(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet34':
model = resnet34(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet50':
model = resnet50(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet101':
model = resnet101(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet152':
model = resnet152(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet121':
model = densenet121(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet161':
model = densenet161(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet169':
model = densenet169(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet201':
model = densenet201(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'inception_v3':
model = inception_v3(
num_classes=num_classes, pretrained=pretrained, transform_input=False, **kwargs)
else:
assert False, "Unknown model architecture (%s)" % model_name
return model
