可以做年龄编辑的gan对抗网络（SAGAN）

过程：

1. 条件生成器（Conditional Generator）

• 输入：随机噪声 z + 年龄标签 age_label

• 实现：将年龄标签嵌入为向量，与噪声拼接后输入网络

• 优点：结构改动小，兼容原自注意力模块

2. 条件判别器（Conditional Discriminator）

• 输入：图像 + 年龄标签

• 实现：将年龄标签嵌入并扩展为与图像同尺寸的单通道条件图，与RGB图像拼接（输入通道变为4）

• 优点：简单有效，让判别器同时学习图像和年龄的一致性

3. 数据集与训练

• 使用 CelebA 人脸数据集（包含年龄属性），将年龄划分为 10 个年龄段（0~9）

• 训练时随机采样年龄标签，引导生成器学习年龄特征

• 训练完成后，通过改变输入年龄标签即可编辑生成人脸的年龄

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import Tensor
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torchvision.utils import save_image
import os
import numpy as np

# ================== 自注意力模块（原样保留） ==================
class SelfAttention(nn.Module):
    def __init__(self, in_channels):
        super(SelfAttention, self).__init__()
        self.in_channels = in_channels
        self.query = nn.Conv2d(in_channels, in_channels // 8, kernel_size=1)
        self.key = nn.Conv2d(in_channels, in_channels // 8, kernel_size=1)
        self.value = nn.Conv2d(in_channels, in_channels, kernel_size=1)
        self.gamma = nn.Parameter(torch.zeros(1))
        self.softmax = nn.Softmax(dim=-1)

    def forward(self, x):
        B, C, W, H = x.size()
        query = self.query(x).view(B, -1, W*H).permute(0, 2, 1)
        key = self.key(x).view(B, -1, W*H)
        value = self.value(x).view(B, -1, W*H)
        attention = torch.bmm(query, key)
        attention = self.softmax(attention)
        out = torch.bmm(value, attention.permute(0, 2, 1))
        out = out.view(B, C, W, H)
        return self.gamma * out + x


# ================== 条件生成器 ==================
class ConditionalGenerator(nn.Module):
    def __init__(self, z_dim, img_channels, features_g, num_age_classes):
        super(ConditionalGenerator, self).__init__()
        self.z_dim = z_dim
        self.num_age_classes = num_age_classes
        # 年龄嵌入层：将类别标签映射为 z_dim 维向量
        self.age_embed = nn.Embedding(num_age_classes, z_dim)

        # 生成器主体：输入通道 = z_dim（噪声） + z_dim（年龄嵌入）
        self.main = nn.Sequential(
            nn.ConvTranspose2d(z_dim + z_dim, features_g * 16, 4, 1, 0, bias=False),
            nn.BatchNorm2d(features_g * 16),
            nn.ReLU(True),

            nn.ConvTranspose2d(features_g * 16, features_g * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_g * 8),
            nn.ReLU(True),

            nn.ConvTranspose2d(features_g * 8, features_g * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_g * 4),
            nn.ReLU(True),
            SelfAttention(features_g * 4),

            nn.ConvTranspose2d(features_g * 4, features_g * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_g * 2),
            nn.ReLU(True),

            nn.ConvTranspose2d(features_g * 2, features_g, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_g),
            nn.ReLU(True),
            SelfAttention(features_g),

            nn.ConvTranspose2d(features_g, img_channels, 4, 2, 1, bias=False),
            nn.Tanh()
        )

    def forward(self, z, age_labels):
        # z: (B, z_dim, 1, 1)
        # age_labels: (B,) 整数标签 0~num_age_classes-1
        age_emb = self.age_embed(age_labels)          # (B, z_dim)
        age_emb = age_emb.view(-1, self.z_dim, 1, 1)  # (B, z_dim, 1, 1)
        # 拼接噪声和年龄嵌入
        x = torch.cat([z, age_emb], dim=1)            # (B, 2*z_dim, 1, 1)
        return self.main(x)


# ================== 条件判别器 ==================
class ConditionalDiscriminator(nn.Module):
    def __init__(self, img_channels, features_d, num_age_classes, img_size=64):
        super(ConditionalDiscriminator, self).__init__()
        self.img_size = img_size
        self.num_age_classes = num_age_classes
        # 年龄嵌入：先映射到中间维度，再通过全连接生成条件图
        self.age_embed = nn.Embedding(num_age_classes, 32)
        self.age_fc = nn.Linear(32, img_size * img_size)  # 生成与图像同尺寸的单通道条件图

        # 判别器输入通道 = 原图通道(3) + 条件图通道(1)
        self.main = nn.Sequential(
            nn.Conv2d(img_channels + 1, features_d, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(features_d, features_d * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_d * 2),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(features_d * 2, features_d * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_d * 4),
            nn.LeakyReLU(0.2, inplace=True),
            SelfAttention(features_d * 4),

            nn.Conv2d(features_d * 4, features_d * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_d * 8),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(features_d * 8, features_d * 16, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_d * 16),
            nn.LeakyReLU(0.2, inplace=True),
            SelfAttention(features_d * 16),

            nn.Conv2d(features_d * 16, 1, 4, 1, 0, bias=False),
            nn.Sigmoid()
        )

    def forward(self, img, age_labels):
        # img: (B, 3, H, W) 假设 H=W=img_size
        # age_labels: (B,)
        B = img.size(0)
        age_emb = self.age_embed(age_labels)          # (B, 32)
        age_map = self.age_fc(age_emb)                # (B, H*W)
        age_map = age_map.view(B, 1, self.img_size, self.img_size)  # (B, 1, H, W)
        # 拼接原图和条件图
        x = torch.cat([img, age_map], dim=1)          # (B, 4, H, W)
        return self.main(x)


# ================== 权重初始化（不变） ==================
def weights_init(m):
    classname = m.__class__.__name__
    if classname.find('Conv') != -1:
        nn.init.normal_(m.weight.data, 0.0, 0.02)
    elif classname.find('BatchNorm') != -1:
        nn.init.normal_(m.weight.data, 1.0, 0.02)
        nn.init.constant_(m.bias.data, 0)


# ================== 数据集预处理（CelebA） ==================
def get_celeba_loader(batch_size, img_size=64, data_root='./data'):
    # 年龄属性在CelebA中的索引（根据官方文档：第31个属性为“年龄”）
    # 但CelebA官方年龄是连续值，我们将其离散化为10个年龄段（0-9）
    def age_transform(target):
        # target 是属性的多维数组，这里只取年龄属性（索引31）
        age = target[31]  # 0~1 二值？实际上CelebA标注的是“Young” (0/1)，不够精细
        # 为了演示，我们改用其他方式或直接使用随机年龄（实战需用真实年龄标签）
        # 这里作为示例，我们假设数据集中有年龄连续值，但CelebA仅有“Young”属性，
        # 因此实际应用中应使用带有年龄标注的数据集（如UTKFace或AgeDB）。
        # 这里我们使用一个简单的替代：用图像文件名或随机生成年龄，仅作演示。
        # 为简化，我们直接生成随机年龄（0~9），以便代码可运行。
        # 正式使用时请替换为真实年龄标签的加载。
        return torch.randint(0, 10, (1,)).item()

    # 由于CelebA年龄标注不精细，我们采用一种更实用的做法：使用UTKFace数据集（年龄连续）
    # 但为了本demo的通用性，我们使用一个模拟数据集：将CIFAR10当作示例（仅演示结构）
    # 实战中请替换为真实人脸数据集。
    print("警告：本demo使用CIFAR-10模拟数据（仅验证代码结构），真实年龄编辑请使用CelebA-HQ或UTKFace。")
    transform = transforms.Compose([
        transforms.Resize(img_size),
        transforms.CenterCrop(img_size),
        transforms.ToTensor(),
        transforms.Normalize([0.5]*3, [0.5]*3)
    ])
    # 使用CIFAR-10作为示例（10类正好对应10个年龄组，方便演示）
    dataset = datasets.CIFAR10(root=data_root, train=True, download=True, transform=transform)
    # 为每个样本生成伪年龄标签（0~9）
    # 注意：CIFAR10的标签是类别，我们直接用它作为年龄标签（纯演示）
    # 实际应用需加载真实年龄
    return DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=2)


# ================== 训练函数 ==================
def train_conditional_gan():
    # 超参数
    z_dim = 100
    img_channels = 3
    features_g = 64
    features_d = 64
    num_age_classes = 10   # 10个年龄段
    img_size = 64
    batch_size = 64
    epochs = 50
    lr = 0.0002
    beta1 = 0.5
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    # 初始化模型
    gen = ConditionalGenerator(z_dim, img_channels, features_g, num_age_classes).to(device)
    disc = ConditionalDiscriminator(img_channels, features_d, num_age_classes, img_size).to(device)
    gen.apply(weights_init)
    disc.apply(weights_init)

    # 优化器
    opt_g = torch.optim.Adam(gen.parameters(), lr=lr, betas=(beta1, 0.999))
    opt_d = torch.optim.Adam(disc.parameters(), lr=lr, betas=(beta1, 0.999))

    # 损失函数
    criterion = nn.BCELoss()

    # 数据加载
    dataloader = get_celeba_loader(batch_size, img_size)

    # 固定噪声用于测试
    fixed_noise = torch.randn(num_age_classes, z_dim, 1, 1, device=device)
    fixed_labels = torch.arange(num_age_classes, device=device)  # 0~9

    print("开始训练...")
    for epoch in range(epochs):
        for i, (imgs, labels) in enumerate(dataloader):
            # 真实图像和标签（这里labels是CIFAR10的类别，我们将其视为年龄标签，仅演示）
            real_imgs = imgs.to(device)
            age_labels = labels.to(device)  # 0~9
            batch_size = real_imgs.size(0)
            real_labels = torch.ones(batch_size, 1, device=device)
            fake_labels = torch.zeros(batch_size, 1, device=device)

            # ---- 训练判别器 ----
            opt_d.zero_grad()
            # 真实样本
            real_validity = disc(real_imgs, age_labels)
            loss_real = criterion(real_validity, real_labels)
            # 生成假样本
            z = torch.randn(batch_size, z_dim, 1, 1, device=device)
            fake_imgs = gen(z, age_labels)
            fake_validity = disc(fake_imgs.detach(), age_labels)
            loss_fake = criterion(fake_validity, fake_labels)
            loss_d = (loss_real + loss_fake) / 2
            loss_d.backward()
            opt_d.step()

            # ---- 训练生成器 ----
            opt_g.zero_grad()
            z = torch.randn(batch_size, z_dim, 1, 1, device=device)
            fake_imgs = gen(z, age_labels)
            validity = disc(fake_imgs, age_labels)
            loss_g = criterion(validity, real_labels)
            loss_g.backward()
            opt_g.step()

        # 每个epoch结束后输出进度并保存样例
        print(f"Epoch [{epoch+1}/{epochs}]  D loss: {loss_d.item():.4f}  G loss: {loss_g.item():.4f}")
        with torch.no_grad():
            sample_imgs = gen(fixed_noise, fixed_labels)
            save_image(sample_imgs, f"age_samples_epoch_{epoch+1}.png", nrow=5, normalize=True)

    # 保存模型
    torch.save(gen.state_dict(), "conditional_generator.pth")
    torch.save(disc.state_dict(), "conditional_discriminator.pth")
    print("训练完成，模型已保存。")


# ================== 推理演示：编辑年龄 ==================
def edit_age_demo(generator_path="conditional_generator.pth"):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    z_dim = 100
    img_channels = 3
    features_g = 64
    num_age_classes = 10

    # 加载训练好的生成器
    gen = ConditionalGenerator(z_dim, img_channels, features_g, num_age_classes).to(device)
    gen.load_state_dict(torch.load(generator_path, map_location=device))
    gen.eval()

    # 固定随机噪声
    z = torch.randn(1, z_dim, 1, 1, device=device)

    # 生成不同年龄的人脸（0~9）
    print("生成不同年龄的人脸（标签0~9）...")
    with torch.no_grad():
        for age in range(num_age_classes):
            label = torch.tensor([age], device=device)
            fake_img = gen(z, label)
            save_image(fake_img, f"age_{age}.png", normalize=True)
            print(f"已保存 age_{age}.png")

    # 也可指定某个年龄连续变化（例如从0到9）
    print("演示编辑年龄：从0岁到9岁变化（同一个人脸）")
    # 这里我们可以改变年龄标签，但为了展示同一潜在编码下年龄变化，我们固定z，变化label
    # 生成一组图像并合成gif（此处仅保存为图片序列）
    for age in range(num_age_classes):
        label = torch.tensor([age], device=device)
        fake_img = gen(z, label)
        save_image(fake_img, f"same_person_age_{age}.png", normalize=True)


if __name__ == "__main__":
    # 1. 训练模型（需联网下载CIFAR-10演示数据）
    train_conditional_gan()

    # 2. 推理演示
    edit_age_demo()

使用说明

1. 环境准备：PyTorch + torchvision，下载CIFAR-10作为演示（实际应用请替换为人脸数据集）。

2. 训练：直接运行脚本，会自动下载CIFAR-10（仅用于演示结构），训练完成后保存模型。

3. 编辑年龄：运行推理函数 edit_age_demo()，会生成固定噪声下不同年龄的人脸图片，实现“编辑年龄”的效果。

再次基础上我提出更加严格的要求：要求生成人物身份不变，年龄从小到大的过渡图片，最终可以制作成视频进行播放的那种！

理论上完全可以，但这个模型实际效果会有明显局限。我可以明确告诉你：它能生成“从小到大变化的图片序列”（幻灯片），但很难做到“完美保持同一个人身份且过渡丝滑”的影院级视频。

1. 怎么做：利用“固定噪声+变年龄”生成序列

# 核心逻辑：固定身份，遍历年龄
z = torch.randn(1, z_dim, 1, 1, device=device)  # 这个z固定不变
for age in range(10):  # 0岁到9岁
    label = torch.tensor([age], device=device)
    img = gen(z, label)  # 生成该年龄下的图像
    save_image(img, f"age_{age}.png")

把这 10 张（或更多年龄段）图片按顺序拼接，用 OpenCV 或 FFmpeg 导出为 MP4，就能看到“一个人”的年龄变化过程。

2、存在一系列问题

• 身份漂移（Identity Shifting）：虽然 z 固定了，但标准 GAN 的潜在空间并没有完美解耦。改变年龄标签时，发型、脸型、甚至性别都可能跟着变，看起来不像同一个人。

• 跳跃感严重（Non-smooth）：模型只学了 10 个离散年龄段（0~9），直接切换标签会导致五官突然“跳变”，无法生成 18岁→18.5岁 这种细腻变化。

• 缺乏时序一致性：每一帧都是独立生成的，眼睛眨动、头部朝向可能忽左忽右，视频会有明显的闪烁（Flickering）。

3. 实战化升级（如何做到真正的细滑视频的建议）

4、图片生成视频的代码

import cv2
import numpy as np

def make_aging_video(generator, z, num_frames=100, fps=10):
    generator.eval()
    frames = []
    # 假设年龄从 0 到 90 岁（标签0~9，我们做插值平滑）
    for i in range(num_frames):
        # 连续年龄值映射到 0~9 之间的浮点数
        age_float = (i / num_frames) * 9.0  
        # 取最近的整数标签（如果想要更平滑，需要改模型为连续输入，这里暂且取整）
        age_label = torch.tensor([int(age_float)], device=device)
        
        with torch.no_grad():
            img_tensor = generator(z, age_label)
        # 转成 OpenCV 可读的 numpy 图像 (H,W,C) 范围 0~255
        img_np = (img_tensor.squeeze(0).permute(1,2,0).cpu().numpy() * 0.5 + 0.5) * 255
        img_np = np.clip(img_np, 0, 255).astype(np.uint8)
        img_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
        frames.append(img_bgr)
    
    # 保存视频
    height, width = frames[0].shape[:2]
    out = cv2.VideoWriter('aging_process.mp4', cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))
    for frame in frames:
        out.write(frame)
    out.release()
    print("视频已生成：aging_process.mp4")

# 调用（接在训练完成后）
z_fixed = torch.randn(1, z_dim, 1, 1, device=device)
make_aging_video(gen, z_fixed, num_frames=150, fps=15)

如果连续年龄回归，会更加的丝滑，接下来我们将修改一版连续年龄回归的代码，还是在这个的基础之上进行！

• 如果想交差/演示：直接用上面的代码生成视频，效果足够让人看懂“年龄在变”这个概念。

• 如果想发论文/做产品：必须放弃离散标签，改用连续年龄回归 + StyleGAN2 主干，并在训练时增加身份一致性损失（Identity Loss），比如用预训练的 ArcFace 提取人脸特征，约束不同年龄帧的特征向量尽量接近。

5、升级连续回归

import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torchvision.utils import save_image
import cv2
import numpy as np
import os

# ================== 自注意力模块（完全保留原样） ==================
class SelfAttention(nn.Module):
    def __init__(self, in_channels):
        super(SelfAttention, self).__init__()
        self.in_channels = in_channels
        self.query = nn.Conv2d(in_channels, in_channels // 8, kernel_size=1)
        self.key = nn.Conv2d(in_channels, in_channels // 8, kernel_size=1)
        self.value = nn.Conv2d(in_channels, in_channels, kernel_size=1)
        self.gamma = nn.Parameter(torch.zeros(1))
        self.softmax = nn.Softmax(dim=-1)

    def forward(self, x):
        B, C, W, H = x.size()
        query = self.query(x).view(B, -1, W*H).permute(0, 2, 1)
        key = self.key(x).view(B, -1, W*H)
        value = self.value(x).view(B, -1, W*H)
        attention = torch.bmm(query, key)
        attention = self.softmax(attention)
        out = torch.bmm(value, attention.permute(0, 2, 1))
        out = out.view(B, C, W, H)
        return self.gamma * out + x


# ================== 升级版：连续年龄生成器 ==================
class ContinuousGenerator(nn.Module):
    def __init__(self, z_dim, img_channels, features_g):
        super(ContinuousGenerator, self).__init__()
        self.z_dim = z_dim
        
        # 【改动1】将离散Embedding换为连续MLP：输入1维(年龄0~1)，输出z_dim维
        self.age_fc = nn.Sequential(
            nn.Linear(1, 128),
            nn.ReLU(True),
            nn.Linear(128, z_dim)
        )

        # 主网络输入通道 = z_dim(噪声) + z_dim(年龄编码)
        self.main = nn.Sequential(
            nn.ConvTranspose2d(z_dim + z_dim, features_g * 16, 4, 1, 0, bias=False),
            nn.BatchNorm2d(features_g * 16),
            nn.ReLU(True),

            nn.ConvTranspose2d(features_g * 16, features_g * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_g * 8),
            nn.ReLU(True),

            nn.ConvTranspose2d(features_g * 8, features_g * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_g * 4),
            nn.ReLU(True),
            SelfAttention(features_g * 4),  # 保留自注意力

            nn.ConvTranspose2d(features_g * 4, features_g * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_g * 2),
            nn.ReLU(True),

            nn.ConvTranspose2d(features_g * 2, features_g, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_g),
            nn.ReLU(True),
            SelfAttention(features_g),      # 保留自注意力

            nn.ConvTranspose2d(features_g, img_channels, 4, 2, 1, bias=False),
            nn.Tanh()
        )

    def forward(self, z, age):
        # z: (B, z_dim, 1, 1)
        # age: (B,) 或 (B,1)，范围归一化到 [0, 1]
        if age.dim() == 1:
            age = age.unsqueeze(1)  # (B, 1)
        
        age_emb = self.age_fc(age)                     # (B, z_dim)
        age_emb = age_emb.view(-1, self.z_dim, 1, 1)   # (B, z_dim, 1, 1)
        
        # 拼接噪声和年龄编码
        x = torch.cat([z, age_emb], dim=1)             # (B, 2*z_dim, 1, 1)
        return self.main(x)


# ================== 升级版：连续年龄判别器 ==================
class ContinuousDiscriminator(nn.Module):
    def __init__(self, img_channels, features_d, img_size=64):
        super(ContinuousDiscriminator, self).__init__()
        self.img_size = img_size
        
        # 【改动2】连续年龄映射为空间条件图（单通道）
        self.age_fc = nn.Sequential(
            nn.Linear(1, 32),
            nn.ReLU(True),
            nn.Linear(32, img_size * img_size)
        )

        # 输入通道 = 原图3通道 + 年龄条件图1通道 = 4
        self.main = nn.Sequential(
            nn.Conv2d(img_channels + 1, features_d, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(features_d, features_d * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_d * 2),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(features_d * 2, features_d * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_d * 4),
            nn.LeakyReLU(0.2, inplace=True),
            SelfAttention(features_d * 4),

            nn.Conv2d(features_d * 4, features_d * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_d * 8),
            nn.LeakyReLU(0.2, inplace=True),

            nn.Conv2d(features_d * 8, features_d * 16, 4, 2, 1, bias=False),
            nn.BatchNorm2d(features_d * 16),
            nn.LeakyReLU(0.2, inplace=True),
            SelfAttention(features_d * 16),

            nn.Conv2d(features_d * 16, 1, 4, 1, 0, bias=False),
            nn.Sigmoid()
        )

    def forward(self, img, age):
        # img: (B, 3, H, W)
        # age: (B,) 或 (B,1)，范围 [0, 1]
        if age.dim() == 1:
            age = age.unsqueeze(1)
            
        B = img.size(0)
        age_map = self.age_fc(age)                       # (B, H*W)
        age_map = age_map.view(B, 1, self.img_size, self.img_size)  # (B,1,H,W)
        
        # 将年龄条件图作为第4通道拼接到原图
        x = torch.cat([img, age_map], dim=1)             # (B, 4, H, W)
        return self.main(x)


# ================== 权重初始化（不变） ==================
def weights_init(m):
    classname = m.__class__.__name__
    if classname.find('Conv') != -1:
        nn.init.normal_(m.weight.data, 0.0, 0.02)
    elif classname.find('BatchNorm') != -1:
        nn.init.normal_(m.weight.data, 1.0, 0.02)
        nn.init.constant_(m.bias.data, 0)

训练模型的代码：训练代码（利用CIFAR-10演示，年龄取类别0~9归一化）

def train_continuous_gan():
    # 超参数
    z_dim = 100
    img_channels = 3
    features_g = 64
    features_d = 64
    img_size = 64
    batch_size = 64
    epochs = 30
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    # 初始化模型
    gen = ContinuousGenerator(z_dim, img_channels, features_g).to(device)
    disc = ContinuousDiscriminator(img_channels, features_d, img_size).to(device)
    gen.apply(weights_init)
    disc.apply(weights_init)

    opt_g = torch.optim.Adam(gen.parameters(), lr=0.0002, betas=(0.5, 0.999))
    opt_d = torch.optim.Adam(disc.parameters(), lr=0.0002, betas=(0.5, 0.999))
    criterion = nn.BCELoss()

    # 演示用CIFAR-10（将标签0~9归一化到0~1作为连续年龄）
    transform = transforms.Compose([
        transforms.Resize(img_size),
        transforms.CenterCrop(img_size),
        transforms.ToTensor(),
        transforms.Normalize([0.5]*3, [0.5]*3)
    ])
    dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=2)

    print("开始训练连续年龄GAN...")
    for epoch in range(epochs):
        for i, (imgs, labels) in enumerate(dataloader):
            real_imgs = imgs.to(device)
            # 【关键】将离散标签(0~9)归一化为连续年龄(0~1)
            age_labels = labels.float().to(device) / 9.0  # 范围 [0, 1]
            batch_size = real_imgs.size(0)

            real_labels = torch.ones(batch_size, 1, device=device)
            fake_labels = torch.zeros(batch_size, 1, device=device)

            # ---- 训练判别器 ----
            opt_d.zero_grad()
            real_validity = disc(real_imgs, age_labels)
            loss_real = criterion(real_validity, real_labels)

            z = torch.randn(batch_size, z_dim, 1, 1, device=device)
            fake_imgs = gen(z, age_labels)
            fake_validity = disc(fake_imgs.detach(), age_labels)
            loss_fake = criterion(fake_validity, fake_labels)

            loss_d = (loss_real + loss_fake) / 2
            loss_d.backward()
            opt_d.step()

            # ---- 训练生成器 ----
            opt_g.zero_grad()
            z = torch.randn(batch_size, z_dim, 1, 1, device=device)
            fake_imgs = gen(z, age_labels)
            validity = disc(fake_imgs, age_labels)
            loss_g = criterion(validity, real_labels)
            loss_g.backward()
            opt_g.step()

        print(f"Epoch [{epoch+1}/{epochs}] D_loss: {loss_d.item():.4f} G_loss: {loss_g.item():.4f}")

    torch.save(gen.state_dict(), "continuous_generator.pth")
    print("训练完成！")

6、生成100帧平滑年龄变化视频

由于输入是连续值，我们可以从 0.00 到 1.00 均匀采样 150 帧，生成丝滑的“变老”视频。

def make_smooth_aging_video(generator_path="continuous_generator.pth"):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    z_dim = 100
    img_channels = 3
    features_g = 64

    # 加载模型
    gen = ContinuousGenerator(z_dim, img_channels, features_g).to(device)
    gen.load_state_dict(torch.load(generator_path, map_location=device))
    gen.eval()

    # 固定一个随机身份（z固定）
    z_fixed = torch.randn(1, z_dim, 1, 1, device=device)
    
    frames = []
    num_frames = 150  # 帧数越多越丝滑
    fps = 15

    print("正在生成年龄变化视频帧...")
    for i in range(num_frames):
        # 年龄从 0.0 均匀递增到 1.0 (代表从幼年到老年)
        age_value = i / (num_frames - 1)
        age_tensor = torch.tensor([age_value], device=device)
        
        with torch.no_grad():
            img_tensor = gen(z_fixed, age_tensor)
        
        # 转成OpenCV图像格式
        img_np = (img_tensor.squeeze(0).permute(1, 2, 0).cpu().numpy() * 0.5 + 0.5) * 255
        img_np = np.clip(img_np, 0, 255).astype(np.uint8)
        img_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
        frames.append(img_bgr)

    # 保存为MP4
    height, width = frames[0].shape[:2]
    out = cv2.VideoWriter('smooth_aging.mp4', cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))
    for frame in frames:
        out.write(frame)
    out.release()
    print("视频已生成：smooth_aging.mp4 (150帧，年龄从0到1连续变化)")

为什么这样改更“实战”？