深度学习之生成对抗式神经网络实战

GAN的目的：产生与真实数据非常相近的假数据

产生器：用于产生假数据

判别器：用于判别真假数据

训练思路：不断使产生器产生假数据，但假数据的标签为真实数据的标签以达到以假乱真的目的，

向判别器不断输入真实数据，标签为真，也不断输入假数据，标签为假，已达到真是真，假是假

的目的

不多说了，贴上代码了，先仔细看看代码然后体会上面的话，有不懂的可以评论

import numpy as np
import torch as t
from torch import nn
from torch.utils.data import Dataset,DataLoader
from torch.autograd import Variable
from torchvision import transforms
import ipdb
import tqdm
import fire
import os
import visdom
from PIL import Image
from torchnet.meter import AverageValueMeter

#first step: build your own dataset class and Config class
class Config(object):
        path = '/home/szh/DCGAN/data/faces'
        imgsize = 96
        batch_size = 2048
        max_epoch = 200
        drop_last=True
        num_workers = 4
        generator_model_path = '/home/szh/checkpoints/mygenerator_epoch180.pth'
        discriminator_model_path = '/home/szh/checkpoints/mydiscriminator_epoch180.pth'

opt = Config()

class MyDataset(Dataset):
        def __init__(self,root):
                self.imgs = [os.path.join(root,img) for img in os.listdir(root)]
        def __getitem__(self,index):
                self.transforms = transforms.Compose([
                        transforms.Resize(opt.imgsize),
                        transforms.CenterCrop(opt.imgsize),
                        transforms.ToTensor(),
                        transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))]
                        )
                img = Image.open(self.imgs[index])
                return self.transforms(img)
        def __len__(self):
                return len(self.imgs)




#define your generator class
class Generator(nn.Module):
        def __init__(self):
                super(Generator,self).__init__()
                #Hout = (Hin-1)*stride-2*padding+kernel_size
                self.net = nn.Sequential(
                        nn.ConvTranspose2d(100,64*8,4,1,0,bias=False),
                        nn.BatchNorm2d(64*8),
                        nn.ReLU(inplace=True),

                        nn.ConvTranspose2d(64*8,64*4,4,2,1,bias=False),
                        nn.BatchNorm2d(64*4),
                        nn.ReLU(inplace=True),

                        nn.ConvTranspose2d(64*4,64*2,4,2,1,bias=False),
                        nn.BatchNorm2d(64*2),
                        nn.ReLU(inplace=True),

                        nn.ConvTranspose2d(64*2,64,4,2,1,bias=False),
                        nn.BatchNorm2d(64),
                        nn.ReLU(inplace=True),

                        nn.ConvTranspose2d(64,3,5,3,1,bias=False),
                        nn.Tanh()
                        )

        def forward(self,x):
                return self.net(x)

mygenerator = nn.DataParallel(Generator().cuda(),device_ids=[0,1,2,3])

#define your discriminator class
class Discriminator(nn.Module):
        def __init__(self):
                super(Discriminator,self).__init__()
                #Hin = (Hout-1)*stride-2*padding+kernel_size
                self.net = nn.Sequential(
                        nn.Conv2d(3,64,5,3,1,bias=False),
                        nn.BatchNorm2d(64),
                        nn.ReLU(inplace=True),

                        nn.Conv2d(64,64*2,4,2,1,bias=False),
                        nn.BatchNorm2d(64*2),
                        nn.ReLU(inplace=True),

                        nn.Conv2d(64*2,64*4,4,2,1,bias=False),
                        nn.BatchNorm2d(64*4),
                        nn.ReLU(inplace=True),

                        nn.Conv2d(64*4,64*8,4,2,1,bias=False),
                        nn.BatchNorm2d(64*8),
                        nn.ReLU(inplace=True),

                        nn.Conv2d(64*8,1,4,1,0,bias=False),
                        nn.Sigmoid())

        def forward(self,x):
                return self.net(x).view(-1)

mydiscriminator = nn.DataParallel(Discriminator().cuda(),device_ids=[0,1,2,3])

#train
def train(**kwargs):
        #parse your hyperparameters
        for k_,v_ in kwargs.items():
                setattr(opt,k_,v_)
        #load your data
        mydataset = MyDataset(opt.path)
        mydataloader = DataLoader(mydataset,batch_size=opt.batch_size,shuffle=True,num_workers=opt.num_workers,drop_last=True)
        #initialization of visualization
        vis = visdom.Visdom(env='szh')
        loss_gmeter = AverageValueMeter()
        loss_dmeter = AverageValueMeter()
        x_value = 0
        #true label、false label and noises
        true_labels = Variable(t.ones(opt.batch_size))
        false_labels = Variable(t.zeros(opt.batch_size))
        noises = Variable(t.randn(opt.batch_size,100,1,1))
        #define your optimizer and loss function
        generator_optimizer = t.optim.Adam(mygenerator.parameters(),lr=2e-4,betas=(0.5,0.999))
        discriminator_optimizer = t.optim.Adam(mydiscriminator.parameters(),lr=2e-4,betas=(0.5,0.999))
        criterion = nn.BCELoss()
        #use gpu
        if t.cuda.is_available:
                mygenerator.cuda()
                mydiscriminator.cuda()
                criterion.cuda()
                true_labels,false_labels = true_labels.cuda(),false_labels.cuda()
                noises = noises.cuda()
        #start training
        for i,epoch in enumerate(tqdm.tqdm(range(opt.max_epoch))):
                for ii,x in enumerate(tqdm.tqdm(mydataloader)):
                        #train discriminator every time
                        discriminator_optimizer.zero_grad()
                        output = mydiscriminator(Variable(x))
                        loss_real = criterion(output,true_labels)
                        loss_real.backward()
                        gen_img = mygenerator(Variable(t.randn(opt.batch_size,100,1,1).cuda()))
                        output = mydiscriminator(gen_img)
                        loss_false = criterion(output,false_labels)
                        loss_false.backward()
                        discriminator_optimizer.step()
                        loss = loss_real + loss_false
                        loss_dmeter.add(loss.data[0])

                        #train generator every five times
                        if ii%5==0:
                                generator_optimizer.zero_grad()
                                gen_img = mygenerator(Variable(t.randn(opt.batch_size,100,1,1).cuda()))
                                output = mydiscriminator(gen_img)
                                loss_ = criterion(output,true_labels)
                                loss_.backward()
                                generator_optimizer.step()
                                loss_gmeter.add(loss_.data[0])
                        if ii%20==0:
                                vis.line(Y=np.array([loss_gmeter.value()[0]]), X=np.array([x_value]),
                                    win=('g_loss'),
                                    opts=dict(title='g_loss'),
                                    update=None if x_value == 0 else 'append'
                                    )
                                vis.line(Y=np.array([loss_dmeter.value()[0]]), X=np.array([x_value]),
                                    win=('d_loss'),
                                    opts=dict(title='d_loss'),
                                    update=None if x_value == 0 else 'append'
                                    )
                                x_value += 1
                #visualize results every 20 epochs and save model
                if i%20 == 0:
                        vis.images(gen_img.data.cpu().numpy()[:64]*0.5+0.5,win='fake')
                        vis.images(x.cpu().numpy()[:64]*0.5+0.5,win='real')
                        t.save(mygenerator.state_dict(),'checkpoints/mygenerator_epoch%s.pth'%epoch)
                        t.save(mydiscriminator.state_dict(),'checkpoints/mydiscriminator_epoch%s.pth'%epoch)

def generate():
        vis = visdom.Visdom(env='szh')
        map_location = lambda storage,loc:storage
        #if you want to load the model then plus the sentence 'nn.DataParallel' otherwise an exception is thrown
        testgenerator = nn.DataParallel(Generator().eval().cuda(),device_ids=[0,1,2,3])
        testdiscriminator = nn.DataParallel(Discriminator().eval().cuda(),device_ids=[0,1,2,3])
        #load model state
        testgenerator.load_state_dict(t.load(opt.generator_model_path,map_location=map_location))
        testdiscriminator.load_state_dict(t.load(opt.discriminator_model_path,map_location=map_location))
        #test 100 noises
        noises = Variable(t.randn(100,100,1,1)).cuda()
        gen_img = testgenerator(noises)
        output = testdiscriminator(gen_img)
        #get top10 indexs
        indexs = output.data.topk(10)[1]
        results = []
        for index in indexs:
                results.append(gen_img.data[index])
        vis.images(t.stack(results).cpu().numpy()*0.5+0.5,win='fake')


if __name__ == '__main__':
        fire.Fire()


#how to run
'''
execute in current window:
python -m visdom.server
execute in another window if you want to train:
python mygan.py train --path=[your images path] --batch-size=[your bacth_size]
execute in another window if you want to test:
python mygan.py generate
'''