Text-to-Imageモデル学習方法論完全ガイド: GANからFlow Matchingまで

[Text-to-Imageモデル進化タイムライン]

2014-2019          2017-2020          2020-2023              2023-現在
    |                  |                  |                      |
   GAN              VAE/VQ-VAE        Diffusion Models      Flow Matching
    |                  |                  |                  + DiT
    v                  v                  v                      v
 ┌──────────┐    ┌──────────┐    ┌────────────────┐    ┌──────────────┐
 │StackGAN  │    │ VQ-VAE   │    │ DDPM (2020)    │    │ SD3 (2024)   │
 │AttnGAN   │    │ VQ-VAE-2 │    │ DALL-E 2(2022) │    │ Flux (2024)  │
 │StyleGAN  │    │ dVAE     │    │ Imagen (2022)  │    │ Pixart-Sigma │
 │BigGAN    │    │          │    │ SD 1.x (2022)  │    │              │
 │GigaGAN   │    │          │    │ SDXL (2023)    │    │              │
 └──────────┘    └──────────┘    └────────────────┘    └──────────────┘

特徴:                特徴:              特徴:                   特徴:
- 敵対的           - 離散的         - 反復的             - 直線パス
  学習               潜在空間         ノイズ除去           - ODEベース
- モード崩壊       - コードブック     - Classifier-Free      - 少ステップ
  問題                学習             Guidance              - DiTバックボーン
- 高速生成               - 2段階        - 潜在空間              - スケーラブル
                      学習         - U-Netバックボーン

min_G max_D  V(D, G) = E_{x~p_data}[log D(x)] + E_{z~p_z}[log(1 - D(G(z)))]

- G (Generator): ランダムノイズzから画像を生成
- D (Discriminator): 実画像と生成画像を判別
- 学習目標: GはDを騙し、Dは正確に判別

# StyleGAN2コア学習ループ（簡略版）
for real_images, _ in dataloader:
    # 1. Discriminatorの学習
    z = torch.randn(batch_size, latent_dim)
    fake_images = generator(z)

    d_real = discriminator(real_images)
    d_fake = discriminator(fake_images.detach())

    d_loss = F.softplus(-d_real).mean() + F.softplus(d_fake).mean()

    # R1 Regularization（lazy: 16ステップごと）
    if step % 16 == 0:
        real_images.requires_grad = True
        d_real = discriminator(real_images)
        r1_grads = torch.autograd.grad(d_real.sum(), real_images)[0]
        r1_penalty = r1_grads.square().sum(dim=[1,2,3]).mean()
        d_loss += 10.0 * r1_penalty

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

    # 2. Generatorの学習
    z = torch.randn(batch_size, latent_dim)
    fake_images = generator(z)
    d_fake = discriminator(fake_images)
    g_loss = F.softplus(-d_fake).mean()

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

[VQ-VAEアーキテクチャ]

入力画像       Encoder      量子化        Decoder      再構成
  (256x256) --> [E(x)] --> z_e --> [Codebook] --> z_q --> [D(z_q)] --> 画像
                             |        |
                             |   ┌────┴────┐
                             |   │ e_1     │
                             |   │ e_2     │  K個のコードベクトル
                             └──>│ ...     │  (Codebook)
                                 │ e_K     │
                                 └─────────┘

  z_q = e_k  where k = argmin_j ||z_e - e_j||
  (最近傍コードベクトルに量子化)

L = ||x - D(z_q)||²                    # 再構成損失
  + ||sg[z_e] - e||²                   # Codebook損失（EMA更新で代替可能）
  + β * ||z_e - sg[e]||²              # Commitment損失

- sg[·]: Stop-gradient演算子
- β: Commitment損失の重み（通常0.25）
- z_e: Encoder出力
- e: 選択されたcodebookベクトル

# VQ-VAE Codebookコア学習コード
class VectorQuantizer(nn.Module):
    def __init__(self, num_embeddings, embedding_dim, commitment_cost=0.25):
        super().__init__()
        self.embedding = nn.Embedding(num_embeddings, embedding_dim)
        self.commitment_cost = commitment_cost

    def forward(self, z_e):
        # z_e: (B, D, H, W) -> (B*H*W, D)
        flat_z = z_e.permute(0, 2, 3, 1).reshape(-1, z_e.shape[1])

        # 最近傍コードブックベクトルを検索
        distances = (flat_z ** 2).sum(dim=1, keepdim=True) \
                  + (self.embedding.weight ** 2).sum(dim=1) \
                  - 2 * flat_z @ self.embedding.weight.t()
        indices = distances.argmin(dim=1)
        z_q = self.embedding(indices).view_as(z_e.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)

        # 損失の計算
        codebook_loss = F.mse_loss(z_q.detach(), z_e)      # commitment
        commitment_loss = F.mse_loss(z_q, z_e.detach())     # codebook
        loss = commitment_loss + self.commitment_cost * codebook_loss

        # Straight-Through Estimator
        z_q_st = z_e + (z_q - z_e).detach()
        return z_q_st, loss, indices

[VQ-VAE-2階層構造]

                    トップレベル（低解像度）
                    ┌─────────────┐
                    │  32x32 grid │  グローバル構造情報
                    │  Codebook   │  （構図、全体的な形状）
                    └──────┬──────┘
                           │
                    ボトムレベル（高解像度）
                    ┌──────┴──────┐
                    │  64x64 grid │  細部ディテール情報
                    │  Codebook   │  （テクスチャ、エッジ）
                    └─────────────┘

q(x_t | x_{t-1}) = N(x_t; √(1-β_t) * x_{t-1}, β_t * I)

- 各タイムステップtで少量のガウシアンノイズを追加
- β_t: ノイズスケジュール（通常linearまたはcosine）
- Tステップ後、x_T ≈ N(0, I)（純粋なガウシアンノイズ）

q(x_t | x_0) = N(x_t; √(ᾱ_t) * x_0, (1-ᾱ_t) * I)

where ᾱ_t = ∏_{s=1}^{t} α_s,  α_t = 1 - β_t

=> x_t = √(ᾱ_t) * x_0 + √(1-ᾱ_t) * ε,  ε ~ N(0, I)

p_θ(x_{t-1} | x_t) = N(x_{t-1}; μ_θ(x_t, t), σ_t² * I)

- ニューラルネットワークε_θがx_tに加えられたノイズεを予測
- 予測されたノイズを除去してx_{t-1}を復元

L_simple = E_{t, x_0, ε} [ ||ε - ε_θ(x_t, t)||² ]

- t ~ Uniform(1, T)
- ε ~ N(0, I)
- x_t = √(ᾱ_t) * x_0 + √(1-ᾱ_t) * ε

# DDPMコア学習ループ
def train_step(model, x_0, noise_scheduler):
    batch_size = x_0.shape[0]

    # 1. ランダムタイムステップサンプリング
    t = torch.randint(0, num_timesteps, (batch_size,))

    # 2. ノイズサンプリング
    noise = torch.randn_like(x_0)

    # 3. 順方向プロセス: x_tを生成
    alpha_bar_t = noise_scheduler.alpha_bar[t]
    x_t = torch.sqrt(alpha_bar_t) * x_0 + torch.sqrt(1 - alpha_bar_t) * noise

    # 4. ノイズ予測
    noise_pred = model(x_t, t)

    # 5. 損失計算（MSE）
    loss = F.mse_loss(noise_pred, noise)

    return loss

# Cosine Scheduleの実装
def cosine_beta_schedule(timesteps, s=0.008):
    steps = timesteps + 1
    x = torch.linspace(0, timesteps, steps)
    alphas_cumprod = torch.cos(((x / timesteps) + s) / (1 + s) * math.pi * 0.5) ** 2
    alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
    betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])
    return torch.clip(betas, 0.0001, 0.9999)

# EDM Noise Schedule（Karras et al., 2022）
def edm_sigma_schedule(num_steps, sigma_min=0.002, sigma_max=80.0, rho=7.0):
    step_indices = torch.arange(num_steps)
    t_steps = (sigma_max ** (1/rho) + step_indices / (num_steps - 1)
               * (sigma_min ** (1/rho) - sigma_max ** (1/rho))) ** rho
    return t_steps

[Latent Diffusion Modelアーキテクチャ]

                          Text Prompt
                              │
                         ┌────┴────┐
                         │  CLIP   │
                         │ Encoder │
                         └────┬────┘
                              │ text embeddings
                              │
┌──────┐    ┌──────┐    ┌─────┴──────┐    ┌──────┐    ┌──────┐
│Image │    │ VAE  │    │   U-Net    │    │ VAE  │    │Output│
│(512  │--->│Encode│--->│ (Denoising │--->│Decode│--->│Image │
│x512) │    │  r   │    │  in Latent │    │  r   │    │(512  │
│      │    │      │    │   Space)   │    │      │    │x512) │
└──────┘    └──────┘    └────────────┘    └──────┘    └──────┘
              │                                 │
              │  64x64x4                        │
              │  (8xダウンサンプリング)           │
              └─────────────────────────────────┘
                    潜在空間 (z)

学習: 潜在空間でのDiffusion
推論: ランダムノイズz_T -> U-Net Denoising -> VAE Decode -> 画像

# Latent Diffusionコア学習
class LatentDiffusionTrainer:
    def __init__(self, vae, unet, text_encoder, noise_scheduler):
        self.vae = vae              # 凍結
        self.unet = unet            # 学習可能
        self.text_encoder = text_encoder  # 凍結
        self.noise_scheduler = noise_scheduler

    def train_step(self, images, captions):
        # 1. VAEで潜在エンコーディング（勾配不要）
        with torch.no_grad():
            latents = self.vae.encode(images).latent_dist.sample()
            latents = latents * self.vae.config.scaling_factor  # 0.18215

        # 2. テキスト埋め込み（勾配不要）
        with torch.no_grad():
            text_embeddings = self.text_encoder(captions)

        # 3. ノイズ追加
        noise = torch.randn_like(latents)
        timesteps = torch.randint(0, 1000, (latents.shape[0],))
        noisy_latents = self.noise_scheduler.add_noise(latents, noise, timesteps)

        # 4. ノイズ予測
        noise_pred = self.unet(noisy_latents, timesteps, text_embeddings)

        # 5. MSE損失
        loss = F.mse_loss(noise_pred, noise)
        return loss

[Cross-Attention付きU-Netの構造]

入力z_t ─────────────────────────────────────────── 出力ε_θ
    │                                                     ▲
    ▼                                                     │
┌────────┐  ┌────────┐  ┌────────┐      ┌────────┐  ┌────────┐
│ Down   │  │ Down   │  │ Down   │      │  Up    │  │  Up    │
│ Block  │──│ Block  │──│ Block  │──┐   │ Block  │──│ Block  │
│ 64x64  │  │ 32x32  │  │ 16x16  │  │   │ 32x32  │  │ 64x64  │
└────────┘  └────────┘  └────────┘  │   └────────┘  └────────┘
    │            │            │     │        ▲           ▲
    │            │            │     ▼        │           │
    │            │            │  ┌────────┐  │           │
    │            │            └──│ Middle │──┘           │
    │            │               │ Block  │              │
    │            │               │ 16x16  │              │
    │            └───────────────└────────┘──────────────┘
    │                    (skip connections)
    └────────────────────────────────────────────────────┘

各ブロックの内部構造:
┌──────────────────────────────────────┐
│  ResNet Block                         │
│  ├── GroupNorm → SiLU → Conv         │
│  ├── Timestep Embedding注入          │
│  └── GroupNorm → SiLU → Conv         │
│                                       │
│  Self-Attention Block                 │
│  ├── LayerNorm → Self-Attention      │
│  └── Skip Connection                  │
│                                       │
│  Cross-Attention Block                │
│  ├── LayerNorm                        │
│  ├── Q = Linear(潜在特徴)            │
│  ├── K = Linear(テキスト埋め込み)    │  ← テキスト条件付け
│  ├── V = Linear(テキスト埋め込み)    │
│  └── Attention(Q, K, V)             │
│                                       │
│  Feed-Forward Block                   │
│  ├── LayerNorm → Linear → GEGLU     │
│  └── Linear → Skip Connection        │
└──────────────────────────────────────┘

学習時:
  - 確率p_uncond（例: 10%）: ε_θ(x_t, t, ∅)  (無条件)
  - 確率1-p_uncond:          ε_θ(x_t, t, c)  (条件付き)

推論時:
  ε_guided = ε_θ(x_t, t, ∅) + w * (ε_θ(x_t, t, c) - ε_θ(x_t, t, ∅))

  - w: guidance scale（通常7.5～15）
  - w=1: 条件付き予測そのまま
  - w>1: テキスト条件の方向により強く移動

# Classifier-Free Guidance学習の実装
def train_step_cfg(model, x_0, text_cond, p_uncond=0.1):
    noise = torch.randn_like(x_0)
    t = torch.randint(0, T, (x_0.shape[0],))
    x_t = add_noise(x_0, noise, t)

    # ランダムに条件付けをドロップ
    mask = torch.rand(x_0.shape[0]) < p_uncond
    cond = text_cond.clone()
    cond[mask] = empty_text_embedding  # null conditioning

    noise_pred = model(x_t, t, cond)
    loss = F.mse_loss(noise_pred, noise)
    return loss

# Classifier-Free Guidance推論
def sample_cfg(model, x_T, text_cond, guidance_scale=7.5):
    x_t = x_T
    for t in reversed(range(T)):
        # 無条件予測
        eps_uncond = model(x_t, t, empty_text_embedding)
        # 条件付き予測
        eps_cond = model(x_t, t, text_cond)
        # ガイド付き予測
        eps = eps_uncond + guidance_scale * (eps_cond - eps_uncond)
        x_t = denoise_step(x_t, eps, t)
    return x_t

[DALL-E 2学習パイプライン]

Text ──→ CLIP Text Encoder ──→ text embedding
                                    │
                              ┌─────┴─────┐
                              │   Prior    │  text emb → CLIP image emb
                              │ (Diffusion)│
                              └─────┬─────┘
                                    │ CLIP image embedding
                              ┌─────┴─────┐
                              │  Decoder   │  CLIP image emb → 64x64画像
                              │ (Diffusion)│
                              └─────┬─────┘
                                    │ 64x64
                              ┌─────┴─────┐
                              │ Super-Res  │  64x64 → 256x256 → 1024x1024
                              │ (Diffusion)│
                              └─────────── ┘

[Imagenアーキテクチャ]

Text ──→ T5-XXL（凍結）──→ text embeddings
                                    │
                              ┌─────┴─────┐
                              │ Base Model │  64x64生成
                              │  (U-Net)   │  cross-attention
                              └─────┬─────┘
                                    │
                              ┌─────┴─────┐
                              │ SR Model 1 │  64x64 → 256x256
                              │  (U-Net)   │
                              └─────┬─────┘
                                    │
                              ┌─────┴─────┐
                              │ SR Model 2 │  256x256 → 1024x1024
                              │  (U-Net)   │
                              └─────────── ┘

[DiTブロックの構造]

     入力トークン（パッチ化された潜在表現）
           │
    ┌──────┴──────┐
    │  LayerNorm  │ ← adaLN-Zero（適応的）
    │  (adaptive) │   γ, β = MLP(timestep + class)
    └──────┬──────┘
           │
    ┌──────┴──────┐
    │    Self-     │
    │  Attention   │
    └──────┬──────┘
           │ (+ residual)
    ┌──────┴──────┐
    │  LayerNorm  │ ← adaLN-Zero
    │  (adaptive) │
    └──────┬──────┘
           │
    ┌──────┴──────┐
    │ Pointwise   │
    │    FFN      │
    └──────┬──────┘
           │ (+ residual, αでスケーリング)
           ▼
     出力トークン

[DALL-E学習パイプライン]

Stage 1: dVAE学習
  Image (256x256) ──→ dVAE Encoder ──→ 32x32グリッドのトークン（8192語彙）
                                           ──→ dVAE Decoder ──→ 再構成画像

  Loss: 再構成 + KLダイバージェンス（Gumbel-Softmax緩和）

Stage 2: Autoregressive Transformer学習
  [BPEテキストトークン (256)] + [画像トークン (1024)] = 1280トークン

  Transformer（120億パラメータ）:
  - 64層、62アテンションヘッド
  - 学習目的: next-token prediction（クロスエントロピー）
  - テキストトークンはcausal attention（左→右）
  - 画像トークンはrow-major orderで自己回帰生成
  - テキスト→画像のcross-attentionを含む

[Diffusion vs Flow Matching比較]

Diffusion（確率的）:              Flow Matching（決定論的）:
  x_0 ~~~> x_T                         x_0 ──────> x_1
  （曲線パス、多くのステップが必要）              （直線パス、少ないステップで可能）

  x₀ •                                x₀ •
     \  曲線                              \  直線
      \    パス                            \    パス
       \                                    \
        \                                    \
     x_T •                              x₁ •  (= ノイズ)

dx = f(x,t)dt + g(t)dW              dx/dt = v_θ(x_t, t)
（SDEベース）                         （ODEベース、velocity field学習）

L_FM = E_{t, x_0, x_1} [ ||v_θ(x_t, t) - u_t(x_t | x_0, x_1)||² ]

where:
  x_t = (1 - t) * x_0 + t * x_1      （線形補間）
  u_t = x_1 - x_0                      （目標速度: 直線パス）
  t ~ Uniform(0, 1)                    （またはlogit-normal）
  x_0 ~ p_data（実データ）
  x_1 ~ N(0, I)（ガウシアンノイズ）

# Rectified Flowコア学習
def rectified_flow_train_step(model, x_0, x_1=None):
    """
    x_0: 実データ（潜在表現）
    x_1: ノイズ（Noneの場合はランダムサンプリング）
    """
    if x_1 is None:
        x_1 = torch.randn_like(x_0)

    # 時間サンプリング（SD3ではlogit-normal）
    t = torch.sigmoid(torch.randn(x_0.shape[0]))  # logit-normal
    t = t.view(-1, 1, 1, 1)

    # 線形補間
    x_t = (1 - t) * x_0 + t * x_1

    # 目標速度（直線方向）
    target_v = x_1 - x_0

    # 速度予測
    v_pred = model(x_t, t)

    # 損失
    loss = F.mse_loss(v_pred, target_v)
    return loss

# SD3のLogit-Normalタイムステップサンプリング
def logit_normal_sampling(batch_size, m=0.0, s=1.0):
    """中間タイムステップにより大きな重みを付与"""
    u = torch.randn(batch_size) * s + m
    t = torch.sigmoid(u)  # (0, 1)範囲
    return t

[MM-DiTブロック]

  画像トークン           テキストトークン
       │                     │
  ┌────┴────┐          ┌────┴────┐
  │adaLN(t) │          │adaLN(t) │
  └────┬────┘          └────┬────┘
       │                     │
       └──────┬──────────────┘
              │ (concatenate)
       ┌──────┴──────┐
       │ Joint Self- │  画像-テキストトークンが
       │  Attention  │     相互にattend
       └──────┬──────┘
              │ (split)
       ┌──────┴──────────────┐
       │                     │
  ┌────┴────┐          ┌────┴────┐
  │   FFN   │          │   FFN   │
  │ (image) │          │ (text)  │
  └────┬────┘          └────┬────┘
       │                     │
  画像出力              テキスト出力

[CLIP学習プロセス]

  Image ──→ Image Encoder ──→ image embedding ─┐
                                                 ├─ cosine similarity
  Text  ──→ Text Encoder  ──→ text embedding  ─┘

  学習目的: マッチするペアの類似度を上げ、マッチしないペアの類似度を下げる
  (InfoNCE Loss)

# Cross-Attentionの実装
class CrossAttention(nn.Module):
    def __init__(self, d_model, d_context, n_heads):
        super().__init__()
        self.n_heads = n_heads
        self.d_head = d_model // n_heads

        self.to_q = nn.Linear(d_model, d_model, bias=False)      # 潜在 → Q
        self.to_k = nn.Linear(d_context, d_model, bias=False)     # テキスト → K
        self.to_v = nn.Linear(d_context, d_model, bias=False)     # テキスト → V
        self.to_out = nn.Linear(d_model, d_model)

    def forward(self, x, context):
        """
        x: (B, H*W, d_model) - 画像潜在特徴
        context: (B, seq_len, d_context) - テキスト埋め込み
        """
        q = self.to_q(x)          # 画像がQuery
        k = self.to_k(context)    # テキストがKey
        v = self.to_v(context)    # テキストがValue

        # Multi-headリシェイプ
        q = q.view(B, -1, self.n_heads, self.d_head).transpose(1, 2)
        k = k.view(B, -1, self.n_heads, self.d_head).transpose(1, 2)
        v = v.view(B, -1, self.n_heads, self.d_head).transpose(1, 2)

        # Attention
        attn = (q @ k.transpose(-2, -1)) / math.sqrt(self.d_head)
        attn = F.softmax(attn, dim=-1)
        out = attn @ v

        out = out.transpose(1, 2).reshape(B, -1, d_model)
        return self.to_out(out)

[テキスト埋め込みの種類]

Text: "a photo of a cat"
         │
    ┌────┴────┐
    │  Text   │
    │ Encoder │
    └────┬────┘
         │
    ┌────┴──────────────────────┐
    │                           │
    ▼                           ▼
 Sequence Embeddings         Pooled Embedding
 (トークンレベル)              (文レベル)
 [h_1, h_2, ..., h_n]       h_pool = h_[EOS]
 Shape: (seq_len, d)         Shape: (d,)
    │                           │
    │                           │
    ▼                           ▼
 Cross-Attentionに使用       グローバル条件付けに使用
 (詳細なトークン別情報)       (文全体の意味)
                              - Timestep embeddingに加算
                              - adaLNパラメータ調整
                              - Vector conditioning

# SDXLテキスト条件付け
def get_sdxl_text_embeddings(text, clip_l, clip_g):
    # CLIP ViT-L: sequence embeddings (77, 768)
    clip_l_output = clip_l(text)
    clip_l_seq = clip_l_output.last_hidden_state      # (77, 768)
    clip_l_pooled = clip_l_output.pooler_output        # (768,)

    # OpenCLIP ViT-bigG: sequence embeddings (77, 1280)
    clip_g_output = clip_g(text)
    clip_g_seq = clip_g_output.last_hidden_state       # (77, 1280)
    clip_g_pooled = clip_g_output.pooler_output        # (1280,)

    # sequence embeddingsを連結 -> Cross-Attentionに使用
    text_embeddings = torch.cat([clip_l_seq, clip_g_seq], dim=-1)  # (77, 2048)

    # pooled embeddingsを連結 -> Vector conditioningに使用
    pooled_embeddings = torch.cat([clip_l_pooled, clip_g_pooled], dim=-1)  # (2048,)

    return text_embeddings, pooled_embeddings

[LAION-5Bデータ収集・フィルタリングパイプライン]

Common Crawl（ウェブアーカイブ）
        │
        ▼
1. HTMLパース: <img>タグからsrc URL + alt-textを抽出
        │
        ▼
2. 画像ダウンロード（img2dataset）
   - 最小解像度フィルタ: width, height ≥ 64
   - 最大アスペクト比: 3:1
        │
        ▼
3. CLIP類似度フィルタリング
   - OpenAI CLIP ViT-B/32でimage-text similarityを計算
   - 英語: cosine similarity ≥ 0.28
   - その他の言語: cosine similarity ≥ 0.26
        │
        ▼
4. 安全性フィルタリング
   - NSFW検出スコア（CLIPベース）
   - ウォーターマーク検出スコア
   - 有害コンテンツ検出
        │
        ▼
5. 重複除去（deduplication）
   - ハッシュベースの完全重複除去
   - CLIP embeddingベースの近似重複除去
        │
        ▼
最終: 58.5億画像-テキストペア
 - 23.2億 英語
 - 22.6億 その他100以上の言語
 - 12.7億 言語未確認

# CLIPスコア計算
from transformers import CLIPModel, CLIPProcessor
model = CLIPModel.from_pretrained("openai/clip-vit-large-patch14")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14")

inputs = processor(text=[caption], images=[image], return_tensors="pt")
outputs = model(**inputs)
clip_score = outputs.logits_per_image.item() / 100.0  # 正規化

[DALL-E 3キャプション改善の効果]

改善前: "cat on table"
      -> 曖昧で詳細情報が不足

改善後: "A fluffy orange tabby cat sitting on a round wooden
       dining table, natural sunlight streaming through a
       window behind, casting soft shadows. The cat has
       bright green eyes and is looking directly at the camera."
      -> 詳細な属性、空間関係、照明情報を含む

[LoRAの原理]

元の重み:  W_0 ∈ R^{d×k}  （固定、凍結）
LoRA更新: ΔW = B × A      where A ∈ R^{r×k}, B ∈ R^{d×r}

最終出力: h = W_0 x + ΔW x = W_0 x + B(Ax)

- r << min(d, k): 低ランク（通常4, 8, 16, 32, 64）
- 学習パラメータ: AとBのみ（全体に比べて非常に少ない）
- 元の重みは固定 → メモリ効率が良い

# LoRA適用例（Stable Diffusion U-Net attentionレイヤー）
class LoRALinear(nn.Module):
    def __init__(self, original_layer, rank=4, alpha=1.0):
        super().__init__()
        self.original = original_layer  # 凍結
        in_features = original_layer.in_features
        out_features = original_layer.out_features

        # LoRAレイヤー
        self.lora_A = nn.Linear(in_features, rank, bias=False)
        self.lora_B = nn.Linear(rank, out_features, bias=False)
        self.scale = alpha / rank

        # 初期化
        nn.init.kaiming_uniform_(self.lora_A.weight)
        nn.init.zeros_(self.lora_B.weight)  # Bを0で初期化 -> 開始時はオリジナルと同一

    def forward(self, x):
        original_out = self.original(x)        # 凍結されたオリジナル出力
        lora_out = self.lora_B(self.lora_A(x)) # LoRA更新
        return original_out + self.scale * lora_out

# Diffusers LoRA学習実行例
accelerate launch train_text_to_image_lora.py \
  --pretrained_model_name_or_path="stabilityai/stable-diffusion-xl-base-1.0" \
  --dataset_name="lambdalabs/naruto-blip-captions" \
  --resolution=1024 \
  --train_batch_size=1 \
  --gradient_accumulation_steps=4 \
  --max_train_steps=15000 \
  --learning_rate=1e-04 \
  --lr_scheduler="cosine" \
  --lr_warmup_steps=0 \
  --rank=4 \
  --mixed_precision="fp16" \
  --output_dir="./sdxl-naruto-lora"

[DreamBooth学習プロセス]

入力: 特定被写体の3-5枚の画像 + 固有識別子 "[V]"
      例: "a [V] dog"（特定の犬）

学習戦略:
1. 被写体画像でモデルをファインチューニング
   - "a [V] dog" → 該当犬の画像

2. Prior Preservation Loss（重要！）
   - 元のモデルで事前に"a dog"画像を生成
   - ファインチューニング中に一般的な犬の生成能力を保持
   - 言語ドリフトの防止

L = L_recon([V] images) + λ * L_prior(class images)

# DreamBooth + LoRA学習（推奨の組み合わせ）
# diffusersライブラリベース
accelerate launch train_dreambooth_lora.py \
  --pretrained_model_name_or_path="stabilityai/stable-diffusion-xl-base-1.0" \
  --instance_data_dir="./my_dog_images" \
  --instance_prompt="a photo of sks dog" \
  --class_data_dir="./class_dog_images" \
  --class_prompt="a photo of dog" \
  --with_prior_preservation \
  --prior_loss_weight=1.0 \
  --num_class_images=200 \
  --resolution=1024 \
  --train_batch_size=1 \
  --gradient_accumulation_steps=1 \
  --learning_rate=1e-4 \
  --lr_scheduler="constant" \
  --max_train_steps=500 \
  --rank=4 \
  --mixed_precision="fp16"

[Textual Inversion]

既存のトークン空間:  [cat] [dog] [car] [tree] ...
                                  │
新しいトークンを追加:           [S*] 学習する新しいコンセプト
                                  │
学習: 3-5枚の画像で[S*]の埋め込みベクトルのみを最適化
モデル全体は凍結

利点: 最小限のパラメータ（1トークン = 768または1024個のfloat）
欠点: LoRA/DreamBoothより表現力が低い

[ControlNetアーキテクチャ]

                   制御入力（例: Cannyエッジ）
                          │
                    ┌─────┴─────┐
                    │  Zero     │
                    │  Conv     │
                    └─────┬─────┘
                          │
                    ┌─────┴─────┐
ロックされたU-Net    │ 学習可能   │  U-Net Encoderのコピー
（オリジナル固定）    │  Copy of  │     （学習可能）
    │               │ U-Net Enc │
    │               └─────┬─────┘
    │                     │
    │               ┌─────┴─────┐
    │               │  Zero     │  学習開始時に出力が0
    │               │  Conv     │     （オリジナルモデルに影響を与えずに開始）
    │               └─────┬─────┘
    │                     │
    └─────── + ───────────┘  オリジナルU-Netの特徴に加算
                  │
              最終出力

# Zero Convolution: 重みとバイアスを0で初期化
class ZeroConv(nn.Module):
    def __init__(self, in_channels, out_channels):
        super().__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, 1)
        nn.init.zeros_(self.conv.weight)
        nn.init.zeros_(self.conv.bias)

    def forward(self, x):
        return self.conv(x)

# 学習開始時: zero conv出力 = 0
# -> ControlNetを追加してもオリジナルモデルの出力に影響なし
# -> 学習が進むにつれて徐々に制御信号を反映

[IP-Adapterアーキテクチャ]

参照画像 ──→ CLIP Image Encoder ──→ image features
                                               │
                                         ┌─────┴─────┐
                                         │ Projection │  学習可能
                                         │   Layer    │
                                         └─────┬─────┘
                                               │
                                         ┌─────┴─────┐
                                         │ Decoupled │  独立したcross-attention
                                         │ Cross-Attn │    （テキストcross-attnと分離）
                                         └─────┬─────┘
                                               │
オリジナルU-Net Cross-Attention ────── + ───────┘
（テキスト条件付け）

出力 = Text_CrossAttn(Q, K_text, V_text) + λ * Image_CrossAttn(Q, K_img, V_img)

[Consistency Modelsの核心アイデア]

Diffusion: x_T → x_{T-1} → ... → x_1 → x_0  （数百ステップ）

Consistency:
  PF-ODE軌道上のすべての点x_tが
  同一のx_0にマッピングされるように学習

  f_θ(x_t, t) = x_0  ∀t ∈ [0, T]

  重要な制約: f_θ(x_0, 0) = x_0（自己整合性）

     x_T ────→ f_θ ────→ x_0
      │                    ↑
     x_t ────→ f_θ ───────┘  （同じx_0にマッピング！）
      │                    ↑
    x_t' ────→ f_θ ───────┘

[PixArt-alpha 3段階学習]

Stage 1: ピクセル依存性の学習（低コスト）
  - ImageNet事前学習済みDiTから開始
  - クラス条件付き → T2I移行の基礎

Stage 2: テキスト-画像アラインメントの学習
  - Cross-attentionでテキスト条件を注入
  - LLaVAで生成した高品質合成キャプションを使用

Stage 3: 高品質美的学習
  - 高品質美的データセットでファインチューニング
  - JourneyDBなどを活用

総学習コスト: 約675 A100 GPU days
（SD 1.5の約6,250 A100 GPU daysの10.8%）

[Stable Diffusion世代別系譜]

SD 1.x (2022)     SDXL (2023)       SD3 (2024)         Flux (2024)
    │                  │                │                   │
  U-Net 860M       U-Net 2.6B      MM-DiT 2-8B        MM-DiT 約12B
    │                  │                │                   │
  CLIP ViT-L       CLIP-L +          CLIP-L +            CLIP-L +
                   OpenCLIP-G        OpenCLIP-G +        OpenCLIP-G +
                                     T5-XXL               T5-XXL
    │                  │                │                   │
  Diffusion        Diffusion        Rectified            Rectified
  (DDPM)           (DDPM)           Flow                 Flow
    │                  │                │                   │
  512x512          1024x1024        1024x1024            1024x1024+
    │                  │                │                   │
  CFG 7.5          CFG 5-9          CFG 3.5-7            Guidance
                                                         Distillation

# EDMフレームワーク（Karras et al., 2022）
# σ(t)ベースのノイズスケジュール - Zero Terminal SNRを保証
# 従来のSDのlinear scheduleに比べ色彩/コントラストが大幅に改善

def edm_precondition(sigma, x_noisy, F_theta):
    """EDM Preconditioning"""
    c_skip = 1.0 / (sigma ** 2 + 1)
    c_out = sigma / (sigma ** 2 + 1).sqrt()
    c_in = 1.0 / (sigma ** 2 + 1).sqrt()
    c_noise = sigma.log() / 4

    D_x = c_skip * x_noisy + c_out * F_theta(c_in * x_noisy, c_noise)
    return D_x

[大規模分散学習構成]

┌─────────────────────────────────────────────────────┐
│                  Data Parallel (DP/DDP)               │
│                                                       │
│  GPU 0        GPU 1        GPU 2        GPU 3        │
│  ┌──────┐    ┌──────┐    ┌──────┐    ┌──────┐       │
│  │Full  │    │Full  │    │Full  │    │Full  │       │
│  │Model │    │Model │    │Model │    │Model │       │
│  │Copy  │    │Copy  │    │Copy  │    │Copy  │       │
│  └──────┘    └──────┘    └──────┘    └──────┘       │
│  Batch 1     Batch 2     Batch 3     Batch 4        │
│                                                       │
│  -> All-Reduceで勾配を同期                            │
│  -> 各GPUで異なるデータバッチ                          │
└─────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────┐
│              FSDP (Fully Sharded Data Parallel)       │
│                                                       │
│  GPU 0        GPU 1        GPU 2        GPU 3        │
│  ┌──────┐    ┌──────┐    ┌──────┐    ┌──────┐       │
│  │Shard │    │Shard │    │Shard │    │Shard │       │
│  │ 1/4  │    │ 2/4  │    │ 3/4  │    │ 4/4  │       │
│  └──────┘    └──────┘    └──────┘    └──────┘       │
│                                                       │
│  -> モデルパラメータをGPU間で分割                      │
│  -> Forward/Backward時に必要なシャードのみをAll-Gather  │
│  -> メモリ効率を最大化（8B以上のモデル学習が可能）      │
└─────────────────────────────────────────────────────┘

# DiffusersベースのText-to-Imageフル学習パイプライン
from diffusers import AutoencoderKL, UNet2DConditionModel, DDPMScheduler
from transformers import CLIPTextModel, CLIPTokenizer
from accelerate import Accelerator
import torch

# 1. モデルの読み込み
vae = AutoencoderKL.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", subfolder="vae"
)
unet = UNet2DConditionModel.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", subfolder="unet"
)
text_encoder = CLIPTextModel.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", subfolder="text_encoder"
)
tokenizer = CLIPTokenizer.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", subfolder="tokenizer"
)
noise_scheduler = DDPMScheduler.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", subfolder="scheduler"
)

# 2. VAEとText Encoderを凍結
vae.requires_grad_(False)
text_encoder.requires_grad_(False)

# 3. Acceleratorセットアップ（分散学習 + Mixed Precision）
accelerator = Accelerator(
    mixed_precision="fp16",          # または "bf16"
    gradient_accumulation_steps=4,
)

# 4. オプティマイザ
optimizer = torch.optim.AdamW(
    unet.parameters(),
    lr=1e-4,
    betas=(0.9, 0.999),
    weight_decay=1e-2,
    eps=1e-8,
)

# 5. EMAセットアップ
from diffusers.training_utils import EMAModel
ema_unet = EMAModel(
    unet.parameters(),
    decay=0.9999,
    use_ema_warmup=True,
)

# 6. 分散学習の準備
unet, optimizer, dataloader = accelerator.prepare(unet, optimizer, dataloader)

# 7. 学習ループ
for epoch in range(num_epochs):
    for batch in dataloader:
        with accelerator.accumulate(unet):
            images = batch["images"]
            captions = batch["captions"]

            # 潜在エンコーディング
            with torch.no_grad():
                latents = vae.encode(images).latent_dist.sample()
                latents = latents * vae.config.scaling_factor

            # テキストエンコーディング
            with torch.no_grad():
                text_inputs = tokenizer(captions, padding="max_length",
                                       max_length=77, return_tensors="pt")
                text_embeds = text_encoder(text_inputs.input_ids)[0]

            # ノイズ追加
            noise = torch.randn_like(latents)
            timesteps = torch.randint(0, 1000, (latents.shape[0],))
            noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)

            # Classifier-Free Guidance: ランダムキャプションドロップアウト
            if torch.rand(1) < 0.1:  # 10%の確率でunconditional
                text_embeds = torch.zeros_like(text_embeds)

            # ノイズ予測
            noise_pred = unet(noisy_latents, timesteps, text_embeds).sample

            # 損失計算
            loss = F.mse_loss(noise_pred, noise)

            # バックワード
            accelerator.backward(loss)
            accelerator.clip_grad_norm_(unet.parameters(), 1.0)
            optimizer.step()
            optimizer.zero_grad()

            # EMA更新
            ema_unet.step(unet.parameters())

[Mixed Precision学習]

Forward Pass:
  - モデル重み: FP16/BF16（メモリ半減）
  - アクティベーション: FP16/BF16

Loss Scaling:
  - 勾配のアンダーフローを防ぐため、損失に大きなスケール（例: 2^16）を乗算
  - バックワード後に勾配を再スケールダウン

Backward Pass:
  - 勾配: FP16/BF16

Optimizer Step:
  - マスター重み: FP32（精度を維持！）
  - FP32マスター重みを更新後、FP16コピーを作成

# BF16 Mixed Precision設定（accelerateベース）
# accelerate config (YAML)
compute_environment: LOCAL_MACHINE
distributed_type: MULTI_GPU
mixed_precision: bf16
num_machines: 1
num_processes: 8

[EMA更新]

θ_ema ← λ * θ_ema + (1 - λ) * θ_model

- λ: 減衰率（通常0.9999～0.99999）
- θ_model: 現在学習中のモデル重み
- θ_ema: EMA重み（推論時に使用）
- 効果: 勾配ノイズを平滑化し、より安定した重みを得る

# Diffusers EMAの実装
from diffusers.training_utils import EMAModel

# EMAモデルの作成
ema_model = EMAModel(
    unet.parameters(),
    decay=0.9999,              # 減衰率
    use_ema_warmup=True,       # ウォームアップ使用
    inv_gamma=1.0,             # ウォームアップパラメータ
    power=3/4,                 # ウォームアップパラメータ
)

# 学習ステップごとに更新
ema_model.step(unet.parameters())

# 推論時にEMA重みを適用
ema_model.copy_to(unet.parameters())

# またはコンテキストマネージャを使用
with ema_model.average_parameters():
    # このブロック内ではEMA重みが使用される
    output = unet(noisy_latents, timesteps, text_embeds)

[T2I学習方法論の進化]

効率性:  フル学習 ──→ LoRA/Adapter ──→ Prompt Tuning
         （数ヶ月、$1M以上）  （数分、$1未満）      （数秒）

アーキテクチャ: U-Net ────────→ DiT ─────────→ MM-DiT + Flow Matching
          (SD 1.x-SDXL)    (DiT, PixArt)   (SD3, Flux)

生成速度: 50-1000ステップ ──→ 20-50ステップ ──→ 1-4ステップ
           (DDPM)            (DDIM, DPM++)   (LCM, LADD, CM)

データ品質: ウェブクロール ──→ フィルタリング ──→ 合成キャプション
            (LAION raw)    (aesthetic)  (DALL-E 3方式)

テキスト理解: CLIPのみ ──→ CLIP + T5 ──→ トリプルエンコーダ
             (SD 1.x)     (Imagen)      (SD3, Flux)