Stable Video Diffusion

Genera videos a partir de imágenes con Stable Video Diffusion en Clore.ai

¡Hay alternativas más nuevas disponibles! Considera FramePack (¡solo 6 GB de VRAM!), Wan2.1 (mayor calidad), o LTX-2 (video con audio nativo).

Genera videos a partir de imágenes usando el modelo SVD de Stability AI.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

¿Qué es Stable Video Diffusion?

SVD (Stable Video Diffusion) genera clips de video cortos a partir de una sola imagen:

• salidas de 14 o 25 fotogramas

• resolución 576x1024

• Generación de movimiento suave

• Pesos de código abierto

Recursos

• HuggingFace: stabilityai/stable-video-diffusion-img2vid-xt

• GitHub: Stability-AI/generative-models

• Artículo: Artículo de SVD

Requisitos de hardware

Modelo	VRAM	GPU recomendada
SVD (14 fotogramas)	16GB	RTX 4090
SVD-XT (25 fotogramas)	24GB	RTX 4090 / A100

Despliegue rápido

Imagen Docker:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Puertos:

22/tcp
7860/http

Comando:

pip install diffusers transformers accelerate && \
pip install gradio && \
python -c "
import gradio as gr
from diffusers import StableVideoDiffusionPipeline
from diffusers.utils import export_to_video
import torch

pipe = StableVideoDiffusionPipeline.from_pretrained(
    'stabilityai/stable-video-diffusion-img2vid-xt',
    torch_dtype=torch.float16,
    variant='fp16'
).to('cuda')

def generate(image, seed, fps):
    generator = torch.manual_seed(seed)
    frames = pipe(image, num_frames=25, generator=generator).frames[0]
    export_to_video(frames, 'output.mp4', fps=fps)
    return 'output.mp4'

gr.Interface(
    fn=generate,
    inputs=[gr.Image(type='pil'), gr.Number(value=42, label='Seed'), gr.Slider(6, 30, value=7, label='FPS')],
    outputs=gr.Video(),
    title='Stable Video Diffusion'
).launch(server_name='0.0.0.0', server_port=7860)
"

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis Pedidos:

1. Ir a Mis Pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Instalación

pip install diffusers transformers accelerate torch

# Para exportar video
pip install imageio[ffmpeg]

Uso básico

import torch
from diffusers import StableVideoDiffusionPipeline
from diffusers.utils import load_image, export_to_video

# Cargar pipeline
pipe = StableVideoDiffusionPipeline.from_pretrained(
    "stabilityai/stable-video-diffusion-img2vid-xt",
    torch_dtype=torch.float16,
    variant="fp16"
)
pipe.to("cuda")

# Cargar y cambiar tamaño de la imagen
image = load_image("input.jpg")
image = image.resize((1024, 576))

# Generar video
generator = torch.manual_seed(42)
frames = pipe(image, num_frames=25, generator=generator).frames[0]

# Guardar video
export_to_video(frames, "output.mp4", fps=7)

SVD vs SVD-XT

Función	SVD	SVD-XT
Fotogramas	14	25
Duración	~2 seg	~3.5 seg
VRAM	16GB	24GB
Calidad	Bueno	Mejor

Optimización de memoria

# Habilitar atención eficiente en memoria
pipe.enable_model_cpu_offload()

# O usar segmentación de atención
pipe.enable_attention_slicing()

# Para VRAM muy baja
pipe.enable_sequential_cpu_offload()

Procesamiento por lotes

import os
from pathlib import Path

input_dir = Path("./images")
output_dir = Path("./videos")
output_dir.mkdir(exist_ok=True)

for img_path in input_dir.glob("*.jpg"):
    image = load_image(str(img_path)).resize((1024, 576))
    frames = pipe(image, num_frames=25).frames[0]
    export_to_video(frames, str(output_dir / f"{img_path.stem}.mp4"), fps=7)
    print(f"Generated: {img_path.stem}.mp4")

Integración con ComfyUI

SVD funciona muy bien en ComfyUI:

1. Instalar ComfyUI

2. Descargar el modelo SVD a models/checkpoints/

3. Usar nodos SVD para el flujo de trabajo img2vid

Solución de problemas

Fuera de memoria

• Usa enable_model_cpu_offload()

• Reducir num_frames a 14

• Usar la variante fp16

Video demasiado corto

• Usa SVD-XT (25 fotogramas) en lugar de SVD (14 fotogramas)

• Interpolar con RIFE para un resultado más suave

Mala calidad de movimiento

• Usa imágenes de entrada de alta calidad

• Asegúrate de que la imagen sea 1024x576 (o 576x1024)

• Prueba diferentes semillas

Errores de CUDA

• Actualiza PyTorch y diffusers

• Verifica la compatibilidad de la versión de CUDA

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

GPU	Tarifa por hora	Tarifa diaria	Sesión de 4 horas
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Los precios varían según el proveedor. Consulta CLORE.AI Marketplace para las tarifas actuales.

Próximos pasos

• AnimateDiff - Animar imágenes SD

• Interpolación RIFE - Aumentar FPS

• Hunyuan Video - Texto a video