1D CGAN实战指南：从零构建一维条件生成对抗网络

1次阅读

共计 4293 个字符，预计需要花费 11 分钟才能阅读完成。

在金融时序预测、医疗信号合成、物联网设备仿真等领域，我们常遇到这样的需求：根据特定条件（如股票板块、患者年龄、设备型号）生成符合真实规律的时序数据。传统方法依赖复杂的手工建模，而 1D CGAN 通过对抗训练自动学习数据分布，能生成带有条件属性的逼真一维序列。

普通 GAN 的生成器输入是随机噪声，而 CGAN 在生成器和判别器中都添加了条件信息（通常以嵌入向量的形式）。这种设计带来两个核心变化：

生成器输入 ：噪声向量 z 与条件标签 y 拼接（concat）或投影相加（projection）
判别器输入 ：真实 / 生成数据 x 与条件标签 y 在特征层面融合

以 PyTorch 为例，条件嵌入的典型实现方式如下：

# 条件嵌入层（标签类别数 -> 隐层维度）self.label_embedding = nn.Embedding(num_classes, embedding_dim)

# 在生成器中融合条件信息
embedded_label = self.label_embedding(y).view(-1, embedding_dim, 1)
noise_with_label = torch.cat([noise, embedded_label], dim=1)

使用转置卷积（ConvTranspose1d）实现上采样
每层后接 BatchNorm 和 LeakyReLU
输出层用 Tanh 将值域约束到 [-1,1]

class Generator(nn.Module):
    def __init__(self, latent_dim, num_classes, seq_len):
        super().__init__()
        self.label_embed = nn.Embedding(num_classes, latent_dim)

        self.model = nn.Sequential(# 输入: (latent_dim*2, 1)
            nn.ConvTranspose1d(latent_dim*2, 256, 4, stride=2, padding=1),
            nn.BatchNorm1d(256),
            nn.LeakyReLU(0.2),

            # 输出序列长度逐步加倍
            nn.ConvTranspose1d(256, 128, 4, stride=2, padding=1),
            nn.BatchNorm1d(128),
            nn.LeakyReLU(0.2),

            nn.ConvTranspose1d(128, 64, 4, stride=2, padding=1),
            nn.BatchNorm1d(64),
            nn.LeakyReLU(0.2),

            # 最终输出 1 通道时序数据
            nn.ConvTranspose1d(64, 1, 4, stride=2, padding=1),
            nn.Tanh())

    def forward(self, noise, labels):
        # 标签嵌入并调整维度
        label_embed = self.label_embed(labels).unsqueeze(2)  # (bs, latent_dim, 1)

        # 拼接噪声和条件向量
        gen_input = torch.cat([noise, label_embed], dim=1)

        return self.model(gen_input)

使用普通卷积（Conv1d）实现下采样
标签信息通过特征图拼接引入
输出层用 Sigmoid 做二分类

class Discriminator(nn.Module):
    def __init__(self, num_classes, seq_len):
        super().__init__()
        self.label_embed = nn.Embedding(num_classes, seq_len)

        self.model = nn.Sequential(# 输入通道数 2 ( 数据 + 条件)
            nn.Conv1d(2, 64, 4, stride=2, padding=1),
            nn.LeakyReLU(0.2),

            nn.Conv1d(64, 128, 4, stride=2, padding=1),
            nn.BatchNorm1d(128),
            nn.LeakyReLU(0.2),

            nn.Conv1d(128, 256, 4, stride=2, padding=1),
            nn.BatchNorm1d(256),
            nn.LeakyReLU(0.2),

            nn.Conv1d(256, 1, 4, stride=2, padding=1),
            nn.Sigmoid())

    def forward(self, x, labels):
        # 将标签扩展为与数据相同的形状
        label_embed = self.label_embed(labels).unsqueeze(1)  # (bs, 1, seq_len)

        # 在通道维度拼接
        d_input = torch.cat([x, label_embed], dim=1)

        return self.model(d_input).view(-1, 1)

模式崩溃（生成单一输出）
增加噪声维度（latent_dim 从 64 提升到 256）
在判别器中使用 Mini-batch Discrimination
尝试 Wasserstein GAN（WGAN）架构
梯度消失（判别器过强）
控制判别器更新频率（gen:dis = 2:1）
改用 Hinge Loss 替代 BCELoss
添加梯度惩罚（GP）项
条件控制失效
检查标签嵌入维度是否足够（建议 >= 噪声维度 1 /4）
在判别器损失中增加条件匹配惩罚项

# 初始化模型
generator = Generator(latent_dim=100, num_classes=10, seq_len=128).to(device)
discriminator = Discriminator(num_classes=10, seq_len=128).to(device)

# 使用带梯度惩罚的优化器
opt_g = torch.optim.Adam(generator.parameters(), lr=2e-4, betas=(0.5, 0.999))
opt_d = torch.optim.Adam(discriminator.parameters(), lr=2e-4, betas=(0.5, 0.999))

for epoch in range(epochs):
    for real_data, labels in dataloader:
        # 训练判别器
        noise = torch.randn(real_data.size(0), 100, 1, device=device)
        fake_data = generator(noise, labels)

        real_loss = discriminator(real_data, labels)
        fake_loss = discriminator(fake_data.detach(), labels)

        # 梯度惩罚计算（WGAN-GP）alpha = torch.rand(real_data.size(0), 1, 1, device=device)
        interpolates = (alpha * real_data + (1-alpha) * fake_data).requires_grad_(True)
        d_interpolates = discriminator(interpolates, labels)

        gradients = torch.autograd.grad(
            outputs=d_interpolates,
            inputs=interpolates,
            grad_outputs=torch.ones_like(d_interpolates),
            create_graph=True,
            retain_graph=True
        )[0]

        gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
        d_loss = -torch.mean(real_loss) + torch.mean(fake_loss) + 10 * gradient_penalty

        opt_d.zero_grad()
        d_loss.backward()
        opt_d.step()

        # 每 5 步更新一次生成器
        if step % 5 == 0:
            g_loss = -torch.mean(discriminator(fake_data, labels))
            opt_g.zero_grad()
            g_loss.backward()
            opt_g.step()

对于一维数据，我们需要先将时序信号转换为频谱图再计算 FID：

def calculate_fid(real_signals, fake_signals, n_fft=64):
    """
    计算时序信号的 FID 分数
    参数:
        real_signals: 真实信号 [num_samples, seq_len]
        fake_signals: 生成信号 [num_samples, seq_len]
        n_fft: STFT 变换点数
    """
    # 转换为频谱特征
    real_spec = torch.stft(real_signals, n_fft, return_complex=True).abs()
    fake_spec = torch.stft(fake_signals, n_fft, return_complex=True).abs()

    # 计算均值和协方差
    mu1, sigma1 = real_spec.mean(0), torch.cov(real_spec)
    mu2, sigma2 = fake_spec.mean(0), torch.cov(fake_spec)

    # FID 计算
    diff = mu1 - mu2
    covmean = torch.sqrt(sigma1 @ sigma2)

    fid = diff.dot(diff) + torch.trace(sigma1 + sigma2 - 2*covmean)
    return fid.item()