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

分手后的思念是犯贱 2023-09-30 16:41 28阅读 0赞

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

## 一、VGG模型 ##

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

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

![7f560a1a56f44fc6a013d3f6d482d651.png][]

## 二、图像风格迁移介绍 ##

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

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

![89a6f7a934ba45d4a62ae0daeac16ac9.jpeg][]

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

![48fa3c7ccb0c418d97cad87cbe199d3d.jpeg][]

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

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

![5ecbb43be9d84e1683b4738d714a0d3f.png][]

## 三、内容损失函数 ##

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

## 四、风格损失函数 ##

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

## 五、主程序代码的实现 ##

程序分为以下几部分

> 1：图像预处理 接收一个PIL图片，改变图片大小，转换为张量，进行标准化然后乘以255
> 
> 2：参数定义
> 
> 3：模型初始化
> 
> 4：运行主函数
> 
> 5：利用VGG网络建立损失函数
> 
> 6：优化
> 
> 7：可视化

最后 部分源码如下

import torch
    import torch.nn as nn
    import torchvision
    import torchvision.transforms as transforms
    from PIL import Image
    
    
    def g = input.size()
        features = input.view(a * b, c * d)
        G = torch.mm(features, features.t())
        return G
    
    class ContentLoss(nn.Module):
    
        def __init__(self, target):
            super(ContentLoss, self).__init__()
            self.target = target.detach()
    
        def forward(self, input):
            self.loss = torch.sum((input-self.target) ** 2) / 2.0
            return input
    
    
    class Style
        def __init__(self, target_feature):
            super(StyleLoss, self).__init__()
            self.target = gram_matrix(target_feature).detach()
    
        def forward(self, input):
            a, b, c, d = input.size()
            G = gram_matrix(input)
            self.loss = torch.sum((G-self.target) ** 2) / (4.0 * b * b * c * d)
            return input
    
    
    class ImagCder:
    
        def __init__(self, image_size, device):
    
            self.device = device
    
            self.preproc = transforms.Compose([
                transforms.Resize(image_size),  # 改变图像大小
                transforms.ToTensor(),
                transforms.Normalize(mean=[0.485, 0.456, 0.406],  # 标准化
                                     std=[1, 1, 1]),
                transforms.Lambda(lambda x: x.mul_(255))
            ])
    
            self.postproc = transforms.Compose([
                transforms.Lambda(lambda x: x.mul_(1./255)),
                transforms.Normalize(mean=[-0.485, -0.456, -0.406], std=[1,1,1])
            ])
    
            self.to_image = transforms.ToPILImage()
    
        def encode(self, image_path):
            image = Image.open(image_path)
            image = self.preproc(image)
            image = image.unsqueeze(0)
            return image.to(self.device, torch.float)
    
        def decode(self, image):
            image = image.cpu().clone()
            image = image.squeeze()
            image = self.postproc(image)
            image = image.clamp(0, 1)
            return self.to_image(image)
    
    content_layers = ['conv_4_2'] # 内容损失函数使用的卷积层
    style_layers = ['conv_1_1', 'conv2_1', 'conv_3_1', 'conv_4_1', 'conv5_1'] # 风格损失函数使用的卷积层
    content_weights = [1] # 内容损失函数的权重
    style_weights = [1e3, 1e3, 1e3, 1e3, 1e3] # 风格损失函数的权重
    num_steps=200 # 最优化的步数
    
    
    class Mo:
    
        def __init__(self, device, image_size):
    
            cnn = torchvision.models.vgg19(weights=True).features.to(device).eval()
            self.cnn = deepcopy(cnn) # 获取预训练的VGG19卷积神经网络
            self.device = device
    
            self.content_losses = []
            self.style_losses = []
    
            self.image_proc = ImageCoder(image_size, device)
    
        def run(self, content_image_path, style_image_path):
    
            content_image = self.image_proc.encode(content_image_path)
            style_image = self.image_proc.encode(style_image_path)
    
            self._build(content_image, style_image) # 建立损失函数
            output_image = self._transfer(content_image) # 进行最优化
    
            return self.image_proc.decode(output_image)
    
        def _bd(self, content_image, style_image):
    
            self.model = nn.Sequential()
    
            block_idx = 1
            conv_idx = 1
    
            # 逐层遍历VGG19，取用需要的卷积层
            for layer in self.cnn.children():
    
                # 识别该层类型并进行编号命名
                if= 'conv_{}_{}'.format(block_idx, conv_idx)
                    conv_idx += 1
                elif isinstance(layer, nn.ReLU):
                    name = 'relu_{}_{}'.format(block_idx, conv_idx)
                    layer = nn.ReLU(inplace=False)
                elif isinstance(layer, nn.MaxPool2d):
                    name = 'pool_{}'.format(block_idx)
                    block_idx += 1
                    conv_idx = 1
                elif isinstance(layer, nn.BatchNorm2d):
                    name = 'bn_{}'.format(block_idx)
                else:
                    raise Exception("invalid layer")
    
                self.model.add_module(name, layer)
    
                # 添加内容损失函数
                if name in content_layers:
                    target = self.model(content_image).detach()
                    content_loss = ContentLoss(target)
                    self.model.add_module("content_loss_{}_{}".format(block_idx, conv_idx), content_loss)
                    self.content_losses.append(content_loss)
    
                # 添加风格损失函数
                if name in style_layers:
                    target_feature = self.model(style_image).detach()
                    style_l StyleLoss(target_feature)
                    self.model.add_module("style_loss_{}_{}".format(block_idx, conv_idx), style_loss)
                    self.style_losses.append(style_loss)
    
            # 留下有用的部分
            i = 0
            for i in range(len(self.model) - 1, -1, -1):
                if isinstance(self.model[i], ContentLoss) or isinstance(self.model[i], StyleLoss):
                    break
            self.model = self.model[:(i + 1)]
    
    
        def _transfer(self, content_image):
    
            output_image = content_image.clone()
            random_image = torch.randn(content_image.data.size(), device=self.device)
            output_image = 0.4 * output_image + 0.6 * random_image
    
            optimizer = torch.optim.LBFGS([output_image.requires_grad_()])
    
            print('Optimizing..')
            run = [0]
            while run[0] <= num_steps:
    
                def closure():
    
                    optimizer.zero_grad()
                    self.model(output_image)
                    style_score = 0
                    content_score = 0
    
                    for sl, sw in zip(self.style_losses, style_weights):
                        style_score += sl.loss * sw
                    for cl, cw in zip(self.content_losses, content_weights):
                        content_score += cl.loss * cw
    
                    loss = style_score + content_score
                    loss.backward()
    
                    run[0] += 1
                    if run[0] % 50 == 0:
                        print("iteration {}: Loss: {:4f} Style Loss: {:4f} Content Loss: {:4f}"
                              .format(run, loss.item(), style_score.item(), content_score.item()))
                    return loss
    
                optimizer.step(closure)
    
            return output_image
    
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    image_size = 256
    model = Model(device, image_size)
    
    style_image_path = 
    content_image_path = 
    out_image = del.run(content_image_path, style_image_path)
    plt.imshow(out_image)
    plt.show()

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

[7f560a1a56f44fc6a013d3f6d482d651.png]: https://img-blog.csdnimg.cn/7f560a1a56f44fc6a013d3f6d482d651.png
[89a6f7a934ba45d4a62ae0daeac16ac9.jpeg]: https://img-blog.csdnimg.cn/89a6f7a934ba45d4a62ae0daeac16ac9.jpeg
[48fa3c7ccb0c418d97cad87cbe199d3d.jpeg]: https://img-blog.csdnimg.cn/48fa3c7ccb0c418d97cad87cbe199d3d.jpeg
[5ecbb43be9d84e1683b4738d714a0d3f.png]: https://img-blog.csdnimg.cn/5ecbb43be9d84e1683b4738d714a0d3f.png