86整數拆分(343)

阿新 • • 發佈：2020-09-11

生成式對抗網路

背景

Ian Goodfellow 2014年 NIPS 首次提出GAN

GAN

目的：訓練一個生成模型，生成想要的資料。

為什麼罪犯製造的假幣越來越逼真？

為什麼GAN可以生成資料？

GAN目標函式：

Tanh 把圖片對映到[-1,1]，可以讓網路更快地收斂。

問題：隨機種子是0-100維的數字還是向量

輸入維數與圖片大小的關係？

KL散度：衡量兩個概率分佈匹配程度的指標

具有不對稱性，提出JS散度

JS散度：兩種KL散度的組合，做了對稱變換

具有非負性、對稱性

極大似然估計等價於最小化生成資料分佈和真實分佈的KL散度。

當判別器D最優的時候，最小化生成器G的目標函式等價於最小化真實分佈和生成分佈的JS散度。

GAN到底在做一個什麼事情？

最大化判別器損失，等價於計算合成數據分佈和真實資料分佈的JS散度

最小化生成器損失，等價於最小化JS散度（也就是優化生成模型）

cGAN

條件生成式對抗網路

改進判別器

DCGAN

深度卷積生成式對抗網路

原始GAN使用全連線網路作為判別器和生成器：

不利於建模影象資訊，向量資料丟失了影象空間資訊。

引數量大。

DCGAN使用卷積神經網路作為判別器和生成器：

通過大量的工程實踐，經驗性地提出一系列的網路結構和優化策略，來有效的建模影象資料。

通過pooling下采樣，pooling是不可學習的，可能造成GAN訓練困難。

判別器：使用滑動卷積（slide>1），使神經網路變得容易訓練。

通過插值法上取樣，插值方法固定不可學習，給訓練造成困難。

生成器(從小的feature map生成大的feature map)：滑動反捲積，3×3變為5×5後卷積，無畫素位置補0。

批歸一化：

加速神經網路收斂

減小神經網路引數對於初始化的依賴

啟用函式：

sigmoid改為ReLU或LReLU

程式碼練習

# 定義生成器
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())

optimizer_G = torch.optim.Adam(net_G.parameters(),lr=0.001)
optimizer_D = torch.optim.Adam(net_D.parameters(),lr=0.001)

batch_size = 250

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)):
        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)
        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)
        D_scores_on_fake = net_D(fake_batch)
        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)

z = torch.empty(n_samples,z_dim).normal_().to(device)
fake_samples = net_G(z)
fake_data = fake_samples.cpu().data.numpy()

fig, ax = plt.subplots(1, 1, facecolor='#4B6EA9')
all_data = np.concatenate((X,fake_data),axis=0)
Y2 = np.concatenate((np.ones(n_samples),np.zeros(n_samples)))
plot_data(ax, all_data, Y2)
plt.show()

CGAN

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

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