基于Pytorch实现DCGAN 代码详解

DCGAN是在GAN上进行的扩展,唯一的区别就是生成器和判别器分别使用转置卷积层和卷积层。在论文Unsupervised Representation Learning With Deep Convolutional Generative Adversarial Networks中提出。

from __future__ import print_function
#%matplotlib inline
import argparse
import os
import random
import torch
import torch.nn as nn
import torch.nn.parallel
import torch.backends.cudnn as cudnn
import torch.optim as optim
import torch.utils.data
import torchvision.datasets as dset
import torchvision.transforms as transforms
import torchvision.utils as vutils
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from IPython.display import HTML

# Set random seed for reproducibility
manualSeed = 999
#manualSeed = random.randint(1, 10000) # use if you want new results
print("Random Seed: ", manualSeed)
random.seed(manualSeed)
torch.manual_seed(manualSeed)
m = nn.ConvTranspose2d(100, 1024, (4,4), stride=(1,1),bias=False)
input = torch.autograd.Variable(torch.randn(20, 100, 1, 1))
output = m(input)
print(output.size())
print(output[0][0])
# Root directory for dataset
dataroot = "/home/kesci/input/dongman9005"

# Number of workers for dataloader
workers = 2

# Batch size during training
batch_size = 128

# Spatial size of training images. All images will be resized to this
#   size using a transformer.
image_size = 64

# Number of channels in the training images. For color images this is 3
nc = 3

# Size of z latent vector (i.e. size of generator input)
nz = 100

# Size of feature maps in generator
ngf = 128

# Size of feature maps in discriminator
ndf = 128

# Number of training epochs
num_epochs = 1

# Learning rate for optimizers
lr = 0.0002

# Beta1 hyperparam for Adam optimizers
beta1 = 0.5

# Number of GPUs available. Use 0 for CPU mode.
ngpu = 0
# We can use an image folder dataset the way we have it setup.
# Create the dataset
dataset = dset.ImageFolder(root=dataroot,
                           transform=transforms.Compose([
                               transforms.Resize(image_size),
                               transforms.CenterCrop(image_size),
                               transforms.ToTensor(),
                               transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
                           ]))
                       
# creat the dataloader
dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,
	shuffle=True, num_workers=workers)

# device which device we want to run on
divice = torch.device("cuda:0" if (torch.cuda.is_available() and ngpu > 0) else "cpu")

# Plot some training images
real_batch = next(iter(dataloader))
plt.figure(figsize=(8,8))
plt.axis("off")
plt.title("Training Images")
#print("real_batch:",type(real_batch),len(real_batch),type(real_batch[0]),real_batch[0].size())
#print(type(real_batch[0][0:64]),real_batch[0][0:64].size())
#print(type(vutils.make_grid(real_batch[0][:64],padding=2, normalize=True)),vutils.make_grid(real_batch[0][:64],padding=2, normalize=True).size())
#print(type(np.transpose(vutils.make_grid(real_batch[0][:64],padding=2, normalize=True).cpu(),(1,2,0))),np.transpose(vutils.make_grid(real_batch[0][:64],padding=2, normalize=True).cpu(),(1,2,0)).size())
plt.imshow(np.transpose(vutils.make_grid(real_batch[0][:64],
			 padding=2, normalize=True).cpu(),(1,2,0)))

def weights_init(m):
    classname = m.__class__.__name__
    if classname.find('Conv') != -1:
        nn.init.normal_(m.weight.data, 0.0, 0.02)
    elif classname.find('BatchNorm') != -1:
        nn.init.normal_(m.weight.data, 1.0, 0.02)
        nn.init.constant_(m.bias.data, 0)
# Generator Code

class Generator(nn.Module):
    def __init__(self, ngpu):
        super(Generator, self).__init__()
        self.ngpu = ngpu
        self.main = nn.Sequential(
            # input is Z, going into a convolution
            nn.ConvTranspose2d( nz, ngf * 8, 4, 1, 0, bias=False),
            nn.BatchNorm2d(ngf * 8),
            nn.ReLU(True),
            # state size. (ngf*8) x 4 x 4
            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.ReLU(True),
            # state size. (ngf*4) x 8 x 8
            nn.ConvTranspose2d( ngf * 4, ngf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.ReLU(True),
            # state size. (ngf*2) x 16 x 16
            nn.ConvTranspose2d( ngf * 2, ngf, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(True),
            # state size. (ngf) x 32 x 32
            nn.ConvTranspose2d( ngf, nc, 4, 2, 1, bias=False),
            nn.Tanh()
            # state size. (nc) x 64 x 64
        )

    def forward(self, input):
        return self.main(input)
# Create the generator
netG = Generator(ngpu)

# Handle multi-gpu if desired
if (ngpu > 1):
    netG = nn.DataParallel(netG, list(range(ngpu)))

# Apply the weights_init function to randomly initialize all weights
#  to mean=0, stdev=0.2.
netG.apply(weights_init)

# Print the model
print(netG)
class Discriminator(nn.Module):
    def __init__(self, ngpu):
        super(Discriminator, self).__init__()
        self.ngpu = ngpu
        self.main = nn.Sequential(
            # input is (nc) x 64 x 64
            nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf) x 32 x 32
            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 2),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf*2) x 16 x 16
            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 4),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf*4) x 8 x 8
            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 8),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf*8) x 4 x 4
            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
            nn.Sigmoid()
        )

    def forward(self, input):
        return self.main(input)
实例化判别器并输出网络结构
# Create the Discriminator
netD = Discriminator(ngpu)

# Handle multi-gpu if desired
if (ngpu > 1):
    netD = nn.DataParallel(netD, list(range(ngpu)))

# Apply the weights_init function to randomly initialize all weights
#  to mean=0, stdev=0.2.
netD.apply(weights_init)

# Print the model

# print(netG)
print(netD)
Discriminator(
  (main): Sequential(
    (0): Conv2d(3, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
    (1): LeakyReLU(negative_slope=0.2, inplace)
    (2): Conv2d(128, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
    (3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (4): LeakyReLU(negative_slope=0.2, inplace)
    (5): Conv2d(256, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
    (6): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (7): LeakyReLU(negative_slope=0.2, inplace)
    (8): Conv2d(512, 1024, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)
    (9): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (10): LeakyReLU(negative_slope=0.2, inplace)
    (11): Conv2d(1024, 1, kernel_size=(4, 4), stride=(1, 1), bias=False)
    (12): Sigmoid()
  )
)
损失函数及优化器
# Initialize BCELoss function
criterion = nn.BCELoss()

# Create batch of latent vectors that we will use to visualize
#  the progression of the generator
fixed_noise = torch.randn(128, nz, 1, 1)
#print(type(fixed_noise),fixed_noise.size())
#print(fixed_noise[0].size(),"\n",fixed_noise[0])
#print(torch.randn(100))
# fixed_z_ = torch.randn((5 * 5, 100)).view(-1, 100, 1, 1)    # fixed noise
# print(type(fixed_z_),"\n",fixed_z_.size())

# Establish convention for real and fake labels during training
real_label = 1
fake_label = 0

# Setup Adam optimizers for both G and D
optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))
训练
第一部分—更新判别器
第二部分—更新生成器
# Training Loop

# Lists to keep track of progress
img_list = []
G_losses = []
D_losses = []
iters = 0

print("Starting Training Loop...")
# For each epoch
for epoch in range(num_epochs):
    # For each batch in the dataloader
    for i, data in enumerate(dataloader, 0):

        ############################
        # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))
        ###########################
        ## Train with all-real batch
        netD.zero_grad()
        # Format batch
        real_cpu = data[0]
        # print(type(data[0]),data[0].size(0),"\n",type(data[1]),data[1].size(),data[1])
        b_size = real_cpu.size(0)
        label = torch.full((b_size,), real_label)
        # print(type(label),label.size(),label)
        # Forward pass real batch through D
        # print(type(real_cpu),real_cpu.size())
        output = netD(real_cpu).view(-1)
        # print(output)
        # Calculate loss on all-real batch
        errD_real = criterion(output, label)
        # print(errD_real)
        # Calculate gradients for D in backward pass
        errD_real.backward()
        D_x = output.mean().item()
        # print(type(output),type(output.mean()),output.mean())

        ## Train with all-fake batch
        # Generate batch of latent vectors
        noise = torch.randn(b_size, nz, 1, 1)
        # Generate fake image batch with G
        fake = netG(noise)
        # print(type(fake),fake.size())
        label.fill_(fake_label)
        # print(type(label),label)
        # Classify all fake batch with D
        # print(type(fake.detach),fake.detach().size())
        output = netD(fake.detach()).view(-1)
        # print(output)
        # Calculate D's loss on the all-fake batch
        errD_fake = criterion(output, label)
        # Calculate the gradients for this batch
        errD_fake.backward()
        # print(errD_fake)
        D_G_z1 = output.mean().item()
        # Add the gradients from the all-real and all-fake batches
        errD = errD_real + errD_fake
        # Update D
        optimizerD.step()

        ############################
        # (2) Update G network: maximize log(D(G(z)))
        ###########################
        netG.zero_grad()
        label.fill_(real_label)  # fake labels are real for generator cost
        # Since we just updated D, perform another forward pass of all-fake batch through D
        output = netD(fake).view(-1)
        # Calculate G's loss based on this output
        errG = criterion(output, label)
        # Calculate gradients for G
        errG.backward()
        D_G_z2 = output.mean().item()
        # Update G
        optimizerG.step()

        # Output training stats
        if i % 50 == 0:
            print('[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f'
                  % (epoch, num_epochs, i, len(dataloader),
                     errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))

        # Save Losses for plotting later
        G_losses.append(errG.item())
        D_losses.append(errD.item())

        # Check how the generator is doing by saving G's output on fixed_noise
        if (iters % 500 == 0) or ((epoch == num_epochs-1) and (i == len(dataloader)-1)):
            with torch.no_grad():
                fake = netG(fixed_noise).detach().cpu()
            img_list.append(vutils.make_grid(fake, padding=2, normalize=True))

        iters += 1
        break
# Training Loop

# Lists to keep track of progress
img_list = []
G_losses = []
D_losses = []
iters = 0

print("loading model...")
netG = Generator(ngpu)
netD = Discriminator(ngpu)

optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))

checkpoint = torch.load("/home/kesci/input/animation_203680/model_animation-20.pth",map_location = 'cpu')
start_epoch = checkpoint['epoch'] + 1
netG.load_state_dict(checkpoint['net_G'])
netD.load_state_dict(checkpoint['net_D'])
optimizerG.load_state_dict(checkpoint['optimizer_G'])
optimizerD.load_state_dict(checkpoint['optimizer_D'])
print("loaded!")


# For each batch in the dataloader
for i, data in enumerate(dataloader, 0):
    noise = torch.randn(64, nz, 1, 1)
    with torch.no_grad():
        fake = netG(noise).detach().cpu()
    img_list.append(vutils.make_grid(fake, padding=2, normalize=True))
    
    iters += 1
    if(iters == 8):
        break
plt.figure(figsize=(10,5))
plt.title("Generator and Discriminator Loss During Training")
plt.plot(G_losses,label="G")
plt.plot(D_losses,label="D")
plt.xlabel("iterations")
plt.ylabel("Loss")
plt.legend()
plt.show()
#%%capture
fig = plt.figure(figsize=(8,8))
plt.axis("off")
ims = [[plt.imshow(np.transpose(i,(1,2,0)), animated=True)] for i in img_list]
ani = animation.ArtistAnimation(fig, ims, interval=1000, repeat_delay=1000, blit=True)

HTML(ani.to_jshtml())
生成器输出 前面我们保存了生成器的输出,现在我们用动画的形式来观察结果,按下播放键开始动画。

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 要使用PyTorch实现DCGAN来训练自己的数据集,你需要按照以下步骤操作: 1. 数据准备:将自己的数据集准备成PyTorch可以读取的格式。确保数据集包含一系列图像,并将它们保存在一个文件夹中。 2. 数据预处理:对数据集进行预处理,例如缩放和裁剪图像大小、归一化像素值等。这些预处理步骤有助于提高模型的训练效果。 3. 定义模型:DCGAN由两个神经网络组成,一个生成器和一个判别器。生成器接收一个噪声向量作为输入,并生成与数据集中图像相似的图像。判别器用于判断输入的图像是真实的还是由生成器生成的假图像。在PyTorch中,你需要定义这两个网络的结构和参数。 4. 定义损失函数和优化器:在DCGAN中,通常使用二进制交叉熵作为损失函数,并使用Adam优化算法来更新网络参数。 5. 训练模型:将准备好的数据集传入生成器和判别器中,通过反向传播来更新网络参数。在训练过程中,生成器和判别器交替训练,以提高生成器生成真实图像的能力,并使判别器更好地区分真实图像和生成图像。 6. 评估模型:使用测试集对训练好的模型进行评估,检查生成器生成的图像质量,并计算模型的性能指标,如生成图像与真实图像之间的相似度分数。 7. 保存模型:在训练完成后,将模型参数保存起来以备后续使用。 这些是使用PyTorch实现DCGAN训练自己的数据集的主要步骤。根据你的数据集和应用场景,你可能需要进行一些适当的调整和改进来获得更好的性能和结果。 ### 回答2: PyTorch是一个开源机器学习框架,可用于实现深度卷积生成对抗网络(DCGAN)来训练自己的数据集。下面是一个简单的步骤,用于实现这个过程: 1. 数据集准备:首先,需要准备自己的数据集。确保数据集包含大量的样本,并将其组织成文件夹的形式,每个文件夹代表一个类别。可以使用torchvision库来加载并预处理数据集。 2. 编写生成器模型:生成器是DCGAN的一部分,它将随机噪声向量转换为生成的图像。使用PyTorch定义一个生成器模型,通常包含几个卷积和反卷积层。 3. 编写判别器模型:判别器是DCGAN的另一部分,它将输入图像识别为真实的图像或生成的图像。使用PyTorch定义一个判别器模型,通常包含几个卷积层和全连接层。 4. 定义损失函数和优化器:DCGAN使用对抗性损失函数,通过最小化生成器和判别器之间的差异来训练模型。在PyTorch中,可以使用二分类交叉熵损失函数和Adam优化器。 5. 训练模型:将数据加载到网络中,将真实的图像标记为“1”,将生成的图像标记为“0”,然后使用与真实图像和生成图像对应的标签训练生成器和判别器。反复迭代此过程,直到生成的图像质量达到预期。 6. 保存模型和结果:在训练完成后,保存生成器模型和生成的图像结果,以备将来使用。 通过按照上述步骤实现,就可以使用PyTorch训练自己的数据集,并生成高质量的图像。可以根据需要进行调整和优化,以获得最佳结果。 ### 回答3: PyTorch是一个深度学习框架,可以用来实现DCGAN(深度卷积生成对抗网络)从而训练自己的数据集。 DCGAN是一种生成对抗网络结构,由生成器和判别器组成。生成器负责生成与训练数据类似的新样本,判别器则负责将生成样本和真实样本进行区分。通过训练生成器和判别器,DCGAN可以生成高质量的图像。 首先,需要准备自己的数据集。可以是任何类型的图像数据集,如猫狗、汽车等。将数据集文件夹中的图像按照一定的规则进行预处理,例如缩放到固定的大小,并将其保存在一个新文件夹中。 接下来,需要定义生成器和判别器的网络结构。生成器通常由一系列转置卷积层组成,而判别器则由普通卷积层组成。在PyTorch中,可以通过定义继承自nn.Module的Python类来定义网络结构。可以选择合适的激活函数、损失函数和优化器等。 然后,创建一个数据加载器,将预处理后的数据集加载到模型中进行训练。在PyTorch中,可以使用torchvision库中的DataLoader和Dataset类来实现数据加载。 接下来,设置超参数,例如学习率、批量大小、迭代次数等。然后,初始化生成器和判别器的模型实例,并将其移动到GPU(如果有)或CPU上。 在训练过程中,首先通过生成器生成一些假样本,并与真实样本一起传入判别器进行区分。然后,根据判别器的输出和真实标签计算损失,更新判别器的权重。接下来,再次生成一些假样本,并将其与真实标本标签交换,再次计算损失并更新生成器的权重。重复该过程多次,直到达到预定的迭代次数。 最后,保存训练好的生成器模型,并使用其来生成新的样本。可以通过生成器的前向传播方法,输入一个随机噪声向量,并将其转换为图像。 通过以上步骤,可以使用PyTorch实现DCGAN训练自己的数据集。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值