05_SGAN

SGAN

　　SSGAN是半监督学习生成对抗网络 (SGAN（ssgan）Semi-Supervised Learning with Generative Adversarial Networks ),初衷是利用GAN生成器生成的样本来改进和提高图像分类任务的性能。在实际的应用中有大量的数据是不带标签的，带标签的数据只占一小部分；充分的利用不标签的“无监督数据”可以提高分类模型泛化和性能。 事实上，在非常多的场景中，带有标签的数据并不容易获 得。半监督学习可以在只需要一小部分的标记数据取得非常好的分类效果。
　　半监督学习算法代表了监督和非监督算法的中间地带，这些算法操作的数据有一些标签，但大部分是没有标签的。一般的，如果仅选择有监督学习的方式，只对带有标签的数据进行操作，这将极大地减小数据集的规模。SSGAN为我们提供了一个使用没有标签数据增强分类器的思路。
　　SGAN论文地址：https://arxiv.org/pdf/1606.01583.pdf
SGAN的设计

　　SGAN的主要思想在鉴别器的设计.相比普通的GAN的鉴别器输出0和1（真和假）， SGAN通 过使鉴别器网络输出 label + 1 类别，将其转换为半监督上下文 . 我们希望设计的鉴别器既扮演执行图像分类任务的分类器的角色，又能区分由生成器生成的生成样本和真实数据.
　　传统的GAN在判别器网络的输出端会使用二分类模式 ,代表真和假。在SGAN中，就是把这个二分类（sigmoid）转化为多分类 (softmax），类型数量为C+1，指代C个标签的数据和" 一个假数据”，表示为

 

　　 SSGAN在数据集上训练生成模型G和D（对 C +1 类别执行分类）。 在训练时， D预测输入属于C+1类中的哪一类，其中添加了一个额外的类对应生成图片。 该方法可以用于创建数据效率更高的分类器。

SGAN的模型设计

 

 　　对于包含C个类别的数据集：真实的图像将被分类到C个类别中，生成的图像将分入第 C+1 类中。

　　在SGAN中，判别器同时接受两种模式的训练：无监督和监督 。

　　　　在无监督模式中，需要区分真实图像和生成的图像，就像在传统的GAN中一样 。
　　　　在监督模式中，需要将一幅图像分类为几个类，就像在标准的神经网络分类器中一样。

　　在半监督GAN中，对判别器模型进行更新，预测K+1个类，其中K为预测问题中的类数，并为一个新的“假”类添加额 外的类标签。它涉及到同时训练无监督分类任务和有监督分类任务的判别器模型。 SGAN巧妙地结合了无监督和监督学习的方面，以最小的标签量，产生难以置信的结果。

 

 

SGAN的代码实现（pytorch版本）

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils import data
import torchvision
from torchvision import transforms

import numpy as np
import matplotlib.pyplot as plt
import os
import glob
from PIL import Image

import time

transform = transforms.Compose([
    transforms.ToTensor(),                        # 取值范围会被归一化到(0, 1)之间
    transforms.Normalize(mean=0.5, std=0.5)       # 设置均值和方差均为0.5
])

# 加载MNIST手写体数据集合

dataset = torchvision.datasets.MNIST('data',
                                     train=True,
                                     transform=transform,
                                     download=True
)

train_label_size = 1000
train_unlabel_size = len(dataset) - train_label_size
label_ds, unlabel_ds = torch.utils.data.random_split(
                                       dataset, 
                                       [train_label_size, train_unlabel_size]
)

len(label_ds), len(unlabel_ds)

label_dl = data.DataLoader(label_ds, batch_size=256, shuffle=True)
unlabel_dl = data.DataLoader(unlabel_ds, batch_size=256, shuffle=True)

test_ds = torchvision.datasets.MNIST('data',
                                     train=False,
                                     transform=transform,
                                     download=True
)

device = "cuda" if torch.cuda.is_available() else "cpu"

test_dl = data.DataLoader(test_ds, batch_size=256)

def test(dataloader, model, loss_fn):
    model.eval()
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    test_loss, correct = 0, 0
    with torch.no_grad():
        for X, y in dataloader:
            X, y = X.to(device), y.to(device)
            pred, _ = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= num_batches
    correct /= size
    return test_loss, correct


#定义生成器
class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.linear1 = nn.Linear(100, 256*7*7)
        self.bn1 = nn.BatchNorm1d(256*7*7)
        self.deconv1 = nn.ConvTranspose2d(256, 128,
                                          kernel_size=(3, 3),
                                          stride=1,
                                          padding=1)     # (128, 7, 7)
        self.bn2 = nn.BatchNorm2d(128)
        
        self.deconv2 = nn.ConvTranspose2d(128, 64,
                                          kernel_size=(4, 4),
                                          stride=2,
                                          padding=1)     # (64, 14, 14)
        self.bn3 = nn.BatchNorm2d(64)
        
        self.deconv3 = nn.ConvTranspose2d(64, 1,
                                          kernel_size=(4, 4),
                                          stride=2,
                                          padding=1)     # (1, 28, 28)
    
    def forward(self, x):
        x = F.relu(self.linear1(x))
        x = self.bn1(x)
        x = x.view(-1, 256, 7, 7)
        x = F.relu(self.deconv1(x))
        x = self.bn2(x)
        x = F.relu(self.deconv2(x))
        x = self.bn3(x)
        x = torch.tanh(self.deconv3(x))
        return x
    
# 定义判别器
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.conv1 = nn.Conv2d(1, 64, kernel_size=3, stride=2)
        self.conv2 = nn.Conv2d(64, 128, kernel_size=3, stride=2)
        self.bn = nn.BatchNorm2d(128)
        self.fc1 = nn.Linear(128*6*6, 10)
        self.fc2 = nn.Linear(128*6*6, 1)
        
    def forward(self, x):
        x = F.dropout2d(F.leaky_relu(self.conv1(x)))
        x = F.dropout2d(F.leaky_relu(self.conv2(x)))    # (batch, 128, 6, 6）
        x = self.bn(x)
        x = x.view(-1, 128*6*6)  # (batch, 128, 6, 6）-->  (batch, 128*6*6)
        x1 = self.fc1(x)  
        x2 = self.fc2(x)
        return x1, x2

gen = Generator().to(device)
dis = Discriminator().to(device)
loss_softmax_fn = nn.CrossEntropyLoss()                 # 定义损失函数 = -log(softmax(xi))  多分类计算损失
loss_sigmoid_fn = torch.nn.BCEWithLogitsLoss()          # 二分类损失函数
d_optimizer = torch.optim.Adam(dis.parameters(), lr=0.00002)
g_optimizer = torch.optim.Adam(gen.parameters(), lr=0.0001)

# 定义可视化函数
def generate_and_save_images(model, epoch, test_input):
    # np.squeeze去掉长度为1的维度
    predictions = np.squeeze(model(test_input).detach().cpu().numpy())
    fig = plt.figure(figsize=(2, 4))                             # 可视化16张图片
    for i in range(predictions.shape[0]):
        plt.subplot(2, 4, i+1)
        plt.imshow((predictions[i] + 1)/2)          # 注意取值范围的转换
        plt.axis('off')
    plt.savefig('./SGAN_mnist/image_at_epoch_{:04d}.png'.format(epoch))
    plt.show()
    plt.close()
    
    
# 设置生成绘图图片的随机张量，这里可视化16张图片
# 生成16个长度为100的随机正态分布张量
test_seed = torch.randn(8, 100, device=device)

D_loss = []                          # 记录训练过程中判别器loss变化
G_loss = []                          # 记录训练过程中生成器loss变化
epochs = []

#开始训练
for epoch in range(1000):
    
    epoch_start = time.time()
    
    D_epoch_loss=0
    G_epoch_loss=0
    count = len(unlabel_dl)
    for unlb_img, _ in unlabel_dl:
        # count = len(unlabel_dl)
        unlb_img = unlb_img.to(device)                  
        size = unlb_img.shape[0]
        random_seed = torch.randn(size, 100, device=device)   # 生成随机输入
        
        lb_img, label = next(iter(label_dl))
        lb_img = lb_img.to(device)
        label = label.to(device)
        
        d_optimizer.zero_grad()
        _, real_sg_out = dis(unlb_img)              # 判别器输入真实图片
        d_real_sg_loss = loss_sigmoid_fn(real_sg_out, 
                                         torch.ones_like(real_sg_out, 
                                         device=device))
        d_real_sg_loss.backward()
        # 生成器输入随机张量得到生成图片
        generated_img = gen(random_seed) 
        # 判别器输入生成图像，注意此处的detach方法
        _, fake_sg_output = dis(generated_img.detach()) 
        d_fake_sg_loss = loss_sigmoid_fn(fake_sg_output, 
                                         torch.zeros_like(fake_sg_output, 
                                         device=device))
        d_fake_sg_loss.backward()
        
        real_sfm_out, _ = dis(lb_img)              # 判别器输入真实图片
        d_real_sfm_loss = loss_softmax_fn(real_sfm_out, label)
        d_real_sfm_loss.backward()
        
        # _, d_real_lb_sg_loss = dis(lb_img)              # 判别器输入真实图片 
        # d_real_lb_sg_loss = loss_sigmoid_fn(read_label_sg_out, 
        #                                     torch.ones_like(read_label_sg_out, 
        #                                     device=device))
        # d_real_lb_sg_loss.backward()
        
        
        disc_loss = d_real_sg_loss + d_fake_sg_loss + d_real_sfm_loss      # 判别器的总损失
        
        d_optimizer.step()
        
        
        g_optimizer.zero_grad()
        
        _, fake_output = dis(generated_img)           # 判别器输入生成图像
        gen_loss = loss_sigmoid_fn(fake_output, 
                                   torch.ones_like(fake_output, 
                                   device=device))
        gen_loss.backward()
        
        g_optimizer.step()
        
        with torch.no_grad():
            D_epoch_loss += disc_loss.item()
            G_epoch_loss += gen_loss.item()
    
    epoch_finish = time.time()
            
    with torch.no_grad():        
        D_epoch_loss /= count
        G_epoch_loss /= count
        D_loss.append(D_epoch_loss)
        G_loss.append(G_epoch_loss)
        epochs.append(epoch)
        
        # 训练完一个Epoch，打印提示并绘制生成的图片
        if epoch%10 == 0:
            test_loss, test_acc = test(test_dl, dis, loss_softmax_fn)
            print("Epoch:", epoch, 
                  'test_loss:{:.2f}'.format(test_loss),
                  'test_accs:{:.2f}'.format(test_acc),
                  'time:{:.2f}s'.format(epoch_finish-epoch_start))
            generate_and_save_images(gen, epoch, test_seed)
            
# 绘制loss函数
def D_G_loss_plot(D_loss, G_loss, epotchs):
    
    fig = plt.figure(figsize=(4, 4))
    
    plt.plot(epotchs, D_loss, label='D_loss')
    plt.plot(epotchs, G_loss, label='G_loss')
    plt.legend()
    
    plt.title("D_G_Loss")
    plt.savefig('./SGAN_mnist/loss_at_epoch_{:04d}.png'.format(epotchs[len(epotchs)-1]))    
    plt.close()

D_G_loss_plot(D_loss, G_loss, epochs)

 

SGAN的效果图及Loss