多变量时间序列生成模型GAN介绍与实现

1. 模型介绍

在大数据时代，生成逼真的时间序列数据对于负载平衡、负载预测和智能资源配置等方面至关重要。多变量时间序列数据生成模型基于生成对抗网络（GAN）的能力，能够在不泄露真实数据隐私的前提下生成相似的合成数据。本文介绍了一种用于生成多变量时间序列数据的GAN模型。

2. 问题提出

云和边缘计算领域的监控数据通常是商业机密或受到数据法规（如GDPR）的保护，获取真实数据用于研究和开发变得非常困难。为了应对这一挑战，研究人员使用合成数据来填补数据空缺。在这种背景下，多变量时间序列生成模型通过GAN的使用，为生成任意数量的时间序列工作负载数据提供了一种新方法。其目标是学习真实生产工作负载的概率分布，并生成统计上相似的时间序列数据。

3. 模型具体实现

3.1 数据预处理

• 数据格式化：将原始数据转换为所需格式。
• 样本过滤：过滤掉不完整的样本。
• 特征缩放：将特征缩放到定义范围内，通常为[0, 1]。
• 数据标准化：将样本适应到[0, 1]的范围内，加速梯度下降过程。

3.2 生成对抗网络（GAN）结构

GAN由两个人工神经网络组成：判别器（Discriminator）和生成器（Generator），通过最小最大博弈进行训练。

• 判别器（Discriminator, D）
  • 两层LSTM单元构成，最后一层为单个LSTM单元输出层，用于最终分类。
  • 输入形状为$n\times m$（$n$为时间步数，$m$为特征数）。

$$y=D(h_{\text{output}})$$

• 生成器（Generator, G）
  • 两层递归层，用高斯噪声初始化，最后连接一个全连接输出层。
  • 每个时间步对应一个输出单元。

$${\hat{h}}_S=g_S(z_S),{\hat{h}}_t=g_X({\hat{h}}_S,{\hat{h}}_{t-1},z_t)$$

• GAN目标
  • 判别器目标：区分真实和合成数据。
  • 生成器目标：生成判别器无法区分的合成数据。

3.3 模式崩溃解决

• 为不同分布的序列训练独立的GANs，避免模式崩溃。
• 使用自动化容器化工作流提高可重复性和可扩展性。

3.4 合成数据验证

• 描述性统计：均值和标准差用于评估数据的分布和趋势。
• 时间序列分析：计算时间序列的相关性和协整性。

4. 代码实现

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# 定义生成器网络
class Generator(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(Generator, self).__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers=2, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        # 确保 x 是三维的
        if x.dim() == 2:
            x = x.unsqueeze(1)  # 添加时间维度
        batch_size = x.size(0)
        h_0 = torch.zeros(2, batch_size, hidden_dim).to(x.device)
        c_0 = torch.zeros(2, batch_size, hidden_dim).to(x.device)
        out, _ = self.lstm(x, (h_0, c_0))
        out = self.fc(out[:, -1, :])  # 使用最后一个时间步的输出
        return out

# 定义判别器网络
class Discriminator(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super(Discriminator, self).__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers=2, batch_first=True)
        self.fc = nn.Linear(hidden_dim, 1)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        # 确保 x 是三维的
        if x.dim() == 2:
            x = x.unsqueeze(1)  # 添加时间维度
        batch_size = x.size(0)
        h_0 = torch.zeros(2, batch_size, hidden_dim).to(x.device)
        c_0 = torch.zeros(2, batch_size, hidden_dim).to(x.device)
        out, _ = self.lstm(x, (h_0, c_0))
        out = self.fc(out[:, -1, :])  # 使用最后一个时间步的输出
        out = self.sigmoid(out)
        return out

# 超参数设置
input_dim = 100  # 输入维度
hidden_dim = 64  # 隐藏层维度
output_dim = 100  # 输出维度
batch_size = 32
num_epochs = 1000
learning_rate = 0.0002

# 初始化生成器和判别器
generator = Generator(input_dim, hidden_dim, output_dim)
discriminator = Discriminator(output_dim, hidden_dim)

# 优化器
g_optimizer = optim.Adam(generator.parameters(), lr=learning_rate)
d_optimizer = optim.Adam(discriminator.parameters(), lr=learning_rate)

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

# 加载数据（使用随机数据进行示例）
real_data = torch.randn(1000, input_dim).unsqueeze(1)  # 确保输入是三维的
dataloader = DataLoader(real_data, batch_size=batch_size, shuffle=True)

# 训练GAN模型
for epoch in range(num_epochs):
    for real_samples in dataloader:
        # 训练判别器
        real_samples = real_samples.float()
        batch_size = real_samples.size(0)
        real_labels = torch.ones(batch_size, 1)
        fake_labels = torch.zeros(batch_size, 1)

        # 生成假的样本
        noise = torch.randn(batch_size, input_dim).unsqueeze(1)  # 确保噪声是三维的
        fake_samples = generator(noise)

        # 计算判别器损失
        d_real_loss = criterion(discriminator(real_samples), real_labels)
        d_fake_loss = criterion(discriminator(fake_samples.detach()), fake_labels)
        d_loss = d_real_loss + d_fake_loss

        d_optimizer.zero_grad()
        d_loss.backward()
        d_optimizer.step()

        # 训练生成器
        noise = torch.randn(batch_size, input_dim).unsqueeze(1)  # 确保噪声是三维的
        fake_samples = generator(noise)
        g_loss = criterion(discriminator(fake_samples), real_labels)

        g_optimizer.zero_grad()
        g_loss.backward()
        g_optimizer.step()

    # 打印损失
    if (epoch + 1) % 100 == 0:
        print(f'Epoch [{epoch + 1}/{num_epochs}], d_loss: {d_loss.item():.4f}, g_loss: {g_loss.item():.4f}')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

参考文献

[1] Leznik, M., Michalsky, P., Willis, P., Schanzel, B., Östberg, P., & Domaschka, J. (2021). Multivariate Time Series Synthesis Using Generative Adversarial Networks. In Proceedings of the 2021 ACM/SPEC International Conference on Performance Engineering (ICPE ’21), April 19–23, 2021, Virtual Event, France. ACM, New York, NY, USA, 8 pages. https://doi.org/10.1145/3427921.3450257

[2] Goodfellow, I., Pouget-Abadie, J., Mirza, M., Xu, B., Warde-Farley, D., Ozair, S., ... & Bengio, Y. (2014). Generative adversarial nets. Advances in neural information processing systems, 27.
1
2
3