python- 用GAN（Generative Adversarial Networks）实现，用于生成手写数字图片。

用GAN（Generative Adversarial Networks）实现，用于生成手写数字图片。

# 导入相关库
import torch
import torch.nn as n
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
import numpy as np

导入 PyTorch 和相关的库，包括：

• torch: PyTorch 库。
• torch.nn: PyTorch 中的神经网络模块。
• torch.optim: PyTorch 中的优化器。
• torch.nn.functional: PyTorch 中的函数式接口。
• torch.utils.data: PyTorch 中的数据加载器。
• torchvision: PyTorch 中的计算机视觉库。
• matplotlib: Python 中的绘图库。
• numpy: Python 中的数值计算库。

# 定义生成器
class Generator(n.Module):

    def __init__(self, latent_dim, img_shape):
        super(Generator, self).__init__()

        self.img_shape = img_shape
        self.fc = n.Linear(latent_dim, 128)
        self.conv1 = n.Conv2d(128, 256, 4, 2, 1)
        self.conv2 = n.Conv2d(256, 512, 4, 2, 1)
        self.conv3 = n.Conv2d(512, 1024, 2, 1)
        self.conv4 = n.Conv2d(1024, self.img_shape[0], 4, 2, 1)

    def forward(self, x):
        x = F.leaky_relu(self.fc(x), 0.2)

        x = x.view(-1, 128, 4)
        x = F.leaky_relu(self.conv1(x), 0.2)
        x = F.leaky_relu(self.conv2(x), 0.2)
        x = F.leaky_relu(self.conv3(x), 0.2)
        x = torch.tanh(self.conv4(x))

        return x

这段代码定义了生成器模型。生成器是一个神经网络模型，用于从随机噪声 z 中生成图片。生成器模型包含以下几个层：

• torch.nn.Linear: 全连接层，将随机噪声 z 映射到 128 维向量。
• torch.nn.Conv2d: 卷积层，用于对生成器的 128 维向量进行卷积操作，生成特征图。
• torch.nn.LeakyReLU: 激活函数，用于激活特征图。
• torch.nn.Tanh: 激活函数，用于将输出范围缩放到 [-1, 1]。

# 定义判别器
class Discriminator(n.Module):

    def __init__(self, img_shape):
        super(Discriminator, self).__init__()
        self.img_shape = img_shape
        self.conv1 = n.Conv2d(self.img_shape[0], 512, 4, 2, 1)
        self.conv2 = n.Conv2d(512, 256, 4, 2, 1)
        self.conv3 = n.Conv2d(256, 128, 4, 2, 1)
        self.fc = n.Linear(128 * 4, 1)


    def forward(self, x):
        x = F.leaky_relu(self.conv1(x), 0.2)
        x = F.leaky_relu(self.conv2(x), 0.2)
        x = F.leaky_relu(self.conv3(x), 0.2)
        x = x.view(-1, 128 * 4)
        x = self.fc(x)
        return x

这段代码定义了判别器模型。判别器是一个神经网络模型，用于判断输入的图片是否为真实图片。判别器模型包含以下几个层：

• torch.nn.Conv2d: 卷积层，

1. 首先，定义了一个Discriminator类，继承自nn.Module，用于构建判别器模型。

2. 接着，在__init__函数中，定义了四个卷积层和一个全连接层，用于构建判别器模型。

3. 最后，在forward函数中，定义了前向传播过程，将输入x通过四个卷积层和一个全连接层，最终得到输出x。

# 定义损失函数
def los_func(real_score, fake_score):
    real_los = torch.mean((real_score - 1) * 2)
    fake_los = torch.mean(fake_score * 2)
    return real_los + fake_los


# 定义训练函数
def train(d