HunyuanVideoとLTX-2の完全分析：オープンソース動画生成モデルのアーキテクチャ・性能・実践ガイド

[AI動画生成モデルの発展タイムライン]

2024 Q1-Q2          2024 Q3-Q4          2025 Q1-Q2          2025 Q3-Q4          2026 Q1
    |                   |                   |                   |                   |
    v                   v                   v                   v                   v
 Sora Preview       HunyuanVideo        Wan 2.1             HunyuanVideo 1.5    LTX-2 Open
 Runway Gen-3       CogVideoX           LTX-Video 1.0       Wan 2.2 (MoE)      Wan 2.6
 Pika 1.0           Kling 1.0           Mochi 1             LTX-2 Preview      Veo 3.1
                    Mochi Preview                            Sora 2

[オープンソース vs 商用モデルの競争]

商用:         Sora --> Sora 2 --> Veo 3.1 --> Kling 3.5
                 \       \           \           \
                  \       \           \           v
オープンソース: CogVideoX -> HunyuanVideo -> Wan 2.1 -> LTX-2
                 \           \           \           \
                  v           v           v           v
             品質格差:     格差縮小:    同等:       逆転:
             商用が優位    急速な       ベンチマーク 速度/アクセス
                           追い上げ     同等        で優位

[HunyuanVideoの入出力パイプライン]

Text-to-Video:
  "A golden retriever running       +----------+     +--------+
   through a sunlit meadow"  -----> | Hunyuan  | --> | Video  |
                                    | Video    |     | Output |
Image-to-Video:                     | Pipeline |     | (MP4)  |
  [入力画像] + プロンプト    -----> |          | --> |        |
                                    +----------+     +--------+
                                         |
                                    MLLM Encoder
                                    3D VAE
                                    DiT Denoiser

[HunyuanVideo 全体アーキテクチャ図]

                    テキストプロンプト
                         |
                         v
                  +-------------+
                  | MLLM Text   |
                  |   Encoder   |
                  | (Decoder-   |
                  |  Only LLM)  |
                  +------+------+
                         |
                  テキストトークン（双方向リファイナー付き）
                         |
                         v
+--------+    +---------------------+    +--------+
| ガウス  | -> | Dual-Stream to      | -> | 脱ノイズ|
| ノイズ  |    | Single-Stream DiT   |    | 結果   |
+--------+    |                     |    +---+----+
              | [Dualフェーズ]       |        |
              |  - 動画トークン      |        v
              |  - テキストトークン   |  +----------+
              |  (独立処理)          |  | 3D VAE   |
              |                     |  | Decoder  |
              | [Singleフェーズ]     |  +----+-----+
              |  - 結合 & 融合       |       |
              +---------------------+       v
                                      最終動画

# Dual-Streamフェーズの疑似コード
class DualStreamBlock(nn.Module):
    def __init__(self, dim, num_heads):
        self.video_attn = MultiHeadAttention(dim, num_heads)
        self.text_attn = MultiHeadAttention(dim, num_heads)
        self.video_ffn = FeedForward(dim)
        self.text_ffn = FeedForward(dim)
        self.video_norm = AdaLayerNorm(dim)
        self.text_norm = AdaLayerNorm(dim)

    def forward(self, video_tokens, text_tokens, timestep):
        # 独立した動画トークン処理
        video_tokens = self.video_norm(video_tokens, timestep)
        video_tokens = video_tokens + self.video_attn(video_tokens)
        video_tokens = video_tokens + self.video_ffn(video_tokens)

        # 独立したテキストトークン処理
        text_tokens = self.text_norm(text_tokens, timestep)
        text_tokens = text_tokens + self.text_attn(text_tokens)
        text_tokens = text_tokens + self.text_ffn(text_tokens)

        return video_tokens, text_tokens

# Single-Streamフェーズの疑似コード
class SingleStreamBlock(nn.Module):
    def __init__(self, dim, num_heads):
        self.attn = MultiHeadAttention(dim, num_heads)
        self.ffn = FeedForward(dim)
        self.norm = AdaLayerNorm(dim)

    def forward(self, video_tokens, text_tokens, timestep):
        # 動画 + テキストトークンを結合
        combined = torch.cat([video_tokens, text_tokens], dim=1)

        # 統合処理（Full Attention）
        combined = self.norm(combined, timestep)
        combined = combined + self.attn(combined)
        combined = combined + self.ffn(combined)

        # 分割して返却
        video_out = combined[:, :video_tokens.shape[1]]
        text_out = combined[:, video_tokens.shape[1]:]

        return video_out, text_out

入力動画:     720 x 1280 x 129フレーム x 3チャネル
              = ~3億5,600万要素

潜在表現:     90 x 160 x 33 x 16チャネル
              = ~760万要素

圧縮比:       ~47:1（要素数ベース）

[テキストエンコーディングパイプライン]

テキストプロンプト
     |
     v
+----------+     +--------------+     +------------------+
| MLLM     | --> | 双方向       | --> | 最終テキスト     |
| (因果的  |     | トークン     |     | 埋め込み         |
|  Attn)   |     | リファイナー |     | (DiT条件)        |
+----------+     +--------------+     +------------------+
  豊かな          双方向の              拡散に最適化された
  セマンティクス  コンテキスト強化      テキスト表現

# Flow Matching学習の疑似コード
def flow_matching_loss(model, x_0, text_cond):
    """
    x_0: 元の動画潜在表現
    text_cond: テキスト条件
    """
    # ランダムな時間ステップのサンプリング
    t = torch.rand(x_0.shape[0], device=x_0.device)

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

    # 線形補間による中間状態
    x_t = (1 - t) * x_0 + t * noise

    # 目標ベクトル場: ノイズの方向
    target = noise - x_0

    # モデルのベクトル場予測
    predicted = model(x_t, t, text_cond)

    # ロス計算
    loss = F.mse_loss(predicted, target)
    return loss

# HunyuanVideoオリジナルモデル（13B）
pip install huggingface_hub
huggingface-cli download tencent/HunyuanVideo --local-dir ./HunyuanVideo

# HunyuanVideo 1.5（8.3B、軽量版）
huggingface-cli download tencent/HunyuanVideo-1.5 --local-dir ./HunyuanVideo-1.5

# Image-to-Videoモデル
huggingface-cli download tencent/HunyuanVideo-I2V --local-dir ./HunyuanVideo-I2V

import torch
from diffusers import HunyuanVideoPipeline, HunyuanVideoTransformer3DModel
from diffusers.utils import export_to_video

# モデルのロード
model_id = "tencent/HunyuanVideo"
transformer = HunyuanVideoTransformer3DModel.from_pretrained(
    model_id,
    subfolder="transformer",
    torch_dtype=torch.bfloat16,
)
pipe = HunyuanVideoPipeline.from_pretrained(
    model_id,
    transformer=transformer,
    torch_dtype=torch.float16,
)
pipe.vae.enable_tiling()
pipe.to("cuda")

# 動画生成
output = pipe(
    prompt="A cat walks on the grass, realistic style, natural lighting",
    height=720,
    width=1280,
    num_frames=129,
    num_inference_steps=30,
    guidance_scale=6.0,
).frames[0]

# 動画の保存
export_to_video(output, "hunyuan_output.mp4", fps=24)

import torch
from diffusers import HunyuanVideoPipeline, HunyuanVideoTransformer3DModel
from diffusers.utils import export_to_video
from transformers import BitsAndBytesConfig

# INT4量子化設定
quant_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_quant_type="nf4",
)

# 量子化されたTransformerのロード
transformer = HunyuanVideoTransformer3DModel.from_pretrained(
    "tencent/HunyuanVideo",
    subfolder="transformer",
    quantization_config=quant_config,
)

pipe = HunyuanVideoPipeline.from_pretrained(
    "tencent/HunyuanVideo",
    transformer=transformer,
    torch_dtype=torch.float16,
)
pipe.vae.enable_tiling()

# 追加のVRAM節約のためのCPUオフロード
pipe.enable_model_cpu_offload()

output = pipe(
    prompt="A beautiful sunset over the ocean, cinematic",
    height=544,
    width=960,
    num_frames=65,
    num_inference_steps=30,
    guidance_scale=6.0,
).frames[0]

export_to_video(output, "quantized_output.mp4", fps=24)

[生成速度の比較（5秒の動画）]

モデル              生成時間     リアルタイム比
LTX-Video 1.0:    ~2秒         2.5倍速い
LTX-2:            ~3-5秒       ~リアルタイム
HunyuanVideo:     ~2-5分       60倍遅い
CogVideoX:        ~3-8分       100倍遅い
Mochi:            ~5-10分      120倍遅い

（H100 GPU、768x512解像度）

[LTX-2 全体アーキテクチャ]

テキストプロンプト
     |
     v
+-------------+
| Text Encoder |  (Gemmaベース)
| + Prompt     |
|   Enhancer   |
+------+------+
       |
       v
+------------------------------------------+
|        非対称デュアルストリームDiT          |
|                                          |
|  +------------------+  +-------------+   |
|  | 動画ストリーム    |  | 音声ストリーム|  |
|  | (広いチャネル、   |  | (狭い、     |   |
|  |  高容量)          |  |  軽量)      |   |
|  +--------+---------+  +------+------+   |
|           |      Cross-Attention  |       |
|           +----------+-----------+       |
+------------------------------------------+
       |                    |
       v                    v
+-------------+      +-------------+
| Video VAE   |      | Audio VAE   |
| Decoder     |      | Decoder     |
| (3D時空間)  |      | (1D時間)    |
+------+------+      +------+------+
       |                    |
       v                    v
   動画出力             音声出力
       |                    |
       +--------+-----------+
                |
                v
         最終AV出力（MP4）

# 1. Python環境（3.10以上を推奨）
conda create -n ltx2 python=3.10
conda activate ltx2

# 2. 公式LTX-2パッケージのインストール
pip install ltx-pipelines

# 3. またはソースからインストール
git clone https://github.com/Lightricks/LTX-2.git
cd LTX-2
pip install -e "packages/ltx-pipelines[all]"
pip install -e "packages/ltx-core[all]"

# 4. モデル重みのダウンロード
huggingface-cli download Lightricks/LTX-2 --local-dir ./models/ltx2

from ltx_pipelines import TI2VidTwoStagesPipeline

# パイプラインの初期化
pipe = TI2VidTwoStagesPipeline.from_pretrained(
    "Lightricks/LTX-2",
    device_map="auto",
    enable_fp8=True,  # FP8でVRAM節約
)

# 動画生成
result = pipe(
    prompt="A serene mountain lake at sunrise, mist rising from the water, "
           "birds flying overhead, cinematic quality",
    negative_prompt="blurry, low quality, distorted",
    height=704,
    width=1216,
    num_frames=121,
    frame_rate=24,
    num_inference_steps=30,
    cfg_guidance_scale=7.5,
    seed=42,
    enhance_prompt=True,  # 自動プロンプト拡張
)

# 保存
result.save("ltx2_output.mp4")

from ltx_pipelines import TI2VidTwoStagesPipeline
from PIL import Image

pipe = TI2VidTwoStagesPipeline.from_pretrained(
    "Lightricks/LTX-2",
    device_map="auto",
    enable_fp8=True,
)

# 入力画像のロード
input_image = Image.open("input_photo.jpg")

# I2V生成
result = pipe(
    prompt="The scene comes alive with gentle wind blowing through the trees",
    images=[input_image],
    height=704,
    width=1216,
    num_frames=121,
    frame_rate=24,
    num_inference_steps=30,
    cfg_guidance_scale=7.5,
    seed=42,
)

result.save("ltx2_i2v_output.mp4")

[シナリオ別推奨モデル]

「最高品質の動画が必要」
  --> HunyuanVideo（v1、13B）
  理由: Full Attention + 13Bで最高の視覚品質

「コンシューマーGPUでローカル実行したい」
  --> LTX-2（FP8）またはHunyuanVideo 1.5
  理由: LTX-2は12GBで動作、HV 1.5は14GBで動作

「高速な反復作業が必要」
  --> LTX-2（蒸留版）
  理由: ほぼリアルタイムの生成速度

「音声付きの動画が必要」
  --> LTX-2
  理由: 音声-動画の同時生成が可能な唯一のモデル

「特定のキャラクター/スタイルを学習したい」
  --> HunyuanVideo + LoRA
  理由: 豊富なLoRAエコシステム

「4K高解像度が必要」
  --> LTX-2
  理由: ネイティブ4Kサポート

「人物/顔の生成が重要」
  --> HunyuanVideo
  理由: 優秀なHuman Fidelityベンチマーク

[Subject] + [Action] + [Environment] + [Camera/Cinematography]

S（Subject）:      主体 - 何が/誰がメインか
A（Action）:       動作 - 何が起きているか
E（Environment）:  環境 - どこで、どんな雰囲気か
C（Camera）:       カメラ - どう撮影されているか

# 基本的な品質制御
"blurry, low quality, distorted, deformed, ugly, bad anatomy,
watermark, text overlay, logo, grainy, noisy"

# 人物生成時の追加
"extra fingers, mutated hands, poorly drawn hands, poorly drawn face,
mutation, deformed, extra limbs, missing limbs"