GAN的matlab代码

由于GAN是一种深度学习算法，其实现需要大量计算资源和数据集，因此建议使用基于Python的深度学习框架（如TensorFlow、PyTorch）实现GAN。以下是一个基于PyTorch实现GAN的示例代码：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader


# Discriminator Network
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.conv1 = nn.Conv2d(1, 64, 4, 2, 1)
        self.conv2 = nn.Conv2d(64, 128, 4, 2, 1)
        self.bn2 = nn.BatchNorm2d(128)
        self.conv3 = nn.Conv2d(128, 256, 4, 2, 1)
        self.bn3 = nn.BatchNorm2d(256)
        self.conv4 = nn.Conv2d(256, 512, 4, 2, 1)
        self.bn4 = nn.BatchNorm2d(512)
        self.conv5 = nn.Conv2d(512, 1, 4, 1, 0)

    def forward(self, x):
        x = torch.nn.functional.leaky_relu(self.conv1(x), 0.2, inplace=True)
        x = torch.nn.functional.leaky_relu(self.bn2(self.conv2(x)), 0.2, inplace=True)
        x = torch.nn.functional.leaky_relu(self.bn3(self.conv3(x)), 0.2, inplace=True)
        x = torch.nn.functional.leaky_relu(self.bn4(self.conv4(x)), 0.2, inplace=True)
        x = torch.sigmoid(self.conv5(x))
        return x


# Generator Network
class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.conv1 = nn.ConvTranspose2d(100, 512, 4, 1, 0)
        self.bn1 = nn.BatchNorm2d(512)
        self.conv2 = nn.ConvTranspose2d(512, 256, 4, 2, 1)
        self.bn2 = nn.BatchNorm2d(256)
        self.conv3 = nn.ConvTranspose2d(256, 128, 4, 2, 1)
        self.bn3 = nn.BatchNorm2d(128)
        self.conv4 = nn.ConvTranspose2d(128, 64, 4, 2, 1)
        self.bn4 = nn.BatchNorm2d(64)
        self.conv5 = nn.ConvTranspose2d(64, 1, 4, 2, 1)

    def forward(self, x):
        x = torch.nn.functional.relu(self.bn1(self.conv1(x)))
        x = torch.nn.functional.relu(self.bn2(self.conv2(x)))
        x = torch.nn.functional.relu(self.bn3(self.conv3(x)))
        x = torch.nn.functional.relu(self.bn4(self.conv4(x)))
        x = torch.tanh(self.conv5(x))
        return x


# Training
def train(discriminator, generator, dataloader, device, epochs=25, lr=0.0002, d_steps=1, g_steps=1):
    criterion = nn.BCELoss()
    d_optimizer = optim.Adam(discriminator.parameters(), lr=lr)
    g_optimizer = optim.Adam(generator.parameters(), lr=lr)
    fixed_noise = torch.randn(64, 100, 1, 1, device=device)
    for epoch in range(epochs):
        for i, (real_images, _) in enumerate(dataloader):
            real_images = real_images.to(device)
            batch_size = real_images.size(0)
            for j in range(d_steps):
                # Train Discriminator
                d_optimizer.zero_grad()
                # Real images
                real_labels = torch.full((batch_size,), 1, device=device)
                d_real_output = discriminator(real_images).view(-1)
                d_real_loss = criterion(d_real_output, real_labels)
                # Fake images
                noise = torch.randn(batch_size, 100, 1, 1, device=device)
                fake_images = generator(noise)
                fake_labels = torch.full((batch_size,), 0, device=device)
                d_fake_output = discriminator(fake_images.detach()).view(-1)
                d_fake_loss = criterion(d_fake_output, fake_labels)
                # Compute total loss and update parameters
                d_loss = d_real_loss + d_fake_loss
                d_loss.backward()
                d_optimizer.step()
            for j in range(g_steps):
                # Train Generator
                g_optimizer.zero_grad()
                noise = torch.randn(batch_size, 100, 1, 1, device=device)
                fake_labels = torch.full((batch_size,), 1, device=device)
                g_output = generator(noise)
                d_output = discriminator(g_output).view(-1)
                g_loss = criterion(d_output, fake_labels)
                g_loss.backward()
                g_optimizer.step()
            if i % 100 == 0:
                print(f"Epoch {epoch}, Batch {i}: D Loss = {d_loss.item()}, G Loss = {g_loss.item()}")
                with torch.no_grad():
                    fake_images = generator(fixed_noise)
                    fake_images = fake_images.detach().cpu()
                    save_image(fake_images, f"epoch{epoch}_batch{i}.png", normalize=True)