gan实战（基础GAN、DCGAN）

原创

已于 2023-05-31 09:22:18 修改 · 1.4k 阅读

26 ·

CC 4.0 BY-SA版权

文章标签：

#生成对抗网络 #深度学习 #python

于 2023-03-23 09:35:24 首次发布

文章介绍了基础Gan和DCGAN的实现过程，包括网络结构、损失函数、训练循环以及实验效果。基础Gan中，定义了生成器和判别器的网络结构，使用BCELoss进行训练。DCGAN则引入了卷积层和批量归一化，训练过程中使用了dropout策略。实验显示，随着训练的进行，模型的损失逐渐降低。

一、基础Gan

1.1 参数

（1）输入：会被放缩到64*64
（2）输出：64*64
（3）数据集：https://pan.baidu.com/s/1RY1e9suUlk5FLYF5z7DfAw 提取码：8n89

1.2 实现

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
import torchvision
from torchvision import transforms
import time
from torch.utils import data
from PIL import Image
import glob

# 生成器生成的数据在 [-1, 1]
transform = transforms.Compose([
#     transforms.Grayscale(num_output_channels=1),
    transforms.Resize(64),
    transforms.ToTensor(),  # 会做0-1归一化，也会channels, height, width
    transforms.Normalize((0.5,), (0.5,))
])

class FaceDataset(data.Dataset):
    def __init__(self, images_path):
        self.images_path = images_path

    def __getitem__(self, index):
        image_path = self.images_path[index]
        pil_img = Image.open(image_path)
        pil_img = transform(pil_img)
        return pil_img

    def __len__(self):
        return len(self.images_path)

images_path = glob.glob('./data/yellow/*.png')
BATCH_SIZE = 16
dataset = FaceDataset(images_path)
dataLoader = data.DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)

# 生成器网络定义
# 输入是长度为100的噪声（正态分布随机数）
# 输出为（1， 28， 28）的图片
class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.main = nn.Sequential(
            nn.Linear(100, 256),
            nn.ReLU(),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Linear(512, 64*64*3),
            nn.Tanh()
        )

    def forward(self, x):
        img = self.main(x)
        img = img.view(-1, 3, 64, 64)
        return img

# 判别器网络定义
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            nn.Linear(64*64*3, 512),
            nn.LeakyReLU(),
            nn.Linear(512, 256),
            nn.LeakyReLU(),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        x = x.view(-1, 64*64*3)
        x = self.main(x)
        return x


device = 'cuda:0' if torch.cuda.is_available() else 'cpu'
print(device)
gen = Generator().to(device)
dis = Discriminator().to(device)
d_optimizer = torch.optim.Adam(dis.parameters(), lr=0.00001)
g_optimizer = torch.optim.Adam