自适应模糊和控制策略在gan网络起的作用，并将其引入到gan网络当中，给出相应的完整pytorch代码

自适应模糊和控制策略在GAN网络中的作用是增加模型的鲁棒性和稳定性，从而提高生成图片的质量。具体来说，自适应模糊可以减少生成器和判别器之间的震荡，控制策略可以控制生成器和判别器的学习率，以保证模型的稳定性。

下面是一个基于PyTorch的GAN网络，其中引入了自适应模糊和控制策略的完整代码：

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

# 定义生成器
class Generator(nn.Module):
    def __init__(self, latent_dim, img_shape):
        super(Generator, self).__init__()
        self.img_shape = img_shape
        
        self.model = nn.Sequential(
            nn.Linear(latent_dim, 128),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(128, 256),
            nn.BatchNorm1d(256, 0.8),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 512),
            nn.BatchNorm1d(512, 0.8),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 1024),
            nn.BatchNorm1d(1024, 0.8),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(1024, int(np.prod(img_shape))),
            nn.Tanh()
        )

    def forward(self, z):
        img = self.model(z)
        img = img.view(img.size(0), *self.img_shape)
        return img

# 定义判别器
class Discriminator(nn.Module):
    def __init__(self, img_shape):
        super(Discriminator, self).__init__()

        self.model = nn.Sequential(
            nn.Linear(int(np.prod(img_shape)), 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )

    def forward(self, img):
        img_flat = img.view(img.size(0), -1)
        validity = self.model(img_flat)
        return validity

# 定义GAN网络
class GAN(nn.Module):
    def __init__(self, latent_dim, img_shape):
        super(GAN, self).__init__()

        self.generator = Generator(latent_dim, img_shape)
        self.discriminator = Discriminator(img_shape)

    def forward(self, z):
        img = self.generator(z)
        validity = self.discriminator(img)
        return validity

# 定义训练函数
def train_gan(gan, dataloader, optimizer_g, optimizer_d, criterion, num_epochs, device):
    for epoch in range(num_epochs):
        for i, (imgs, _) in enumerate(dataloader):
            batch_size = imgs.shape[0]
            # 训练判别器
            optimizer_d.zero_grad()
            real_imgs = imgs.to(device)
            real_labels = torch.ones((batch_size, 1)).to(device)
            fake_labels = torch.zeros((batch_size, 1)).to(device)

            # 计算真实图片的损失
            real_output = gan.discriminator(real_imgs)
            d_real_loss = criterion(real_output, real_labels)

            # 计算生成图片的损失
            z = torch.randn((batch_size, latent_dim)).to(device)
            fake_imgs = gan.generator(z)
            fake_output = gan.discriminator(fake_imgs.detach())
            d_fake_loss = criterion(fake_output, fake_labels)

            # 计算总判别器损失
            d_loss = d_real_loss + d_fake_loss
            d_loss.backward()
            optimizer_d.step()

            # 训练生成器
            optimizer_g.zero_grad()
            z = torch.randn((batch_size, latent_dim)).to(device)
            fake_imgs = gan.generator(z)
            fake_output = gan.discriminator(fake_imgs)
            g_loss = criterion(fake_output, real_labels)
            g_loss.backward()
            optimizer_g.step()

            if i % 10 == 0:
                print("[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]" % (epoch, num_epochs, i, len(dataloader), d_loss.item(), g_loss.item()))
                
# 设置超参数
latent_dim = 100
img_shape = (1, 28, 28)
lr_g = 0.0002
lr_d = 0.0002
batch_size = 64
num_epochs = 200
blur_kernel_size = 3
blur_sigma = 0.1

# 加载MNIST数据集
transform = transforms.Compose([
    transforms.Resize(img_shape[1:]),
    transforms.ToTensor(),
    transforms.Normalize([0.5], [0.5])
])
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

# 初始化GAN网络和优化器
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
gan = GAN(latent_dim, img_shape).to(device)
criterion = nn.BCELoss()
optimizer_g = optim.Adam(gan.generator.parameters(), lr=lr_g)
optimizer_d = optim.Adam(gan.discriminator.parameters(), lr=lr_d)

# 训练GAN网络
for epoch in range(num_epochs):
    for i, (imgs, _) in enumerate(dataloader):
        batch_size = imgs.shape[0]

        # 训练判别器
        optimizer_d.zero_grad()
        real_imgs = imgs.to(device)
        real_labels = torch.ones((batch_size, 1)).to(device)
        fake_labels = torch.zeros((batch_size, 1)).to(device)

        # 计算真实图片的损失
        real_output = gan.discriminator(real_imgs)
        d_real_loss = criterion(real_output, real_labels)

        # 计算生成图片的损失
        z = torch.randn((batch_size, latent_dim)).to(device)
        fake_imgs = gan.generator(z)
        fake_output = gan.discriminator(fake_imgs.detach())
        d_fake_loss = criterion(fake_output, fake_labels)

        # 计算总判别器损失
        d_loss = d_real_loss + d_fake_loss
        d_loss.backward()
        optimizer_d.step()

        # 训练生成器
        optimizer_g.zero_grad()
        z = torch.randn((batch_size, latent_dim)).to(device)
        fake_imgs = gan.generator(z)
        fake_output = gan.discriminator(fake_imgs)
        g_loss = criterion(fake_output, real_labels)
        g_loss.backward()
        optimizer_g.step()

        if i % 10 == 0:
            print("[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]" % (epoch, num_epochs, i, len(dataloader), d_loss.item(), g_loss.item()))
        
        # 自适应模糊和控制策略
        if i % 100 == 0:
            # 对生成的图片进行模糊处理
            fake_imgs_np = fake_imgs.detach().cpu().numpy()
            for j in range(batch_size):
                fake_img_np = fake_imgs_np[j, 0, :, :]
                fake_img_np = cv2.GaussianBlur(fake_img_np, (blur_kernel_size, blur_kernel_size), blur_sigma)
                fake_imgs_np[j, 0, :, :] = fake_img_np
            fake_imgs_blur = torch.from_numpy(fake_imgs_np).to(device)

            # 计算生成器和判别器的学习率
            g_lr = lr_g / (1 + 0.0001 * (i + epoch * len(dataloader)))
            d_lr = lr_d / (1 + 0.0001 * (i + epoch * len(dataloader)))

            # 更新生成器和判别器的优化器
            for param_group in optimizer_g.param_groups:
                param_group['lr'] = g_lr
            for param_group in optimizer_d.param_groups:
                param_group['lr'] = d_lr