改进AnimeGANv2的图像动漫风格转换系统

最新推荐文章于 2024-05-29 11:54:43 发布
最新推荐文章于 2024-05-29 11:54:43 发布
阅读量1.2k 收藏 16
点赞数 1
文章标签： 计算机视觉 深度学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/prchen818/article/details/127612669
版权

1.研究背景

图像风格转换技术已经融入到人们的生活中,并被广泛应用于图像艺术化、卡通化、图像着色、滤镜处理和去遮挡等实际场景中,因此,图像风格转换具有重要的研究意义与应用价值.AnimeGANv2是近年来用于多域图像风格转换的生成对抗网络框架.AnimeGANv2通过简单地下采样提取特征,然后通过上采样生成图片,但是生成图片的背景颜色信息、人物脸部的细节特征会与输入图像有较大差异.对AnimeGANv2的网络结构进行改进,通过引入U-Net和边缘损失函数,提出了用于图像风格转换的UE-AnimeGANv2模型

2.图片演示

2.png

3.png

3.视频演示

改进AnimeGANv2的图像动漫风格转换系统（源码＆教程）_哔哩哔哩_bilibili

4.AnimeGANv2简介

在计算机视觉和艺术风格转移方面，将现实世界场景的照片转换为动漫风格的图像是一项有意义且具有挑战性的任务。我们之前提出的AnimeGAN结合了神经风格迁移合生成对抗网络（GAN）来完成这项任务。但是，AnimeGAN仍然存在一些明显的问题，例如模型生成的图像中存在高频伪影。因此，在本研究汇总，我们提出了AnimeGAN的改进版本，即AnimeGANv2。它通过简单的改变网络中特征的归一化来防止高频伪影的产生。此外，我们进一步缩小了生成器网络的规模，以实现更高效的动画风格转换。在新建立的高质量数据集上训练的AnimeGANv2可以生成视觉质量比AnimeGAN更好的动画图像。

5.算法改进

为了使生成的图像具有原始照片的内容，引入了预先训练好的 VGG19 作为感知网络，获得生成的图像和原始照片的深度感知特征的L1丢失。
我的理解：跟 CartoonGAN 使用的方法类似，通过预训练模型可以更好的提取图片的高维信息，这样可以在风格不同的情况之下比较两个照片的差别，毕竟两个图像的风格即使不一样，但是高维的语义信息是一样的。这也就是为什么这几个网络不需要像 Cycle GAN 和 Dual GAN 一样需要同时训练两个模型来保证模型的正常收敛。

其他增强

在生成器上执行一个初始化训练，只使用内容丢失Lcon(G, D)对生成网络G进行预先训练，使 AnimeGAN 的训练更容易和更稳定， CartoonGAN 提出的。（没搞懂为什么）
带有 1×1 卷积核的最后一个卷积层不使用归一化层，并且后面使用的是tanh非线性激活函数。（没搞懂为什么）
各个模块中使用的激活函数都是 LReLU。

image.png

生成器的网络可以看作是编解码器网络，标准卷积、深度可分离卷积、残差网络、上采样和下采样模块。
image.png

6.损失函数的改进

首先是对于训练数据的处理，TODO

生成器损失函数主要分为四个部分（公式图片），不同的损失有不同的权重系数，作者所采用的是 300、1.5、3、10：
image.png

  1. 对抗损失（adv），是生成器 G 中影响动画转换过程的对抗性损失。
  2. 内容损失（con），是帮助生成的图像保留输入照片内容的内容丢失。
  3. 灰度风格损失（gra），使生成的图像在纹理和线条上具有清晰的动漫风格。
  4. 颜色重建损失（col），使生成的图像具有原照片的颜色。

对于内容丢失和灰度风格丢失，使用预先训练好的VGG19作为感知网络，提取图像的高级语义特征。它们表示为（此公式的图片）:

image.png

鉴别器使用的损失函数，除了引入 CartoonGAN 提出的促进边缘的对抗损失，使 AnimeGANv2 生成的图像具有清晰的重现边缘外，还采用了一种新型的灰度对抗损失，防止生成的图像以灰度图像的形式显示。最后，鉴别器的损失函数表示如图。
image.png

7.代码实现

import torch
import torch.nn as nn
import torch.nn.parallel



def weights_init(m):
    classname = m.__class__.__name__
    if classname.find('Conv') != -1:
        m.weight.data.normal_(0.0, 0.02)
    elif classname.find('BatchNorm') != -1:
        m.weight.data.normal_(1.0, 0.02)
        m.bias.data.fill_(0)

# DCGAN model, fully convolutional architecture
class _netG_1(nn.Module):
    def __init__(self, ngpu, nz, nc , ngf, n_extra_layers_g):
        super(_netG_1, self).__init__()
        self.ngpu = ngpu
        #self.nz = nz
        #self.nc = nc
        #self.ngf = ngf
        main = nn.Sequential(
            # input is Z, going into a convolution
            # state size. nz x 1 x 1
            nn.ConvTranspose2d(     nz, ngf * 8, 4, 1, 0, bias=False),
            nn.BatchNorm2d(ngf * 8),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ngf*8) x 4 x 4
            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ngf*4) x 8 x 8
            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ngf*2) x 16 x 16
            nn.ConvTranspose2d(ngf * 2,     ngf, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ngf) x 32 x 32
        )

        # Extra layers
        for t in range(n_extra_layers_g):
            main.add_module('extra-layers-{0}.{1}.conv'.format(t, ngf),
                            nn.Conv2d(ngf, ngf, 3, 1, 1, bias=False))
            main.add_module('extra-layers-{0}.{1}.batchnorm'.format(t, ngf),
                            nn.BatchNorm2d(ngf))
            main.add_module('extra-layers-{0}.{1}.relu'.format(t, ngf),
                            nn.LeakyReLU(0.2, inplace=True))

        main.add_module('final_layer.deconv', 
        	             nn.ConvTranspose2d(ngf, nc, 4, 2, 1, bias=False)) # 5,3,1 for 96x96
        main.add_module('final_layer.tanh', 
        	             nn.Tanh())
            # state size. (nc) x 96 x 96

        self.main = main


    def forward(self, input):
        gpu_ids = None
        if isinstance(input.data, torch.cuda.FloatTensor) and self.ngpu > 1:
            gpu_ids = range(self.ngpu)
        return nn.parallel.data_parallel(self.main, input, gpu_ids), 0

class _netD_1(nn.Module):
    def __init__(self, ngpu, nz, nc, ndf,  n_extra_layers_d):
        super(_netD_1, self).__init__()
        self.ngpu = ngpu
        main = nn.Sequential(
            # input is (nc) x 96 x 96
            nn.Conv2d(nc, ndf, 4, 2, 1, bias=False), # 5,3,1 for 96x96
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf) x 32 x 32
            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 2),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf*2) x 16 x 16
            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 4),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf*4) x 8 x 8
            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 8),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf*8) x 4 x 4
        )

        # Extra layers
        for t in range(n_extra_layers_d):
            main.add_module('extra-layers-{0}.{1}.conv'.format(t, ndf * 8),
                            nn.Conv2d(ndf * 8, ndf * 8, 3, 1, 1, bias=False))
            main.add_module('extra-layers-{0}.{1}.batchnorm'.format(t, ndf * 8),
                            nn.BatchNorm2d(ndf * 8))
            main.add_module('extra-layers-{0}.{1}.relu'.format(t, ndf * 8),
                            nn.LeakyReLU(0.2, inplace=True))


        main.add_module('final_layers.conv', nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False))
        main.add_module('final_layers.sigmoid', nn.Sigmoid())
        # state size. 1 x 1 x 1
        self.main = main

    def forward(self, input):
        gpu_ids = None
        if isinstance(input.data, torch.cuda.FloatTensor) and self.ngpu > 1:
            gpu_ids = range(self.ngpu)
        output = nn.parallel.data_parallel(self.main, input, gpu_ids)
        return output.view(-1, 1)




class _netD_2(nn.Module):
    def __init__(self, ngpu, nz, nc , ndf):
        super(_netD_2, self).__init__()
        self.ngpu = ngpu
        self.convs = nn.Sequential(
            # input is (nc) x 96 x 96
            nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf) x 32 x 32
            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 2),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf*2) x 16 x 16
            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 4),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf*4) x 8 x 8
            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 8),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf*8) x 4 x 4
            nn.Conv2d(ndf * 8, 1024, 4, 1, 0, bias=False),
            nn.LeakyReLU(inplace=True),
            nn.Dropout(0.5),
            # state size. 1024 x 1 x 1
        )
        self.fcs = nn.Sequential(
            nn.Linear(1024, 1024),
            nn.LeakyReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(1024, 1),            
            nn.Sigmoid()
            )
    def forward(self, input):
        gpu_ids = None
        if isinstance(input.data, torch.cuda.FloatTensor) and self.ngpu > 1:
            gpu_ids = range(self.ngpu)
        output = nn.parallel.data_parallel(self.convs, input, gpu_ids)
        output = self.fcs(output.view(-1,1024))
        return output.view(-1, 1)

# with z decoder and fc layers
class _netG_2(nn.Module):
    def __init__(self, ngpu, nz, nc , ngf):
        super(_netG_2, self).__init__()
        self.ngpu = ngpu
        self.nz = nz
        self.fcs = nn.Sequential(
            # input is Z, going into a convolution
            # state size. nz x 1 x 1
            nn.Linear(nz, 1024),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(1024, 1024),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            )
        
        self.decode_fcs = nn.Sequential(
            nn.Linear(1024, 1024),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(1024, nz),
            )

        self.convs = nn.Sequential(
            # 1024x1x1
            nn.ConvTranspose2d(1024, ngf * 8, 4, 1, 0, bias=False),
            nn.BatchNorm2d(ngf * 8),
            nn.ReLU(inplace=True),
            # state size. (ngf*8) x 4 x 4
            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.ReLU(inplace=True),
            # state size. (ngf*4) x 8 x 8
            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.ReLU(inplace=True),
            # state size. (ngf*2) x 16 x 16
            nn.ConvTranspose2d(ngf * 2,     ngf, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(inplace=True),
            # state size. (ngf) x 32 x 32
            nn.ConvTranspose2d(    ngf,      nc, 4, 2, 1, bias=False),
            nn.Tanh()
            # state size. (nc) x 96 x 96
        )
    def forward(self, input):
        input = self.fcs(input.view(-1,self.nz))
        gpu_ids = None
        if isinstance(input.data, torch.cuda.FloatTensor) and self.ngpu > 1:
            gpu_ids = range(self.ngpu)
        z_prediction = self.decode_fcs(input)
        input = input.view(-1,1024,1,1)
        output = nn.parallel.data_parallel(self.convs, input, gpu_ids)
        return output, z_prediction


# DCGAN model with fc layers
class _netG_3(nn.Module):
    def __init__(self, ngpu, nz, nc , ngf):
        super(_netG_3, self).__init__()
        self.ngpu = ngpu
        self.fcs = nn.Sequential(
            # input is Z, going into a convolution
            # state size. nz x 1 x 1
            nn.Linear(nz, 1024),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(1024, 1024),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            )
        self.convs = nn.Sequential(
            # 1024x1x1
            nn.ConvTranspose2d(1024, ngf * 8, 4, 1, 0, bias=False),
            nn.BatchNorm2d(ngf * 8),
            nn.ReLU(inplace=True),
            # state size. (ngf*8) x 4 x 4
            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.ReLU(inplace=True),
            # state size. (ngf*4) x 8 x 8
            nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.ReLU(inplace=True),
            # state size. (ngf*2) x 16 x 16
            nn.ConvTranspose2d(ngf * 2,     ngf, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(inplace=True),
            # state size. (ngf) x 32 x 32
            nn.ConvTranspose2d(    ngf,      nc, 4, 2, 1, bias=False),
            nn.Tanh()
            # state size. (nc) x 96 x 96
        )
    def forward(self, input):
        input = self.fcs(input.view(-1,nz))
        gpu_ids = None
        if isinstance(input.data, torch.cuda.FloatTensor) and self.ngpu > 1:
            gpu_ids = range(self.ngpu)
        input = input.view(-1,1024,1,1)
        return nn.parallel.data_parallel(self.convs, input, gpu_ids)

8.系统整合

1.png

9.完整源码＆环境部署视频教程＆自定义UI界面

10.参考文献

[1]欧阳宁,梁婷,林乐平.基于自注意力网络的图像超分辨率重建[J].计算机应用.2019,(8).DOI:10.11772/j.issn.1001-9081.2019010158.
[2]朱新山,姚思如,孙彪,等.图像质量评价：融合视觉特性与结构相似性指标[J].哈尔滨工业大学学报.2018,(5).DOI:10.11918/j.issn.0367-6234.201709138.
[3]姚乃明,郭清沛,乔逢春,等.基于生成式对抗网络的鲁棒人脸表情识别[J].自动化学报.2018,(5).DOI:10.16383/j.aas.2018.c170477.
[4]高媛,刘志,秦品乐,等.基于深度残差生成对抗网络的医学影像超分辨率算法[J].计算机应用.2018,(9).DOI:10.11772/j.issn.1001-9081.2018030574.
[5]周飞燕,金林鹏,董军.卷积神经网络研究综述[J].计算机学报.2017,(6).DOI:10.11897/SP.J.1016.2017.01229.
[6]卢宏涛,张秦川.深度卷积神经网络在计算机视觉中的应用研究综述[J].数据采集与处理.2016,(1).DOI:10.16337/j.1004-9037.2016.01.001.
[7]李生.自然语言处理的研究与发展[J].燕山大学学报.2013,(5).DOI:10.3969/j.issn.1007-791X.2013.05.001.
[8]常建英.基于生成对抗网络的图像风格转换[D].2021
[9]Huynh-Thu Q.,Ghanbari M…Scope of validity of PSNR in image/video quality assessment[J].Electronics Letters.2008,44(13).
[10]Bovik A.C.,Zhou Wang,Simoncelli E.P.,等.Image quality assessment: from error visibility to structural similarity[J].IEEE Transactions on Image Processing.2004,13(4).

prchen818
关注
  • 1
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
实现制作动漫版的你---动漫风格迁移网络AnimeGANv2
热衷于开源，热爱人工智能领域，时常分享机器学习，数据挖掘项目及方法，我们一起努力！
11-21 2033
最近居家太无聊了，无意见逛到了AI社区，发现最近AI算法热度还是很高，什么AI绘画，还有什么AI作诗，写歌。可以说，人工智能领域在一步步挑战人类的高度，从循规蹈矩的简单工作，到高难度的智慧挑战，现在已经在挑战人类最后防线—思想，创作！不过我还是觉得人工智能的路还很遥远！
animegan2-pytorch:AnimeGANv2的PyTorch实现
05-05
的PyTorch实现 从原始存储库转换重量（需要TensorFlow 1.x） git clone https://github.com/TachibanaYoshino/AnimeGANv2 python convert_weights.py 推理 python test.py --input_dir [image_folder_path] --device [cpu/cuda] 转换后的[ ]样式模型的结果 （输入图像，原始tensorflow结果，pytorch结果从左到右） 脸部模型：从此提取出来，带有L2 + VGG + GAN损失和CelebA-HQ图像。 有关推断，请参见test_faces.ipynb 。 可以从下载模型文件（8MB）。 享受！ 注意：不包含培训代码/在RTX3090 + PyTorch1.7.1上进行了测试/由于，转换后的权重结果略有不同
AnimeGANv2 照片动漫化：如何基于 PyTorch 和神经网络给 GirlFriend 制作漫画风头像？_图片动漫化原理(1)
最新发布
2401_85112052的博客
05-29 1575
将现实世界场景的照片转换为动漫风格图像的方法，这是计算机视觉和艺术风格转换中一项有意义且具有挑战性的任务，而本文中我们介绍的 AnimeGAN 就是 GitHub 上一款爆火的二次元漫画风格迁移工具，可以实现快速的动画风格迁移。该工具是基于神经风格迁移和生成对抗网络 (GAN) 技术打造的，相比于传统的神经网络模型，GAN 是一种全新的非监督式的架构。
animeganv2
qq_40935876的博客
10-12 1395
基于华为昇思MindSpore实现AnimeGANv2。
漫画风格迁移神器 AnimeGANv2：快速生成你的漫画形象
风信子的猫Redamancy的快乐星球
11-21 1万+
趁着有空的时间，给大家介绍一些有趣的项目吧，比如这个漫画风格迁移神器 AnimeGANv2，可以快速生成自己的漫画形象
现实照片一键动漫化,打造专属自己的漫画脸—— AnimeGAN v2 C++推理
热门推荐
知来者逆的博客
11-24 1万+
AnimeGAN是来自武汉大学和湖北工业大学的AI项目，是由神经网络风格迁移加生成对抗网络（GAN）而成，它是基于CartoonGAN的改进，并提出了一个更加轻量级的生成器架构。。官方的有放出三个试玩的模型，有两个模型是针对人脸的，有一个是卡通效果，可以用来试试别的图像的，熟悉python和pytorch的直接git下来就可以本地部署了,就可以试玩了。先看看人像的效果我的demo里面的图像第一张是原图，第二第三张是人像模型，第四张是卡通效果。
AnimeGAN-torch：使用Pytorch从AnimeGANv2复制结果
02-15
动漫火炬 此仓库是在Pytorch中复制AnimeGANv2的结果 这个分支是实现从NOGAN培训 。 由于GAN训练本身是不稳定的，因此希望尽可能少地进行GAN训练，同时仍然具有GAN的作用。 NOGAN在图像着色中效果很好，这是图像到图像翻译中的任务，从直观上讲，它也应适用于其他图像到图像翻译任务。 AnimeGAN的NOGAN培训的功能丧失使用相同的损失 。 NOGAN的培训在笔记本电脑上进行，该笔记本电脑需要大量培训，并且要经过很多检查点和反复试验。 该分支增加了FP16培训表格 。 请参阅设置为培训的不同级别的文档。 FP16培训不适用于GAN培训。
图像卡通化AnimeGANv2
02-14
AnimeGANv2，作为这一领域的代表性工作，它利用深度学习技术将真实照片转换为具有动漫风格的艺术作品，极大地拓宽了图像创作的可能性。本文将深入探讨AnimeGANv2的工作原理、实现过程以及在图像卡通化领域的应用。 ...
C# AnimeGANv2 人像动漫化 源码
10-12
C# AnimeGANv2 是一个基于C#编程语言实现的人像动漫化项目，它利用了深度学习模型AnimeGANv2来将真实人物图像转换为动漫风格的图像。这个项目的源码不仅提供了实际操作的示例，还为我们深入了解计算机视觉和深度学习...
C# AnimeGANv2 人像动漫化
10-12
标题中的"C# AnimeGANv2 人像动漫化"指的是使用C#编程语言实现的AnimeGANv2模型，该模型可以将真实人物图像转换为动漫风格的图像。AnimeGANv2是深度学习领域的一种应用，它基于生成对抗网络（Generative Adversarial...
AnimeGANv2-基于Pytorch实现人脸动漫化算法animeGANv2-附项目源码+效果展示-优质项目实战.zip
05-27
AnimeGANv2是一个深度学习模型，它利用PyTorch框架实现了将真实世界的人脸图像转换为动漫风格的算法。这个项目不仅提供了完整的源代码，还包含实际效果展示，是AIGC（人工智能生成内容）领域的一个优质实战案例。让...
animeganexe.rar
11-24
AnimeGAN将现实照片动漫化的可执行文件，下载后把图像放到images目录下运行就可以得到效果。
AnimeGAN_tensorflow 源代码和数据集合
08-10
AnimeGAN_tensorflow 源代码和数据集合
AnimeGAN：AnimeGAN的Tensorflow实现，用于快速照片动画！ 这是论文“ AnimeGAN：一种用于照片动画的新型轻量级GAN”的开源，它使用GAN框架将真实世界的照片转换为动漫图像
02-06
日本动漫 AnimeGAN的Tensorflow实现可用于快速照片动画！可以在或在上访问该论文。 更新： data_mean.py用于计算整个样式数据的三通道（BGR）色差，这些差值用于在训练过程中平衡样式数据的色调对所生成图像的影响。 例如，Hayao样式数据的整体色调为淡黄色。 adjust_brightness.py用于基于输入照片的亮度来调整生成图像的亮度。 一些训练超参数发生变化。 在线访问：感谢开发在线访问项目，您可以通过浏览器实现照片动画，而无需安装任何软件，。 好消息：tensorflow-1.15.0与该存储库的代码兼容。 在此版本中，无需任何修改即可运行此代码
animegan2.rar
11-24
AnimeGANv2是一个基于深度学习的算法，专用于将真实照片转换成动漫风格的图像，这种技术也被称为照片动漫化或头像转漫画。该算法是AnimeGAN的升级版，优化了原有模型，提升了转换效果，使得生成的动漫形象更为细腻、...
一文教你用AnimeGANv2将你女朋友的照片变成动漫人物照
网络技术联盟站
09-12 5610
AnimeGANv2是我见过为数不多的如此丝滑处理动漫图生成的算法，从本文正文中，大家也不难发现，从一张肖像图到动漫图，处理过程还是蛮快的，而且出图的质量也很高，与原香相比，动漫图并没有失真太多。大家有兴趣一定要去体验一下，体验地址。希望本文对您有所帮助，有任何问题可以在下方评论区与我讨论！
人脸动漫化AnimeGAN V2的具体实施步骤
iossow的博客
04-29 7332
关于人脸动漫画,AnimeGAN的完善，给同学带来一些帮助
使用AnimeGAN2将照片动漫化--入门
a18792721831的博客
01-30 567
效果是有，可能是我选择的目标图片比较特殊，所以效果不是特别明显吧。遇到的问题：安装依赖的时候，特别是tensorflow的依赖，github上面推荐是1.15.0版本，但是我在实际安装中，存在各种冲突，最后使用1.14.0解决了。其次就是查找依赖的时候，有哪些版本，需要到网站上面搜索，可以安装pip_search工具进行查找。祝大家玩得开心~
强烈安利试试这个！效果爆炸的漫画变身AI，火到服务器几度挤爆
量子位
11-21 3950
金磊 丰色 发自 凹非寺量子位 报道 | 公众号 QbitAI“排队1241人，等待2600秒……”——这届网友为了看一眼自己在动漫里的样子，可真是拼了！“始作俑者”是一款可以把人像变动漫...
AnimeGANv2灰度风格损失
06-12
AnimeGANv2 灰度风格损失是指在 AnimeGANv2 模型训练中，用于衡量生成图像与目标灰度图像之间的相似度的损失函数。它是通过计算生成图像与目标灰度图像之间的均方误差来实现的。具体来说，它是通过将生成图像和目标...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值