0
0

使用PyTorch搭建VGG模型进行图像风格迁移实战（附源码和数据集）

需要源码和图片集请点赞关注收藏后评论区留言或者私信~~~

一、VGG模型

VGG模型是科学家们提出的图像分类模型，这一模型采用了简单粗暴的堆砌3×3卷积层的方式构建模型，并花费大量的时间逐层训练，最终在ImageNet图像分类比赛中获得了亚军，这一模型的优点是结构简单，容易理解，便于利用到其他任务当中

VGG-19网络的卷积部分由5哥卷积块构成，每个卷积块中有多个卷积层，结尾处有一个池化层 结构如下图所示

二、图像风格迁移介绍

图像风格迁移是指将一张风格图的风格与另一张内容图的内容想结合并生成新的图像，利用预训练的VGG网络提取图像特征，并基于图像特征组合出了两种特征度量，一种用于表示图像的内容，另一种用于表示图像的风格，它们将这两种特征度量加权组合，通过最优化的方式生成新的图像，使新的图像同时具有一幅图像的风格和另一幅图像的内容

风格图如下 是梵高著名的画作《星空》

内容图如下 选自意大利的一个街道（可以看出是个阳光晴朗的日子，非常的暖色调）

让我们来看看进行图像风格迁移，即把梵高的风格加到这幅图的内容上会是什么效果！

哈哈 显示是有一点抽象和模糊的感觉，但这也正是星空的风格！

三、内容损失函数

内容损失函数用于衡量两幅图像之间的内容差异大小，通过两幅图片由VGG网络某一卷积层提取的特征图来表示

四、风格损失函数

风格损失函数用于衡量两幅图像之间的风格差异大小，首先需要通过计算特征图的Gram矩阵得到图像风格的数学表示

五、主程序代码的实现

程序分为以下几部分

1：图像预处理 接收一个PIL图片，改变图片大小，转换为张量，进行标准化然后乘以255

2：参数定义

3：模型初始化

4：运行主函数

5：利用VGG网络建立损失函数

6：优化

7：可视化

最后 部分源码如下

  1. import torch
  2. import torch.nn as nn
  3. import torchvision
  4. import torchvision.transforms as transforms
  5. from PIL import Image
  7. def g = input.size()
  8.     features = input.view(a * b, c * d)
  9.     G = torch.mm(features, features.t())
  10.     return G
  12. class ContentLoss(nn.Module):
  14.     def __init__(self, target):
  15.         super(ContentLoss, self).__init__()
  16.         self.target = target.detach()
  18.     def forward(self, input):
  19.         self.loss = torch.sum((input-self.target) ** 2) / 2.0
  20.         return input
  22. class Style
  23.     def __init__(self, target_feature):
  24.         super(StyleLoss, self).__init__()
  25.         self.target = gram_matrix(target_feature).detach()
  27.     def forward(self, input):
  28.         a, b, c, d = input.size()
  29.         G = gram_matrix(input)
  30.         self.loss = torch.sum((G-self.target) ** 2) / (4.0 * b * b * c * d)
  31.         return input
  33. class ImagCder:
  35.     def __init__(self, image_size, device):
  37.         self.device = device
  39.         self.preproc = transforms.Compose([
  40.             transforms.Resize(image_size),  # 改变图像大小
  41.             transforms.ToTensor(),
  42.             transforms.Normalize(mean=[0.485, 0.456, 0.406],  # 标准化
  43.                                  std=[1, 1, 1]),
  44.             transforms.Lambda(lambda x: x.mul_(255))
  45.         ])
  47.         self.postproc = transforms.Compose([
  48.             transforms.Lambda(lambda x: x.mul_(1./255)),
  49.             transforms.Normalize(mean=[-0.485, -0.456, -0.406], std=[1,1,1])
  50.         ])
  52.         self.to_image = transforms.ToPILImage()
  54.     def encode(self, image_path):
  55.         image = Image.open(image_path)
  56.         image = self.preproc(image)
  57.         image = image.unsqueeze(0)
  58.         return image.to(self.device, torch.float)
  60.     def decode(self, image):
  61.         image = image.cpu().clone()
  62.         image = image.squeeze()
  63.         image = self.postproc(image)
  64.         image = image.clamp(0, 1)
  65.         return self.to_image(image)
  67. content_layers = ['conv_4_2'] # 内容损失函数使用的卷积层
  68. style_layers = ['conv_1_1', 'conv2_1', 'conv_3_1', 'conv_4_1', 'conv5_1'] # 风格损失函数使用的卷积层
  69. content_weights = [1] # 内容损失函数的权重
  70. style_weights = [1e3, 1e3, 1e3, 1e3, 1e3] # 风格损失函数的权重
  71. num_steps=200 # 最优化的步数
  73. class Mo:
  75.     def __init__(self, device, image_size):
  77.         cnn = torchvision.models.vgg19(weights=True).features.to(device).eval()
  78.         self.cnn = deepcopy(cnn) # 获取预训练的VGG19卷积神经网络
  79.         self.device = device
  81.         self.content_losses = []
  82.         self.style_losses = []
  84.         self.image_proc = ImageCoder(image_size, device)
  86.     def run(self, content_image_path, style_image_path):
  88.         content_image = self.image_proc.encode(content_image_path)
  89.         style_image = self.image_proc.encode(style_image_path)
  91.         self._build(content_image, style_image) # 建立损失函数
  92.         output_image = self._transfer(content_image) # 进行最优化
  94.         return self.image_proc.decode(output_image)
  96.     def _bd(self, content_image, style_image):
  98.         self.model = nn.Sequential()
  100.         block_idx = 1
  101.         conv_idx = 1
  103.         # 逐层遍历VGG19，取用需要的卷积层
  104.         for layer in self.cnn.children():
  106.             # 识别该层类型并进行编号命名
  107.             if= 'conv_{}_{}'.format(block_idx, conv_idx)
  108.                 conv_idx += 1
  109.             elif isinstance(layer, nn.ReLU):
  110.                 name = 'relu_{}_{}'.format(block_idx, conv_idx)
  111.                 layer = nn.ReLU(inplace=False)
  112.             elif isinstance(layer, nn.MaxPool2d):
  113.                 name = 'pool_{}'.format(block_idx)
  114.                 block_idx += 1
  115.                 conv_idx = 1
  116.             elif isinstance(layer, nn.BatchNorm2d):
  117.                 name = 'bn_{}'.format(block_idx)
  118.             else:
  119.                 raise Exception("invalid layer")
  121.             self.model.add_module(name, layer)
  123.             # 添加内容损失函数
  124.             if name in content_layers:
  125.                 target = self.model(content_image).detach()
  126.                 content_loss = ContentLoss(target)
  127.                 self.model.add_module("content_loss_{}_{}".format(block_idx, conv_idx), content_loss)
  128.                 self.content_losses.append(content_loss)
  130.             # 添加风格损失函数
  131.             if name in style_layers:
  132.                 target_feature = self.model(style_image).detach()
  133.                 style_l StyleLoss(target_feature)
  134.                 self.model.add_module("style_loss_{}_{}".format(block_idx, conv_idx), style_loss)
  135.                 self.style_losses.append(style_loss)
  137.         # 留下有用的部分
  138.         i = 0
  139.         for i in range(len(self.model) - 1, -1, -1):
  140.             if isinstance(self.model[i], ContentLoss) or isinstance(self.model[i], StyleLoss):
  141.                 break
  142.         self.model = self.model[:(i + 1)]
  144.     def _transfer(self, content_image):
  146.         output_image = content_image.clone()
  147.         random_image = torch.randn(content_image.data.size(), device=self.device)
  148.         output_image = 0.4 * output_image + 0.6 * random_image
  150.         optimizer = torch.optim.LBFGS([output_image.requires_grad_()])
  152.         print('Optimizing..')
  153.         run = [0]
  154.         while run[0] <= num_steps:
  156.             def closure():
  158.                 optimizer.zero_grad()
  159.                 self.model(output_image)
  160.                 style_score = 0
  161.                 content_score = 0
  163.                 for sl, sw in zip(self.style_losses, style_weights):
  164.                     style_score += sl.loss * sw
  165.                 for cl, cw in zip(self.content_losses, content_weights):
  166.                     content_score += cl.loss * cw
  168.                 loss = style_score + content_score
  169.                 loss.backward()
  171.                 run[0] += 1
  172.                 if run[0] % 50 == 0:
  173.                     print("iteration {}: Loss: {:4f} Style Loss: {:4f} Content Loss: {:4f}"
  174.                           .format(run, loss.item(), style_score.item(), content_score.item()))
  175.                 return loss
  177.             optimizer.step(closure)
  179.         return output_image
  181. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  182. image_size = 256
  183. model = Model(device, image_size)
  185. style_image_path = 
  186. content_image_path = 
  187. out_image = del.run(content_image_path, style_image_path)
  188. plt.imshow(out_image)
  189. plt.show()

** 创作不易 觉得有帮助请点赞关注收藏~~~**

标签： pytorch 深度学习 人工智能
本文转载自: https://blog.csdn.net/jiebaoshayebuhui/article/details/127809992
版权归原作者 showswoller 所有， 如有侵权，请联系我们删除。
登录后发布评论

“使用PyTorch搭建VGG模型进行图像风格迁移实战（附源码和数据集）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？