一.生成对抗网络基本概念

1.发展背景

自然界中人类的特性可以概括两大特殊能力，分别是认识和创造。那么在深度学习-神经网络中，我们之前所学习的全连接神经网络、卷积神经网络等，它们都有一个共同的特点就是只实现了认识的功能，或者说是分类。那么如何让网络能够具有创造力，能根据我们的需求去自主地创造呢？换句话说，我们想让一直当评委/裁判的神经网络，现在能够自己上台去表演。这就是生成对抗网络的由来。

生成式对抗网络（GAN, Generative Adversarial Networks ）是一种深度学习模型，它在2014年由Ian Goodfellow首次提出，该模型通过框架中（至少）两个模块：生成模块（Generative Model）和判别模块（Discriminative Model）的互相博弈学习产生相当好的输出。随后几年里，GAN飞速发展，产生了广泛的应用。并衍生出了很多流行的模型变种，比如DCGAN、C-GAN、WGAN、pix2pix等等。

2.核心思想

GAN主要由生成器模型G和判别器模型D两大模块组成，原始 GAN 理论中，并不要求 G 和 D 都是神经网络，只需要是能拟合相应生成和判别的函数即可。但实用中一般均使用不同结构的深度神经网络作为 G 和 D 。其中：

生成器模型G：生成器是用来创造样本的。其输入一些随机噪声，通过生成网络输出我们需要的样本数据（二维图像数据等）

判别器模型D：判别器是用来识别真假的。其输入生成器生成的样本和真实样本，通过判别网络输出对样本数据的真假分类判别（二分类）。

GAN受博弈论中的零和博弈启发，将生成问题视作判别器和生成器这两个网络的对抗和博弈：生成器从给定噪声中（一般是指均匀分布或者正态分布）产生合成数据，判别器分辨生成器的的输出和真实数据。前者试图产生更接近真实的数据，相应地，后者试图更完美地分辨真实数据与生成数据。由此，两个网络在对抗中进步，在进步后继续对抗，由生成式网络得的数据也就越来越完美，逼近真实数据，从而可以生成想要得到的数据（图片、序列、视频等），二者在不断的对抗中逐步到达一种纳什均衡状态。

通俗点来说：假如你（G）是一个初级绘画师，你想提高你的绘画能力达到世界大师的水平。但是只靠你自己是无法成功的，所以你叫来了你的朋友（D）帮助你。你们训练的方式就是：你不断创作绘画作品，然后将你的绘画作品和世界大师的作品一起交给你的朋友鉴赏，然后你的朋友来分辨哪一个是你画的，哪一个是大师的。

对于你来说：每次朋友鉴赏完成后，告诉你他的分辨结果。然后你根据结果不断改进自己不足的地方。目的就是不断提高自己的水平，让你朋友分辨不出来哪一个是你画的哪一个是大师的。

对于你朋友来说：每次你创作完成之后，要对你的进步负责。他都要尽可能正确的将大师作品和你画的作品区分开来，提高自己的鉴赏水平。

在你们两个不断地博弈对抗的过程中，你的绘画水平不断提高，甚至能达到以假乱真的效果。而你的朋友的鉴赏水平不断提高，甚至真画假画一眼便知。你们两个在对抗中一起成长，达到平衡。

二.训练过程

初始化生成器G和判别器D两个网络的初始参数。

固定生成器G的网络参数，从训练集抽取一个batch，生成器输入定义的随机噪声分布生成n个输出样本。

将真实训练样本数据与生成器输出样本数据拼接为判别器输入，并给以label真（1）和假（0），训练辨别器D，使其尽可能区分输入样本的真假。

这样循环训练更新k次判别器D之后，固定判别器参数。从训练集抽取一个batch，生成器输入定义的随机噪声分布生成n个输出样本。

将真实训练样本数据与生成器输出样本数据拼接为判别器输入，并给以label全真（1），训练辨别器D，使生成器输出的数据尽可能的真实，辨别器尽可能区分不了真假。

多轮这样的更新迭代后，理想状态下，最终辨别器D无法区分图片到底是来自真实的训练样本集合，还是来自生成器G生成的样本即可，此时辨别的概率为0.5，完成训练。或者达到相应的训练轮数阈值。

三.黑白图像着色问题实践

1.问题背景

黑白图像的彩色化问题一直以来都是研究的热点，该问题旨在输入黑白图像，输出着色彩色化后的彩色图像。对于此问题可以看作是一个色彩生成问题，我们可以借助GAN网络来进行解决。

2.颜色空间

自然界中人们对于颜色的感受可以量化为色调、饱和度和亮度，其中色调表示颜色纯色的属性，比如红橙黄绿青蓝紫。饱和度表示色彩的鲜艳程度，纯色光越多饱和度越高，比如颜色的浓淡深浅。亮度描述颜色的明暗程度，可划分为黑灰白三个层次。颜色常用的量化定义分为三种类型，分别是RGB空间、YUV空间、Lab空间，三种颜色空间的说明如下：

（1）RGB颜色空间

（2）YUV颜色空间

（3）Lab颜色空间

3.实验设计思路（条件-生成对抗网络）

图片数据集导入（使用DUTS数据集）

图片数据处理：将导入的彩色rgb图像转换为Lab格式图像，按照训练集：测试集划分为5：1的比例，并将图像的L通道分量复制作为黑白图像噪声用于生成器神经网络输入训练

设计实现生成网络模型：使用改进的U-Net模型作为生成网络，输入为L通道分量的单通道黑白图像，输出为预测的a、b通道，叠加L通道分量后形成Lab格式的预测彩色图片

设计实现判别网络模型：输入真实图片和生成器预测图片拼接的数据集，输出预测标签（fake or true）

网络训练：每一轮先训练k次判别网络，固定生成网络；再训练一次生成网络，固定判别网络。如此反复多轮直到达到一定的阈值。

模型测试：使用训练好的生成模型，输入L通道的黑白图像，输出预测彩色图片

（1）数据集

（2）模型结构

4.代码实现

（1）工具方法 util.py

import numpy as np
import torch
from skimage import color
from PIL import Image
import torchvision.transforms as transforms
from torchvision import utils#从(h,w,c)格式的Lab中拿到 标准化的Tensor L通道、ab通道
def splitFromLab(image_lab):image_lab = image_lab.transpose((2, 0, 1)) #(c,h,w)image_l = image_lab[0]/100 #(h,w) L通道范围 0~100 -> 归一化到 0~1image_ab = image_lab[1:,:,:]/110 #(2,h,w) ab通道 -> 归一化到 -1~1image_l = torch.from_numpy(image_l).unsqueeze(0) #(1,h,w) Tensorimage_ab = torch.from_numpy(image_ab) #(2,h,w) Tensor#返回标准化 L (1,h,w) + 真实图像lab(3,h,w)return image_l,torch.cat([image_l,image_ab],dim=0)def TransfertToRGB(image):#image (1,3,h,w) -> (3,h,w)image = image.squeeze(0)image[0,:,:]*=100image[1:,:,:]*=110image_ndarray = np.array(image)#image (3,h,w) -> (h,w,3)image_lab = image_ndarray.transpose((1,2,0))#image rgb (h,w,3)image_rgb = color.lab2rgb(image_lab)#image rgb (1,3,h,w)image_rgb = torch.from_numpy(image_rgb.transpose((2, 0, 1))).unsqueeze(0)return image_rgbdef TransferBacktoWhite(path):transTensor = transforms.ToTensor()  # 将PIL Image自动转化并归一化为tensor(c,h,w)img_path = pathimage = Image.open(img_path).convert("RGB")  # 图片为 "RGB"格式 真彩图像 三通道 (h,w,c) 范围[0,255] -> 二值黑白图像.convert("1")image_tensor = transTensor(image)image_tensor[image_tensor>0.5] = 1image_tensor[image_tensor<=0.5] = 0save_path = r"D:\日常材料\图片照片\签名结果.png"# 注意，save_image将图像保存为RGB三通道，如果是二值图像则三个通道数值都相同，即伪灰度图像utils.save_image(image_tensor, save_path)if __name__ == "__main__":path = r"D:\日常材料\图片照片\导师签名2.png"TransferBacktoWhite(path)

（2）数据集 data.py

import os
import numpy as np
from PIL import Image
from torch.utils.data import Dataset
from util import *
from skimage import color
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"#构造自定义数据集
class ModelDataset(Dataset):def __init__(self,image_dir):super(ModelDataset, self).__init__()self.image_dir = image_dirself.images = os.listdir(self.image_dir) #os.listdir()函数用于返回指定的文件夹包含的文件或文件夹的[名字]的列表。def __len__(self):return len(self.images)def __getitem__(self, index):#加载图片img_path = os.path.join(self.image_dir,self.images[index]) #os.path.join函数用于将字符串按照系统盘符拼接为路径image = Image.open(img_path).convert("RGB").resize((256,256)) #图片为 "RGB"格式 真彩图像 三通道 (h,w,c) 范围[0,255]# 图片转化为rgb Numpy (h,w,c)image_rgb = np.array(image)image_grey = np.array(image.convert("L"))/255# 将rgb空间 -> lab空间image_lab = color.rgb2lab(image_rgb)# 获取L、lab Tensor格式(c,h,w)归一化数据image_l,image_lab = splitFromLab(image_lab)return image_l,image_lab,torch.from_numpy(image_grey).unsqueeze(0)'''
图片处理：
1.PIL(1)PIL读取数据：Image.open() 返回Image对象，尺寸为(width,height)(2)PIL显示图像：Image.show()：调用本地的图片浏览器显示(3)PIL Image转换到Numpy ndarray：np.array(Image)，尺寸为(height,width,channel)(4)matplotlib显示ndarry图像：plt.imshow(img)+plt.show() ，要求img尺寸为(H, W, C)
2.skimage(1)skimage读取数据：io.imread(img_path) ,返回ndarray格式，尺寸为(height,width,channel)(2)skimage显示图像：直接使用plt.show()显示ndarray(3)skimage颜色空间转换- rgb -> lab: color.rgb2lab(rgb, illuminant='D65', observer='2', *, channel_axis=- 1) 默认将(h,w,c)的rgb ndarray图像转化为(h,w,c)的lab图像- lab -> rgb: color.lab2rgb(lab, illuminant='D65', observer='2', *, channel_axis=- 1) 默认将(h,w,c)的lab ndarray图像转化为(h,w,c)的rgb图像(4)注意：- 对于rgb to lab来说：a.如果输入rgb为[0,255]的int类型，则在转换时，函数会先将输入/255转换到[0,1]之间的float64（这叫gamma矫正），再计算lab通道。b.如果输入rgb为[0,1]的/255之后的标准化float64数据，则函数不会进行处理，直接拿来计算labc.函数最终返回float64 的 lab空间图像ndarrayd.该函数就是严格按照rgb2lab公式来的：先->xyz->lab，要算gamma(r/255)矫正->lab等等，所以求出来的lab取值范围就是 L[0,100],a[-110,110],b[-110,110]- 对于lab to rgb来说：输入lab空间矩阵，返回[0,1]之间标准化的rgb颜色矩阵3.Pytorch(1)神经网络中训练要求数据格式必须为 (channel,height,width)(2)格式转换1：torchvision.transforms.ToTensor 把一个取值范围是[0,255]的PIL.Image或者shape为(H,W,C)的numpy.ndarray，转换成形状为[C,H,W]，取值范围是[0,1.0]的torch.FloatTensor（除以255，自动进行归一化）(3)格式转换2：交换维度np.transpose( xxx,  (2, 0, 1))  将xxx (H x W x C)的ndarray 转化为 (C x H x W)的ndarray
'''

（3）网络模型 net.py

import torch
import torch.nn as nn#1.生成器-卷积模块
class ConvBlock(nn.Module):def __init__(self,in_channel,out_channel):super(ConvBlock, self).__init__()#构建 卷积块（进行两次卷积操作）self.layer = nn.Sequential(#第一次卷积操作nn.Conv2d(in_channel,out_channel,kernel_size=3,stride=1,padding=1),#卷积操作 (batch,in_ch,h,w) -> (batch,out_ch,h,w) 不改变大小nn.BatchNorm2d(out_channel),#批标准化 将数据标准化到正态分布nn.ReLU(inplace=True),#激活函数 inplace=True表示覆盖输入数据（避免了临时变量频繁释放，提高效率）#第二次卷积操作nn.Conv2d(out_channel, out_channel, kernel_size=3, stride=1, padding=1),# 卷积操作 (batch,in_ch,h,w) -> (batch,out_ch,h,w) 不改变大小nn.BatchNorm2d(out_channel),  # 批标准化 将数据标准化到正态分布nn.ReLU(inplace=True),  # 激活函数 inplace=True表示覆盖输入数据（避免了临时变量频繁释放，提高效率）)def forward(self,x):return self.layer(x)#2.生成器-上采样模块：反卷积+拼接
class DeConvBlock(nn.Module):def __init__(self,in_channel,out_channel):super(DeConvBlock, self).__init__()#上采样：反卷积 (batch,in_ch,h,w) -> (batch,out_ch,2h,2w)self.up = nn.ConvTranspose2d(in_channel,out_channel,kernel_size=2,stride=2)def forward(self,input_1,input_2):output_2 = self.up(input_2) #先上采样merge = torch.cat([input_1,output_2],dim=1) #跳跃连接，合并输入return merge #返回合并后结果#3.生成器网络
class Generator(nn.Module):def __init__(self,in_channel,out_channel):super(Generator, self).__init__()filter_maps = [64,128,256,512,1024]self.pool = nn.MaxPool2d(2)# 编码器self.encoderConv1 = ConvBlock(in_channel, filter_maps[0])self.encoderConv2 = ConvBlock(filter_maps[0], filter_maps[1])self.encoderConv3 = ConvBlock(filter_maps[1], filter_maps[2])self.encoderConv4 = ConvBlock(filter_maps[2], filter_maps[3])self.encoderConv5 = ConvBlock(filter_maps[3], filter_maps[4])# 解码器self.upSimple1 = DeConvBlock(filter_maps[4], filter_maps[3])self.decoderConv1 = ConvBlock(filter_maps[4], filter_maps[3])self.upSimple2 = DeConvBlock(filter_maps[3], filter_maps[2])self.decoderConv2 = ConvBlock(filter_maps[3], filter_maps[2])self.upSimple3 = DeConvBlock(filter_maps[2], filter_maps[1])self.decoderConv3 = ConvBlock(filter_maps[2], filter_maps[1])self.upSimple4 = DeConvBlock(filter_maps[1], filter_maps[0])self.decoderConv4 = ConvBlock(filter_maps[1], filter_maps[0])# 输出self.final = nn.Conv2d(filter_maps[0], out_channel, kernel_size=1)self.out = nn.Tanh()def forward(self, x):# 编码，下采样过程en_x1 = self.encoderConv1(x)  # 输出 (batch,64,256,256)down_x1 = self.pool(en_x1)  # 输出 (batch,64,128,128)en_x2 = self.encoderConv2(down_x1)  # 输出 (batch,128,128,128)down_x2 = self.pool(en_x2)  # 输出 (batch,128,64,64)en_x3 = self.encoderConv3(down_x2)  # 输出 (batch,256,64,64)down_x3 = self.pool(en_x3)  # 输出(batch,256,32,32)en_x4 = self.encoderConv4(down_x3)  # 输出(batch,512,32,32)down_x4 = self.pool(en_x4)  # 输出(batch,512,16,16)en_x5 = self.encoderConv5(down_x4)  # 输出(batch,1024,16,16)# 解码，上采样过程up_x1 = self.upSimple1(en_x4, en_x5)  # 输出 (batch,1024,32,32)de_x1 = self.decoderConv1(up_x1)  # 输出 (batch,512,32,32)up_x2 = self.upSimple2(en_x3, de_x1)  # 输出 (batch,512,64,64)de_x2 = self.decoderConv2(up_x2)  # 输出 (batch,256,64,64)up_x3 = self.upSimple3(en_x2, de_x2)  # 输出 (batch,256,128,128)de_x3 = self.decoderConv3(up_x3)  # 输出 (batch,128,128,128)up_x4 = self.upSimple4(en_x1, de_x3)  # 输出 (batch,128,256,256)de_x4 = self.decoderConv4(up_x4)  # 输出 (batch,64,256,256)# 输出return self.out(self.final(de_x4))  # 输出(batch,2,256,256) 图像ab通道 并标准化到(-1,1)#4.判别器-卷积模块
class DiscriminatorBlock(nn.Module):def __init__(self,in_channel,out_channel):super(DiscriminatorBlock, self).__init__()#论文：使用stride=2来代替pool进行下采样，pool会损失信息！self.block = nn.Sequential(nn.Conv2d(in_channel, out_channel, kernel_size=4, stride=2, padding=1),nn.BatchNorm2d(out_channel),nn.LeakyReLU(0.2,inplace=True))def forward(self,x):return self.block(x)#5.判别器网络
class Discriminator(nn.Module):def __init__(self,in_channel):super(Discriminator, self).__init__()filter_maps = [32,64, 128, 256, 512]self.Conv1 = DiscriminatorBlock(in_channel,filter_maps[0])self.Conv2 = DiscriminatorBlock(filter_maps[0],filter_maps[1])self.Conv3 = DiscriminatorBlock(filter_maps[1],filter_maps[2])self.Conv4 = DiscriminatorBlock(filter_maps[2],filter_maps[3])self.Conv5 = DiscriminatorBlock(filter_maps[3],filter_maps[4])self.Conv6 = DiscriminatorBlock(filter_maps[4],filter_maps[4])self.out = nn.Conv2d(filter_maps[4],1,kernel_size=4,stride=1)self.cls = nn.Sigmoid()def forward(self,x):x = self.Conv1(x) #(b,32,128,128)x = self.Conv2(x) #(b,64,64,64)x = self.Conv3(x) #(b,128,32,32)x = self.Conv4(x) #(b,256,16,16)x = self.Conv5(x) #(b,512,8,8)x = self.Conv6(x) #(b,512,4,4)return self.cls(self.out(x)).view(-1) #(b,1,1,1) -> 一维(b)

（4）网络训练模块 train.py

import os
import torch
from torch.utils.data import DataLoader
from data import *
from net import *device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')#调整设备，优先使用gpu
img_dir = r"D:\日常材料\作业报告\机器学习\DUTS数据集\DUTS-TE\DUTS-TE-Image"
weightD_path = "params/Dnet.pth"
weightG_path = "params/Gnet.pth"
batch_size = 4
epoch = 10
d_every = 1
g_every = 2if __name__ == "__main__":#1.加载自己训练数据集的数据加载器data_loader = DataLoader(ModelDataset(img_dir),batch_size=batch_size,shuffle=True)#2.将模型加载到设备上Dnet,Gnet = Discriminator(3).to(device),Generator(1,2).to(device)#2.1加载预训练权重(如果有的话)if os.path.exists(weightD_path):Dnet.load_state_dict(torch.load(weightD_path))if os.path.exists(weightG_path):Gnet.load_state_dict(torch.load(weightG_path))#3.设置优化器和损失optim_D = torch.optim.Adam(Dnet.parameters(),lr=0.0001,betas=(0.5,0.999))optim_G = torch.optim.Adam(Gnet.parameters(),lr=0.0001,betas=(0.5,0.999))criterion = torch.nn.BCELoss()#4.设置真假标签（真为1，假为0）true_label = torch.ones(batch_size).to(device)fake_label = torch.zeros(batch_size).to(device)#4.开始训练for i in range(epoch):lossSum_D = 0.0lossSum_G = 0.0for index,(img_l,img_real,_) in enumerate(data_loader):#img_l,img_real = img_l.to(device),img_real.to(device) #将数据放到设备上img_l,img_real = img_l.type(torch.cuda.FloatTensor).to(device),img_real.type(torch.cuda.FloatTensor).to(device)if index % d_every==0:#训练判别器，固定生成器#1.训练真实图片，尽可能将真图片判别为正确output_real = Dnet(img_real)loss_real = criterion(output_real,true_label)#累计梯度optim_D.zero_grad()loss_real.backward()#2.训练假图片，尽可能将假图片判别为假output_ab = Gnet(img_l).detach()#使用detach截断计算图，防止判别器更新生成器img_fake = torch.cat([img_l,output_ab],dim=1).to(device)output_fake = Dnet(img_fake)loss_fake = criterion(output_fake,fake_label)#累计梯度loss_fake.backward()#3.更新判别网络optim_D.step()lossSum_D = lossSum_D + loss_real.item() + loss_fake.item()if index % g_every==0:# 训练生成器，固定判别器# 1.生成假图片output_ab = Gnet(img_l)img_fake = torch.cat([img_l, output_ab], dim=1).to(device)output_fake = Dnet(img_fake)#2.让假图片尽可能以假乱真loss_fakeTrue = criterion(output_fake,true_label)#更新参数optim_G.zero_grad()loss_fakeTrue.backward()optim_G.step()lossSum_G = lossSum_G + loss_fakeTrue.item()torch.save(Dnet.state_dict(),weightD_path)#每一轮都保存训练参数weighttorch.save(Gnet.state_dict(),weightG_path)print("[epoch %d]: Dloss is %.3f and Gloss is %.3f" % (i+1,lossSum_D,lossSum_G))

（5）网络测试模块 test.py

import os
import torch
from net import *
from data import *
from torch.utils.data import DataLoader
from torchvision import utils
from util import *
import matplotlib.pyplot as pltimage_dir = r"D:\日常材料\作业报告\机器学习\DUTS数据集\train_data"
save_dir = r"D:\日常材料\作业报告\机器学习\DUTS数据集\color_result"
weightG_path = "params/Gnet.pth"Gnet = Generator(1,2)
if os.path.exists(weightG_path):Gnet.load_state_dict(torch.load(weightG_path))print("weights load successful")
else:print("weights is not exist")Gnet.eval() #切换训练模式
test_loader = DataLoader(ModelDataset(image_dir),batch_size=1,shuffle=False) #(1,c,h,w) 网络必须四维输入#不进行计算图构建
with torch.no_grad():for index,(test_img_l,test_img_real,test_img_grey) in enumerate(test_loader):test_img_l,test_img_real = test_img_l.type(torch.FloatTensor),test_img_real.type(torch.FloatTensor)out_ab = Gnet(test_img_l)out_image = torch.cat([test_img_l,out_ab],dim=1)image_grey = torch.cat([test_img_grey,test_img_grey,test_img_grey],dim=1)image_real = TransfertToRGB(test_img_real)image_color = TransfertToRGB(out_image)# 将真实图像和预测图象拼接(拼接到batch上，构造雪碧网格图)，也可以降维输出单个图像img = torch.cat([image_grey,image_real,image_color],dim=0)#保存图像save_path = os.path.join(save_dir,str(index)+".png")#注意，save_image将图像保存为RGB三通道，如果是二值图像则三个通道数值都相同，即伪灰度图像utils.save_image(img,save_path)

5.测试结果

从左到右依次是：黑白图像、原彩色图像、预测输出彩色图像。

深度学习（五）生成对抗网络入门与实践相关推荐

【深度学习】生成对抗网络（GAN）的tensorflow实现
[深度学习]生成对抗网络(GAN)的tensorflow实现一.GAN原理二.GAN的应用三.GAN的tensorflow实现参考资料 GAN( Generative Adversarial ...
深度学习之生成对抗网络（8）WGAN-GP实战
深度学习之生成对抗网络(8)WGAN-GP实战代码修改完整代码 WGAN WGAN_train 代码修改 WGAN-GP模型可以在原来GAN代码实现的基础上仅做少量修改.WGAN-GP模型的判别 ...
深度学习之生成对抗网络（7）WGAN原理
深度学习之生成对抗网络(7)WGAN原理 1. JS散度的缺陷 2. EM距离 3. WGAN-GP WGAN算法从理论层面分析了GAN训练不稳定的原因,并提出了有效的解决方法.那么是什么原因导致了 ...
深度学习之生成对抗网络（6）GAN训练难题
深度学习之生成对抗网络(6)GAN训练难题 1. 超参数敏感 2. 模式崩塌尽管从理论层面分析了GAN网络能够学习到数据的真实分布,但是在工程实现中,常常出现GAN网络训练困难的问题,主要体现在G ...
深度学习之生成对抗网络（4）GAN变种
深度学习之生成对抗网络(4)GAN变种 1. DCGAN 2. InfoGAN 3. CycleGAN 4. WGAN 5. Equal GAN 6. Self-Attention GAN 7. Bi ...
深度学习之生成对抗网络（2）GAN原理
深度学习之生成对抗网络(2)GAN原理 1. 网络结构生成网络G(z)\text{G}(\boldsymbol z)G(z) 判别网络D(x)\text{D}(\boldsymbol x)D(x) ...
深度学习之生成对抗网络（1）博弈学习实例
深度学习之生成对抗网络(1)博弈学习实例博弈学习实例在生成对抗网络(Generative Adversarial Network,简称GAN)发明之前,变分自编码器被认为是理论完备,实现简单, ...
深度学习之生成对抗网络（5）纳什均衡
深度学习之生成对抗网络(5)纳什均衡 1. 判别器状态 2. 生成器状态 3. 纳什均衡点现在我们从理论层面进行分析,通过博弈学习的训练方式,生成器G和判别器D分别会达到什么平衡状态.具体地,我们 ...
【深度学习】生成对抗网络
下文以图片作为数据举例介绍. 生成网络(生成器)–>以假乱真生成网络的职责是把随机点模仿成与真实数据集相似的图片,这些随机点是从一个潜在空间中随机抽取的.它可以看作一个实现"点对点变 ...

深度学习（五）生成对抗网络入门与实践

一.生成对抗网络基本概念

1.发展背景

2.核心思想

二.训练过程

三.黑白图像着色问题实践

1.问题背景

2.颜色空间

（1）RGB颜色空间

（2）YUV颜色空间

（3）Lab颜色空间

3.实验设计思路（条件-生成对抗网络）

（1）数据集

（2）模型结构

4.代码实现

（1）工具方法 util.py

（2）数据集 data.py

（3）网络模型 net.py

（4）网络训练模块 train.py

（5）网络测试模块 test.py

5.测试结果

深度学习（五）生成对抗网络入门与实践相关推荐

最新文章

热门文章

深度学习（五） 生成对抗网络入门与实践

一.生成对抗网络基本概念

1.发展背景

2.核心思想

二.训练过程

三.黑白图像着色问题实践

1.问题背景

2.颜色空间

（1）RGB颜色空间

（2）YUV颜色空间

（3）Lab颜色空间

3.实验设计思路 （条件-生成对抗网络）

（1）数据集

（2） 模型结构

4.代码实现

（1）工具方法 util.py

（2）数据集 data.py

（3）网络模型 net.py

（4）网络训练模块 train.py

（5）网络测试模块 test.py

5.测试结果

深度学习（五） 生成对抗网络入门与实践相关推荐

最新文章

热门文章

深度学习（五）生成对抗网络入门与实践

3.实验设计思路（条件-生成对抗网络）

（2）模型结构

深度学习（五）生成对抗网络入门与实践相关推荐