1 | 给马穿上斑马皮的生成对抗网络小实验以及Torch Hub简介

GAN网络实验

今天这一节还是练手小实验。
这个实验的方案是使用一个能把马变成斑马的网络，这个网络是基于GAN（generative adversarial network 生成对抗网络）来构建的。所谓的生成对抗网络可以理解成有两个人，一个是古董鉴定大师，一个赝品伪造大师，当然最开始他俩都比较弱，但是在训练网络的过程中，实现的逻辑就是赝品伪造大师造出来赝品给鉴定大师看，鉴定大师判断这是不是赝品，然后把结果告诉伪造大师，伪造大师就再调整自己的伪造手段，不断的尝试新的技巧，比如把赝品泡在油里面，或者把赝品埋在土里等等，经过不停的演进，伪造大师造出来的赝品就可以以假乱真了。

当然，在学习之初我们也不需要关心具体的模型结构，直接来动手跑一下吧。
前面是一些必须的函数定义部分，大概是生成器模型构造的过程，我也不是很懂，就暂且这么写吧。

import torch
import torch.nn as nn

class ResNetBlock(nn.Module): # <1>

    def __init__(self, dim):
        super(ResNetBlock, self).__init__()
        self.conv_block = self.build_conv_block(dim)

    def build_conv_block(self, dim):
        conv_block = []

        conv_block += [nn.ReflectionPad2d(1)]

        conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=0, bias=True),
                       nn.InstanceNorm2d(dim),
                       nn.ReLU(True)]

        conv_block += [nn.ReflectionPad2d(1)]

        conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=0, bias=True),
                       nn.InstanceNorm2d(dim)]

        return nn.Sequential(*conv_block)

    def forward(self, x):
        out = x + self.conv_block(x) # <2>
        return out


class ResNetGenerator(nn.Module):

    def __init__(self, input_nc=3, output_nc=3, ngf=64, n_blocks=9): # <3> 

        assert(n_blocks >= 0)
        super(ResNetGenerator, self).__init__()

        self.input_nc = input_nc
        self.output_nc = output_nc
        self.ngf = ngf

        model = [nn.ReflectionPad2d(3),
                 nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=True),
                 nn.InstanceNorm2d(ngf),
                 nn.ReLU(True)]

        n_downsampling = 2
        for i in range(n_downsampling):
            mult = 2**i
            model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3,
                                stride=2, padding=1, bias=True),
                      nn.InstanceNorm2d(ngf * mult * 2),
                      nn.ReLU(True)]

        mult = 2**n_downsampling
        for i in range(n_blocks):
            model += [ResNetBlock(ngf * mult)]

        for i in range(n_downsampling):
            mult = 2**(n_downsampling - i)
            model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),
                                         kernel_size=3, stride=2,
                                         padding=1, output_padding=1,
                                         bias=True),
                      nn.InstanceNorm2d(int(ngf * mult / 2)),
                      nn.ReLU(True)]

        model += [nn.ReflectionPad2d(3)]
        model += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)]
        model += [nn.Tanh()]

        self.model = nn.Sequential(*model)

    def forward(self, input): # <3>
        return self.model(input)

然后是实例化，并从已经保存的模型文件中把模型参数读出来

netG = ResNetGenerator()
model_path = '../../data/p1ch2/horse2zebra_0.4.0.pth'
model_data = torch.load(model_path)
netG.load_state_dict(model_data)

紧接着就跟我们上一节的方式一样了,开启网络的eval模式，定义预处理方法，然后把图片读进来

netG.eval()
from PIL import Image
from torchvision import transforms
preprocess = transforms.Compose([transforms.Resize(256),
                                 transforms.ToTensor()])
img = Image.open("../../data/p1ch2/horse.jpg")
img

这里用的原图如下所示

image.png

对图像数据进行向量化并生成batch数据，然后丢进已经训练好的网络中

img_t = preprocess(img)
batch_t = torch.unsqueeze(img_t, 0)
out_t = (batch_out.data.squeeze() + 1.0) / 2.0
out_img = transforms.ToPILImage()(out_t)
# out_img.save('../data/p1ch2/zebra.jpg')
out_img

我们看一下效果

看起来效果还是不错的，除了马本身，其他的地方基本上没有什么变化，虽然细节的位置处理的有点不是那么好，但是总体来说还不错，绝大部分人基本上可以把它看做是一匹斑马了。
不过，这时候我想知道，如果把上一节的金毛狗狗放进去会是什么情况，于是我又操作了一下。

from PIL import Image
from torchvision import transforms
img = Image.open("../../data/p1ch2/bobby.jpg")
img_t = preprocess(img)
batch_t = torch.unsqueeze(img_t, 0)
batch_out = netG(batch_t)
out_t = (batch_out.data.squeeze() + 1.0) / 2.0
out_img = transforms.ToPILImage()(out_t)
# out_img.save('../data/p1ch2/zebra.jpg')
out_img

结果如下图所示，金毛狗狗的脖子还有耳朵上有斑马纹，另外旁边的沙发和地板也有一些变化，好吧，看来还是只能处理马。

Torch Hub

这里为什么要说Torch Hub呢，其实一提起Hub大家都知道有很多好的Hub网站，提供了大量免费的资源，让的我们在庞大互联网上寻找资源不再是那么费劲，比如我们的GitHub。对于Torch Hub，也是基于这样的想法，目的就是收集众多的模型，形成一个存储库，其中定义了一套标准的API，任何想要使用的人都可以经过简单的API调用来使用那些成熟的模型，而不再需要每一个模型都去学习一套API。
当我们去调用一个模型的时候，可以使用下面的代码

import torch
from torch import hub
resnet18_model = hub.load('pytorch/vision:master',
                              'resnet18',
                              pretrained=True)

写了这段代码，就可以直接从线上库里获得训练好的模型，当然，我在执行这段代码的时候遇到了一些问题，首先是这个库里已经没有了master分支，这不是问题，把它改成了main。然后，就在最新的代码里，加入了一行代码导致我的运行出错了。我查了一段时间，但是暂时还没找到解决方案，所以这个问题暂时先放到这里，等我解决了再来更新。

问题说明：
在最新版的torchvision的hubconf.py 文件里加入了这个from torchvision.models import get_weight，但是在torchvision.models我似乎没找到这个get_weight方法，这句代码刚加了3天。

好了，今天先写这么多。