def vgg(**config):
dataset = config.pop('dataset', 'imagenet')
depth = config.pop('depth', 16)
bn = config.pop('bn', True)
if dataset == 'imagenet':
config.setdefault('num_classes', 1000)
if depth == 11:
if bn is False:
return vgg11(pretrained=False, **config)
else:
return vgg11_bn(pretrained=False, **config)
if depth == 13:
if bn is False:
return vgg13(pretrained=False, **config)
else:
return vgg13_bn(pretrained=False, **config)
if depth == 16:
if bn is False:
return vgg16(pretrained=False, **config)
else:
return vgg16_bn(pretrained=False, **config)
if depth == 19:
if bn is False:
return vgg19(pretrained=False, **config)
else:
return vgg19_bn(pretrained=False, **config)
elif dataset == 'cifar10':
config.setdefault('num_classes', 10)
elif dataset == 'cifar100':
config.setdefault('num_classes', 100)
config.setdefault('batch_norm', bn)
return VGG(model_name[depth], **config)
def __init__(self):
super(VGG11Base, self).__init__()
vgg11 = vgg.vgg11_bn(pretrained=True)
vgg11.features[14] = nn.MaxPool2d((2, 2), (2, 1),
(0, 1)) # batch,256,4,26
vgg11.features[21] = nn.MaxPool2d((2, 2), (2, 1),
(0, 1)) # batch,512,2,27
vgg11.features[22] = nn.Conv2d(512,
512,
kernel_size=(2, 2),
stride=(2, 1),
padding=(0, 0)) # batch,512,1,26
self.vgg11_base = vgg11.features[:25]
def vgg_11(batch_norm=True, pretrained=False, fixed_feature=True):
""" VGG 11-layer model from torchvision's vgg model.
:param batch_norm: train model with batch normalization
: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.
"""
if batch_norm:
from torchvision.models.vgg import vgg11_bn
model = vgg11_bn(pretrained)
else:
from torchvision.models.vgg import vgg11
model = vgg11(pretrained)
ff = True if pretrained and fixed_feature else False
return _VGG(model, model.features, ff)
def __init__(self,
subtype='vgg16',
out_stages=[2, 3, 4],
backbone_path=None,
pretrained=False):
super(VGG, self).__init__()
self.out_stages = out_stages
self.backbone_path = backbone_path
self.pretrained = pretrained
if subtype == 'vgg11':
self.pretrained = True
features = vgg11_bn(pretrained=self.pretrained).features
self.out_channels = [64, 128, 256, 512, 512]
elif subtype == 'vgg13':
self.pretrained = True
features = vgg13_bn(pretrained=self.pretrained).features
self.out_channels = [64, 128, 256, 512, 512]
elif subtype == 'vgg16':
self.pretrained = True
features = vgg16_bn(pretrained=self.pretrained).features
self.out_channels = [64, 128, 256, 512, 512]
elif subtype == 'vgg19':
self.pretrained = True
features = vgg19_bn(pretrained=self.pretrained).features
self.out_channels = [64, 128, 256, 512, 512]
else:
raise NotImplementedError
self.out_channels = self.out_channels[self.out_stages[0]:self.
out_stages[-1] + 1]
self.conv1 = nn.Sequential(*list(features.children())[:7])
self.layer1 = nn.Sequential(*list(features.children())[7:14])
self.layer2 = nn.Sequential(*list(features.children())[14:24])
self.layer3 = nn.Sequential(*list(features.children())[24:34])
self.layer4 = nn.Sequential(*list(features.children())[34:43])
if not self.pretrained:
if self.backbone_path:
self.pretrained = True
self.backbone.load_state_dict(torch.load(self.backbone_path))
else:
self.init_weights()
def __init__(self, backbone, num_color, num_style, num_season,
num_category):
super(Model, self).__init__()
if backbone == 'mobilenet_v2':
base_network = mobilenet_v2(pretrained=True)
self.features = base_network.features
self.out_filters = base_network.last_channel
elif backbone == 'vgg11_bn':
base_network = vgg11_bn(pretrained=True)
self.features = base_network.features
self.out_filters = 512
else:
raise Exception(f"[!] Invalid model: {backbone}")
self.avg_pool = nn.Sequential(nn.ReflectionPad2d(1),
nn.Conv2d(self.out_filters, 512, 3),
nn.ReLU(), nn.AdaptiveAvgPool2d((7, 7)))
self.color_classifier = nn.Linear(512 * 7 * 7, num_color)
self.style_classifier = nn.Linear(512 * 7 * 7, num_style)
# self.part_classifier = nn.Linear(512 * 7 * 7, num_part)
self.season_classifier = nn.Linear(512 * 7 * 7, num_season)
self.category_classifier = nn.Linear(512 * 7 * 7, num_category)
import torch
from torchvision.models.vgg import vgg11_bn
vgg = vgg11_bn(pretrained=False)
class model(torch.nn.Module):
def __init__(self, ):
super().__init__()
self.conv1 = torch.nn.Conv2d(1, 3, 3, stride=1, padding=1)
# self.layer = vgg.features
self.layer1 = torch.nn.Sequential(
*[vgg.features[i] for i in range(0, 4, 1)])
self.layer2 = torch.nn.Sequential(
*[vgg.features[i] for i in range(4, 8, 1)])
self.layer3 = torch.nn.Sequential(
*[vgg.features[i] for i in range(8, 14, 1)])
self.layer4 = torch.nn.Sequential(
*[vgg.features[i] for i in range(15, 22, 1)])
self.layer5 = torch.nn.Sequential(
*[vgg.features[i] for i in range(22, 29, 1)])
# embedding_dim = 10
self.linear1 = torch.nn.Linear(512, 100)
self.linear2 = torch.nn.Linear(100, 100)
self.linear3 = torch.nn.Linear(100, 10)
o = self.layer_uo(u) + self.layer_so(s)
o = self.layer_oo(nn.Tanh()(o)) #torch.Size([3, 37])
outputs.append(o)
#update c from o(evaluating) or ground truth(training)
if self.training:
c = labels[:, :, frame]
else:
c = nn.Softmax(dim=1)(o).detach()
c = (c == c.max(1, keepdim=True)[0]).float()
outputs = torch.stack(outputs, dim=-1) #torch.Size([3, 37, 7])
if return_alpha:
alphas = torch.stack(alphas, dim=-1) #torch.Size([3, 26, 7])
return outputs, alphas
return outputs
def _get_alpha_u(self, f, s):
a = self.layer_va(nn.Tanh()(self.layer_fa(f.transpose(1, 2)) +
self.layer_sa(s).unsqueeze(1)))
a = self.layer_aa(nn.Tanh()(a)).squeeze(-1)
alpha = nn.Softmax(dim=1)(a) #[3,26]
u = (f * alpha.unsqueeze(1)).sum(-1)
return alpha, u
# check the model
if __name__ == '__main__':
x = torch.randn(3, 3, 32, 100)
vgg_ = vgg.vgg11_bn(pretrained=True)
vgg_v = OldAttention()
a = vgg_v(x)
def recordVGG(info):
global SKIP
import torchvision.models.vgg as vggGen
if not (SKIP and 'vgg11' in info['name_list']):
INFO("proceeding for VGG11...")
net = vggGen.vgg11(pretrained=True).cuda()
sum = __summary(net, [3, 224, 224], verbose=True)
__writeInfoJSON(sum, 'vgg11')
else:
INFO("Skip VGG11")
if not (SKIP and 'vgg13' in info['name_list']):
INFO("proceeding for VGG13...")
net = vggGen.vgg13(pretrained=True).cuda()
sum = __summary(net, [3, 224, 224], verbose=True)
__writeInfoJSON(sum, 'vgg13')
else:
INFO("Skip VGG13")
if not (SKIP and 'vgg16' in info['name_list']):
INFO("proceeding for VGG16...")
net = vggGen.vgg16(pretrained=True).cuda()
sum = __summary(net, [3, 224, 224], verbose=True)
__writeInfoJSON(sum, 'vgg16')
else:
INFO("Skip VGG16")
if not (SKIP and 'vgg19' in info['name_list']):
INFO("proceeding for VGG19...")
net = vggGen.vgg19(pretrained=True).cuda()
sum = __summary(net, [3, 224, 224], verbose=True)
__writeInfoJSON(sum, 'vgg19')
else:
INFO("Skip VGG19")
if not (SKIP and 'vgg11_bn' in info['name_list']):
INFO("proceeding for VGG11_bn...")
net = vggGen.vgg11_bn(pretrained=True).cuda()
sum = __summary(net, [3, 224, 224], verbose=True)
__writeInfoJSON(sum, 'vgg11_bn')
else:
INFO("Skip VGG11_bn")
if not (SKIP and 'vgg13_bn' in info['name_list']):
INFO("proceeding for VGG13_bn...")
net = vggGen.vgg13_bn(pretrained=True).cuda()
sum = __summary(net, [3, 224, 224], verbose=True)
__writeInfoJSON(sum, 'vgg13_bn')
else:
INFO("Skip VGG13_bn")
if not (SKIP and 'vgg16_bn' in info['name_list']):
INFO("proceeding for VGG16_bn...")
net = vggGen.vgg16_bn(pretrained=True).cuda()
sum = __summary(net, [3, 224, 224], verbose=True)
__writeInfoJSON(sum, 'vgg16_bn')
else:
INFO("Skip VGG16_bn")
if not (SKIP and 'vgg19_bn' in info['name_list']):
INFO("proceeding for VGG19_bn...")
net = vggGen.vgg19_bn(pretrained=True).cuda()
sum = __summary(net, [3, 224, 224], verbose=True)
__writeInfoJSON(sum, 'vgg19_bn')
else:
INFO("Skip VGG19_bn")
def load_model(model_name, classes=1000, pretrained=True, in_channels=3):
"""Load the specified VGG architecture for ImageNet
Args:
model_name: VGG architecture type
classes: number of predicted classes
pretrained: load pretrained network on ImageNet
"""
if pretrained:
assert classes == 1000, "Pretrained models are provided only for Imagenet."
kwargs = {'num_classes': classes}
if model_name == 'vgg11':
net = VGG.vgg11(pretrained=pretrained, **kwargs)
if in_channels != 3:
input_layer = nn.Conv2d(in_channels, 64, kernel_size=3, padding=1)
nn.init.kaiming_normal_(input_layer.weight,
mode='fan_out',
nonlinearity='relu')
input_layer.bias.data.zero_()
net.features[0] = input_layer
elif model_name == 'vgg13':
net = VGG.vgg13(pretrained=pretrained, **kwargs)
if in_channels != 3:
input_layer = nn.Conv2d(in_channels, 64, kernel_size=3, padding=1)
nn.init.kaiming_normal_(input_layer.weight,
mode='fan_out',
nonlinearity='relu')
input_layer.bias.data.zero_()
net.features[0] = input_layer
elif model_name == 'vgg16':
net = VGG.vgg16(pretrained=pretrained, **kwargs)
if in_channels != 3:
input_layer = nn.Conv2d(in_channels, 64, kernel_size=3, padding=1)
nn.init.kaiming_normal_(input_layer.weight,
mode='fan_out',
nonlinearity='relu')
input_layer.bias.data.zero_()
net.features[0] = input_layer
elif model_name == 'vgg19':
net = VGG.vgg19(pretrained=pretrained, **kwargs)
if in_channels != 3:
input_layer = nn.Conv2d(in_channels, 64, kernel_size=3, padding=1)
nn.init.kaiming_normal_(input_layer.weight,
mode='fan_out',
nonlinearity='relu')
input_layer.bias.data.zero_()
net.features[0] = input_layer
elif model_name == 'vgg11bn':
net = VGG.vgg11_bn(pretrained=pretrained, **kwargs)
if in_channels != 3:
input_layer = nn.Conv2d(in_channels, 64, kernel_size=3, padding=1)
nn.init.kaiming_normal_(input_layer.weight,
mode='fan_out',
nonlinearity='relu')
input_layer.bias.data.zero_()
net.features[0] = input_layer
elif model_name == 'vgg13bn':
net = VGG.vgg13_bn(pretrained=pretrained, **kwargs)
if in_channels != 3:
input_layer = nn.Conv2d(in_channels, 64, kernel_size=3, padding=1)
nn.init.kaiming_normal_(input_layer.weight,
mode='fan_out',
nonlinearity='relu')
input_layer.bias.data.zero_()
net.features[0] = input_layer
elif model_name == 'vgg16bn':
net = VGG.vgg16_bn(pretrained=pretrained, **kwargs)
if in_channels != 3:
input_layer = nn.Conv2d(in_channels, 64, kernel_size=3, padding=1)
nn.init.kaiming_normal_(input_layer.weight,
mode='fan_out',
nonlinearity='relu')
input_layer.bias.data.zero_()
net.features[0] = input_layer
elif model_name == 'vgg19bn':
net = VGG.vgg19_bn(pretrained=pretrained, **kwargs)
if in_channels != 3:
input_layer = nn.Conv2d(in_channels, 64, kernel_size=3, padding=1)
nn.init.kaiming_normal_(input_layer.weight,
mode='fan_out',
nonlinearity='relu')
input_layer.bias.data.zero_()
net.features[0] = input_layer
elif model_name == 'vgg19_orig':
net = VGG.vgg19(pretrained=False, **kwargs)
if in_channels != 3:
input_layer = nn.Conv2d(in_channels, 64, kernel_size=3, padding=1)
net.features[0] = input_layer
init_weights_vgg_orig(net)
elif model_name == 'alexnet':
net = AlexNet(pretrained=pretrained, **kwargs)
if in_channels != 3:
input_layer = nn.Conv2d(in_channels,
64,
kernel_size=11,
stride=4,
padding=2)
nn.init.kaiming_normal_(input_layer.weight,
mode='fan_out',
nonlinearity='relu')
input_layer.bias.data.zero_()
net.features[0] = input_layer
elif model_name == 'lenet':
kwargs['in_channels'] = in_channels
net = lenet(**kwargs)
else:
raise ValueError("Unsupported model architecture.")
return net
import sys
sys.path.insert(0,'.')
import torch
from torch.autograd import Variable
from torchvision.models.vgg import vgg11_bn
import pytorch_to_caffe
if __name__=='__main__':
name='vgg11_bn'
net=vgg11_bn(True)
net.eval()
input=Variable(torch.ones([1,3,224,224]))
pytorch_to_caffe.trans_net(net,input,name)
pytorch_to_caffe.save_prototxt('{}.prototxt'.format(name))
pytorch_to_caffe.save_caffemodel('{}.caffemodel'.format(name))
def _create_model(self, scratch: bool, num_classes: int):
model = vgg11_bn(pretrained=not scratch)
num_features = 4096
model.classifier[6] = nn.Linear(num_features, num_classes)
print("create model {}".format(model))
return model
