我用AI给女友画了一幅画，这届算法有点强！

柔光的暖阳◎ 2023-01-20 15:56 238阅读 0赞

大家好，我是 Jack。

小时候，我其实还是有点艺术细胞的，喜欢看火影忍者和七龙珠的我，虽然没学过绘画，但也笨手笨脚地画了不少作品。

特意叫我妈，把我收藏多年的小破本拿出来，分享下我儿时的快乐。

![24d5b90cb002ec263c13e72734e46f5e.png][]

小学几年级画的记不清了，只记得一画就是小半天，还拿去学校显摆了一番。

如今，再让我拿起铅笔，画个素描，我是画不出来了。

**不过，我另辟蹊径，用起了算法。我lbw，没有开挂！**

## Anime2Sketch ##

Anime2Sketch 是一个动画、漫画、插画等艺术作品的**素描提取器**。

给我个艺术作品，我直接把它变成素描作品：

![20210513182427717.gif][]

耗时1秒临摹的素描作品：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2M0MDY0OTU3NjI_size_16_color_FFFFFF_t_70][]

Anime2Sketch 算法也非常简单，就是一个 UNet 结构，生成素描作品，可以看下它的网络结构：

import torch 
    import torch.nn as nn 
    import functools
    
    
    class UnetGenerator(nn.Module):
        """Create a Unet-based generator"""
    
        def __init__(self, input_nc, output_nc, num_downs, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False):
            """Construct a Unet generator
            Parameters:
                input_nc (int)  -- the number of channels in input images
                output_nc (int) -- the number of channels in output images
                num_downs (int) -- the number of downsamplings in UNet. For example, # if |num_downs| == 7,
                                    image of size 128x128 will become of size 1x1 # at the bottleneck
                ngf (int)       -- the number of filters in the last conv layer
                norm_layer      -- normalization layer
            We construct the U-Net from the innermost layer to the outermost layer.
            It is a recursive process.
            """
            super(UnetGenerator, self).__init__()
            # construct unet structure
            unet_block = UnetSkipConnectionBlock(ngf * 8, ngf * 8, input_nc=None, submodule=None, norm_layer=norm_layer, innermost=True)  # add the innermost layer
            for _ in range(num_downs - 5):          # add intermediate layers with ngf * 8 filters
                unet_block = UnetSkipConnectionBlock(ngf * 8, ngf * 8, input_nc=None, submodule=unet_block, norm_layer=norm_layer, use_dropout=use_dropout)
            # gradually reduce the number of filters from ngf * 8 to ngf
            unet_block = UnetSkipConnectionBlock(ngf * 4, ngf * 8, input_nc=None, submodule=unet_block, norm_layer=norm_layer)
            unet_block = UnetSkipConnectionBlock(ngf * 2, ngf * 4, input_nc=None, submodule=unet_block, norm_layer=norm_layer)
            unet_block = UnetSkipConnectionBlock(ngf, ngf * 2, input_nc=None, submodule=unet_block, norm_layer=norm_layer)
            self.model = UnetSkipConnectionBlock(output_nc, ngf, input_nc=input_nc, submodule=unet_block, outermost=True, norm_layer=norm_layer)  # add the outermost layer
    
        def forward(self, input):
            """Standard forward"""
            return self.model(input)
    
    class UnetSkipConnectionBlock(nn.Module):
        """Defines the Unet submodule with skip connection.
            X -------------------identity----------------------
            |-- downsampling -- |submodule| -- upsampling --|
        """
    
        def __init__(self, outer_nc, inner_nc, input_nc=None,
                     submodule=None, outermost=False, innermost=False, norm_layer=nn.BatchNorm2d, use_dropout=False):
            """Construct a Unet submodule with skip connections.
            Parameters:
                outer_nc (int) -- the number of filters in the outer conv layer
                inner_nc (int) -- the number of filters in the inner conv layer
                input_nc (int) -- the number of channels in input images/features
                submodule (UnetSkipConnectionBlock) -- previously defined submodules
                outermost (bool)    -- if this module is the outermost module
                innermost (bool)    -- if this module is the innermost module
                norm_layer          -- normalization layer
                use_dropout (bool)  -- if use dropout layers.
            """
            super(UnetSkipConnectionBlock, self).__init__()
            self.outermost = outermost
            if type(norm_layer) == functools.partial:
                use_bias = norm_layer.func == nn.InstanceNorm2d
            else:
                use_bias = norm_layer == nn.InstanceNorm2d
            if input_nc is None:
                input_nc = outer_nc
            downconv = nn.Conv2d(input_nc, inner_nc, kernel_size=4,
                                 stride=2, padding=1, bias=use_bias)
            downrelu = nn.LeakyReLU(0.2, True)
            downnorm = norm_layer(inner_nc)
            uprelu = nn.ReLU(True)
            upnorm = norm_layer(outer_nc)
    
            if outermost:
                upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc,
                                            kernel_size=4, stride=2,
                                            padding=1)
                down = [downconv]
                up = [uprelu, upconv, nn.Tanh()]
                model = down + [submodule] + up
            elif innermost:
                upconv = nn.ConvTranspose2d(inner_nc, outer_nc,
                                            kernel_size=4, stride=2,
                                            padding=1, bias=use_bias)
                down = [downrelu, downconv]
                up = [uprelu, upconv, upnorm]
                model = down + up
            else:
                upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc,
                                            kernel_size=4, stride=2,
                                            padding=1, bias=use_bias)
                down = [downrelu, downconv, downnorm]
                up = [uprelu, upconv, upnorm]
    
                if use_dropout:
                    model = down + [submodule] + up + [nn.Dropout(0.5)]
                else:
                    model = down + [submodule] + up
    
            self.model = nn.Sequential(*model)
    
        def forward(self, x):
            if self.outermost:
                return self.model(x)
            else:   # add skip connections
                return torch.cat([x, self.model(x)], 1)
    
    
    def create_model(gpu_ids=[]):
        """Create a model for anime2sketch
        hardcoding the options for simplicity
        """
        norm_layer = functools.partial(nn.InstanceNorm2d, affine=False, track_running_stats=False)
        net = UnetGenerator(3, 1, 8, 64, norm_layer=norm_layer, use_dropout=False)
        ckpt = torch.load('weights/netG.pth')
        for key in list(ckpt.keys()):
            if 'module.' in key:
                ckpt[key.replace('module.', '')] = ckpt[key]
                del ckpt[key]
        net.load_state_dict(ckpt)
        if len(gpu_ids) > 0:
            assert(torch.cuda.is_available())
            net.to(gpu_ids[0])
            net = torch.nn.DataParallel(net, gpu_ids)  # multi-GPUs
        return net

UNet 应该都很熟悉了，就不多介绍了。

> 项目地址：https://github.com/Mukosame/Anime2Sketch

环境部署也很简单，只需要安装以下三个库：

torch>=0.4.1
    torchvision>=0.2.1
    Pillow>=6.0.0

然后下载权重文件，即可。

权重文件放在了GoogleDrive，**为了方便大家，我将代码和权重文件，还有一些测试图片，都打包好了。**

直接下载，即可运行（提取码：a7r4）：

[https://pan.baidu.com/s/1h6bqgphqUUjj4fz61Y9HCA][https_pan.baidu.com_s_1h6bqgphqUUjj4fz61Y9HCA]

进入项目根目录，直接运行命令：

python3 test.py --dataroot test_samples --load_size 512 --output_dir results

运行效果：

![70fa522893001ee016f32f9efff86c59.gif][]

“画”得非常快，我在网上找了一些图片进行测试。

鸣人和带土：

![da332f85d7320fc4908c746963e174c7.png][]

柯南和灰原哀：

![e0b9bc0b1274b308913bb48ff87caea3.png][]

## 絮叨 ##

使用算法前：

这样的素描，没有灵魂！

使用算法后：

![888a3c150794e17e91270726c5a59fe7.gif][]

**拿了一些真人的图片进行了测试，发现效果很差，果然真人的线条还是要复杂一些的。**

**最后再送大家一本，帮助我拿到 BAT 等一线大厂 offer 的数据结构刷题笔记，是一位 Google 大神写的，对于算法薄弱或者需要提高的同学都十分受用（提起码：m19c）：**

[BAT 大佬分类总结的 Leetcode 刷题模版，助你搞定 90% 的面试][BAT _ Leetcode _ 90_]

**以及我整理的 BAT 算法工程师学习路线，书籍+视频，完整的学习路线和说明，对于想成为算法工程师的，绝对能有所帮助（提取码：jack）：**

[我是如何成为算法工程师的，超详细的学习路线][Link 1]

我是 Jack，我们下期见。

[24d5b90cb002ec263c13e72734e46f5e.png]: /images/20221021/f168373bbb424dcfac326b44b8dadf59.png
[20210513182427717.gif]: /images/20221021/adafa02c69f14e229d49e6188ce9e024.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2M0MDY0OTU3NjI_size_16_color_FFFFFF_t_70]: /images/20221021/6939f7fe63574c3aba346a1d55a3efba.png
[https_pan.baidu.com_s_1h6bqgphqUUjj4fz61Y9HCA]: https://pan.baidu.com/s/1h6bqgphqUUjj4fz61Y9HCA
[70fa522893001ee016f32f9efff86c59.gif]: /images/20221021/a4f94166cf9744c0a9889612d678219c.png
[da332f85d7320fc4908c746963e174c7.png]: /images/20221021/f81a12738b9246f98123b2dc10718719.png
[e0b9bc0b1274b308913bb48ff87caea3.png]: /images/20221021/5df71a41197a4361be3150ff7007fa5c.png
[888a3c150794e17e91270726c5a59fe7.gif]: /images/20221021/41da3a7be8024f1da40b92b76c494d59.png
[BAT _ Leetcode _ 90_]: https://pan.baidu.com/s/1txDItPwDrnG8mOloOFbGaQ
[Link 1]: https://pan.baidu.com/s/12tbVrUF056pY7aCyMpgl1w