辅助分类器生成对抗网络（ Auxiliary Classifier Generative Adversarial Network，ACGAN）（附带pytorch代码）
ACGAN相对于CGAN使的判别器不仅可以判别真假，也可以判别类别 。通过对生成数据类别的判断，判别器可以更好地传递loss函数使得生成器能够更加准确地找到label对应的噪声分布。
1 ACGAN基本原理
1.2 ACGAN模型解释
ACGAN相对于CGAN使的判别器不仅可以判别真假，也可以判别类别 。通过对生成数据类别的判断，判别器可以更好地传递loss函数使得生成器能够更加准确地找到label对应的噪声分布，通过下图告诉了我们ACGAN与CGAN的异同之处 ：
对于CGAN和ACGAN，生成器输入均为潜在矢量及其标签，输出是属于输入类标签的伪造数据。对于CGAN，判别器的输入是数据（包含假的或真实的数据）及其标签， 输出是图像属于真实数据的概率。对于ACGAN，判别器的输入是数据，而输出是该图像属于真实数据的概率以及其类别概率。
在ACGAN中，对于生成器来说有两个输入，一个是标签的分类数据c，另一个是随机数据z，得到生成数据为 ；对于判别器，产生跨域标签和源数据的概率分布
1.2 ACGAN损失函数
对于判别器而言，即希望分类正确，有希望能正确分辨数据的真假；对于生成器而言，也希望分类正确，但希望判别器不能正确分辨真假。因此在训练判别器的时候，我们希望LSE+LCS最大化；在训练生成器的时候，我们希望LCS-LSE最大化。
logP(SR = real | Xreal)表示鉴别器将真实样本源正确分类为真实样本的对数似然;logP(SR = fake | Xfake)表示鉴别器正确地将假样本的来源分类为假样本的对数似然E[.]表示所有样本的平均值logP(CS = CS | Xreal)表示鉴别器正确分类真实样本的对数似然logP(CS = CS | Xfake)表示鉴别器正确分类具有正确类别标签的假样本的对数似然
判别器的损失函数 = LSE + LCS；生成器的损失函数 = LCS - LSE
- LSE测量鉴别器正确区分样本是真还是假的程度。这有助于鉴别器熟练地识别来源(真实的或生成的)。
- LCS确保生成的样本不仅看起来真实，而且携带正确的类信息。它引导生成器在不同的类中产生多样化和现实的样本。
2 ACGAN pytorch代码实现
完整代码链接：https://github.com/znxlwm/pytorch-generative-model-collections/tree/master
（但是这个代码我训练的时候损失函数也对应的上，得到的图片是黑乎乎的一片，也不知道是什么原因，如果知道的师傅可以麻烦告知一下吗？（感谢））
这个代码在训练ACGAN模型的时候加载数据集的时候会出现问题，因为我使用的是minist数据集，所以应该改为单通道的：
import utils, torch, time, os, pickle
import numpy as np
import torch.nn as nn
import torch.optim as optim
from dataloader import dataloader
class generator(nn.Module):
# Network Architecture is exactly same as in infoGAN (https://arxiv.org/abs/1606.03657)
# Architecture : FC1024_BR-FC7x7x128_BR-(64)4dc2s_BR-(1)4dc2s_S
def __init__(self, input_dim=100, output_dim=1, input_size=32, class_num=10):
super(generator, self).__init__()
self.input_dim = input_dim
self.output_dim = output_dim
self.input_size = input_size
self.class_num = class_num
self.fc = nn.Sequential(
nn.Linear(self.input_dim + self.class_num, 1024),
nn.BatchNorm1d(1024),
nn.ReLU(),
nn.Linear(1024, 128 * (self.input_size // 4) * (self.input_size // 4)),
nn.BatchNorm1d(128 * (self.input_size // 4) * (self.input_size // 4)),
nn.ReLU(),
)
self.deconv = nn.Sequential(
nn.ConvTranspose2d(128, 64, 4, 2, 1),
nn.BatchNorm2d(64),
nn.ReLU(),
nn.ConvTranspose2d(64, self.output_dim, 4, 2, 1),
nn.Tanh(),
)
utils.initialize_weights(self)
def forward(self, input, label):
x = torch.cat([input, label], 1)
x = self.fc(x)
x = x.view(-1, 128, (self.input_size // 4), (self.input_size // 4))
x = self.deconv(x)
return x
class discriminator(nn.Module):
# Network Architecture is exactly same as in infoGAN (https://arxiv.org/abs/1606.03657)
# Architecture : (64)4c2s-(128)4c2s_BL-FC1024_BL-FC1_S
def __init__(self, input_dim=1, output_dim=1, input_size=32, class_num=10):
super(discriminator, self).__init__()
self.input_dim = input_dim
self.output_dim = output_dim
self.input_size = input_size
self.class_num = class_num
self.conv = nn.Sequential(
nn.Conv2d(self.input_dim, 64, 4, 2, 1),
nn.LeakyReLU(0.2),
nn.Conv2d(64, 128, 4, 2, 1),
nn.BatchNorm2d(128),
nn.LeakyReLU(0.2),
)
self.fc1 = nn.Sequential(
nn.Linear(128 * (self.input_size // 4) * (self.input_size // 4), 1024),
nn.BatchNorm1d(1024),
nn.LeakyReLU(0.2),
)
self.dc = nn.Sequential(
nn.Linear(1024, self.output_dim),
nn.Sigmoid(),
)
self.cl = nn.Sequential(
nn.Linear(1024, self.class_num),
)
utils.initialize_weights(self)
def forward(self, input):
x = self.conv(input)
x = x.view(-1, 128 * (self.input_size // 4) * (self.input_size // 4))
x = self.fc1(x)
d = self.dc(x)
c = self.cl(x)
return d, c
class ACGAN(object):
def __init__(self, args):
# parameters
self.epoch = args.epoch
self.sample_num = 100
self.batch_size = args.batch_size
self.save_dir = args.save_dir
self.result_dir = args.result_dir
self.dataset = args.dataset
self.log_dir = args.log_dir
self.gpu_mode = args.gpu_mode
self.model_name = args.gan_type
self.input_size = args.input_size # 输入图像的尺寸
self.z_dim = 62 # 潜在向量维度
self.class_num = 10
self.sample_num = self.class_num ** 2 # 总样本的数量
# load dataset
self.data_loader = dataloader(self.dataset, self.input_size, self.batch_size) # 加载数据集
data = self.data_loader.__iter__().__next__()[0] # 获得第一个批次的数据，data 的形状通常是 (batch_size, channels, height, width)
# networks init
self.G = generator(input_dim=self.z_dim, output_dim=data.shape[1], input_size=self.input_size)
self.D = discriminator(input_dim=data.shape[1], output_dim=1, input_size=self.input_size)
self.G_optimizer = optim.Adam(self.G.parameters(), lr=args.lrG, betas=(args.beta1, args.beta2))
self.D_optimizer = optim.Adam(self.D.parameters(), lr=args.lrD, betas=(args.beta1, args.beta2))
# 查看是否启用了gpu模式
if self.gpu_mode:
self.G.cuda()
self.D.cuda()
self.BCE_loss = nn.BCELoss().cuda() # 将交叉熵损失加载到GPU
self.CE_loss = nn.CrossEntropyLoss().cuda() # 将二元交叉熵损失加载到GPU
else:
self.BCE_loss = nn.BCELoss()
self.CE_loss = nn.CrossEntropyLoss()
print('---------- Networks architecture -------------')
utils.print_network(self.G)
utils.print_network(self.D)
print('-----------------------------------------------')
# fixed noise & condition
# 为每个类别生成潜在向量（latent vector）z，并确保同一类别的所有样本共享相同的潜在向量
self.sample_z_ = torch.zeros((self.sample_num, self.z_dim))
for i in range(self.class_num):
self.sample_z_[i*self.class_num] = torch.rand(1, self.z_dim) # 为每一个类别随机生成潜在变量
for j in range(1, self.class_num):
self.sample_z_[i*self.class_num + j] = self.sample_z_[i*self.class_num] # 同一类别的样本共享相同的潜在变量
# 为每个样本创造标签向量
temp = torch.zeros((self.class_num, 1)) # 10*1
for i in range(self.class_num):
temp[i, 0] = i
temp_y = torch.zeros((self.sample_num, 1))
for i in range(self.class_num):
temp_y[i*self.class_num: (i+1)*self.class_num] = temp # 给每个样本赋予相同的标签
# 编码one-hot
self.sample_y_ = torch.zeros((self.sample_num, self.class_num)).scatter_(1, temp_y.type(torch.LongTensor), 1)
if self.gpu_mode:
self.sample_z_, self.sample_y_ = self.sample_z_.cuda(), self.sample_y_.cuda()
# 用于训练模型
def train(self):
self.train_hist = {}
self.train_hist['D_loss'] = []
self.train_hist['G_loss'] = []
self.train_hist['per_epoch_time'] = []
self.train_hist['total_time'] = []
self.y_real_, self.y_fake_ = torch.ones(self.batch_size, 1), torch.zeros(self.batch_size, 1)
if self.gpu_mode:
self.y_real_, self.y_fake_ = self.y_real_.cuda(), self.y_fake_.cuda()
self.D.train()
print('training start!!')
start_time = time.time()
for epoch in range(self.epoch):
self.G.train()
epoch_start_time = time.time()
for iter, (x_, y_) in enumerate(self.data_loader):
if iter == self.data_loader.dataset.__len__() // self.batch_size:
break
z_ = torch.rand((self.batch_size, self.z_dim))
y_vec_ = torch.zeros((self.batch_size, self.class_num)).scatter_(1, y_.type(torch.LongTensor).unsqueeze(1), 1)
if self.gpu_mode:
x_, z_, y_vec_ = x_.cuda(), z_.cuda(), y_vec_.cuda()
# update D network
self.D_optimizer.zero_grad() # 梯度清0
D_real, C_real = self.D(x_) # 获取判别器的预测结果
D_real_loss = self.BCE_loss(D_real, self.y_real_)
C_real_loss = self.CE_loss(C_real, torch.max(y_vec_, 1)[1])
G_ = self.G(z_, y_vec_) # 生成伪造数据
D_fake, C_fake = self.D(G_)
D_fake_loss = self.BCE_loss(D_fake, self.y_fake_)
C_fake_loss = self.CE_loss(C_fake, torch.max(y_vec_, 1)[1])
D_loss = D_real_loss + C_real_loss + D_fake_loss + C_fake_loss
self.train_hist['D_loss'].append(D_loss.item())
D_loss.backward()
self.D_optimizer.step() # 更新判别器权重
# update G network
self.G_optimizer.zero_grad()
G_ = self.G(z_, y_vec_)
D_fake, C_fake = self.D(G_)
G_loss = self.BCE_loss(D_fake, self.y_real_)
C_fake_loss = self.CE_loss(C_fake, torch.max(y_vec_, 1)[1])
G_loss += C_fake_loss
self.train_hist['G_loss'].append(G_loss.item())
G_loss.backward()
self.G_optimizer.step()
# 打印训练信息
if ((iter + 1) % 100) == 0:
print("Epoch: [%2d] [%4d/%4d] D_loss: %.8f, G_loss: %.8f" %
((epoch + 1), (iter + 1), self.data_loader.dataset.__len__() // self.batch_size, D_loss.item(), G_loss.item()))
# 每一轮训练结束-------------
self.train_hist['per_epoch_time'].append(time.time() - epoch_start_time)
with torch.no_grad(): # 结束进行梯度运算
self.visualize_results((epoch+1))
# 每一epoch训练结束-------------
self.train_hist['total_time'].append(time.time() - start_time)
print("Avg one epoch time: %.2f, total %d epochs time: %.2f" % (np.mean(self.train_hist['per_epoch_time']),
self.epoch, self.train_hist['total_time'][0]))
print("Training finish!... save training results")
self.save() # 保存训练历史
utils.generate_animation(self.result_dir + '/' + self.dataset + '/' + self.model_name + '/' + self.model_name,
self.epoch)
utils.loss_plot(self.train_hist, os.path.join(self.save_dir, self.dataset, self.model_name), self.model_name)
# 用于可视化生成的图像
def visualize_results(self, epoch, fix=True):
self.G.eval()
if not os.path.exists(self.result_dir + '/' + self.dataset + '/' + self.model_name):
os.makedirs(self.result_dir + '/' + self.dataset + '/' + self.model_name)
image_frame_dim = int(np.floor(np.sqrt(self.sample_num)))
if fix:
""" fixed noise """
samples = self.G(self.sample_z_, self.sample_y_)
else:
""" random noise """
sample_y_ = torch.zeros(self.batch_size, self.class_num).scatter_(1, torch.randint(0, self.class_num - 1, (self.batch_size, 1)).type(torch.LongTensor), 1)
sample_z_ = torch.rand((self.batch_size, self.z_dim))
if self.gpu_mode:
sample_z_, sample_y_ = sample_z_.cuda(), sample_y_.cuda()
samples = self.G(sample_z_, sample_y_)
if self.gpu_mode:
samples = samples.cpu().data.numpy().transpose(0, 2, 3, 1)
else:
samples = samples.data.numpy().transpose(0, 2, 3, 1)
samples = (samples + 1) / 2
utils.save_images(samples[:image_frame_dim * image_frame_dim, :, :, :], [image_frame_dim, image_frame_dim],
self.result_dir + '/' + self.dataset + '/' + self.model_name + '/' + self.model_name + '_epoch%03d' % epoch + '.png')
# 用于保存模型和训练历史
def save(self):
save_dir = os.path.join(self.save_dir, self.dataset, self.model_name)
if not os.path.exists(save_dir):
os.makedirs(save_dir)
torch.save(self.G.state_dict(), os.path.join(save_dir, self.model_name + '_G.pkl'))
torch.save(self.D.state_dict(), os.path.join(save_dir, self.model_name + '_D.pkl'))
with open(os.path.join(save_dir, self.model_name + '_history.pkl'), 'wb') as f:
pickle.dump(self.train_hist, f)
# 用于加载模型和训练历史
def load(self):
save_dir = os.path.join(self.save_dir, self.dataset, self.model_name)
self.G.load_state_dict(torch.load(os.path.join(save_dir, self.model_name + '_G.pkl')))
self.D.load_state_dict(torch.load(os.path.join(save_dir, self.model_name + '_D.pkl')))
由于上一个代码训练有问题，因此我训练的是以下代码：
模型结构：
# %%
'''
acgan structure.
the network model architecture from the paper [ACGAN](https://arxiv.org/abs/1610.09585)
'''
import torch
import torch.nn as nn
import numpy as np
from torch.nn.modules.activation import Sigmoid
# %%
class Generator(nn.Module):
'''
pure Generator structure
'''
def __init__(self, image_size=64, z_dim=100, conv_dim=64, channels = 1, n_classes=10):
super(Generator, self).__init__()
self.imsize = image_size
self.channels = channels
self.z_dim = z_dim
self.n_classes = n_classes
self.label_embedding = nn.Embedding(self.n_classes, self.z_dim)
self.linear = nn.Linear(self.z_dim, 768)
self.deconv1 = nn.Sequential(
nn.ConvTranspose2d(768, 384, 4, 1, 0, bias=False),
nn.BatchNorm2d(384),
nn.ReLU(True)
)
self.deconv2 = nn.Sequential(
nn.ConvTranspose2d(384, 256, 4, 2, 1, bias=False),
nn.BatchNorm2d(256),
nn.ReLU(True)
)
self.deconv3 = nn.Sequential(
nn.ConvTranspose2d(256, 192, 4, 2, 1, bias=False),
nn.BatchNorm2d(192),
nn.ReLU(True),
)
self.deconv4 = nn.Sequential(
nn.ConvTranspose2d(192, 64, 4, 2, 1, bias=False),
nn.BatchNorm2d(64),
nn.ReLU(True)
)
self.last = nn.Sequential(
nn.ConvTranspose2d(64, self.channels, 4, 2, 1, bias=False),
nn.Tanh()
)
def forward(self, z, labels):
label_emb = self.label_embedding(labels)
gen_input = torch.mul(label_emb, z)
out = self.linear(gen_input)
out = out.view(-1, 768, 1, 1)
out = self.deconv1(out)
out = self.deconv2(out)
out = self.deconv3(out)
out = self.deconv4(out)
out = self.last(out) # (*, c, 64, 64)
return out
# %%
class Discriminator(nn.Module):
'''
pure discriminator structure
'''
def __init__(self, image_size = 64, conv_dim = 64, channels = 1, n_classes = 10):
super(Discriminator, self).__init__()
self.imsize = image_size
self.channels = channels
self.n_classes = n_classes
# (*, c, 64, 64)
self.conv1 = nn.Sequential(
nn.Conv2d(self.channels, 16, 3, 2, 1, bias=False),
nn.LeakyReLU(0.2, inplace=True),
nn.Dropout(0.5, inplace=False)
)
# (*, 64, 32, 32)
self.conv2 = nn.Sequential(
nn.Conv2d(16, 32, 3, 1, 1, bias=False),
nn.BatchNorm2d(32),
nn.LeakyReLU(0.2, inplace=True),
nn.Dropout(0.5, inplace=False)
)
# (*, 128, 16, 16)
self.conv3 = nn.Sequential(
nn.Conv2d(32, 64, 3, 2, 1, bias=False),
nn.BatchNorm2d(64),
nn.LeakyReLU(0.2, inplace=True),
nn.Dropout(0.5, inplace=False)
)
# (*, 256, 8, 8)
self.conv4 = nn.Sequential(
nn.Conv2d(64, 128, 3, 1, 1, bias=False),
nn.BatchNorm2d(128),
nn.LeakyReLU(0.2, inplace=True),
nn.Dropout(0.5, inplace=False)
)
self.conv5 = nn.Sequential(
nn.Conv2d(128, 256, 3, 2, 1, bias=False),
nn.BatchNorm2d(256),
nn.LeakyReLU(0.2, inplace=True),
nn.Dropout(0.5, inplace=False)
)
self.conv6 = nn.Sequential(
nn.Conv2d(256, 512, 3, 1, 1, bias=False),
nn.BatchNorm2d(512),
nn.LeakyReLU(0.2, inplace=True),
nn.Dropout(0.5, inplace=False)
)
# output layers
# (*, 512, 8, 8)
# dis fc
self.last_adv = nn.Sequential(
nn.Linear(8*8*512, 1),
# nn.Sigmoid()
)
# aux classifier fc
self.last_aux = nn.Sequential(
nn.Linear(8*8*512, self.n_classes),
nn.Softmax(dim=1)
)
def forward(self, input):
out = self.conv1(input)
out = self.conv2(out)
out = self.conv3(out)
out = self.conv4(out)
out = self.conv5(out)
out = self.conv6(out)
flat = out.view(input.size(0), -1)
fc_dis = self.last_adv(flat)
fc_aux = self.last_aux(flat)
return fc_dis.squeeze(), fc_aux
数据加载：
# %%
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import torch
import torchvision.transforms as transform
from torchvision.utils import save_image
from torch.utils.data import DataLoader
from torchvision import datasets
# %%
def getdDataset(opt):
if opt.dataset == 'mnist':
dst = datasets.MNIST(
# 相对路径，以调用的文件位置为准——因为我不是每次都想下载数据，因为很多数据是重复的
root='D:\\ProfessionStudy\\AI\\data',
train=True,
download=True,
transform=transform.Compose(
[transform.Resize(opt.img_size), transform.ToTensor(), transform.Normalize([0.5], [0.5])]
)
)
elif opt.dataset == 'fashion':
dst = datasets.FashionMNIST(
root='D:\\ProfessionStudy\\AI\\data',
train=True,
download=True,
# split='mnist',
transform=transform.Compose(
[transform.Resize(opt.img_size), transform.ToTensor(), transform.Normalize([0.5], [0.5])]
)
)
elif opt.dataset == 'cifar10':
dst = datasets.CIFAR10(
root='D:\\ProfessionStudy\\AI\\data',
train=True,
download=True,
transform=transform.Compose(
[transform.Resize(opt.img_size), transform.ToTensor(), transform.Normalize([0.5], [0.5])]
)
)
dataloader = DataLoader(
dst,
batch_size=opt.batch_size,
shuffle=True,
)
return dataloader
# %%
from torchvision.utils import make_grid
import matplotlib.pyplot as plt
import numpy as np
if __name__ == "__main__":
class opt:
dataroot = '../../data'
dataset = 'mnist'
img_size = 32
batch_size = 10
dataloader = getdDataset(opt)
for i, (imgs, labels) in enumerate(dataloader):
print(i, imgs.shape, labels.shape)
print(labels)
img = imgs[0]
img = img.numpy()
img = make_grid(imgs, normalize=True).numpy()
img = np.transpose(img, (1, 2, 0))
plt.imshow(img)
plt.show()
plt.close()
break
# %%
训练过程：
# %%
"""
wgan with different loss function, used the pure dcgan structure.
"""
import os
import time
import torch
import datetime
import torch.nn as nn
import torchvision
from torchvision.utils import save_image
from models.acgan import Generator, Discriminator
from utils.utils import *
# %%
class Trainer_acgan(object):
def __init__(self, data_loader, config):
super(Trainer_acgan, self).__init__()
# data loader
self.data_loader = data_loader
# exact model and loss
self.model = config.model
# model hyper-parameters
self.imsize = config.img_size
self.g_num = config.g_num
self.z_dim = config.z_dim
self.channels = config.channels
self.n_classes = config.n_classes
self.g_conv_dim = config.g_conv_dim
self.d_conv_dim = config.d_conv_dim
self.epochs = config.epochs
self.batch_size = config.batch_size
self.num_workers = config.num_workers
self.g_lr = config.g_lr
self.d_lr = config.d_lr
self.beta1 = config.beta1
self.beta2 = config.beta2
self.pretrained_model = config.pretrained_model
self.dataset = config.dataset
self.use_tensorboard = config.use_tensorboard
# path
self.image_path = config.dataroot
self.log_path = config.log_path
self.sample_path = config.sample_path
self.log_step = config.log_step
self.sample_step = config.sample_step
self.version = config.version
# path with version
self.log_path = os.path.join(config.log_path, self.version)
self.sample_path = os.path.join(config.sample_path, self.version)
if self.use_tensorboard:
self.build_tensorboard()
self.build_model()
def train(self):
'''
Training
'''
# fixed input for debugging 用于每个epoch训练完成生成器后，用来测试其性能的
fixed_z = tensor2var(torch.randn(self.batch_size, self.z_dim)) # (*, 100)
fixed_labels = tensor2var(torch.randint(0, self.n_classes, (self.batch_size,), dtype=torch.long))
# fixed_labels = to_LongTensor(np.array([num for _ in range(self.n_classes) for num in range(self.n_classes)]))
for epoch in range(self.epochs):
# start time
start_time = time.time()
for i, (real_images, labels) in enumerate(self.data_loader):
# configure input
real_images = tensor2var(real_images)
labels = tensor2var(labels)
# adversarial ground truths；valid 和 fake 是用于计算判别器损失的对抗性标签。
valid = tensor2var(torch.full((real_images.size(0),), 0.9)) # (*, )
fake = tensor2var(torch.full((real_images.size(0),), 0.0)) #(*, )
# ==================== Train D 训练判别器 ==================
self.D.train()
self.G.train()
self.D.zero_grad()
# 计算真实数据损失
dis_out_real, aux_out_real = self.D(real_images)
d_loss_real = self.adversarial_loss_sigmoid(dis_out_real, valid) + self.aux_loss(aux_out_real, labels)
# noise z for generator
# 随机初始化假数据和标签
z = tensor2var(torch.randn(real_images.size(0), self.z_dim)) # *, 100
gen_labels = tensor2var(torch.randint(0, self.n_classes, (real_images.size(0),), dtype=torch.long))
# 生成假数据和标签
fake_images = self.G(z, gen_labels) # (*, c, 64, 64)
dis_out_fake, aux_out_fake = self.D(fake_images) # (*,)
# 计算假数据的损失
d_loss_fake = self.adversarial_loss_sigmoid(dis_out_fake, fake) + self.aux_loss(aux_out_fake, gen_labels)
# total d loss
d_loss = d_loss_real + d_loss_fake
d_loss.backward()
# update D
self.d_optimizer.step()
# calculate dis accuracy
d_acc = compute_acc(aux_out_real, aux_out_fake, labels, gen_labels)
# train the generator every 5 steps 每五步训练一次生成器
if i % self.g_num == 0:
# =================== Train G and gumbel =====================
self.G.zero_grad()
# create random noise
fake_images = self.G(z, gen_labels)
# compute loss with fake images
dis_out_fake, aux_out_fake = self.D(fake_images) # batch x n
g_loss_fake = self.adversarial_loss_sigmoid(dis_out_fake, valid) + self.aux_loss(aux_out_fake, gen_labels)
g_loss_fake.backward()
# update G
self.g_optimizer.step()
# 每个epoch训练完成-------------------------------------------------------------------------------------------
# log to the tensorboard
self.logger.add_scalar('d_loss', d_loss.data, epoch)
self.logger.add_scalar('g_loss_fake', g_loss_fake.data, epoch)
# end one epoch
# print out log info
if (epoch) % self.log_step == 0:
elapsed = time.time() - start_time
elapsed = str(datetime.timedelta(seconds=elapsed))
print("Elapsed [{}], G_step [{}/{}], D_step[{}/{}], d_loss: {:.4f}, g_loss: {:.4f}, Acc: {:.4f}"
.format(elapsed, epoch, self.epochs, epoch,
self.epochs, d_loss.item(), g_loss_fake.item(), d_acc))
# sample images
if (epoch) % self.sample_step == 0:
self.G.eval()
# save real image
save_sample(self.sample_path + '/real_images/', real_images, epoch)
with torch.no_grad():
fake_images = self.G(fixed_z, fixed_labels)
# save fake image
save_sample(self.sample_path + '/fake_images/', fake_images, epoch)
# sample sample one images
save_sample_one_image(self.sample_path, real_images, fake_images, epoch)
# 所有epoch训练完成-----------------------------------------------------------------------------------------------
# 建立训练模型
def build_model(self):
self.G = Generator(image_size = self.imsize, z_dim = self.z_dim, conv_dim = self.g_conv_dim, channels = self.channels).cuda()
self.D = Discriminator(image_size = self.imsize, conv_dim = self.d_conv_dim, channels = self.channels).cuda()
# apply the weights_init to randomly initialize all weights
# to mean=0, stdev=0.2
self.G.apply(weights_init)
self.D.apply(weights_init)
# optimizer
self.g_optimizer = torch.optim.Adam(self.G.parameters(), self.g_lr, [self.beta1, self.beta2])
self.d_optimizer = torch.optim.Adam(self.D.parameters(), self.d_lr, [self.beta1, self.beta2])
# for orignal gan loss function
self.adversarial_loss_sigmoid = nn.BCEWithLogitsLoss().cuda()
self.aux_loss = nn.CrossEntropyLoss().cuda()
# print networks
print(self.G)
print(self.D)
# 日志记录
def build_tensorboard(self):
from torch.utils.tensorboard import SummaryWriter
self.logger = SummaryWriter(self.log_path)
def save_image_tensorboard(self, images, text, step):
if step % 100 == 0:
img_grid = torchvision.utils.make_grid(images, nrow=8)
self.logger.add_image(text + str(step), img_grid, step)
self.logger.close()
额外知识
什么是对数似然函数？
概率：在给定参数值的情况下，概率用于描述未来出现某种情况的观测数据的可信度。
似然：在给定观测数据的情况下，似然用于描述参数值的可信度。
极大似然估计：在给定观测数据的情况下，某个参数值有多个取值可能，但是如果存在某个参数值，使其对应的似然值最大，那就说明这个值就是该参数最可信的参数值。
对数似然函数
极大似然估计的求解方法，往往是对参数θ求导，然后找到导函数为0时对应的参数值，根据函数的单调性，找到极大似然估计时对应的参数θ。
但是在实际问题中，对于大批量的样本（大量的观测结果），其概率值是由很多项相乘组成的式子，对于参数θ的求导，是一个很复杂的问题，于是我们一个直观的想法，就是把它转成对数函数，累乘就变成了累加，即似然函数也就变成了对数似然函数。
对数似然函数的的主要作用，就是用来定义某个机器学习模型的损失函数，线性回归或者逻辑回归中都可以用到，然后我们再根据梯度下降/上升法求解损失函数的最优解，取得最优解时对应的参数θ，就是我们机器学习模型想要学习的参数 。
参考：
ACGAN(Auxiliary Classifier GAN)详解与实现（tensorflow2.x实现）-CSDN博客
一天一GAN-day4-ACGAN - 知乎 (zhihu.com)
GAN生成对抗网络-ACGAN原理与基本实现-条件生成对抗网络05 - gemoumou - 博客园 (cnblogs.com)
[生成对抗网络GAN入门指南]（9）ACGAN: Conditional Image Synthesis with Auxiliary Classifier GANs-CSDN博客
【For非数学专业】通俗理解似然函数、概率、极大似然估计和对数似然_对数似然估计-CSDN博客
https://github.com/znxlwm/pytorch-generative-model-collections/tree/master
