GANsGenerative Adversarial Nets

Posted 2022-09-28 SupV

【GANs】Generative Adversarial Nets

• 1 GAN
• • 1.1 GANs的简介
  • 1.2 思想与目标函数
  • 1.3 GAN代码
  • 1.4 全局最优推导
  • 1.5 GANs方向展望

1 GAN

1.1 GANs的简介

Generative Adversarial Nets原文链接

• 判别器模型（网络）：一般熟知的带标签的分类、回归等监督学习都属于判别器模型。学习的是某种分布下的条件概率分布$p(y|x)$。

• 生成器模型（网络）：聚类、自动编码器等无监督学习模型。学习的是联合分布概率$p(x,y)$。通过模型学习到最优的$p(x|y)$

在现实中，判别模型在分类工作中的表现通常优于生成模型，但在一些创造性的工作中显然生成模型更有意义。

1.2 思想与目标函数

生成器和判别器不断对抗博弈，直到两个网络到达最终的动态均衡状态，即判别器无法识别生成器的图像真假。

我们想学习到的是像训练集那样的数据分布：$p_g(z)$➡真实数据分布，$z$是噪声。

但是 我们可知道的是，极大似然函数去找概率分布会有很复杂的计算问题，因此我们才看作者采用的方式，绕过极大似然函数来逼近真实数据分布。

逼近过程：

$x\sim P_{data}$
$z\sim P_z$

• 我们看训练$D$（想让$D$性能高）：

if x is from Pdata : D(x) ↑ --→ log(D(x)) ↑

if z is from Pz : D(G(z)) ↓ --→ 1 - D(G(z)) ↑ <=> log(1 -  D(G(z))) ↑

得到关于$D$的目标函数
${}_D^{max}{E}_{x\sim P_{data}}[logD(x)]+E_{z\sim P_z}(1-D(G(z)))$

• 在来看训练$G$（想让$G$性能高）：

z is from Pz : D(z) ↑ --→ 1-D(G(z)) ↓ <=> log(1-D(G(z))) ↓

得到关于$G$的目标函数：
${}_G^{min}{E}_{z\sim P_z}(1-D(G(z)))$

由$G$和$D$的两个目标，得到总的目标函数:(GAN原始论文中的目标函数)
${}_G^{min}{}_D^{max}{E}_{x\sim P_{data}}[logD(x)]+E_{z\sim P_z}(1-D(G(z)))$
以这个目标函数训练下去，$G$和$D$将在博弈中达到最优。

全局最优存在且函数收敛，在介绍完代码后证明。

1.3 GAN代码

# GAN_2014.py
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras import Sequential,Model
from tensorflow.keras.layers import Dense,Reshape,Input,Flatten
from tensorflow.keras.layers import LeakyReLU,BatchNormalization
from tensorflow.keras.datasets import mnist
from tensorflow.keras.optimizers import Adam

class GAN():
	def __init__(self):
		self.latent_dim = 100
		self.img_rows = 28
		self.img_cols = 28
		self.channel  = 1
		self.img_shape = (self.img_rows,self.img_cols,self.channel)
		
		self.discrinator = self.build_discrinator()         # 构建
		optimizer = Adam(0.0002,0.5)
		self.discrinator.compile(loss='binary_crossentropy',
								 optimizer=optimizer,
								 metrics=['accuracy'])
		 
		self.generator = self.build_generator()             # generator就可以完成从noise到img的生成
		
		self.discrinator.trainable = False
		z = Input(shape=(self.latent_dim,))
		img = self.generator(z)
		validity = self.discrinator(img)

		self.combined = Model(z,validity)
		self.combined .compile(loss='binary_crossentropy',optimizer=optimizer)  # 完成了叠加模型的构建
		
		
		
	# 构建生成器模型
	def build_generator(self):
		model = Sequential()
		# 添加一层全连接层
		model.add(Dense(256, input_dim=self.latent_dim ))  # 输入噪声是一维含有100个元素的向量
		model.add(LeakyReLU(alpha=0.2))
		model.add(BatchNormalization(momentum=0.8))         # BN层
		model.add(Dense(512))
		model.add(LeakyReLU(alpha=0.2))
		model.add(BatchNormalization(momentum=0.8))         # BN层

		model.add(Dense(1024))
		model.add(LeakyReLU(alpha=0.2))
		model.add(BatchNormalization(momentum=0.8))         # BN层

		model.add(Dense(np.prod(self.img_shape),activation='tanh'))  # 神经元个数（输出）等于图像尺寸乘积 
		model.add(Reshape(self.img_shape))                 # reshape成图像形状 28*28*1
		model.summary()                                    # 记录各层参数情况
		
		noise = Input(shape=(self.latent_dim,))
		img = model(noise)
		
		return Model(noise,img)                            # 返回输入为噪声，输出为预测图的Model

	# 构建判别器模型
	def build_discrinator(self):
		# 需要输入图片 然后判别真假  img--→label
		model = Sequential()
		model.add(Flatten(input_shape=self.img_shape))     # 将图像拉成一维
		model.add(Dense(512))
		model.add(LeakyReLU(alpha=0.2))
		model.add(Dense(256))
		model.add(LeakyReLU(alpha=0.2))
		model.add(Dense(1,activation='sigmoid'))           # 输出结果落在0-1概率区间
		
		model.summary()                                    # 记录各层参数情况
		
		img = Input(shape=self.img_shape)
		validity = model(img)                              # 将输入图输入模型之后预测出来的输出概率
		return Model(img,validity)                         # 由图像生成可能性
	
	def train(self,epochs,batch_size=128,sample_interval=50):
		# 获取mnist手写数字数据集
		(X_train, _),(_,_) = mnist.load_data()             # shape : 60000*28*28
		# 将图像值转化成（-1，1）
		X_train = X_train / 127.5 - 1.
		X_train = np.expand_dims(X_train,axis=3)           # 扩展成60000*28*28*1
		
		valid = np.ones((batch_size, 1))                   # 完成对Batch个图像进行1标签的操作
		fake  = np.zeros((batch_size,1))                   # 完成对虚假图像进行0标签的操作
		for epoch in range(epochs):
			# ---------------------------
			# 训练判别器
			# ---------------------------
			# 选择batch_size个图像样本（随机）
			idx = np.random.randint(0,X_train.shape[0],batch_size)
			imgs = X_train[idx]                            # batch_size*28*28*1  真实样本
			noise = np.random.normal(0,1,(batch_size,self.latent_dim))
			# 使用生成器将noise生成img
			gen_imgs = self.generator.predict(noise)       # 完成了噪声生成图像 也就是 虚假图像
			d_loss_real = self.discrinator.train_on_batch(imgs,valid)
			d_loss_fake = self.discrinator.train_on_batch(gen_imgs,fake)
			d_loss = 0.5 * np.add(d_loss_fake, d_loss_real)
			# 完成了对判别器的训练
			
			# ---------------------------
			# 训练生成器
			# ---------------------------
			noise = np.random.normal(0,1,(batch_size,self.latent_dim))  # batch_size*100
			g_loss = self.combined.train_on_batch(noise,valid)
			
			print('%d [D loss: %f, acc.: %.2f%%] [G loss: %f]' % (epoch,d_loss[0], 100*d_loss[1],g_loss)) 
			
			# 每200轮保存一个Batch图像
			if epoch % sample_interval == 0:
				self.sample_images(epoch)
		
	def sample_images(self,epoch):
		r,c = 5,5
		noise = np.random.normal(0,1,(r*c,self.latent_dim))
		gen_imgs = self.generator.predict(noise)
		
		# Rescale image 0 - 1
		gen_imgs = 0.5 * gen_imgs + 0.5
		
		fig,axs = plt.subplots(r,c)
		cnt = 0
		for i in range(r):
			for j in range(c):
				axs[i,j].imshow(gen_imgs[cnt, :, :, 0],cmap='gray')
				axs[i,j].axis('off')
				cnt += 1
		fig.savefig('images/%d.png' % epoch)
		plt.close()
			  

if __name__ == '__main__':
	gan = GAN()
	gan.train(epochs=30000,batch_size=32,sample_interval=200)
			

tree

test
│  GAN_2014.py
└─ images

1.4 全局最优推导

$x\sim P_{data}$
$z\sim 以上是关于GANsGenerative\; Adversarial\; Nets的主要内容，如果未能解决你的问题，请参考以下文章$