def get_official_model(name):
if name == 'resnet152':
model_path = 'resnet152-b121ed2d.pth'
model = models.resnet152(pretrained=False)
if name == 'resnext101_32x8d':
model_path = 'resnext101_32x8d-8ba56ff5.pth'
model = models.resnext101_32x8d(pretrained=False)
#model = torch.hub.load('pytorch/vision:v0.4.2', 'resnet152', pretrained=True)
#model = models.resnet152(pretrained=False)
model.load_state_dict(
torch.load('C:/Users/Administrator/.cache/torch/checkpoints/' +
model_path,
map_location='cpu'))
model.eval()
return model
def createModel(num_classes=6, w_drop=True):
model_ft = models.resnext101_32x8d(pretrained=True)
num_ftrs = model_ft.fc.in_features
if not w_drop:
model_ft.fc = nn.Linear(num_ftrs, num_classes)
else:
model_ft.fc = nn.Sequential(
nn.Dropout(0.5),
nn.Linear(num_ftrs, num_classes)
)
return model_ft
def __init__(self, resnet_layers, num_attributes=40):
super(FaceAttrResNeXt, self).__init__()
assert resnet_layers in [50, 101]
if resnet_layers == 50:
pt_model = tvmodels.resnext50_32x4d(pretrained=True, progress=False)
elif resnet_layers == 101:
pt_model = tvmodels.resnext101_32x8d(pretrained=True, progress=False)
pt_out = pt_model.fc.out_features
self.pretrained = pt_model
self.num_attributes = num_attributes
for i in range(num_attributes):
setattr(self, 'classifier' + str(i).zfill(2),
nn.Sequential(FC_Block(pt_out, pt_out // 2),
nn.Linear(pt_out // 2, 2)))
self.name = 'FaceAttrResNeXt_'+str(resnet_layers)
def load_model(model_name):
global MODEL_NAME
# Detect if we have a GPU available
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
if model_name == 'ResNet':
model = models.resnet152(pretrained=False)
model.load_state_dict(torch.load(os.path.join(PRETRAINED_DEEP_MODEL_DIR, MODEL_NAME[model_name]), map_location=device))
elif model_name == 'AlexNet':
model = models.AlexNet()
model.load_state_dict(torch.load(os.path.join(PRETRAINED_DEEP_MODEL_DIR, MODEL_NAME[model_name]), map_location=device))
elif model_name == 'VGG':
model = models.VGG(_vgg_make_layers(_vgg_cfg['E'], batch_norm=True), init_weights=False)
model.load_state_dict(torch.load(os.path.join(PRETRAINED_DEEP_MODEL_DIR, MODEL_NAME[model_name]), map_location=device))
elif model_name == 'DenseNet':
model = models.DenseNet(num_init_features=64, growth_rate=32, block_config=(6, 12, 48, 32))
pattern = re.compile(
r'^(.*denselayer\d+\.(?:norm|relu|conv))\.((?:[12])\.(?:weight|bias|running_mean|running_var))$')
state_dict = torch.load(os.path.join(PRETRAINED_DEEP_MODEL_DIR, MODEL_NAME[model_name]), map_location=device)
for key in list(state_dict.keys()):
res = pattern.match(key)
if res:
new_key = res.group(1) + res.group(2)
state_dict[new_key] = state_dict[key]
del state_dict[key]
model.load_state_dict(state_dict)
elif model_name == 'GoogleNet':
# googlenet
kwargs = dict()
kwargs['transform_input'] = True
kwargs['aux_logits'] = False
# if kwargs['aux_logits']:
# warnings.warn('auxiliary heads in the pretrained googlenet model are NOT pretrained, '
# 'so make sure to train them')
original_aux_logits = kwargs['aux_logits']
kwargs['aux_logits'] = True
kwargs['init_weights'] = False
model = models.GoogLeNet(**kwargs)
model.load_state_dict(torch.load(os.path.join(PRETRAINED_DEEP_MODEL_DIR, MODEL_NAME[model_name]), map_location=device))
if not original_aux_logits:
model.aux_logits = False
del model.aux1, model.aux2
elif model_name == 'ResNext101':
model = models.resnext101_32x8d(pretrained=False)
model.load_state_dict(torch.load(os.path.join(PRETRAINED_DEEP_MODEL_DIR, MODEL_NAME[model_name]), map_location=device))
else:
raise ValueError("Model name must be one of ['VGG', 'ResNet', 'DenseNet', 'AlexNet', 'GoogleNet', 'ResNext101']")
return model
def __init__(self,
num_classes: int,
pretrained_model_name: str = "efficientnet-b7",
backbone_freeze=True):
super(ResNext, self).__init__()
self.backbone = resnext101_32x8d(pretrained=True)
self.backbone.requires_grad_(not backbone_freeze)
self.backbone.fc = nn.Linear(in_features=2048,
out_features=4096,
bias=True) # resnext fc
self.classifier = nn.Sequential(
nn.Linear(4096, 4096),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(4096, num_classes),
)
def __init__(self, out_dim=14, in_dim=20, **kwargs):
super().__init__()
self.attn = Attention(embed_dim=1024, num_heads=4)
self.main = tvm.resnext101_32x8d(pretrained=True)
self.main.conv1 = nn.Conv2d(in_dim,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.main.fc = nn.Linear(self.main.fc.in_features, out_dim)
# dim between layer2 and layer3 = B x 512 x 32 x 32
self.main.layer3 = nn.Sequential(self.attn, self.main.layer3)
def __init__(self, name, nclasses=40, pretraining=True, cnn_name='vgg11'):
super(SVCNN, self).__init__(name)
self.classnames = ['airplane', 'bathtub', 'bed', 'bench', 'bookshelf', 'bottle', 'bowl', 'car', 'chair',
'cone', 'cup', 'curtain', 'desk', 'door', 'dresser', 'flower_pot', 'glass_box',
'guitar', 'keyboard', 'lamp', 'laptop', 'mantel', 'monitor', 'night_stand',
'person', 'piano', 'plant', 'radio', 'range_hood', 'sink', 'sofa', 'stairs',
'stool', 'table', 'tent', 'toilet', 'tv_stand', 'vase', 'wardrobe', 'xbox']
self.nclasses = nclasses
self.pretraining = pretraining
self.cnn_name = cnn_name
self.use_resnet = cnn_name.startswith('resnet')
self.use_densenet = cnn_name.startswith('desnet')
self.mean = Variable(torch.FloatTensor([0.0142, 0.0142, 0.0142]), requires_grad=False).cuda()
self.std = Variable(torch.FloatTensor([0.0818, 0.0818, 0.0818]), requires_grad=False).cuda()
if self.use_resnet:
if self.cnn_name == 'resnet18':
self.net = models.resnet18(pretrained=self.pretraining)
self.net.fc = nn.Linear(512, 40)
elif self.cnn_name == 'resnet34':
self.net = models.resnet34(pretrained=self.pretraining)
self.net.fc = nn.Linear(512, 40)
elif self.cnn_name == 'resnet50':
self.net = models.resnet50(pretrained=self.pretraining)
self.net.fc = nn.Linear(2048, 40)
elif self.cnn_name == 'resnet50x':
self.net = models.resnext50_32x4d(pretrained=self.pretraining)
self.net.fc = nn.Linear(2048, 40)
elif self.cnn_name == 'resnet101x':
self.net = models.resnext101_32x8d(pretrained=self.pretraining)
self.net.fc = nn.Linear(2048, 40)
else:
if self.cnn_name == 'alexnet':
self.net_1 = models.alexnet(pretrained=self.pretraining).features
self.net_2 = models.alexnet(pretrained=self.pretraining).classifier
elif self.cnn_name == 'vgg11':
self.net_1 = models.vgg11(pretrained=self.pretraining).features
self.net_2 = models.vgg11(pretrained=self.pretraining).classifier
elif self.cnn_name == 'vgg16':
self.net_1 = models.vgg16(pretrained=self.pretraining).features
self.net_2 = models.vgg16(pretrained=self.pretraining).classifier
self.net_2._modules['6'] = nn.Linear(4096, 40)
def get_backbone(name, pretrained=True):
""" Loading backbone, defining names for skip-connections and encoder output. """
# TODO: More backbones
# loading backbone model
if name == 'resnet18':
backbone = models.resnet18(pretrained=pretrained)
elif name == 'resnet34':
backbone = models.resnet34(pretrained=pretrained)
elif name == 'resnet50':
backbone = models.resnet50(pretrained=pretrained)
elif name == 'resnet101':
backbone = models.resnet101(pretrained=pretrained)
elif name == 'resnext50':
backbone = models.resnext50_32x4d(pretrained=pretrained)
elif name == 'resnext101':
backbone = models.resnext101_32x8d(pretrained=pretrained)
else:
raise NotImplemented(
'{} backbone model is not implemented so far.'.format(name))
# specifying skip feature and output names
if name.startswith('resnet18') or name.startswith('resnet34'):
feature_sizes = [
backbone.conv1.out_channels,
backbone.layer1[-1].conv2.out_channels,
backbone.layer2[-1].conv2.out_channels,
backbone.layer3[-1].conv2.out_channels,
backbone.layer4[-1].conv2.out_channels
]
feature_names = ['relu', 'layer1', 'layer2', 'layer3', 'layer4']
elif name.startswith('resnet') or name.startswith('resnext'):
feature_sizes = [
backbone.conv1.out_channels,
backbone.layer1[-1].conv3.out_channels,
backbone.layer2[-1].conv3.out_channels,
backbone.layer3[-1].conv3.out_channels,
backbone.layer4[-1].conv3.out_channels
]
feature_names = ['relu', 'layer1', 'layer2', 'layer3', 'layer4']
else:
raise NotImplemented(
'{} backbone model is not implemented so far.'.format(name))
return backbone, feature_sizes, feature_names
def initialize_model(model_name="resnext101", use_pretrained=True):
# Initialize these variables which will be set in this if statement. Each of these
# variables is model specific.
model_ft = None
input_size = 0
num_classes = 1000
if model_name == "resnext101":
""" ResNext101
"""
model_ft = models.resnext101_32x8d(pretrained=use_pretrained)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "resnest269":
""" ResNest269
"""
# model_ft = resnest269(pretrained=use_pretrained)
model_ft = resnest269(pretrained=False)
model_ft.load_state_dict(
torch.load("/home/wangkai/pretrain_model/resnest269-0cc87c48.pth"))
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 416
elif model_name == "resnext50":
""" ResNext50
"""
model_ft = models.resnext50_32x4d(pretrained=use_pretrained)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "resnet152":
""" ResNet152
"""
model_ft = models.resnet152(pretrained=use_pretrained)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
else:
print("Invalid model name, exiting...")
exit()
return model_ft, input_size
def __init__(self, class_num):
super(PCB_resnext, self).__init__()
self.part = 6 # We cut the pool5 to 6 parts
#model_ft = models.resnet50(pretrained=True)
model_ft = models.resnext101_32x8d(pretrained=False)
self.model = model_ft
self.avgpool = nn.AdaptiveAvgPool2d((self.part, 1))
self.avgpool_glo = nn.AdaptiveAvgPool2d((1, 1))
self.dropout = nn.Dropout(p=0.3)
self.bnneck = nn.BatchNorm1d(2048)
# remove the final downsample
self.model.layer4[0].downsample[0].stride = (1, 1)
self.model.layer4[0].conv2.stride = (1, 1)
# define 6 classifiers
for i in range(self.part):
name = 'classifier' + str(i)
setattr(self, name, ClassBlock(2048, class_num, True, False, 512))
def __init__(self,
n_class=5,
pretrained=True,
use_fc_=True,
name="ResNext"):
super(Resnet50_FC2, self).__init__()
self.name = name
#self.basemodel = models.resnet50(pretrained=pretrained)
self.basemodel = models.resnext101_32x8d(pretrained=pretrained,
progress=True)
self.basemodel.fc = torch.nn.Identity()
self.fc = torch.nn.Linear(2048, n_class)
for name, param in self.basemodel.named_parameters():
if 'fc' not in name: # and 'layer4' not in name
param.requires_grad = False
self.use_fc_ = use_fc_
def load_model(model_name):
if model_name == 'resnet18':
return models.resnet18(pretrained=True)
if model_name == 'resnet34':
return models.resnet34(pretrained=True)
if model_name == 'resnet50':
return models.resnet50(pretrained=True)
if model_name == 'resnet101':
return models.resnet101(pretrained=True)
if model_name == 'resnet152':
return models.resnet152(pretrained=True)
if model_name == 'resnext50_32x4d':
return models.resnext50_32x4d(pretrained=True)
if model_name == 'resnext101_32x8d':
return models.resnext101_32x8d(pretrained=True)
if model_name == 'wide_resnet50_2':
return models.wide_resnet50_2(pretrained=True)
if model_name == 'wide_resnet101_2':
return models.wide_resnet101_2(pretrained=True)
if model_name == 'resnet18_swsl':
return torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', 'resnet18_swsl')
if model_name == 'resnet50_swsl':
return torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', 'resnet50_swsl')
if model_name == 'resnext50_32x4d_swsl':
return torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', 'resnext50_32x4d_swsl')
if model_name == 'resnext101_32x4d_swsl':
return torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', 'resnext101_32x4d_swsl')
if model_name == 'resnext101_32x8d_swsl':
return torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', 'resnext101_32x8d_swsl')
if model_name == 'resnext101_32x16d_swsl':
return torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', 'resnext101_32x16d_swsl')
if model_name == 'resnet18_ssl':
return torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', 'resnet18_ssl')
if model_name == 'resnet50_ssl':
return torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', 'resnet50_ssl')
if model_name == 'resnext50_32x4d_ssl':
return torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', 'resnext50_32x4d_ssl')
if model_name == 'resnext101_32x4d_ssl':
return torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', 'resnext101_32x4d_ssl')
if model_name == 'resnext101_32x8d_ssl':
return torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', 'resnext101_32x8d_ssl')
if model_name == 'resnext101_32x16d_ssl':
return torch.hub.load('facebookresearch/semi-supervised-ImageNet1K-models', 'resnext101_32x16d_ssl')
return None
def prepareNetwork2(tipo=3):
if tipo in [3, 4, 6]:
if tipo == 3:
encoder = models.inception_v3(pretrained=True)
elif tipo == 4:
encoder = models.resnext101_32x8d(pretrained=True)
elif tipo == 6:
encoder = models.resnet152(pretrained=True)
encoder.fc = nn.Sequential()
elif tipo == 5:
encoder = models.densenet161(pretrained=True)
encoder.classifier = nn.Sequential()
encoder.eval()
for param in encoder.parameters():
param.requires_grad = False
encoder = encoder.cuda()
return encoder
def __init__(self, args, use_pretrained=True):
super(ResNext, self).__init__()
if use_pretrained:
self.embedder = torch.hub.load("facebookresearch/WSL-Images",
"resnext101_32x8d_wsl")
else:
self.embedder = tvmodels.resnext101_32x8d(pretrained=False)
# elif args.encoder == "resnet50":
# self.embedder = tvmodels.resnet50_32x4d(pretrained=True)
self.embedder.fc = nn.Linear(2048, args.num_classes)
for m in self.embedder.fc.modules():
if isinstance(m, nn.Linear):
nn.init.kaiming_normal_(m.weight)
if hasattr(m, "bias") and m.bias is not None:
nn.init.constant_(m.bias, 0)
def __init__(self):
super().__init__()
# load the pretrained VGG16 network
self.model = resnext101_32x8d(pretrained=True)
# dissect the network in order to get access to the feature maps of
# the convolutional layers
self.model.layer1.register_backward_hook(self.grad_hook)
self.model.layer1.register_forward_hook(self.feature_hook)
self.model.layer2.register_backward_hook(self.grad_hook)
self.model.layer2.register_forward_hook(self.feature_hook)
self.model.layer3.register_backward_hook(self.grad_hook)
self.model.layer3.register_forward_hook(self.feature_hook)
self.model.layer4.register_backward_hook(self.grad_hook)
self.model.layer4.register_forward_hook(self.feature_hook)
def __init__(self, config):
super().__init__()
self.model = models.resnext101_32x8d(pretrained=True)
for param in self.model.parameters():
param.requires_grad = False
self.model.fc = nn.Sequential(
nn.Linear(self.model.fc.in_features, config["lin1_size"]),
nn.BatchNorm1d(config["lin1_size"]),
nn.ReLU(),
nn.Dropout(p=0.25),
nn.Linear(config["lin1_size"], config["lin2_size"]),
nn.BatchNorm1d(config["lin2_size"]),
nn.ReLU(),
nn.Dropout(p=0.2),
nn.Linear(config["lin2_size"], config["output_size"]),
nn.LogSoftmax(dim=1)
)
def __init__(self, base_model, out_dim):
super().__init__()
self.resnet_dict = {"resnet18": models.resnet18(pretrained=False),
"resnet50": models.resnet50(pretrained=False),
"resnet101": models.resnet101(pretrained=False),
"resnet152": models.resnet152(pretrained=False),
"resnext50_wide": models.resnext50_32x4d(pretrained=False),
"resnext101_wide": models.resnext101_32x8d(pretrained=False),
}
resnet = self._get_basemodel(base_model)
num_ftrs = resnet.fc.in_features
self.features = nn.Sequential(*list(resnet.children())[:-2])
self.pool = nn.Sequential(*list(resnet.children())[-2:-1])
# projection MLP
self.l1 = nn.Linear(num_ftrs, num_ftrs)
self.l2 = nn.Linear(num_ftrs, out_dim)
self.weights_init()
def load_model():
labels = []
with open(label_path, 'r') as filehandle:
for line in filehandle:
currentPlace = line[:-1]
labels.append(currentPlace)
device = torch.device("cpu")
model_ft = models.resnext101_32x8d(pretrained=False)
num_ftrs = model_ft.fc.in_features
nb_classes = len(labels)
model_ft.fc = nn.Linear(num_ftrs, nb_classes)
model_ft = model_ft.to(device)
model_ft.load_state_dict(
torch.load(model_path, map_location=torch.device('cpu')))
model_ft.eval()
to_return = list()
to_return.append(model_ft)
to_return.append(labels)
return to_return
def __init__(self, variant, num_classes, print_model=False):
"""
variant -> defines the ResNet variant used for this experiment (18, 50, etc)
num_classes -> the number of classes in the experiment
"""
super().__init__()
self.variant = variant
self.num_classes = num_classes
if variant == 50:
self.model = models.resnext50_32x4d(pretrained=True)
num_filters = self.model.fc.in_features
self.model.fc = nn.Linear(num_filters, self.num_classes)
self.input_size = 224
if variant == 101:
self.model = models.resnext101_32x8d(pretrained=True)
num_filters = self.model.fc.in_features
self.model.fc = nn.Linear(num_filters, self.num_classes)
self.input_size = 224
def __init__(self, args, use_pretrained=True):
super(ImageTransformer, self).__init__()
from torch.nn import TransformerEncoder, TransformerEncoderLayer
self.args = args
# Embedding
if args.encoder == "resnext101":
if use_pretrained:
self.embedder = torch.hub.load("facebookresearch/WSL-Images",
"resnext101_32x8d_wsl")
else:
self.embedder = tvmodels.resnext101_32x8d(pretrained=False)
if self.args.freeze_encoder:
self.freeze_encoder()
self.units = args.units
if self.units == 2048:
self.embedder.fc = nn.Identity()
else:
self.embedder.fc = nn.Linear(2048, self.units)
for m in self.embedder.fc.modules():
if isinstance(m, nn.Linear):
nn.init.kaiming_normal_(m.weight)
if hasattr(m, "bias") and m.bias is not None:
nn.init.constant_(m.bias, 0)
# self.src_mask = None
self.position_encoder = PositionalEncoding1D(
self.units) # (ninp, dropout)
encoder_layer = TransformerEncoderLayer(d_model=self.units,
nhead=8,
dim_feedforward=2048,
dropout=0.1)
self.transformer_encoder = TransformerEncoder(
encoder_layer=encoder_layer, num_layers=2)
self.transformer_decoder = nn.Linear(self.units, self.args.num_classes)
def __init__(self, slug='r50', pretrained=True):
super().__init__()
if not pretrained:
print("Caution, not loading pretrained weights.")
if slug == 'r18':
self.resnet = models.resnet18(pretrained=pretrained)
num_bottleneck_filters = 512
elif slug == 'r34':
self.resnet = models.resnet34(pretrained=pretrained)
num_bottleneck_filters = 512
elif slug == 'r50':
self.resnet = models.resnet50(pretrained=pretrained)
num_bottleneck_filters = 2048
elif slug == 'r101':
self.resnet = models.resnet101(pretrained=pretrained)
num_bottleneck_filters = 2048
elif slug == 'r152':
self.resnet = models.resnet152(pretrained=pretrained)
num_bottleneck_filters = 2048
elif slug == 'rx50':
self.resnet = models.resnext50_32x4d(pretrained=pretrained)
num_bottleneck_filters = 2048
elif slug == 'rx101':
self.resnet = models.resnext101_32x8d(pretrained=pretrained)
num_bottleneck_filters = 2048
elif slug == 'r50d':
self.resnet = timm.create_model('gluon_resnet50_v1d',
pretrained=pretrained)
convert_to_inplace_relu(self.resnet)
num_bottleneck_filters = 2048
elif slug == 'r101d':
self.resnet = timm.create_model('gluon_resnet101_v1d',
pretrained=pretrained)
convert_to_inplace_relu(self.resnet)
num_bottleneck_filters = 2048
else:
assert False, "Bad slug: %s" % slug
self.outplanes = num_bottleneck_filters
def __init__(self, network, num_joints):
super(ResNet, self).__init__()
# load pretrained resnet model
if network == 'resnet50':
pretrained = models.resnet50(pretrained=True)
elif network == 'resnet101':
pretrained = models.resnet101(pretrained=True)
elif network == 'resnet152':
pretrained = models.resnet152(pretrained=True)
elif network == 'resnext101':
pretrained = models.resnext101_32x8d(pretrained=True)
else:
raise ValueError('unsupported network %s' % network)
# remove last 2 layers
modules = list(pretrained.children())[:-2]
# add 1st deconv block (stride = 16)
modules.append(nn.Sequential(nn.ConvTranspose2d(2048, 256, kernel_size=4, stride=2, padding=1, bias=False),
nn.BatchNorm2d(256),
nn.ReLU(inplace=True)))
# add 2nd deconv block (stride = 32)
modules.append(nn.Sequential(nn.ConvTranspose2d(256, 256, kernel_size=4, stride=2, padding=1, bias=False),
nn.BatchNorm2d(256),
nn.ReLU(inplace=True)))
# add 3rd deconv block (stride = 64)
modules.append(nn.Sequential(nn.ConvTranspose2d(256, 256, kernel_size=4, stride=2, padding=1, bias=False),
nn.BatchNorm2d(256),
nn.ReLU(inplace=True)))
# add regression layer
modules.append(nn.Conv2d(256, num_joints, 1))
self.module = nn.ModuleList(modules)
self.network = network
self.num_joints = num_joints
self.fliptest = False
def load_model(name,
num_classes,
input_height=64,
input_width=64,
num_of_channels=3):
if name == 'COAPModNet':
net = COAPModNet(num_classes=num_classes)
elif name == 'COAPNet':
net = COAPNet(num_classes=num_classes)
elif name == 'SimpleNet':
net = SimpleNet(num_classes=num_classes)
elif name == 'AlexNet':
net = models.AlexNet(num_classes=num_classes)
elif name == 'PlanktonNet':
net = PlanktonNet(num_classes=num_classes)
elif name == 'ResNet18':
net = models.resnet18(num_of_channels, num_classes)
elif name == 'ResNet34':
net = models.resnet34(num_of_channels, num_classes)
elif name == 'ResNet50':
net = models.resnet50(num_of_channels, num_classes)
elif name == 'ResNet101':
net = models.resnet101(num_of_channels, num_classes)
elif name == 'ResNet152':
net = models.resnet152(num_of_channels, num_classes)
elif name == 'VGGNet11':
net = models.vgg11(num_classes=num_classes)
elif name == 'VGGNet13':
net = models.vgg13(num_classes=num_classes)
elif name == 'VGGNet16':
net = models.vgg16(num_classes=num_classes)
elif name == 'VGGNet19':
net = models.vgg19(num_classes=num_classes)
elif name == 'ResNext50':
net = models.resnext50_32x4d(num_classes=num_classes)
elif name == 'ResNext101':
net = models.resnext101_32x8d(num_classes=num_classes)
elif name == 'GoogLeNet':
net = models.GoogLeNet(num_classes=num_classes)
return net
def main():
model = models.resnext101_32x8d(pretrained=True)
model.eval()
batch_size = 32
x = torch.randn(batch_size, 3, 224, 224, requires_grad=True)
# set export_params=True to export model params
torch.onnx.export(
model, # model being run
x, # model input (or a tuple for multiple inputs)
"resnext101_32x8d.onnx", # where to save the model (can be a file or file-like object)
export_params=
False, # store the trained parameter weights inside the model file
opset_version=10, # the ONNX version to export the model to
do_constant_folding=
True, # whether to execute constant folding for optimization
input_names=['input'], # the model's input names
output_names=['output'], # the model's output names
)
def read_model(model_path):
checkpoint = torch.load(model_path, map_location=torch.device(
'cpu')) # seems to work despite warning, returns a dict
classes = checkpoint["classes"]
resnet = models.resnext101_32x8d()
x = checkpoint.get('state_dict')
#remove 'module' string from key, necessary for CPU based model
from collections import OrderedDict
new_state_dict = OrderedDict()
for k, v in x.items():
name = k[7:] # remove `module.`
new_state_dict[name] = v
# load params
#set number of classes
num_ftrs = resnet.fc.in_features
resnet.fc = torch.nn.Linear(num_ftrs, len(classes))
resnet.load_state_dict(new_state_dict)
resnet.eval()
return classes, resnet
def init_net(embed_dim: int, dropout: float = 0.1, freeze: bool = False, depth: int = 1, use_obj: bool = True):
if depth == 1:
model = models.resnet18(pretrained=True)
elif depth == 2:
model = models.resnet34(pretrained=True)
elif depth == 3:
model = models.resnet50(pretrained=True)
elif depth == 4:
model = models.resnet101(pretrained=True)
elif depth == 5:
model = models.resnet152(pretrained=True)
elif depth == 6:
model = models.resnext101_32x8d(pretrained=True)
model.__class__ = ModifiedResnet
model.dropout = dropout
model.layer_norm = torch.nn.LayerNorm(embed_dim, eps=1e-12)
if freeze:
for param in model.parameters():
param.requires_grad = False
current_weight = model.state_dict()["fc.weight"]
model.fc = torch.nn.Linear(in_features=current_weight.size()[1], out_features=embed_dim, bias=False)
model.fc.train()
model.object_feat_fc = torch.nn.Linear(in_features=1024 + 7 + embed_dim, out_features=embed_dim, bias=False)
model.object_feat_fc.train()
# Learning embedding of each CNN region.
model.location_embedding = nn.Embedding(49, embed_dim)
model.location_embedding.train(True)
model.object_embedding = nn.Embedding(91, embed_dim)
model.object_embedding.train(True)
model.fcnn = None
if use_obj:
model.fcnn = fasterrcnn_resnet50_fpn(pretrained=True)
model.fcnn.eval()
return model
def __init__(self, params):
super(encoder, self).__init__()
self.params = params
import torchvision.models as models
if params.encoder == 'densenet121_bts':
self.base_model = models.densenet121(pretrained=True).features
self.feat_names = [
'relu0', 'pool0', 'transition1', 'transition2', 'norm5'
]
self.feat_out_channels = [64, 64, 128, 256, 1024]
elif params.encoder == 'densenet161_bts':
self.base_model = models.densenet161(pretrained=True).features
self.feat_names = [
'relu0', 'pool0', 'transition1', 'transition2', 'norm5'
]
self.feat_out_channels = [96, 96, 192, 384, 2208]
elif params.encoder == 'resnet50_bts':
self.base_model = models.resnet50(pretrained=True)
self.feat_names = ['relu', 'layer1', 'layer2', 'layer3', 'layer4']
self.feat_out_channels = [64, 256, 512, 1024, 2048]
elif params.encoder == 'resnet101_bts':
self.base_model = models.resnet101(pretrained=True)
self.feat_names = ['relu', 'layer1', 'layer2', 'layer3', 'layer4']
self.feat_out_channels = [64, 256, 512, 1024, 2048]
elif params.encoder == 'resnext50_bts':
self.base_model = models.resnext50_32x4d(pretrained=True)
self.feat_names = ['relu', 'layer1', 'layer2', 'layer3', 'layer4']
self.feat_out_channels = [64, 256, 512, 1024, 2048]
elif params.encoder == 'resnext101_bts':
self.base_model = models.resnext101_32x8d(pretrained=True)
self.feat_names = ['relu', 'layer1', 'layer2', 'layer3', 'layer4']
self.feat_out_channels = [64, 256, 512, 1024, 2048]
elif params.encoder == 'mobilenetv2_bts':
self.base_model = models.mobilenet_v2(pretrained=True).features
self.feat_inds = [2, 4, 7, 11, 19]
self.feat_out_channels = [16, 24, 32, 64, 1280]
self.feat_names = []
else:
print('Not supported encoder: {}'.format(params.encoder))
def make_model(n_classes=2):
if MODEL == 'vgg16':
model = models.vgg16(pretrained=True, progress=True)
elif MODEL == 'mobilenet':
model = models.mobilenet_v2(pretrained=True, progress=True)
elif MODEL == 'resnet50':
model = models.resnet50(pretrained=True, progress=True)
elif MODEL == 'resnext101':
model = models.resnext101_32x8d(pretrained=True, progress=True)
else:
raise ValueError('Invalid pretrained model.')
model.n_classes = n_classes
if FROZEN:
for param in model.parameters():
param.requires_grad = False
final = nn.Sequential(nn.ReLU(), nn.Dropout(0.5), nn.Linear(1000, 1000),
nn.ReLU(), nn.Dropout(0.5), nn.Linear(1000, 750),
nn.ReLU(), nn.Dropout(0.5), nn.Linear(750, 750),
nn.ReLU(), nn.Dropout(0.5), nn.Linear(750, 500),
nn.ReLU(), nn.Dropout(0.5),
nn.Linear(500, model.n_classes))
if MODEL == 'vgg16':
model.classifier[6] = nn.Sequential(nn.Linear(4096, model.n_classes))
elif MODEL == 'mobilenet':
model.classifier = nn.Sequential(nn.Linear(1280, 1000), final)
elif MODEL in ['resnet50', 'resnext101']:
model.fc = nn.Sequential(nn.Linear(model.fc.in_features, 1000), final)
print(f'Transfer learning from {MODEL}.')
total_params = sum(p.numel() for p in model.parameters())
print(f'{total_params:,} total parameters.')
total_trainable_params = sum(p.numel() for p in model.parameters()
if p.requires_grad)
print(f'{total_trainable_params:,} training parameters.')
return model
def initialize_model(model_name, num_classes, feature_extract, use_pretrained=True):
# Initialize these variables which will be set in this if statement. Each of these
# variables is model specific.
model_ft = None
input_size = 0
if model_name == "resnet18":
""" Resnet18
"""
model_ft = models.resnet18(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "resnet152":
""" Resnet18
"""
model_ft = models.resnet152(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "ResNeXt-101-32x8d":
""" ResNeXt-101-32x8d
"""
model_ft = models.resnext101_32x8d(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
else:
print("Invalid model name, exiting...")
exit()
return model_ft, input_size
def __init__(self, model_name, n_frozen_layers):
super(Pretrained_model, self).__init__()
if model_name == "resnet50":
from torchvision.models import resnet50
self.pretrained = resnet50(pretrained=True)
elif model_name == "resnet18":
from torchvision.models import resnet18
self.pretrained = resnet18(pretrained=True)
elif model_name == "resnext101":
from torchvision.models import resnext101_32x8d
self.pretrained = resnext101_32x8d(pretrained=True)
#freeze the first n_frozen_layers
ct = 0
for child in self.pretrained.children():
ct += 1
if ct <= n_frozen_layers:
for param in child.parameters():
param.requires_grad = False
#the last fc layers n_classes outputs
self.fc = nn.Linear(self.pretrained.fc.out_features, nclasses)
