第六周: 生成式对抗网络

视频学习

1. GAN（生成式对抗网络）

GAN的框架

GAN的工作原理

由判别器和生成器组成
判别器（Discriminator)：区分真实(real)样本和虚假(fake)样本。对于真实样本，尽可能给出高的评分1；对于虚假数据，尽可能给出低的评分0
生成器（Generator)：欺骗判别器。生成虚假数据，使得判别器D能够尽可能给出高的评分1
生成器和判器存在着对抗的关系，通过不断的对抗使最终结果无限接近我们想要的结果
随机噪声z：从一个先验分布（人为定义，一般是均匀分布或者正态分布）中随机采样的向量
真实样本x：从数据库中采样的样本；合成样本G(z)：生成模型G输出的样本

GAN目标函数

GAN训练算法

随机初始化生成器和判别器
交替训练判别器D和生成器G，直到收敛

（1）步骤1：固定生成器G，训练判别器D区分真实图像与合成图像，赋予真实图像高分，赋予合成图像低分

（2) 步骤2：固定判别器D，训练生成器G欺骗判别器D，更新生成器的参数，使其合成的图片被生成器D赋予高分

重复执行以上两步

GAN训练策略

KL散度与JS散度

极大似然估计

GAN在做的事情

最大化判别器损失，等价于计算合成数据分布和真实数据分布的JS散度
最小化生成器损失，等价于最小化JS散度（也就是优化生成模型）

2. cGAN（条件生成式对抗网络）

网络结构

目标函数

3. DcGAN（深度卷积生成式对抗网络）

网络结构（判别器）

使用滑动卷积（strided convolution）
除了输入层，全部使用批归一化
使用Leaky ReLu激活函数
除了最后一层，不使用全连接层

网络结构（生成器）

使用滑动反卷积（fractional strided convolution）
除了输出层，全部使用批归一化
使用ReLu激活函数，最后一层使用tanh激活函数

滑动卷积、滑动反卷积：

使得判别器和生成器可以学习自己的上采样和下采样策略

批归一化：

训练更稳定

Tanh激活函数：

更快的学习到真实数据的颜色空间

训练策略

数据预处理：所有输入数据归一化到[-1,1]
激活函数：Leaky ReLu的斜率设置为0.2
初始化：使用均值为0，标准差为0.02的正态分布初始化网络参数
优化器：使用Adam优化器，学习率为0.0002，betal=0.5，beta2=0.999

代码练习

GAN

首先借助于 sklearn.datasets.make_moons 库，生成双半月形的数据，同时把数据点画出来。可以看出，数据散点呈现两个半月形状。

生成器： 32 ==> 128 ==> 2
判别器： 2 ==> 128 ==> 1
生成器生成的是样本，即一组坐标（x,y），我们希望生成器能够由一组任意的 32组噪声生成座标（x,y）处于两个半月形状上。

判别器输入的是一组座标（x,y），最后一层是sigmoid函数，是一个范围在（0，1）间的数，即样本为真或者假的置信度。如果输入的是真样本，得到的结果尽量接近1；如果输入的是假样本，得到的结果尽量接近0。

import torch.nn as nn

z_dim = 32
hidden_dim = 128

# 定义生成器
net_G = nn.Sequential(
            nn.Linear(z_dim,hidden_dim),
            nn.ReLU(), 
            nn.Linear(hidden_dim, 2))

# 定义判别器
net_D = nn.Sequential(
            nn.Linear(2,hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim,1),
            nn.Sigmoid())

# 网络放到 GPU 上
net_G = net_G.to(device)
net_D = net_D.to(device)

# 定义网络的优化器
optimizer_G = torch.optim.Adam(net_G.parameters(),lr=0.0001)
optimizer_D = torch.optim.Adam(net_D.parameters(),lr=0.0001)

对抗训练过程:

batch_size = 50
nb_epochs = 1000

loss_D_epoch = []
loss_G_epoch = []

for e in range(nb_epochs):
    np.random.shuffle(X)
    real_samples = torch.from_numpy(X).type(torch.FloatTensor)
    loss_G = 0
    loss_D = 0
    for t, real_batch in enumerate(real_samples.split(batch_size)):
        # 固定生成器G，改进判别器D
        # 使用normal_()函数生成一组随机噪声，输入G得到一组样本
        z = torch.empty(batch_size,z_dim).normal_().to(device)
        fake_batch = net_G(z)
        # 将真、假样本分别输入判别器，得到结果
        D_scores_on_real = net_D(real_batch.to(device))
        D_scores_on_fake = net_D(fake_batch)
        # 优化过程中，假样本的score会越来越小，真样本的score会越来越大，下面 loss 的定义刚好符合这一规律，
        # 要保证loss越来越小，真样本的score前面要加负号
        # 要保证loss越来越小，假样本的score前面是正号（负负得正）
        loss = -torch.mean(torch.log(1-D_scores_on_fake) + torch.log(D_scores_on_real))
        # 梯度清零
        optimizer_D.zero_grad()
        # 反向传播优化
        loss.backward()
        # 更新全部参数
        optimizer_D.step()
        loss_D += loss
                    
        # 固定判别器，改进生成器
        # 生成一组随机噪声，输入生成器得到一组假样本
        z = torch.empty(batch_size,z_dim).normal_().to(device)
        fake_batch = net_G(z)
        # 假样本输入判别器得到 score
        D_scores_on_fake = net_D(fake_batch)
        # 我们希望假样本能够骗过生成器，得到较高的分数，下面的 loss 定义也符合这一规律
        # 要保证 loss 越来越小，假样本的前面要加负号
        loss = -torch.mean(torch.log(D_scores_on_fake))
        optimizer_G.zero_grad()
        loss.backward()
        optimizer_G.step()
        loss_G += loss
    
    if e % 50 ==0:
        print(f'\n Epoch {e} , D loss: {loss_D}, G loss: {loss_G}') 

    loss_D_epoch.append(loss_D)
    loss_G_epoch.append(loss_G)

可以看出训练结果是十分不理想的，其中，白色的是原来的真实样本，黑色的点是生成器生成的样本。看起来，效果是不令人满意的。现在把学习率修改为 0.001，batch_size改大到250：

loss明显减小了，训练结果比一开始好多了。

CGAN和DCGAN

Conditional Generative Adversarial Nets，简单来说就是条件生成-对抗网络。在生成器以及判别器上它都多了一个标签作为输入。

所以，生成器的输入是噪声和标签，输出还是生成图；判别器的输入是生成图，真实图以及标签，输出还是真和假。

这里epoch我设置为100

CGAN

下面分别是判别器和生成器的网络结构，可以看出网络结构非常简单，具体如下：

生成器：(784 + 10) ==> 512 ==> 256 ==> 1
判别器：(100 + 10) ==> 128 ==> 256 ==> 512 ==> 784

可以看出，去掉生成器和判别器那 10 维的标签信息，和普通的GAN是完全一样的。

class Discriminator(nn.Module):
	'''全连接判别器，用于1x28x28的MNIST数据,输出是数据和类别'''
	def __init__(self):
		super(Discriminator, self).__init__()
		self.model = nn.Sequential(
			  nn.Linear(28*28+10, 512),
			  nn.LeakyReLU(0.2, inplace=True),
			  nn.Linear(512, 256),
			  nn.LeakyReLU(0.2, inplace=True),
			  nn.Linear(256, 1),
			  nn.Sigmoid()
		)
  
	def forward(self, x, c):
		x = x.view(x.size(0), -1)
		validity = self.model(torch.cat([x, c], -1))
		return validity

class Generator(nn.Module):
	'''全连接生成器，用于1x28x28的MNIST数据，输入是噪声和类别'''
	def __init__(self, z_dim):
		super(Generator, self).__init__()
		self.model = nn.Sequential(
			  nn.Linear(z_dim+10, 128),
			  nn.LeakyReLU(0.2, inplace=True),
			  nn.Linear(128, 256),
			  nn.BatchNorm1d(256, 0.8),
			  nn.LeakyReLU(0.2, inplace=True),
			  nn.Linear(256, 512),
			  nn.BatchNorm1d(512, 0.8),
			  nn.LeakyReLU(0.2, inplace=True),
			  nn.Linear(in_features=512, out_features=28*28),
			  nn.Tanh()
	 	)

	def forward(self, z, c):
		x = self.model(torch.cat([z, c], dim=1))
		x = x.view(-1, 1, 28, 28)
		return x

训练过程：

# 开始训练，一共训练total_epochs
for epoch in range(total_epochs):

	# torch.nn.Module.train() 指的是模型启用 BatchNormalization 和 Dropout
	# torch.nn.Module.eval() 指的是模型不启用 BatchNormalization 和 Dropout
	# 因此，train()一般在训练时用到， eval() 一般在测试时用到
	generator = generator.train()

	# 训练一个epoch
	for i, data in enumerate(dataloader):

		# 加载真实数据
		real_images, real_labels = data
		real_images = real_images.to(device)
		# 把对应的标签转化成 one-hot 类型
		tmp = torch.FloatTensor(real_labels.size(0), 10).zero_()
		real_labels = tmp.scatter_(dim=1, index=torch.LongTensor(real_labels.view(-1, 1)), value=1)
		real_labels = real_labels.to(device)

		# 生成数据
		# 用正态分布中采样batch_size个随机噪声
		z = torch.randn([batch_size, z_dim]).to(device)
		# 生成 batch_size 个 ont-hot 标签
		c = torch.FloatTensor(batch_size, 10).zero_()
		c = c.scatter_(dim=1, index=torch.LongTensor(np.random.choice(10, batch_size).reshape([batch_size, 1])), value=1)
		c = c.to(device)
		# 生成数据
		fake_images = generator(z,c)

		# 计算判别器损失，并优化判别器
		real_loss = bce(discriminator(real_images, real_labels), ones)
		fake_loss = bce(discriminator(fake_images.detach(), c), zeros)
		d_loss = real_loss + fake_loss

		d_optimizer.zero_grad()
		d_loss.backward()
		d_optimizer.step()

		# 计算生成器损失，并优化生成器
		g_loss = bce(discriminator(fake_images, c), ones)

		g_optimizer.zero_grad()
		g_loss.backward()
		g_optimizer.step()

		# 输出损失
	print("[Epoch %d/%d] [D loss: %f] [G loss: %f]" % (epoch, total_epochs, d_loss.item(), g_loss.item()))

结果十分不理想

DCGAN

class D_dcgan(nn.Module):
	'''滑动卷积判别器'''
	def __init__(self):
		super(D_dcgan, self).__init__()
		self.conv = nn.Sequential(
            # 第一个滑动卷积层，不使用BN，LRelu激活函数
            nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),
            # 第二个滑动卷积层，包含BN，LRelu激活函数
            nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, stride=2, padding=1),
            nn.BatchNorm2d(32),
            nn.LeakyReLU(0.2, inplace=True),
            # 第三个滑动卷积层，包含BN，LRelu激活函数
            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=2, padding=1),
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.2, inplace=True),
            # 第四个滑动卷积层，包含BN，LRelu激活函数
            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=4, stride=1),
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.2, inplace=True)
        )

		# 全连接层+Sigmoid激活函数
		self.linear = nn.Sequential(nn.Linear(in_features=128, out_features=1), nn.Sigmoid())

	def forward(self, x):
		x = self.conv(x)
		x = x.view(x.size(0), -1)
		validity = self.linear(x)
		return validity

class G_dcgan(nn.Module):
	'''反滑动卷积生成器'''

	def __init__(self, z_dim):
		super(G_dcgan, self).__init__()
		self.z_dim = z_dim
		# 第一层：把输入线性变换成256x4x4的矩阵，并在这个基础上做反卷机操作
		self.linear = nn.Linear(self.z_dim, 4*4*256)
		self.model = nn.Sequential(
            # 第二层：bn+relu
            nn.ConvTranspose2d(in_channels=256, out_channels=128, kernel_size=3, stride=2, padding=0),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            # 第三层：bn+relu
            nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=3, stride=2, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            # 第四层:不使用BN，使用tanh激活函数
            nn.ConvTranspose2d(in_channels=64, out_channels=1, kernel_size=4, stride=2, padding=2),
            nn.Tanh()
        )

	def forward(self, z):
		# 把随机噪声经过线性变换，resize成256x4x4的大小
		x = self.linear(z)
		x = x.view([x.size(0), 256, 4, 4])
		# 生成图片
		x = self.model(x)
		return x

epoch为30结果还是可以的，但是epoch设为100结果很不理想。

posted @ 2020-09-12 17:19 EdwardBY 阅读(500) 评论(0) 收藏举报

刷新页面返回顶部

EdwardBY

第六周: 生成式对抗网络

公告