深度生成AI正在重塑我们创造和理解内容的方式。当ChatGPT让文本生成变得触手可及时图像、视频、3D模型等复杂内容的生成技术也在飞速发展。多伦多大学2025年夏季的深度生成AI课程正是站在这一技术浪潮前沿的系统性学习机会。这门课程的价值不仅在于传授理论知识更重要的是它提供了从基础原理到前沿应用的完整路径。对于想要深入理解AI生成技术背后机制而不仅仅是调用API的开发者来说这样的课程能够帮助建立扎实的技术根基。在当前AI工具泛滥但原理理解稀缺的环境下系统学习深度生成AI显得尤为珍贵。1. 深度生成AI的核心价值与学习意义深度生成AI之所以重要是因为它代表了AI从识别到创造的质变。传统的判别式模型擅长分类和预测而生成式模型能够创造出全新的内容。这种能力在创意产业、科学研究、产品设计等领域具有革命性意义。多伦多大学的这门课程从生成式AI的基础理论出发覆盖了变分自编码器(VAE)、生成对抗网络(GAN)、扩散模型等核心架构。与市面上很多只讲用法的教程不同这门课程深入探讨了不同生成模型的数学原理和适用场景。比如为什么在某些任务中扩散模型比GAN表现更好VAE在latent space建模中的独特优势是什么这些深度理解对于在实际项目中正确选择技术方案至关重要。从职业发展角度看掌握深度生成AI意味着具备了参与前沿AI项目的能力。无论是开发AI绘画工具、构建视频生成系统还是设计药物分子结构都需要扎实的生成模型知识作为基础。这门课程通过理论结合实践的方式帮助学习者建立这种核心竞争力。2. 课程核心内容与技术架构解析2.1 生成模型基础理论课程首先建立了生成模型的概率论基础。生成式AI的核心思想是学习数据分布$p(x)$然后从这个分布中采样生成新样本。这与判别式模型学习$p(y|x)$有本质区别。# 生成模型与判别模型的直观对比 import numpy as np import matplotlib.pyplot as plt # 生成模型学习数据分布p(x) def generative_model(data): # 估计数据分布参数 mu np.mean(data, axis0) sigma np.cov(data.T) return mu, sigma # 判别模型学习条件分布p(y|x) def discriminative_model(X, y): # 直接学习决策边界 from sklearn.linear_model import LogisticRegression model LogisticRegression() model.fit(X, y) return model这种理论基础决定了生成模型能够创造全新数据而判别模型只能对已有数据进行分类。2.2 变分自编码器(VAE)深度解析VAE是课程重点讲解的第一个现代生成模型。它的核心创新在于引入了变分推断来解决intractable的后验分布问题。import torch import torch.nn as nn import torch.nn.functional as F class VAE(nn.Module): def __init__(self, input_dim784, hidden_dim400, latent_dim20): super(VAE, self).__init__() # 编码器 self.encoder nn.Sequential( nn.Linear(input_dim, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, hidden_dim), nn.ReLU() ) # 潜在空间的均值和方差 self.fc_mu nn.Linear(hidden_dim, latent_dim) self.fc_logvar nn.Linear(hidden_dim, latent_dim) # 解码器 self.decoder nn.Sequential( nn.Linear(latent_dim, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, input_dim), nn.Sigmoid() ) def reparameterize(self, mu, logvar): 重参数化技巧 std torch.exp(0.5 * logvar) eps torch.randn_like(std) return mu eps * std def forward(self, x): # 编码 h self.encoder(x) mu, logvar self.fc_mu(h), self.fc_logvar(h) # 重参数化 z self.reparameterize(mu, logvar) # 解码 x_recon self.decoder(z) return x_recon, mu, logvar # VAE损失函数重构损失 KL散度 def vae_loss(recon_x, x, mu, logvar): recon_loss F.binary_cross_entropy(recon_x, x, reductionsum) kl_loss -0.5 * torch.sum(1 logvar - mu.pow(2) - logvar.exp()) return recon_loss kl_lossVAE的优势在于其latent space具有良好的数学性质支持有意义的插值和语义操作。但它的生成质量通常不如GAN这是课程中会详细讨论的权衡点。2.3 生成对抗网络(GAN)技术演进GAN通过对抗训练的方式实现了高质量的生成效果。课程从原始GAN开始逐步深入到WGAN、StyleGAN等改进版本。class Generator(nn.Module): def __init__(self, latent_dim100, img_dim784): super(Generator, self).__init__() self.model nn.Sequential( nn.Linear(latent_dim, 256), nn.LeakyReLU(0.2), nn.Linear(256, 512), nn.LeakyReLU(0.2), nn.Linear(512, 1024), nn.LeakyReLU(0.2), nn.Linear(1024, img_dim), nn.Tanh() ) def forward(self, z): return self.model(z) class Discriminator(nn.Module): def __init__(self, img_dim784): super(Discriminator, self).__init__() self.model nn.Sequential( nn.Linear(img_dim, 1024), nn.LeakyReLU(0.2), nn.Dropout(0.3), nn.Linear(1024, 512), nn.LeakyReLU(0.2), nn.Dropout(0.3), nn.Linear(512, 256), nn.LeakyReLU(0.2), nn.Dropout(0.3), nn.Linear(256, 1), nn.Sigmoid() ) def forward(self, img): return self.model(img) # GAN训练循环的关键步骤 def train_gan(generator, discriminator, dataloader, epochs100): g_optimizer torch.optim.Adam(generator.parameters()) d_optimizer torch.optim.Adam(discriminator.parameters()) criterion nn.BCELoss() for epoch in range(epochs): for real_imgs, _ in dataloader: batch_size real_imgs.size(0) # 训练判别器 real_labels torch.ones(batch_size, 1) fake_labels torch.zeros(batch_size, 1) # 真实图像损失 real_outputs discriminator(real_imgs) d_loss_real criterion(real_outputs, real_labels) # 生成图像损失 z torch.randn(batch_size, 100) fake_imgs generator(z) fake_outputs discriminator(fake_imgs.detach()) d_loss_fake criterion(fake_outputs, fake_labels) d_loss d_loss_real d_loss_fake d_optimizer.zero_grad() d_loss.backward() d_optimizer.step() # 训练生成器 z torch.randn(batch_size, 100) fake_imgs generator(z) outputs discriminator(fake_imgs) g_loss criterion(outputs, real_labels) g_optimizer.zero_grad() g_loss.backward() g_optimizer.step()课程特别强调了GAN训练中的挑战如模式崩塌、训练不稳定等问题并介绍了相应的解决方案。2.4 扩散模型当前的技术前沿扩散模型是当前生成式AI的主流技术课程详细讲解了DDPM、DDIM等核心算法。class DiffusionModel(nn.Module): def __init__(self, network, timesteps1000): super().__init__() self.network network self.timesteps timesteps # 定义噪声调度 self.betas torch.linspace(1e-4, 0.02, timesteps) self.alphas 1.0 - self.betas self.alphas_cumprod torch.cumprod(self.alphas, dim0) def forward_diffusion(self, x0, t): 前向扩散过程 noise torch.randn_like(x0) sqrt_alphas_cumprod_t torch.sqrt(self.alphas_cumprod[t]) sqrt_one_minus_alphas_cumprod_t torch.sqrt(1 - self.alphas_cumprod[t]) xt sqrt_alphas_cumprod_t * x0 sqrt_one_minus_alphas_cumprod_t * noise return xt, noise def reverse_diffusion(self, xt, t): 反向扩散过程 predicted_noise self.network(xt, t) return predicted_noise def training_step(self, x0): t torch.randint(0, self.timesteps, (x0.size(0),)) xt, noise self.forward_diffusion(x0, t) predicted_noise self.reverse_diffusion(xt, t) loss F.mse_loss(predicted_noise, noise) return loss def sample(self, shape, device): 从噪声生成样本 x torch.randn(shape, devicedevice) for i in reversed(range(self.timesteps)): t torch.tensor([i] * shape[0], devicedevice) predicted_noise self.reverse_diffusion(x, t) alpha_t self.alphas[t] alpha_cumprod_t self.alphas_cumprod[t] if i 0: noise torch.randn_like(x) else: noise torch.zeros_like(x) x (1 / torch.sqrt(alpha_t)) * ( x - ((1 - alpha_t) / torch.sqrt(1 - alpha_cumprod_t)) * predicted_noise ) torch.sqrt(self.betas[t]) * noise return x扩散模型的理论相对复杂但生成质量显著优于之前的技术。课程通过渐进式的讲解方式帮助学习者建立直观理解。3. 实践环境搭建与工具链配置深度生成AI的学习需要合适的硬件和软件环境。课程推荐使用Python 3.8和PyTorch框架这是当前生成式AI研究的主流工具链。3.1 基础环境配置# 创建conda环境 conda create -n deep-genai python3.8 conda activate deep-genai # 安装核心依赖 pip install torch torchvision torchaudio pip install numpy matplotlib pandas pip install jupyter notebook # 安装生成式AI相关库 pip install diffusers transformers pip install einops accelerate pip install opencv-python pillow3.2 GPU环境配置检查对于生成式AI任务GPU加速至关重要。课程提供了环境检查脚本import torch import subprocess def check_environment(): print( 环境检查报告 ) # 检查PyTorch版本 print(fPyTorch版本: {torch.__version__}) # 检查CUDA可用性 cuda_available torch.cuda.is_available() print(fCUDA可用: {cuda_available}) if cuda_available: print(fCUDA版本: {torch.version.cuda}) print(fGPU设备: {torch.cuda.get_device_name(0)}) print(fGPU数量: {torch.cuda.device_count()}) # 检查GPU内存 gpu_memory torch.cuda.get_device_properties(0).total_memory / 1e9 print(fGPU内存: {gpu_memory:.1f} GB) # 检查其他重要库 try: import diffusers print(fDiffusers版本: {diffusers.__version__}) except ImportError: print(Diffusers未安装) try: import transformers print(fTransformers版本: {transformers.__version__}) except ImportError: print(Transformers未安装) if __name__ __main__: check_environment()3.3 数据集准备与管理课程使用多个标准数据集进行实践import torchvision import torchvision.transforms as transforms from torch.utils.data import DataLoader def prepare_datasets(): 准备训练和测试数据集 # 数据预处理 transform transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,)) ]) # MNIST数据集基础练习 mnist_train torchvision.datasets.MNIST( root./data, trainTrue, downloadTrue, transformtransform) mnist_test torchvision.datasets.MNIST( root./data, trainFalse, downloadTrue, transformtransform) # CIFAR-10数据集进阶练习 cifar_transform transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) cifar_train torchvision.datasets.CIFAR10( root./data, trainTrue, downloadTrue, transformcifar_transform) cifar_test torchvision.datasets.CIFAR10( root./data, trainFalse, downloadTrue, transformcifar_transform) return { mnist: {train: mnist_train, test: mnist_test}, cifar10: {train: cifar_train, test: cifar_test} } # 创建数据加载器 def create_dataloaders(datasets, batch_size128): dataloaders {} for name, dataset in datasets.items(): train_loader DataLoader( dataset[train], batch_sizebatch_size, shuffleTrue) test_loader DataLoader( dataset[test], batch_sizebatch_size, shuffleFalse) dataloaders[name] { train: train_loader, test: test_loader } return dataloaders4. 完整项目实战从VAE到扩散模型课程通过一个完整的图像生成项目串联起各种生成模型技术。4.1 VAE实战手写数字生成def train_vae_mnist(): 在MNIST数据集上训练VAE # 准备数据 datasets prepare_datasets() mnist_loader datasets[mnist][train] # 初始化模型 device torch.device(cuda if torch.cuda.is_available() else cpu) vae VAE().to(device) optimizer torch.optim.Adam(vae.parameters(), lr1e-3) # 训练循环 vae.train() for epoch in range(50): total_loss 0 for batch_idx, (data, _) in enumerate(mnist_loader): data data.view(data.size(0), -1).to(device) optimizer.zero_grad() recon_batch, mu, logvar vae(data) loss vae_loss(recon_batch, data, mu, logvar) loss.backward() optimizer.step() total_loss loss.item() avg_loss total_loss / len(mnist_loader.dataset) print(fEpoch {epoch}, Loss: {avg_loss:.4f}) return vae def visualize_vae_results(vae, device): 可视化VAE生成结果 vae.eval() with torch.no_grad(): # 从潜在空间采样 z torch.randn(64, 20).to(device) samples vae.decoder(z).cpu() # 显示生成图像 fig, axes plt.subplots(8, 8, figsize(12, 12)) for i, ax in enumerate(axes.flat): ax.imshow(samples[i].view(28, 28), cmapgray) ax.axis(off) plt.tight_layout() plt.show()4.2 GAN实战生成更复杂的图像def train_gan_cifar10(): 在CIFAR-10数据集上训练GAN datasets prepare_datasets() cifar_loader datasets[cifar10][train] device torch.device(cuda if torch.cuda.is_available() else cpu) generator Generator(latent_dim100, img_dim3*32*32).to(device) discriminator Discriminator(img_dim3*32*32).to(device) # 使用更好的优化器 g_optimizer torch.optim.Adam(generator.parameters(), lr0.0002, betas(0.5, 0.999)) d_optimizer torch.optim.Adam(discriminator.parameters(), lr0.0002, betas(0.5, 0.999)) criterion nn.BCELoss() for epoch in range(100): for i, (real_imgs, _) in enumerate(cifar_loader): batch_size real_imgs.size(0) real_imgs real_imgs.view(batch_size, -1).to(device) # 训练判别器 real_labels torch.ones(batch_size, 1).to(device) fake_labels torch.zeros(batch_size, 1).to(device) # 真实图像 real_outputs discriminator(real_imgs) d_loss_real criterion(real_outputs, real_labels) # 生成图像 z torch.randn(batch_size, 100).to(device) fake_imgs generator(z) fake_outputs discriminator(fake_imgs.detach()) d_loss_fake criterion(fake_outputs, fake_labels) d_loss d_loss_real d_loss_fake d_optimizer.zero_grad() d_loss.backward() d_optimizer.step() # 训练生成器 z torch.randn(batch_size, 100).to(device) fake_imgs generator(z) outputs discriminator(fake_imgs) g_loss criterion(outputs, real_labels) g_optimizer.zero_grad() g_loss.backward() g_optimizer.step() if epoch % 10 0: print(fEpoch {epoch}, D_loss: {d_loss.item():.4f}, G_loss: {g_loss.item():.4f}) return generator, discriminator4.3 扩散模型实战现代生成技术class UNet(nn.Module): 简单的UNet架构用于扩散模型 def __init__(self, in_channels1, out_channels1): super().__init__() # 编码器 self.enc1 self._block(in_channels, 64) self.enc2 self._block(64, 128) self.enc3 self._block(128, 256) # 瓶颈层 self.bottleneck self._block(256, 512) # 解码器 self.dec3 self._block(512 256, 256) self.dec2 self._block(256 128, 128) self.dec1 self._block(128 64, 64) self.final nn.Conv2d(64, out_channels, kernel_size1) def _block(self, in_channels, out_channels): return nn.Sequential( nn.Conv2d(in_channels, out_channels, 3, padding1), nn.ReLU(), nn.Conv2d(out_channels, out_channels, 3, padding1), nn.ReLU() ) def forward(self, x, tNone): # 编码路径 e1 self.enc1(x) e2 self.enc2(nn.MaxPool2d(2)(e1)) e3 self.enc3(nn.MaxPool2d(2)(e2)) # 瓶颈 b self.bottleneck(nn.MaxPool2d(2)(e3)) # 解码路径包含跳跃连接 d3 self.dec3(torch.cat([nn.Upsample(scale_factor2)(b), e3], dim1)) d2 self.dec2(torch.cat([nn.Upsample(scale_factor2)(d3), e2], dim1)) d1 self.dec1(torch.cat([nn.Upsample(scale_factor2)(d2), e1], dim1)) return self.final(d1) def train_diffusion_model(): 训练扩散模型 datasets prepare_datasets() mnist_loader datasets[mnist][train] device torch.device(cuda if torch.cuda.is_available() else cpu) model UNet().to(device) diffusion DiffusionModel(model).to(device) optimizer torch.optim.Adam(diffusion.parameters(), lr1e-4) diffusion.train() for epoch in range(100): total_loss 0 for batch_idx, (data, _) in enumerate(mnist_loader): data data.to(device) optimizer.zero_grad() loss diffusion.training_step(data) loss.backward() optimizer.step() total_loss loss.item() avg_loss total_loss / len(mnist_loader) print(fEpoch {epoch}, Loss: {avg_loss:.4f}) return diffusion5. 模型评估与性能分析生成模型的评估比判别模型更复杂课程介绍了多种评估方法。5.1 定量评估指标import torch import torch.nn.functional as F from torchmetrics.image import FrechetInceptionDistance from sklearn.metrics import accuracy_score class GenerativeModelEvaluator: def __init__(self, real_data_loader): self.real_data_loader real_data_loader self.fid FrechetInceptionDistance(feature64) def calculate_fid(self, generated_images): 计算FID分数 # 重置指标 self.fid.reset() # 处理真实图像 for real_batch, _ in self.real_data_loader: # 将图像转换为3通道FID需要 if real_batch.shape[1] 1: real_batch real_batch.repeat(1, 3, 1, 1) self.fid.update(real_batch, realTrue) # 处理生成图像 if generated_images.shape[1] 1: generated_images generated_images.repeat(1, 3, 1, 1) self.fid.update(generated_images, realFalse) return self.fid.compute() def calculate_inception_score(self, generated_images): 计算Inception Score # 使用预训练的Inception模型 from torchvision.models import inception_v3 inception_model inception_v3(pretrainedTrue, transform_inputFalse) inception_model.eval() # 获取预测概率 with torch.no_grad(): predictions F.softmax(inception_model(generated_images), dim1) # 计算KL散度 py predictions.mean(dim0) scores [] for p in predictions: kl F.kl_div(py.log(), p, reductionsum) scores.append(kl.exp().item()) return sum(scores) / len(scores) def visual_quality_assessment(self, generated_images, real_images): 视觉质量评估 # 计算SSIM结构相似性 from torchmetrics.image import StructuralSimilarityIndexMeasure ssim StructuralSimilarityIndexMeasure(data_range1.0) ssim_score ssim(generated_images, real_images) # 计算PSNR峰值信噪比 from torchmetrics.image import PeakSignalNoiseRatio psnr PeakSignalNoiseRatio() psnr_score psnr(generated_images, real_images) return { ssim: ssim_score.item(), psnr: psnr_score.item() } def compare_generative_models(): 比较不同生成模型的性能 device torch.device(cuda if torch.cuda.is_available() else cpu) datasets prepare_datasets() test_loader datasets[mnist][test] evaluator GenerativeModelEvaluator(test_loader) # 生成测试图像 vae train_vae_mnist() generator, _ train_gan_cifar10() diffusion train_diffusion_model() # 为每个模型生成样本 with torch.no_grad(): # VAE样本 z_vae torch.randn(1000, 20).to(device) vae_samples vae.decoder(z_vae).view(-1, 1, 28, 28) # GAN样本 z_gan torch.randn(1000, 100).to(device) gan_samples generator(z_gan).view(-1, 1, 28, 28) # 扩散模型样本 diffusion_samples diffusion.sample((1000, 1, 28, 28), device) # 计算评估指标 results {} results[VAE] { FID: evaluator.calculate_fid(vae_samples), Inception Score: evaluator.calculate_inception_score(vae_samples) } results[GAN] { FID: evaluator.calculate_fid(gan_samples), Inception Score: evaluator.calculate_inception_score(gan_samples) } results[Diffusion] { FID: evaluator.calculate_fid(diffusion_samples), Inception Score: evaluator.calculate_inception_score(diffusion_samples) } return results5.2 生成样本多样性分析def analyze_diversity(generated_samples, real_samples): 分析生成样本的多样性 # 使用PCA降维可视化 from sklearn.decomposition import PCA from sklearn.manifold import TSNE # 展平图像 generated_flat generated_samples.view(generated_samples.size(0), -1).cpu().numpy() real_flat real_samples.view(real_samples.size(0), -1).cpu().numpy() # PCA分析 pca PCA(n_components2) generated_pca pca.fit_transform(generated_flat) real_pca pca.transform(real_flat) # t-SNE分析 tsne TSNE(n_components2, random_state42) generated_tsne tsne.fit_transform(generated_flat) real_tsne tsne.fit_transform(real_flat) return { pca: {generated: generated_pca, real: real_pca}, tsne: {generated: generated_tsne, real: real_tsne} } def plot_diversity_analysis(analysis_results): 绘制多样性分析结果 fig, axes plt.subplots(1, 2, figsize(15, 6)) # PCA图 axes[0].scatter(analysis_results[pca][real][:, 0], analysis_results[pca][real][:, 1], alpha0.5, label真实数据) axes[0].scatter(analysis_results[pca][generated][:, 0], analysis_results[pca][generated][:, 1], alpha0.5, label生成数据) axes[0].set_title(PCA多样性分析) axes[0].legend() # t-SNE图 axes[1].scatter(analysis_results[tsne][real][:, 0], analysis_results[tsne][real][:, 1], alpha0.5, label真实数据) axes[1].scatter(analysis_results[tsne][generated][:, 0], analysis_results[tsne][generated][:, 1], alpha0.5, label生成数据) axes[1].set_title(t-SNE多样性分析) axes[1].legend() plt.tight_layout() plt.show()6. 实际应用场景与项目部署深度生成AI技术在实际项目中有广泛的应用前景。6.1 创意内容生成class CreativeContentGenerator: def __init__(self, model_path, devicecuda): self.device device self.model self.load_model(model_path) def generate_artistic_images(self, prompt, num_images4): 生成艺术图像 # 使用预训练的扩散模型 from diffusers import StableDiffusionPipeline pipe StableDiffusionPipeline.from_pretrained(runwayml/stable-diffusion-v1-5) pipe pipe.to(self.device) images pipe(prompt, num_images_per_promptnum_images).images return images def style_transfer(self, content_image, style_image): 风格迁移 # 使用预训练的风格迁移模型 pass def image_inpainting(self, image, mask): 图像修复 from diffusers import StableDiffusionInpaintPipeline pipe StableDiffusionInpaintPipeline.from_pretrained( runwayml/stable-diffusion-inpainting) pipe pipe.to(self.device) result pipe(prompt, imageimage, mask_imagemask).images[0] return result # 实际应用示例 def creative_demo(): generator CreativeContentGenerator() # 生成艺术图像 artistic_images generator.generate_artistic_images( a beautiful landscape with mountains and lake, digital art) # 显示结果 fig, axes plt.subplots(2, 2, figsize(12, 12)) for i, ax in enumerate(axes.flat): ax.imshow(artistic_images[i]) ax.axis(off) plt.tight_layout() plt.show()6.2 科学计算与分子生成class MolecularGenerator: def __init__(self): self.device torch.device(cuda if torch.cuda.is_available() else cpu) def generate_molecules(self, target_properties, num_samples100): 生成具有特定性质的分子 # 使用图神经网络生成分子图 pass def optimize_molecule(self, initial_molecule, target_property): 优化分子结构 pass def validate_molecules(self, generated_molecules): 验证生成分子的有效性 from rdkit import Chem from rdkit.Chem import Descriptors valid_molecules [] for smi in generated_molecules: mol Chem.MolFromSmiles(smi) if mol is not None: # 计算分子描述符 properties { mw: Descriptors.MolWt(mol), logp: Descriptors.MolLogP(mol), hbd: Descriptors.NumHDonors(mol) } valid_molecules.append((smi, properties)) return valid_molecules7. 常见问题与解决方案在学习和应用深度生成AI过程中会遇到各种技术挑战。7.1 训练稳定性问题问题现象可能原因解决方案损失函数震荡剧烈学习率过高降低学习率使用学习率调度器生成质量差模式崩塌使用Wasserstein GAN、梯度惩罚训练速度慢批量大小不合适调整批量大小使用混合精度训练内存不足模型太大使用梯度检查点减少批量大小7.2 生成质量优化def improve_generation_quality(model, dataloader): 提高生成质量的实用技巧 # 1. 使用标签平滑 def label_smoothing(real_labels, smooth_factor0.1): return real_labels * (1 - smooth_factor) smooth_factor / 2 # 2. 使用梯度惩罚 def gradient_penalty(discriminator, real_data, fake_data): batch_size real_data.size(0) alpha torch.rand(batch_size, 1, 1, 1).to(real_data.device) # 插值样本 interpolated alpha * real_data (1 - alpha) * fake_data interpolated.requires_grad_(True) # 计算判别器输出 d_interpolated discriminator(interpolated) # 计算梯度 gradients torch.autograd.grad( outputsd_interpolated, inputsinterpolated, grad_outputstorch.ones_like(d_interpolated), create_graphTrue, retain_graphTrue)[0] gradients gradients.view(batch_size, -1) gradient_norm gradients.norm(2, dim1) penalty ((gradient_norm - 1) ** 2).mean() return penalty # 3. 使用指数移动平均 class EMA: def __init__(self, model, decay0.999): self.model model self.decay decay self.shadow {} self.backup {} # 初始化影子参数 for name, param in model.named_parameters(): if param.requires_grad: self.shadow[name] param.data.clone() def update(self): for name, param in self.model.named_parameters(): if param.requires_grad: self.shadow[name] self.decay * self.shadow[name] \ (1 - self.decay) * param.data def apply_shadow(self): for name, param in self.model.named_parameters(): if param