def __init__(self, n_downsample, input_dim, dim, style_dim, norm, activ, pad_type):
super(VggStyleEncoder, self).__init__()
# self.vgg = models.vgg19(pretrained=True).features
# VggStyleEncoder(3, input_dim=3, dim=64, int(style_dim/SP_input_nc)=512/8, norm='none', activ=relu, pad_type=reflect)
vgg19 = models.vgg19(pretrained=False)
vgg19.load_state_dict(torch.load('/home/ssl/PycharmProjects/ADGAN/data/deepfashion/vgg19-dcbb9e9d.pth'))
self.vgg = vgg19.features
for param in self.vgg.parameters():
param.requires_grad_(False)
self.conv1 = Conv2dBlock(input_dim, dim, 7, 1, 3, norm=norm, activation=activ, pad_type=pad_type) # 3->64,concat,维度不变
dim = dim*2
self.conv2 = Conv2dBlock(dim , dim, 4, 2, 1, norm=norm, activation=activ, pad_type=pad_type) # 128->128，维度减半
dim = dim*2
self.conv3 = Conv2dBlock(dim , dim, 4, 2, 1, norm=norm, activation=activ, pad_type=pad_type) # 256->256，维度减半
dim = dim * 2
self.conv4 = Conv2dBlock(dim, dim, 4, 2, 1, norm=norm, activation=activ, pad_type=pad_type) # 512->512，维度减半
dim = dim * 2#512
self.model = []
self.model += [nn.AdaptiveAvgPool2d(1)] # global average pooling
self.model += [nn.Conv2d(dim, style_dim, 1, 1, 0)]
self.model = nn.Sequential(*self.model)#(1024,64,1,1)
self.output_dim = dim
def __init__(self, device='cpu'):
super(VGG19, self).__init__()
features = list(vgg19(pretrained=True).features)
if device == "cuda":
self.features = nn.ModuleList(features).cuda().eval()
else:
self.features = nn.ModuleList(features).eval()
def __init__(self):
super(VggFeatures, self).__init__()
self.vgg_layers = vgg.vgg19(pretrained=True).features
self.layer_name_mapping = {
'26': "relu4",
'35': "relu5",
}
def __init__(self, i=5, include_max_pool=False):
super(FeatureExtractor, self).__init__()
model = vgg19(pretrained=True)
# Break layers and normalization by Tak-Wai Hui and Wai-Ho Kwok https://github.com/twhui/SRGAN-PyTorch
children = list(model.features.children())
max_pool_indices = [
index for index, m in enumerate(children)
if isinstance(m, tr.nn.MaxPool2d)
]
target_features = children[:max_pool_indices[
i - 1] + 1] if include_max_pool else children[:max_pool_indices[i -
1]]
self.features = tr.nn.Sequential(*target_features)
mean = tr.autograd.Variable(
tr.Tensor([0.485, 0.456, 0.406]).view(
1, 3, 1,
1)) # [0.485-1, 0.456-1, 0.406-1] if input in range [-1,1]
std = tr.autograd.Variable(
tr.Tensor([0.229, 0.224, 0.225]).view(
1, 3, 1,
1)) # [0.229*2, 0.224*2, 0.225*2] if input in range [-1,1]
self.register_buffer('mean', mean)
self.register_buffer('std', std)
def get_network(device):
net = vgg.vgg19(pretrained=True)
# get features from last layer
new_classifier = nn.Sequential(*list(net.classifier.children())[:-1])
net.classifier = new_classifier
return net.to(device)
def _fuse(inputs, model=None, with_exp=False):
with torch.no_grad():
if model is None:
model = vgg19(True)
model.cuda().eval()
tc_inputs = []
relus_acts = []
for input_img in inputs:
tc_input = to_pytorch(input_img)
relus_act, out = get_activation(model, tc_input)
tc_inputs.append(tc_input)
relus_acts.append(relus_act)
saliency_max = None
idx = 0
for relus_list in zip(*relus_acts):
saliency_current, D = fusion_strategy(relus_list, tc_inputs,
with_exp)
idx += 1
if saliency_max is None:
saliency_max = saliency_current
else:
saliency_max = torch.max(saliency_max, saliency_current)
output = np.squeeze(saliency_max.cpu().numpy())
if output.ndim == 3:
output = np.transpose(output, (1, 2, 0))
return output
def __init__(self,
feature_layer=34,
use_bn=False,
use_input_norm=True,
device=torch.device('cpu'),
z_norm=False): #Note: PPON uses cuda instead of CPU
super(VGGFeatureExtractor, self).__init__()
if use_bn:
model = vgg.vgg19_bn(pretrained=True)
else:
model = vgg.vgg19(pretrained=True)
self.use_input_norm = use_input_norm
if self.use_input_norm:
if z_norm: # if input in range [-1,1]
mean = torch.Tensor([0.485-1, 0.456-1, 0.406-1]).view(1, 3, 1, 1).to(device)
std = torch.Tensor([0.229*2, 0.224*2, 0.225*2]).view(1, 3, 1, 1).to(device)
else: # input in range [0,1]
mean = torch.Tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1).to(device)
std = torch.Tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1).to(device)
self.register_buffer('mean', mean)
self.register_buffer('std', std)
self.features = nn.Sequential(*list(model.features.children())[:(feature_layer + 1)])
# No need to BP to variable
for k, v in self.features.named_parameters():
v.requires_grad = False
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(PerceptualLoss, self).__init__()
vgg = vgg19(pretrained=True)
loss_network = nn.Sequential(*list(vgg.features)[:34]).eval()
for param in loss_network.parameters():
param.requires_grad = False
self.loss_network = loss_network
self.mse_loss = nn.MSELoss()
def __init__(self):
super().__init__()
vgg = vgg19(pretrained=True)
features_slice = vgg.features[:35]
perceptual_network = nn.Sequential(*features_slice).eval()
for param in perceptual_network.parameters():
param.requires_grad = False
self.perceptual_network = perceptual_network
def __init__(self):
super(VGGFeatureExtractor, self).__init__()
vgg = vgg19(pretrained=True)
loss_network = nn.Sequential(*list(vgg.features)[:18]).eval()
for param in loss_network.parameters():
param.requires_grad = False
self.loss_network = loss_network
self.perception_loss = nn.MSELoss()
def __init__(self):
super(VGG19,self).__init__()
self.vgg = vgg19(pretrained=True)
self.encoder_1 = self.vgg.features[0:4]
self.encoder_2 = self.vgg.features[4:9]
self.encoder_3 = self.vgg.features[9:18]
self.encoder_4 = self.vgg.features[18:27]
self.encoder_5 = self.vgg.features[27:36]
def __init__(self):
super().__init__()
vgg = vgg19(pretrained=True)
loss_network = nn.Sequential(*list(vgg.features)[:35]).eval()
for param in loss_network.parameters():
param.requires_grad = False
self.loss_network = loss_network
self.l1_loss = nn.L1Loss()
def __init__(self, device):
super(VGGLoss, self).__init__()
vgg19_model = vgg19(pretrained=True, progress=False)
feature_extractor = nn.Sequential(
*list(vgg19_model.features)[:31]).eval()
for param in feature_extractor.parameters():
param.requires_grad = False
self.feature_extractor = feature_extractor.to(device)
self.mse = nn.MSELoss()
def __init__(self):
super(LossNetwork, self).__init__()
self.vgg_layers = vgg.vgg19(pretrained=True).features
self.layer_name_mapping = {
'3': "relu1",
'8': "relu2",
'13': "relu3",
'22': "relu4",
'31': "relu5", #1_2 to 5_2
}
def __init__(self):
super(PerceptualLossVGG19, self).__init__()
vgg = vgg19(pretrained=True)
loss_network = nn.Sequential(*list(vgg.features)[:36]).eval()
if torch.cuda.is_available():
loss_network = loss_network.cuda()
for param in loss_network.parameters():
param.requires_grad = False
self.loss_network = loss_network
self.mse_loss = nn.MSELoss()
def __init__(self):
super(LossNetwork, self).__init__()
self.vgg_layers = vgg.vgg19(pretrained=True).features
self.detach_layers = {
'3': "relu1",
'8': "relu2",
'17': "relu3",
'26': "relu4",
'35': "relu5",
}
def __init__(self):
super(VggNetwork, self).__init__()
self.vgg_layers = vgg.vgg19(pretrained=True).features
self.layer_name_mapping = {
'3': "relu1",
'8': "relu2",
'17': "relu3",
'26': "relu4",
'35': "relu5",
}
def __init__(self):
super(VggNetwork, self).__init__()
self.vgg_layers = vgg.vgg19(pretrained=True).features
self.layer_name_mapping = {
'2': "conv1",
'7': "conv2",
'16': "conv3",
'25': "conv4",
'34': "conv5",
}
def __init__(self):
super(SourceNetwork, self).__init__()
vgg = vgg19(True)
layers = vgg.features
# print(layers)
self.layer1 = layers[:5]
self.layer2 = layers[5:10]
self.layer3 = layers[10:19]
self.layer4 = layers[19:28]
self.layer5 = layers[28:]
def __init__(self, n_downsample, input_dim, dim, style_dim, norm, activ,
pad_type):
super(VggStyleEncoder, self).__init__()
# self.vgg = models.vgg19(pretrained=True).features
vgg19 = models.vgg19(pretrained=False)
vgg19.load_state_dict(
torch.load('/nitthilan/data/ADGAN/data/vgg19-dcbb9e9d.pth'))
self.vgg = vgg19.features
for param in self.vgg.parameters():
param.requires_grad_(False)
self.conv1 = Conv2dBlock(input_dim,
dim,
7,
1,
3,
norm=norm,
activation=activ,
pad_type=pad_type) # 3->64,concat
dim = dim * 2
self.conv2 = Conv2dBlock(dim,
dim,
4,
2,
1,
norm=norm,
activation=activ,
pad_type=pad_type) # 128->128
dim = dim * 2
self.conv3 = Conv2dBlock(dim,
dim,
4,
2,
1,
norm=norm,
activation=activ,
pad_type=pad_type) # 256->256
dim = dim * 2
self.conv4 = Conv2dBlock(dim,
dim,
4,
2,
1,
norm=norm,
activation=activ,
pad_type=pad_type) # 512->512
dim = dim * 2
self.model = []
self.model += [nn.AdaptiveAvgPool2d(1)] # global average pooling
self.model += [nn.Conv2d(dim, style_dim, 1, 1, 0)]
self.model = nn.Sequential(*self.model)
self.output_dim = dim
def __init__(self):
super(GeneratorLoss, self).__init__()
vgg = vgg19(pretrained=True)
loss_network = nn.Sequential(*list(vgg.features)[:35]).eval()
for param in loss_network.parameters():
param.requires_grad = False
self.loss_network = loss_network
self.mse_loss = nn.MSELoss()
self.tv_loss = TVLoss()
self.content_loss = nn.L1Loss()
self.text_loss = TextureLoss()
def __init__(self, lambda1, lambda2, lambda3):
super(GeneratorLoss, self).__init__()
vgg = vgg19(pretrained=True)
self.lambda1 = lambda1
self.lambda2 = lambda2
self.lambda3 = lambda3
loss_network = nn.Sequential(*list(vgg.features)[:37]).eval()
for param in loss_network.parameters():
param.requires_grad = False
self.loss_network = loss_network
self.mse_loss = nn.MSELoss()
def vgg19_bn_planet(pretrained=True):
net = vgg19(num_classes=17)
if pretrained:
state_dict = net.state_dict()
# load pretrained dictionary
pretrained_dict = model_zoo.load_url(model_urls['vgg19'])
state_dict.update({
key: pretrained_dict[key]
for key in state_dict if 'classifier' not in key
})
net.load_state_dict(state_dict)
return net
def __init__(self):
super(PerceptualLoss, self).__init__()
self.model = (vgg19(pretrained=True).to(device))
trainable_(self.model, False)
self.loss = nn.MSELoss().to(device)
self.vgg_layers = self.model.features
self.layer_names = {
'0': 'conv1_1',
'3': 'relu1_2',
'6': 'relu2_1',
'8': 'relu2_2',
'11': 'relu3_1'
}
def __init__(self):
super(LossNetwork, self).__init__()
vggn = vgg.vgg19(pretrained=True)
vggn.features[0] = nn.Conv2d(1, 64, kernel_size=3, padding=1)
self.vgg_layers = vggn.features
self.layer_name_mapping = {
'3': "relu1",
'8': "relu2",
'17': "relu3",
'26': "relu4",
'35': "relu5",
}
def __init__(self, args): super(GeneratorLoss, self).__init__() # note that vgg is for RGB image, hence not compatible with gray-scale self.vgg = vgg19(pretrained=True) self.loss_network = nn.Sequential(*list(self.vgg.features)[:35]).eval() for param in self.loss_network.parameters(): param.requires_grad = False # average over all the pixels in the batch self.mse_loss = nn.MSELoss(reduction='mean') self.tv_loss = TVLoss() self.bce_loss = nn.BCELoss(reduction='mean') self.adversarial_weight = args.gamma self.perception_weight = args.sigma
def __init__(self, layers = [8, 17, 26, 35], replace_pooling = False):
super(TextureLoss, self).__init__()
self.layers = layers
self.model = vgg19(pretrained=True).features
if replace_pooling:
self.model._modules['4'] = nn.AvgPool2d((2,2), (2,2), (1,1))
self.model._modules['9'] = nn.AvgPool2d((2,2), (2,2), (1,1))
self.model._modules['18'] =nn.AvgPool2d((2,2), (2,2), (1,1))
self.model._modules['27'] =nn.AvgPool2d((2,2), (2,2), (1,1))
self.model._modules['36'] = nn.AvgPool2d((2,2), (2,2), (1,1))
for param in self.model.parameters():
param.requires_grad = False
def __init__(self,
weight_perception=0.006,
weight_adversarial=0.001,
weight_image=1,
network="vgg16"):
super(GeneratorLoss, self).__init__()
self.network = network
self.weight_image = weight_image
self.weight_adversarial = weight_adversarial
self.weight_perception = weight_perception
if network == "vgg16":
pretrained_net = vgg16(pretrained=True)
loss_network = nn.Sequential(
*list(pretrained_net.features)[:31]).eval()
elif network == "vgg19":
pretrained_net = vgg19(pretrained=True)
loss_network = nn.Sequential(
*list(pretrained_net.features)[:37]).eval()
elif network == "resnet101":
pretrained_net = resnet101(pretrained=True)
loss_network = nn.Sequential(
*list(pretrained_net.classifier.children())[:-1]).eval()
elif network == "vgg16vgg19":
pretrained_net_vgg16 = vgg16(pretrained=True)
loss_network = nn.Sequential(
*list(pretrained_net_vgg16.features)[:31]).eval()
pretrained_net_vgg19 = vgg19(pretrained=True)
loss_network_vgg19 = nn.Sequential(
*list(pretrained_net_vgg19.features)[:27]).eval()
for param in loss_network_vgg19.parameters():
param.requires_grad = False
self.loss_network_vgg19 = loss_network_vgg19
for param in loss_network.parameters():
param.requires_grad = False
self.loss_network = loss_network
self.mse_loss = nn.MSELoss()
def __init__(self):
super().__init__()
features = vgg19(pretrained=True).features[:30]
self.features = nn.ModuleList(list(features)).eval().to(device)
self.mean = torch.tensor([0.485, 0.456, 0.406]).view(-1, 1,
1).to(device)
self.std = torch.tensor([0.229, 0.224, 0.225]).view(-1, 1,
1).to(device)
for param in self.features.parameters():
param.requires_grad = False
self.mean.requires_grad = False
self.std.requires_grad = False
def test_vgg19(self):
# VGG 19-layer model (configuration "E")
x = Variable(torch.randn(BATCH_SIZE, 3, 224, 224).fill_(1.0))
self.exportTest(toC(vgg19()), toC(x))
def test_vgg19(self):
state_dict = model_zoo.load_url(model_urls['vgg19'], progress=False)
self.run_model_test(vgg19(), train=False, batch_size=BATCH_SIZE,
state_dict=state_dict)
