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    |     | 출력    |
Image-to-Video:                     | Pipeline |     | (MP4)  |
  [입력 이미지] + 프롬프트   -----> |          | --> |        |
                                    +----------+     +--------+
                                         |
                                    MLLM 인코더
                                    3D VAE
                                    DiT Denoiser

[HunyuanVideo 전체 아키텍처 다이어그램]

                    텍스트 프롬프트
                         |
                         v
                  +-------------+
                  | MLLM 텍스트 |
                  |   인코더    |
                  | (Decoder-   |
                  |  Only LLM)  |
                  +------+------+
                         |
                  텍스트 토큰 (bidirectional refiner 적용)
                         |
                         v
+--------+    +---------------------+    +--------+
| 가우시안 | -> | Dual-Stream to      | -> | 디노이즈 |
| 노이즈  |    | Single-Stream DiT   |    |  결과   |
+--------+    |                     |    +---+----+
              | [Dual Phase]        |        |
              |  - Video Tokens     |        v
              |  - Text Tokens      |  +----------+
              |  (독립 처리)         |  | 3D VAE   |
              |                     |  | Decoder  |
              | [Single Phase]      |  +----+-----+
              |  - Concat & Fuse    |       |
              +---------------------+       v
                                      최종 비디오

# Dual-Stream Phase 의사 코드
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 Phase 의사 코드
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 frames x 3 channels
                = 약 356M 값

잠재 표현:      90 x 160 x 33 x 16 channels
                = 약 7.6M 값

압축비:         약 47:1 (전체 원소 기준)

[3D VAE 압축 과정 시각화]

입력 비디오 (720x1280x129)
        |
        v
  +------------------+
  | Encoder          |
  | - Spatial Down   |  Block 1-3: 공간 다운샘플링 (8x)
  |   (8x reduction) |  log2(8) = 3 블록
  |                  |
  | - Temporal Down  |  Block 4: 시간 다운샘플링 (4x)
  |   (4x reduction) |  log2(4) = 2 블록
  |                  |
  | - Channel Map    |  3ch -> 16ch latent
  +------------------+
        |
        v
  잠재 표현 (90x160x33x16)
        |
        v
  +------------------+
  | Decoder          |
  | - Temporal Up    |
  | - Spatial Up     |
  | - Channel Map    |  16ch -> 3ch RGB
  +------------------+
        |
        v
  복원된 비디오 (720x1280x129)

[텍스트 인코딩 파이프라인]

텍스트 프롬프트
     |
     v
+----------+     +--------------+     +------------------+
| MLLM     | --> | Bidirectional| --> | 최종 텍스트 임베딩 |
| (Causal  |     | Token        |     | (DiT 조건으로 사용)|
|  Attn)   |     | Refiner      |     |                  |
+----------+     +--------------+     +------------------+
  풍부한            양방향 문맥           디퓨전 최적화된
  의미 추출          보강                 텍스트 표현

# Flow Matching 학습 의사 코드
def flow_matching_loss(model, x_0, text_cond):
    """
    x_0: 원본 비디오 latent
    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

[Unified Image-Video 학습]

이미지 데이터:  [Frame 1] ---------> 1 프레임 비디오로 처리
                    |
비디오 데이터:  [Frame 1][Frame 2]...[Frame N] -> N 프레임 비디오
                    |
                    v
            동일한 3D VAE + DiT 파이프라인

장점:
- 이미지 데이터의 풍부한 시각적 지식 활용
- 비디오 데이터의 시간적 동역학 학습
- 단일 모델로 이미지/비디오 모두 생성 가능

[데이터 큐레이션 파이프라인]

원시 데이터 수집
     |
     v
+------------------+
| 1. 기본 필터링    |  - 해상도, 길이, 비트레이트 기준
|    (Basic Filter) |  - 워터마크/로고 감지
+------------------+
     |
     v
+------------------+
| 2. 미적 품질 평가  |  - LAION Aesthetic Score
|    (Aesthetic)    |  - 프레임별 품질 점수
+------------------+
     |
     v
+------------------+
| 3. 모션 품질 평가  |  - 광학 흐름(Optical Flow) 분석
|    (Motion)       |  - 모션 스무스니스 점수
+------------------+
     |
     v
+------------------+
| 4. 텍스트 캡션 생성|  - MLLM 기반 자동 캡셔닝
|    (Captioning)   |  - 상세 설명 + 짧은 설명
+------------------+
     |
     v
+------------------+
| 5. 중복 제거      |  - 의미적 유사도 기반
|    (Dedup)        |  - 해싱 기반 중복 제거
+------------------+
     |
     v
  최종 학습 데이터셋

[Progressive Training 시각화]

Stage 1          Stage 2          Stage 3          Stage 4
256x256          512x512          960x544          1280x720
17 frames        33 frames        65 frames        129 frames

+----+           +--------+       +------------+   +----------------+
|    |           |        |       |            |   |                |
|    |           |        |       |            |   |                |
+----+           |        |       |            |   |                |
                 +--------+       +------------+   +----------------+

기본 개념 -----> 디테일 -------> 고해상도 ------> 최종 품질
                               적응               미세조정

[VBench-2.0 차원별 성능 비교 (상대적 강점)]

                    HunyuanVideo    Sora         Kling 1.6     CogVideoX-1.5
Human Fidelity     ████████████    ████████████  ████████      ██████
Motion Rationality ████████████    ████████████  ██████████    ██████
Controllability    ██████          ████████      ████████████  ██████████
Physics/Common     ████████        ██████        ██████████    ████████
Camera Control     ████████        ████████      ████████████  ██████████
Prompt Adherence   ██████████      ██████████    ████████████  ████████████

# 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 HunyuanVideo15Pipeline
from diffusers.utils import export_to_video

model_id = "hunyuanvideo-community/HunyuanVideo-1.5-480p_t2v"
pipe = HunyuanVideo15Pipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
)
pipe.vae.enable_tiling()
pipe.to("cuda")

output = pipe(
    prompt="A cat walks on the grass, realistic",
    num_inference_steps=50,
).frames[0]

export_to_video(output, "output_1_5.mp4", fps=15)

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 = 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()

# CPU 오프로드로 추가 VRAM 절약
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)

[ComfyUI HunyuanVideo 기본 워크플로우]

+----------------+     +------------------+     +-------------+
| Load Checkpoint| --> | CLIP Text Encode | --> | KSampler    |
| (HunyuanVideo) |     | (Prompt 입력)    |     | Advanced    |
+----------------+     +------------------+     +------+------+
                                                       |
+----------------+     +------------------+            |
| Empty Latent   | --> | (연결)           | -----------+
| Video          |     |                  |            |
| (크기/프레임)   |     +------------------+            v
+----------------+                              +-------------+
                                                | VAE Decode  |
                                                +------+------+
                                                       |
                                                       v
                                                +-------------+
                                                | Save Video  |
                                                | (MP4 출력)   |
                                                +-------------+

guidance_scale 영향:

낮음 (1-3):     창의적, 다양한 결과, 프롬프트와 느슨한 매칭
중간 (4-7):     균형 잡힌 품질과 프롬프트 충실도 [권장]
높음 (8-15):    프롬프트에 매우 충실, 과포화/아티팩트 위험

num_inference_steps 영향:

20 steps:       빠른 생성, 약간의 품질 손실
30 steps:       좋은 균형점 [권장]
50 steps:       최고 품질, 생성 시간 증가

# FP8 가중치를 활용한 추론
# HuggingFace에서 FP8 가중치 다운로드
# --use-fp8 플래그를 사용하여 FP8 추론 활성화

# 공식 리포지토리 방식
python sample_video.py \
    --model HunyuanVideo \
    --prompt "A beautiful landscape" \
    --video-size 720 1280 \
    --video-length 129 \
    --infer-steps 30 \
    --use-fp8 \
    --fp8-weight-path ./ckpts/hunyuan-video-t2v-720p/transformers/mp_rank_00_model_states_fp8.pt

# 1. 환경 설치
git clone https://github.com/kohya-ss/musubi-tuner.git
cd musubi-tuner
pip install -r requirements.txt

# 2. 학습 데이터 준비
# videos.txt: 비디오 파일 경로 (한 줄에 하나)
# prompts.txt: 각 비디오에 대한 프롬프트 (한 줄에 하나)
# 비디오 해상도: 32의 배수
# 프레임 수: 4k 또는 4k+1 (예: 16, 32, 49, 81)

# 3. latent 캐싱
python cache_latents.py \
    --dataset_config dataset.toml \
    --vae_path ./models/hunyuan_video_vae_fp32.safetensors

# 4. 텍스트 인코더 출력 캐싱
python cache_text_encoder_outputs.py \
    --dataset_config dataset.toml \
    --text_encoder_path ./models/text_encoder

# 5. LoRA 학습 실행
python hv_train_network.py \
    --dataset_config dataset.toml \
    --pretrained_model_name_or_path ./models/hunyuan_video.safetensors \
    --network_module networks.lora \
    --network_dim 32 \
    --learning_rate 1e-4 \
    --max_train_steps 1000 \
    --output_dir ./output \
    --output_name my_hunyuan_lora

[LTX-Video 진화 타임라인]

LTX-Video 0.9          LTX-Video 0.9.8         LTX-2                LTX-2 Open Source
(2024.11)              (2025 중반)               (2025.10)             (2026.01)
    |                       |                       |                     |
    v                       v                       v                     v
+----------+          +----------+            +-----------+          +-----------+
| 2B 모델   |          | 13B 모델  |            | 19B 모델   |          | 19B 모델   |
| T2V Only  |          | T2V/I2V   |            | T2V/I2V    |          | 완전 공개   |
| 실시간 속도 |          | 품질 향상  |            | +Audio     |          | 코드+가중치 |
| 768x512   |          | 고해상도   |            | 4K, 50fps  |          | 학습 코드   |
+----------+          +----------+            +-----------+          +-----------+

핵심 진화: 속도 유지 + 품질 대폭 향상 + 오디오 생성 추가 + 4K 지원

[생성 속도 비교 (5초 비디오 기준)]

모델              생성 시간    실시간 대비
LTX-Video 1.0:    ~2초         2.5x 빠름     ████████████████████████████████
LTX-2:            ~3-5초       약 실시간      ██████████████████████████
HunyuanVideo:     ~2-5분       60x 느림       ████
CogVideoX:        ~3-8분       100x 느림      ███
Mochi:            ~5-10분      120x 느림      ██

(H100 GPU 기준, 768x512 해상도)

[LTX-2 전체 아키텍처]

텍스트 프롬프트
     |
     v
+-------------+
| 텍스트 인코더 |  (Gemma 기반)
| + 프롬프트   |
|   향상기     |
+------+------+
       |
       v
+------------------------------------------+
|        비대칭 듀얼 스트림 DiT              |
|                                          |
|  +------------------+  +-------------+   |
|  | 비디오 스트림      |  | 오디오 스트림 |   |
|  | (넓은 채널,       |  | (좁은 채널,  |   |
|  |  고용량)          |  |  경량)       |   |
|  +--------+---------+  +------+------+   |
|           |      Cross-Attention  |       |
|           +----------+-----------+       |
+------------------------------------------+
       |                    |
       v                    v
+-------------+      +-------------+
| Video VAE   |      | Audio VAE   |
| Decoder     |      | Decoder     |
| (3D 시공간)  |      | (1D 시간)    |
+------+------+      +------+------+
       |                    |
       v                    v
   비디오 출력          오디오 출력
       |                    |
       +--------+-----------+
                |
                v
         최종 AV 출력 (MP4)

[LTX-2 Video VAE 압축 시각화]

입력 비디오: 1920 x 1080 x 80 frames x 3 channels

     공간 압축 (32x32)
     +-----> 60 x 33.75 (패딩 후 64x34)

     시간 압축 (8x)
     +-----> 10 latent frames

     채널 확장
     +-----> 128 latent channels

출력 Latent: 64 x 34 x 10 x 128
압축비: 약 1:192

[비교] HunyuanVideo VAE:
입력: 1280 x 720 x 129 x 3
출력: 160 x 90 x 33 x 16
압축비: 약 1:47

[비대칭 듀얼 스트림 DiT 구조]

                    공유 타임스텝 조건
                         |
            +------------+------------+
            |                         |
     +------v-------+         +------v-------+
     | 비디오 스트림  |         | 오디오 스트림  |
     | (Wide Stream)|         | (Narrow)     |
     |              |         |              |
     | - 넓은 채널   |         | - 좁은 채널   |
     | - 3D 시공간   |         | - 1D 시간     |
     |   Attention  |         |   Attention  |
     | - 고용량 FFN  |         | - 경량 FFN    |
     |              |         |              |
     +------+-------+         +------+-------+
            |                         |
            |   Bidirectional Cross   |
            |      Attention          |
            +--------+---+-----------+
                     |   |
            +--------v---v-----------+
            |  Cross-Modality AdaLN  |
            |  (공유 타임스텝 조건)    |
            +------------------------+

# 프롬프트 향상 예시
# 입력: "A dog running in the park"
# 향상된 프롬프트: "A golden retriever running joyfully through a sunlit park,
#   green grass, trees in the background, natural lighting, cinematic quality,
#   smooth motion, 4K resolution"

[LTX-2 Two-Stage Pipeline]

Stage 1: 기본 비디오 생성
+------------------+
| 저해상도 생성      |  8 steps (distilled)
| (기본 구조 생성)   |  빠른 속도
+--------+---------+
         |
         v
Stage 2: 공간 업스케일링
+------------------+
| Spatial Upsampler |  4 steps
| (고해상도 향상)    |  세부 디테일 추가
+--------+---------+
         |
         v
    최종 비디오 출력

[오디오-비디오 동시 생성]

프롬프트: "Ocean waves crashing on a rocky shore at sunset"

기존 파이프라인:
  T2V 모델 -> 비디오 -> V2A 모델 -> 오디오 (별도 과정)

LTX-2 파이프라인:
  LTX-2 -> 비디오 + 오디오 (단일 과정, 동기화됨)

장점:
- 비디오-오디오 완벽 동기화
- 단일 모델로 통합 처리
- 추가 모델 불필요
- 시간적 일관성 보장

[Keyframe Conditioning 워크플로우]

Frame 1 (시작)        Frame 60 (중간)        Frame 121 (끝)
+----------+          +----------+          +----------+
| 키프레임 1 |          | 키프레임 2 |          | 키프레임 3 |
| (입력)    |          | (입력)    |          | (입력)    |
+----+-----+          +----+-----+          +----+-----+
     |                     |                     |
     +----------+----------+----------+----------+
                |                     |
          자동 보간              자동 보간
          (LTX-2)               (LTX-2)

# LTX-2 LoRA 학습 기본 명령어
python -m ltx_train \
    --config configs/lora_config.yaml \
    --data_dir ./training_data \
    --output_dir ./lora_output \
    --num_train_steps 1000 \
    --learning_rate 1e-4

# 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")

from ltx_pipelines import DistilledPipeline

# Distilled 파이프라인 (8-step 추론)
pipe = DistilledPipeline.from_pretrained(
    "Lightricks/LTX-2",
    device_map="auto",
    enable_fp8=True,
)

# 빠른 생성 (8 sigmas, stage1: 8 steps, stage2: 4 steps)
result = pipe(
    prompt="A colorful butterfly landing on a flower",
    height=512,
    width=768,
    num_frames=121,
    frame_rate=24,
)

result.save("ltx2_fast_output.mp4")

python -m ltx_pipelines.ti2vid_two_stages \
    --checkpoint-path ./models/ltx2/checkpoint.safetensors \
    --distilled-lora ./models/ltx2/distilled_lora.safetensors 0.8 \
    --spatial-upsampler-path ./models/ltx2/upsampler.safetensors \
    --gemma-root ./models/gemma \
    --prompt "A beautiful sunset over the ocean, golden light reflecting on calm water" \
    --negative-prompt "blurry, low quality" \
    --height 704 \
    --width 1216 \
    --num-frames 121 \
    --seed 42 \
    --output-path output.mp4

# ComfyUI-LTXVideo 설치
cd ComfyUI/custom_nodes
git clone https://github.com/Lightricks/ComfyUI-LTXVideo.git
pip install -r ComfyUI-LTXVideo/requirements.txt

# 필요한 모델은 첫 실행 시 자동 다운로드됨

[ComfyUI LTX-2 워크플로우]

+------------------+     +------------------+     +-------------+
| LTX-2 Model      | --> | Text Encode      | --> | LTX-2       |
| Loader           |     | (Gemma)          |     | Sampler     |
+------------------+     +------------------+     +------+------+
                                                         |
+------------------+     +------------------+            |
| Empty Latent     | --> | (연결)           | -----------+
| Video            |     |                  |            |
| (크기/프레임 설정) |     +------------------+            v
+------------------+                              +-------------+
                                                  | LTX-2 VAE   |
+------------------+                              | Decode       |
| (Optional)       |                              +------+------+
| Input Image      | ---------------------------------->|
| (I2V 모드)       |                                    v
+------------------+                              +-------------+
                                                  | Save Video  |
                                                  | (MP4+Audio) |
                                                  +-------------+

해상도: width와 height 모두 32의 배수여야 함
  - 예: 768x512, 1216x704, 1920x1080

프레임 수: 8k+1 형태여야 함
  - 예: 9, 17, 25, 33, 41, 49, 57, 65, 73, 81, 89, 97, 105, 113, 121

[VRAM 사용량 비교 (같은 해상도/프레임)]

해상도: 768x512, 121 frames

                     VRAM 사용량 (GB)
HunyuanVideo (FP16): ████████████████████████████████████████ 40GB
HunyuanVideo (FP8):  ████████████████████████████████ 30GB
HunyuanVideo (INT4): ████████████████ 16GB
LTX-2 (FP16):       ████████████████████████ 24GB
LTX-2 (FP8):        ████████████████ 16GB
LTX-2 (FP8+Opt):    ████████████ 12GB

[시나리오별 추천 모델]

"최고 품질의 비디오가 필요하다"
  --> HunyuanVideo (v1, 13B)
  이유: Full Attention + 13B로 최고 시각 품질

"소비자 GPU로 로컬 실행하고 싶다"
  --> LTX-2 (FP8) 또는 HunyuanVideo 1.5
  이유: LTX-2는 12GB에서도 동작, HV 1.5는 14GB

"빠른 반복 작업이 필요하다"
  --> LTX-2 (Distilled)
  이유: 실시간 수준의 생성 속도

"오디오가 포함된 비디오가 필요하다"
  --> LTX-2
  이유: 유일하게 AV 동시 생성 지원

"특정 캐릭터/스타일 학습이 필요하다"
  --> HunyuanVideo + LoRA
  이유: 풍부한 LoRA 생태계

"4K 고해상도가 필요하다"
  --> LTX-2
  이유: 네이티브 4K 지원

"인체/얼굴 생성이 중요하다"
  --> HunyuanVideo
  이유: Human Fidelity 벤치마크 우수

[VBench 전체 점수 비교 (근사치)]

Wan 2.1 (14B):     ██████████████████████████████████████████████ 84.7%
HunyuanVideo:      ████████████████████████████████████████████ 83%
LTX-2:             ██████████████████████████████████████████ 81%
CogVideoX-5B:      ████████████████████████████████████████ 79%
Mochi 1:           ██████████████████████████████████████ 77%

차원별 강점:
- Subject Consistency: Wan 2.1 우세
- Motion Smoothness:   Wan 2.1, HunyuanVideo 우세
- Human Fidelity:      HunyuanVideo, Sora 우세
- Generation Speed:    LTX-2 압도적 우세
- Resolution Range:    LTX-2 (4K) 우세
- Audio Integration:   LTX-2 유일

[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"

# 자연 풍경 시 추가
"artificial looking, oversaturated, unrealistic colors,
cartoon style, anime style"

1. 상세한 장면 묘사를 선호 (MLLM 인코더가 복잡한 설명 잘 이해)
2. 영어 프롬프트 권장 (최적 성능)
3. 카메라 움직임 명시 (전문 용어 사용)
4. 감정/분위기 키워드 포함

예시:
"Cinematic shot of a young woman walking through a rain-soaked
Tokyo street at night, neon reflections on wet pavement, umbrella
in hand, slow motion, anamorphic lens flare, moody atmosphere,
shallow depth of field, 35mm film grain"

1. enhance_prompt=True 활용하여 자동 프롬프트 향상
2. 간결하지만 핵심 요소를 포함
3. 오디오 관련 힌트 추가 가능
4. 단일 장면에 집중 (장면 전환 회피)

예시:
"Ocean waves crashing against rocky cliffs at sunset, seagulls
flying overhead, wind sound, warm golden light, wide angle shot"

[비디오 생성 AI 발전 로드맵 (예상)]

2026                    2027                    2028
  |                       |                       |
  v                       v                       v
현재 상태:               단기 예측:               중장기 예측:
- 5~10초 클립            - 30~60초 비디오          - 수 분 길이 비디오
- 720p~4K               - 8K 지원                - 완전한 영화 생성
- 기본 물리 시뮬레이션    - 정확한 물리 엔진        - 인터랙티브 비디오
- AV 동시 생성 시작      - 다국어 음성 + 자막      - 실시간 스트리밍 생성
- LoRA 커스터마이징      - 캐릭터 일관성 완벽      - 자동 편집/연출

[오픈소스 vs 상용 모델 경쟁 구도]

         품질
          ^
          |
    최고  |                              * Sora 2
          |                         * Veo 3.1
          |                    * Kling 3.5
          |               * HunyuanVideo
          |          * LTX-2    * Wan 2.1
          |     * CogVideoX
          |  * Mochi
    낮음  +---+---+---+---+---+---+---+----> 접근성/비용
         높은비용            무료/오픈소스

트렌드: 오픈소스 모델이 빠르게 상용 모델에 근접
- 2024: 상용 모델이 압도적 우위
- 2025: 오픈소스가 빠르게 추격
- 2026: 일부 차원에서 오픈소스가 역전 (속도, 접근성)