Open-Sora: 29K+ Stars — 오픈소스 비디오 생성 완벽 설치 가이드 2026

# 핵심 추론 파이프라인 (간소화)
import torch
from opensora.models import STDiT3, T5Encoder, DC_AE
from opensora.schedulers import RectifiedFlowScheduler

# 모델 로드
stdit = STDiT3.from_pretrained("hpcai-tech/Open-Sora-v2").cuda()
text_encoder = T5Encoder.from_pretrained("google/t5-v1_1-xxl").cuda()
vae = DC_AE.from_pretrained("hpcai-tech/Open-Sora-v2/vae").cuda()

# 프롬프트 인코딩
prompt = "A serene underwater scene featuring a sea turtle"
prompt_embed = text_encoder.encode(prompt)  # [1, 512, 4096]

# 잠재 노이즈 초기화
latent = torch.randn(1, 16, 16, 128, 128).cuda()  # [B, C, T, H, W]

# 정류 흐름으로 디노이징
scheduler = RectifiedFlowScheduler(num_steps=50)
for t in scheduler.timesteps:
    noise_pred = stdit(latent, t, prompt_embed)
    latent = scheduler.step(noise_pred, t, latent)

# 비디오로 디코딩
video = vae.decode(latent)  # [1, 3, 65, 768, 768]

# 가상 환경 생성
conda create -n opensora python=3.10 -y
conda activate opensora

# 저장소 클론
git clone https://github.com/hpcaitech/Open-Sora.git
cd Open-Sora

# PyTorch 설치 (CUDA 12.1)
pip install torch==2.4.0 torchvision==0.19.0 --index-url https://download.pytorch.org/whl/cu121

# Open-Sora 설치
pip install -v .

# 선택적 가속기 설치
pip install xformers==0.0.27.post2 --index-url https://download.pytorch.org/whl/cu121
pip install flash-attn --no-build-isolation

# 저장소 클론
git clone https://github.com/hpcaitech/Open-Sora.git
cd Open-Sora

# Docker 이미지 빌드
docker build -t opensora:latest .

# 대화형 컨테이너 실행
docker run -ti --gpus all \
  -v $(pwd):/workspace/Open-Sora \
  -p 7860:7860 \
  --name opensora \
  opensora:latest

# 컨테이너 낶에서 모델 가중치 다운로드
pip install "huggingface_hub[cli]"
huggingface-cli download hpcai-tech/Open-Sora-v2 --local-dir ./ckpts

FROM nvidia/cuda:12.1.0-cudnn8-devel-ubuntu22.04

WORKDIR /workspace/Open-Sora

# 시스템 종속성
RUN apt-get update && apt-get install -y \
    git wget curl build-essential \
    libgl1 libglib2.0-0 \
    && rm -rf /var/lib/apt/lists/*

# Python 종속성
COPY requirements.txt .
RUN pip install -r requirements.txt

# Open-Sora 설치
COPY . .
RUN pip install -v .

# 성능 최적화 도구 설치
RUN pip install xformers==0.0.27.post2 --index-url https://download.pytorch.org/whl/cu121
RUN pip install flash-attn --no-build-isolation

EXPOSE 7860
CMD ["/bin/bash"]

# 옵션 1: HuggingFace
pip install "huggingface_hub[cli]"
huggingface-cli download hpcai-tech/Open-Sora-v2 --local-dir ./ckpts

# 옵션 2: ModelScope (중국 기반 사용자용)
pip install modelscope
modelscope download hpcai-tech/Open-Sora-v2 --local_dir ./ckpts

# 다운로드 확인
ls -la ./ckpts/
# 예상 출력: model.safetensors, config.json, vae/, text_encoder/

# 별도 환경에서 ComfyUI 설치
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
pip install -r requirements.txt

# Open-Sora용 커스텀 노드 생성
mkdir -p custom_nodes/opensora-bridge
cd custom_nodes/opensora-bridge

# custom_nodes/opensora-bridge/opensora_node.py
import subprocess
import torch
import os

class OpenSoraTextToVideo:
    """Open-Sora 텍스트-비디오 생성용 ComfyUI 노드"""
    
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "prompt": ("STRING", {"multiline": True}),
                "resolution": (["256px", "768px"], {"default": "768px"}),
                "num_frames": ("INT", {"default": 65, "min": 17, "max": 129}),
                "steps": ("INT", {"default": 50, "min": 20, "max": 100}),
            }
        }
    
    RETURN_TYPES = ("VIDEO",)
    FUNCTION = "generate_video"
    CATEGORY = "video_generation"
    
    def generate_video(self, prompt, resolution, num_frames, steps):
        # 프롬프트를 CSV에 쓰기
        with open("/tmp/opensora_input.csv", "w") as f:
            f.write(f"id,text\n0,\"{prompt}\"\n")
        
        # 추론 실행
        cmd = [
            "torchrun", "--nproc_per_node", "1", "--standalone",
            "scripts/diffusion/inference.py",
            f"configs/diffusion/inference/{resolution}.py",
            "--save-dir", "/tmp/opensora_output",
            "--dataset.data-path", "/tmp/opensora_input.csv",
            "--num_frames", str(num_frames),
        ]
        subprocess.run(cmd, cwd="/workspace/Open-Sora")
        
        video_path = "/tmp/opensora_output/video_0.mp4"
        return (video_path,)

NODE_CLASS_MAPPINGS = {
    "OpenSoraTextToVideo": OpenSoraTextToVideo,
}

NODE_DISPLAY_NAME_MAPPINGS = {
    "OpenSoraTextToVideo": "Open-Sora Text to Video",
}

# configs/diffusion/inference/t2i2v_768px.py
# 텍스트-이미지-비디오 구성
model = dict(
    type="STDiT3",
    from_pretrained="./ckpts/model.safetensors",
    enable_flash_attn=True,
    enable_layernorm_kernel=True,
)

vae = dict(
    type="DC-AE",
    from_pretrained="./ckpts/vae",
)

text_encoder = dict(
    type="t5",
    from_pretrained="./ckpts/text_encoder",
)

# FLUX T2I 모델 구성
t2i_model = dict(
    type="flux-schnell",
    from_pretrained="black-forest-labs/FLUX.1-schnell",
)

# 샘플링 구성
num_sampling_steps = 50
cfg_scale = 7.5
cfg_channel = 3  # 이미지 조건화 스케일

# Gradio 종속성 설치
pip install gradio spaces

# 웹 UI 시작
python gradio/app.py --model-type v2 --checkpoint ./ckpts

# ColossalAI 설치
pip install colossalai

# 멀티 GPU 훈련 시작 (8x A100)
torchrun --nproc_per_node 8 --standalone \
    scripts/train.py \
    configs/diffusion/train/stage1.py \
    --data-path /path/to/video/dataset \
    --batch-size 2 \
    --mixed-precision bf16

# 긴 비디오를 위한 시퀀스 병렬성 (>65 프레임)
torchrun --nproc_per_node 8 --standalone \
    scripts/train.py \
    configs/diffusion/train/stage2_sp.py \
    --data-path /path/to/video/dataset \
    --sequence-parallel-size 4

# 1. CPU 오프로딩 (~40% VRAM 절약, 25% 느림)
torchrun --nproc_per_node 1 --standalone \
    scripts/diffusion/inference.py \
    configs/diffusion/inference/t2i2v_256px.py \
    --prompt "raining, sea" \
    --offload True

# 2. Flash Attention 3 (15-20% 속도 향상, 품질 손실 없음)
# 먼저 설치:
git clone https://github.com/Dao-AILab/flash-attention
cd flash-attention/hopper
python setup.py install

# 3. 양자화 추론 (INT8, 50% VRAM 절약)
torchrun --nproc_per_node 1 --standalone \
    scripts/diffusion/inference.py \
    configs/diffusion/inference/t2i2v_256px.py \
    --prompt "raining, sea" \
    --quantization int8

# 4. 혼합 정밀도 (BF16)
torchrun --nproc_per_node 1 --standalone \
    scripts/diffusion/inference.py \
    configs/diffusion/inference/t2i2v_256px.py \
    --prompt "raining, sea" \
    --mixed-precision bf16

# 고해상도 생성을 위한 텐서 병렬성
torchrun --nproc_per_node 8 --standalone \
    scripts/diffusion/inference.py \
    configs/diffusion/inference/t2i2v_768px.py \
    --save-dir samples \
    --prompt "A soaring drone footage captures coastal cliffs" \
    --tp-size 4

# 효과적인 프롬프트 구조
prompt = """A cinematic wide shot of a golden retriever running along a sandy beach at sunset. 
Ocean waves break in the background with warm golden hour lighting. 
The camera follows the dog in slow motion, capturing flying fur details. 
High production value, anamorphic lens, shallow depth of field."""

# 피하세요: 모호하거나 추상적인 프롬프트
# 나쁨: "a dog video"
# 좋음: 자세한 주제 + 동작 + 환경 + 조명 + 칩라라 움직임

# docker-compose.prod.yml
version: '3.8'

services:
  opensora:
    build: .
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - CUDA_VISIBLE_DEVICES=0,1,2,3
      - HF_HOME=/workspace/cache
    volumes:
      - ./ckpts:/workspace/Open-Sora/ckpts:ro
      - ./samples:/workspace/Open-Sora/samples
      - huggingface_cache:/workspace/cache
    ports:
      - "7860:7860"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    healthcheck:
      test: ["CMD", "python", "-c", "import torch; torch.cuda.is_available()"]
      interval: 30s
      timeout: 10s
      retries: 3
    restart: unless-stopped
    
  # 선택적: 배치 작업 대기열 워커
  worker:
    build: .
    runtime: nvidia
    command: python scripts/diffusion/batch_worker.py --queue redis:6379
    environment:
      - NVIDIA_VISIBLE_DEVICES=4,5,6,7
    volumes:
      - ./ckpts:/workspace/Open-Sora/ckpts:ro
      - ./samples:/workspace/Open-Sora/samples
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 4
              capabilities: [gpu]

volumes:
  huggingface_cache:

# production_monitor.py
import torch
import time
import psutil
from prometheus_client import Counter, Histogram, start_http_server

# 메트릭
GENERATION_COUNTER = Counter('opensora_generations_total', '총 비디오 생성 수')
GENERATION_DURATION = Histogram('opensora_generation_seconds', '생성 시간')
VRAM_USAGE = Histogram('opensora_vram_usage_bytes', '최대 VRAM 사용량')

def generate_with_monitoring(prompt, config):
    process = psutil.Process()
    start_mem = process.memory_info().rss
    
    torch.cuda.reset_peak_memory_stats()
    start_time = time.time()
    
    try:
        video = run_inference(prompt, config)
        
        duration = time.time() - start_time
        peak_vram = torch.cuda.max_memory_allocated()
        
        GENERATION_COUNTER.inc()
        GENERATION_DURATION.observe(duration)
        VRAM_USAGE.observe(peak_vram)
        
        return {
            'video': video,
            'duration': duration,
            'peak_vram_gb': peak_vram / 1e9,
            'peak_ram_gb': (process.memory_info().rss - start_mem) / 1e9,
        }
    except Exception as e:
        raise

# 9090 포트에서 메트릭 서버 시작
start_http_server(9090)