📌 JAX로 Time-Series GAN(TSGAN) 구현 - 현실감 있는 시계열 데이터 생성하기

📌 JAX로 Time-Series GAN(TSGAN) 구현 - 현실감 있는 시계열 데이터 생성하기

---

🚀 왜 시계열 GAN이 필요한가?

현실 세계에서는 시계열 데이터가 적거나 불균형한 경우가 많습니다.
예를 들어:

• 센서 오작동 상황이 적게 기록됨
• 이상 데이터 수집이 제한적
• 고가의 측정 비용 등

**시계열 GAN(Time-Series GAN, TSGAN)**은 이러한 문제를 해결하기 위해
실제와 유사한 새로운 시계열 데이터를 생성할 수 있는 강력한 도구입니다.

---

💡 1. TSGAN 구조

구성 요소 역할

Generator (G)	랜덤 노이즈를 받아서 시계열을 생성
Discriminator (D)	시계열이 진짜인지(GT) 가짜인지(G에서 생성) 판별
Loss	G는 D를 속이도록 학습, D는 G를 판별하도록 학습

---

🧱 2. 구현 개요 (JAX + Flax)

• 생성자: LSTM 기반 시계열 생성 네트워크
• 판별자: 시계열을 보고 진짜/가짜 여부를 분류
• 입력 데이터: 센서 또는 금융 시계열 (윈도우형 데이터)

---

💾 3. 시계열 데이터 전처리

import pandas as pd
import jax.numpy as jnp
from sklearn.preprocessing import MinMaxScaler

# 예시: 시계열 데이터 불러오기
df = pd.read_csv("sensor_data.csv")  # 'value' 열 포함 가정
data = df['value'].values.reshape(-1, 1)

# 정규화
scaler = MinMaxScaler()
data_scaled = scaler.fit_transform(data)

# 윈도우화
def make_windows(data, window=30):
    X = []
    for i in range(len(data) - window):
        X.append(data[i:i+window])
    return jnp.array(X)

real_data = make_windows(data_scaled)  # shape: (samples, 30, 1)

---

🧠 4. 모델 정의 - Generator / Discriminator

반응형

🧬 Generator

from flax import linen as nn

class Generator(nn.Module):
    hidden_size: int = 64
    seq_len: int = 30

    @nn.compact
    def __call__(self, z):  # z: (batch, latent_dim)
        x = nn.Dense(self.hidden_size)(z)
        x = nn.relu(x)
        x = nn.Dense(self.seq_len * 1)(x)  # output: (batch, 30*1)
        x = x.reshape((z.shape[0], self.seq_len, 1))
        return x

🔍 Discriminator

class Discriminator(nn.Module):
    hidden_size: int = 64

    @nn.compact
    def __call__(self, x):  # x: (batch, 30, 1)
        x = x.reshape((x.shape[0], -1))  # flatten
        x = nn.Dense(self.hidden_size)(x)
        x = nn.leaky_relu(x, 0.2)
        x = nn.Dense(1)(x)
        return x

---

⚙️ 5. 학습 초기화

import optax
from flax.training import train_state
import jax
import jax.random as random

gen = Generator()
dis = Discriminator()
key = random.PRNGKey(0)

latent_dim = 20
batch_input = jnp.ones((1, latent_dim))
real_input = jnp.ones((1, 30, 1))

gen_params = gen.init(key, batch_input)
dis_params = dis.init(key, real_input)

gen_tx = optax.adam(1e-4)
dis_tx = optax.adam(1e-4)

gen_state = train_state.TrainState.create(apply_fn=gen.apply, params=gen_params, tx=gen_tx)
dis_state = train_state.TrainState.create(apply_fn=dis.apply, params=dis_params, tx=dis_tx)

---

📉 6. 손실 함수 정의 (GAN 방식)

def discriminator_loss_fn(dis_params, real, fake):
    real_logits = dis.apply(dis_params, real)
    fake_logits = dis.apply(dis_params, fake)
    loss = -jnp.mean(jnp.log(jax.nn.sigmoid(real_logits)) + jnp.log(1 - jax.nn.sigmoid(fake_logits)))
    return loss

def generator_loss_fn(gen_params, dis_params, z):
    fake = gen.apply(gen_params, z)
    fake_logits = dis.apply(dis_params, fake)
    loss = -jnp.mean(jnp.log(jax.nn.sigmoid(fake_logits)))
    return loss

---

🏃 7. 학습 루프

@jax.jit
def train_step(gen_state, dis_state, real_batch, key):
    z = random.normal(key, (real_batch.shape[0], latent_dim))

    # Generator 손실
    g_loss, g_grads = jax.value_and_grad(generator_loss_fn)(gen_state.params, dis_state.params, z)
    gen_state = gen_state.apply_gradients(grads=g_grads)

    # Discriminator 손실
    fake_data = gen.apply(gen_state.params, z)
    d_loss, d_grads = jax.value_and_grad(discriminator_loss_fn)(dis_state.params, real_batch, fake_data)
    dis_state = dis_state.apply_gradients(grads=d_grads)

    return gen_state, dis_state, g_loss, d_loss

---

🧪 8. 학습 실행

batch_size = 64
epochs = 100

for epoch in range(epochs):
    for i in range(0, len(real_data), batch_size):
        real_batch = real_data[i:i+batch_size]
        key, subkey = random.split(key)
        gen_state, dis_state, g_loss, d_loss = train_step(gen_state, dis_state, real_batch, subkey)
    print(f"Epoch {epoch+1} | G Loss: {g_loss:.4f} | D Loss: {d_loss:.4f}")

---

🎨 9. 시계열 데이터 생성 및 시각화

def generate_samples(gen_state, num_samples=10):
    z = random.normal(key, (num_samples, latent_dim))
    fake = gen.apply(gen_state.params, z)
    return fake

import matplotlib.pyplot as plt

samples = generate_samples(gen_state, 5)

plt.figure(figsize=(12, 4))
for i, seq in enumerate(samples):
    plt.plot(seq.squeeze(), label=f"Sample {i+1}")
plt.title("Generated Time-Series Samples (TSGAN)")
plt.legend()
plt.show()

---

✅ 10. TSGAN 활용 아이디어

응용 분야 설명

데이터 증강	이상 상황 재현 데이터 생성
GAN-based 이상 탐지	생성자가 학습하지 못한 시계열은 이상치로 간주
시뮬레이션 시스템	센서, 환경 변수, 사용량 데이터 생성

---

📌 다음 글 예고: JAX로 시계열 + 조건부 GAN (cGAN) 구현 - 조건 기반 시계열 생성

다음 글에서는 **조건부 GAN(Conditional GAN)**을 사용해
"센서 상태가 좋을 때의 시계열", "주가 상승 구간 예측" 등
조건을 주어 가짜 시계열을 제어하는 방법을 배웁니다.

---

 

JAX, GAN, 시계열 생성, TSGAN, 딥러닝, Flax, 고속 연산, Anomaly Detection, 센서 시계열, 시계열 데이터 증강, Generative Model, Autoencoder, Time-Series Forecasting, JAX 예제, Python GAN, 시계열 딥러닝