from __future__ import print_functionimport torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optimfrom PIL import Image
import matplotlib.pyplot as pltimport torchvision.transforms as transforms
import torchvision.models as modelsimport copy

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

#输出图片的期望大小
imsize = 512 if torch.cuda.is_available() else 128  # 如果使用的设备不是GPU，那么就使用小点的大小loader = transforms.Compose([transforms.Resize(imsize),  # 输入图像的规模，调整其大小transforms.ToTensor()])  # 将其转换成torch张量def image_loader(image_name):image = Image.open(image_name)# 用来满足网络的输入维度的假batch维度，即不足之处补0image = loader(image).unsqueeze(0)return image.to(device, torch.float)#下载的风格图像可很容图像
style_img = image_loader("./data/imagese/picasso.jpg")
content_img = image_loader("./data/images/dancing.jpg")#断言风格图像和内容图像是否大小一致，如果大小不一致则报错，说明需要大小一致的内容和风格图像
assert style_img.size() == content_img.size(), \"we need to import style and content images of the same size"

unloader = transforms.ToPILImage()  # 将图像再次转换成PIL图像plt.ion()def imshow(tensor, title=None):  #该函数用来显示你上传的内容和风格两张图像image = tensor.cpu().clone()  # 克隆张量并不进行更改image = image.squeeze(0)      # 移除假batch维度，即删掉上面添加的0remove the fake batch dimensionimage = unloader(image)       #将图像转换成PIL图像plt.imshow(image)             #显示图像if title is not None:plt.title(title) #title用于为图片标注标题plt.pause(0.001) # 稍作停顿，以便更新绘图plt.figure()
imshow(style_img, title='Style Image')plt.figure()
imshow(content_img, title='Content Image')

class ContentLoss(nn.Module):def __init__(self, target,):super(ContentLoss, self).__init__()# 我们从用于动态计算梯度的树中“分离”目标内容：这是一个状态值，而不是一个变量# 否则该标准的forward方法将抛出一个errorself.target = target.detach()def forward(self, input):self.loss = F.mse_loss(input, self.target)return input

def gram_matrix(input):a, b, c, d = input.size()  # a=batch size(=1)# b=number of feature maps# (c,d)=dimensions of a f. map (N=c*d)features = input.view(a * b, c * d)  # resise F_XL into \hat F_XLG = torch.mm(features, features.t())  # 计算gram产出# 我们通过在每一个特征映射中数亿元素数量的方法来规范化gram矩阵的值return G.div(a * b * c * d)

class StyleLoss(nn.Module):def __init__(self, target_feature):super(StyleLoss, self).__init__()self.target = gram_matrix(target_feature).detach()def forward(self, input):G = gram_matrix(input)self.loss = F.mse_loss(G, self.target)return input

cnn = models.vgg19(pretrained=True).features.to(device).eval()

cnn_normalization_mean = torch.tensor([0.485, 0.456, 0.406]).to(device)
cnn_normalization_std = torch.tensor([0.229, 0.224, 0.225]).to(device)# 创建一个模块去规范化输入图像，所以我们能够轻易地将其输入到nn.Sequential
class Normalization(nn.Module):def __init__(self, mean, std):super(Normalization, self).__init__()# 使用.view方法去将mean和std值变为[C x 1 x 1]维，所以他们能够直接与形状为[B x C x H x W]的图像张量工作# B是batch大小，C是通道数，H是高，W是宽度self.mean = torch.tensor(mean).view(-1, 1, 1)self.std = torch.tensor(std).view(-1, 1, 1)def forward(self, img):#规范化imgreturn (img - self.mean) / self.std

# 想要用来计算风格/内容损失的层次深度
content_layers_default = ['conv_4']
style_layers_default = ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5']def get_style_model_and_losses(cnn, normalization_mean, normalization_std,style_img, content_img,content_layers=content_layers_default,style_layers=style_layers_default):cnn = copy.deepcopy(cnn)# 规范化模块normalization = Normalization(normalization_mean, normalization_std).to(device)# 只是为了获得迭代入口或内容/风格损失content_losses = []style_losses = []# 假设cnn是一个nn.Sequential，所以我们创建了一个新的nn.Sequential去放入假设被顺序激活的模块model = nn.Sequential(normalization)i = 0  # 每次看见卷积时自增for layer in cnn.children(): //去判断cnn中的子序列是什么类型的层if isinstance(layer, nn.Conv2d):i += 1name = 'conv_{}'.format(i)elif isinstance(layer, nn.ReLU):name = 'relu_{}'.format(i)# 本地版本没有和我们下面插入的ContentLoss和StyleLoss相处地很好# 所以我们使用另一个版本来替代它layer = nn.ReLU(inplace=False)elif isinstance(layer, nn.MaxPool2d):name = 'pool_{}'.format(i)elif isinstance(layer, nn.BatchNorm2d):name = 'bn_{}'.format(i)else:raise RuntimeError('Unrecognized layer: {}'.format(layer.__class__.__name__))//只有是上面几种类型的层才会添加到规范化的model中model.add_module(name, layer)if name in content_layers: //如果该name存在于content_layers，就会为其添加内容损失的计算# 添加内容损失target = model(content_img).detach()content_loss = ContentLoss(target)model.add_module("content_loss_{}".format(i), content_loss)content_losses.append(content_loss)if name in style_layers: //如果该name存在于style_layers，就会为其添加风格损失的计算# 添加风格损失target_feature = model(style_img).detach()style_loss = StyleLoss(target_feature)model.add_module("style_loss_{}".format(i), style_loss)style_losses.append(style_loss)# 现在我们在最后一个内容和风格损失后修建层次for i in range(len(model) - 1, -1, -1): //由后向前获得model的值if isinstance(model[i], ContentLoss) or isinstance(model[i], StyleLoss):breakmodel = model[:(i + 1)]return model, style_losses, content_losses

input_img = content_img.clone()
# 如果你想要使用白噪声，请取消下面一行的注释
# input_img = torch.randn(content_img.data.size(), device=device)# 添加原始输入图像到figure:
plt.figure()
imshow(input_img, title='Input Image')

def get_input_optimizer(input_img):# 该行用于显示输入是一个需要梯度的参数optimizer = optim.LBFGS([input_img.requires_grad_()])return optimizer

def run_style_transfer(cnn, normalization_mean, normalization_std,content_img, style_img, input_img, num_steps=300,style_weight=1000000, content_weight=1):"""运行风格转移"""print('Building the style transfer model..')model, style_losses, content_losses = get_style_model_and_losses(cnn,normalization_mean, normalization_std, style_img, content_img)optimizer = get_input_optimizer(input_img)print('Optimizing..')run = [0]while run[0] <= num_steps:def closure():# 修正更新过的输入图像的值input_img.data.clamp_(0, 1)optimizer.zero_grad()model(input_img)style_score = 0content_score = 0for sl in style_losses:style_score += sl.lossfor cl in content_losses:content_score += cl.lossstyle_score *= style_weightcontent_score *= content_weightloss = style_score + content_scoreloss.backward()run[0] += 1if run[0] % 50 == 0:print("run {}:".format(run))print('Style Loss : {:4f} Content Loss: {:4f}'.format(style_score.item(), content_score.item()))print()return style_score + content_scoreoptimizer.step(closure)# 最后一次修正input_img.data.clamp_(0, 1)return input_img

output = run_style_transfer(cnn, cnn_normalization_mean, cnn_normalization_std,content_img, style_img, input_img)plt.figure()
imshow(output, title='Output Image')# sphinx_gallery_thumbnail_number = 4
plt.ioff()
plt.show()

(deeplearning2) userdeMBP:neural transfer user$ python neural_style_tutorial.py
Downloading: "https://download.pytorch.org/models/vgg19-dcbb9e9d.pth" to /Users/user/.torch/models/vgg19-dcbb9e9d.pth
100.0%
Building the style transfer model..
neural_style_tutorial.py:121: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).self.mean = torch.tensor(mean).view(-1, 1, 1)
neural_style_tutorial.py:122: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).self.std = torch.tensor(std).view(-1, 1, 1)
Optimizing..
run [50]:
Style Loss : 93.626976 Content Loss: 17.819944run [100]:
Style Loss : 22.882374 Content Loss: 15.977382run [150]:
Style Loss : 9.978903 Content Loss: 14.216763run [200]:
Style Loss : 5.153259 Content Loss: 12.498219run [250]:
Style Loss : 3.383650 Content Loss: 10.965824run [300]:
Style Loss : 2.633158 Content Loss: 9.868271