# Generación de video con IA

Genera videos usando Stable Video Diffusion, AnimateDiff y otros modelos.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrar por tipo de GPU, VRAM y precio
3. Elegir **Bajo demanda** (tarifa fija) o **Spot** (precio de puja)
4. Configura tu pedido:
   * Selecciona imagen Docker
   * Establece puertos (TCP para SSH, HTTP para interfaces web)
   * Agrega variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera el despliegue

### Accede a tu servidor

* Encuentra los detalles de conexión en **Mis Pedidos**
* Interfaces web: Usa la URL del puerto HTTP
* SSH: `ssh -p <port> root@<proxy-address>`

## Modelos disponibles

| Modelo      | Tipo           | VRAM | Duración     |
| ----------- | -------------- | ---- | ------------ |
| SVD         | Imagen a video | 16GB | 4 segundos   |
| SVD-XT      | Imagen a video | 20GB | 4 segundos   |
| AnimateDiff | Texto a video  | 12GB | 2-4 segundos |
| CogVideoX   | Texto a video  | 24GB | 6 segundos   |

## Stable Video Diffusion (SVD)

### Despliegue rápido

**Imagen Docker:**

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

**Puertos:**

```
22/tcp
7860/http
```

**Comando:**

```bash
pip install diffusers transformers accelerate gradio imageio && \
python svd_server.py
```

## 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.

### Script SVD

```python
import torch
from diffusers import StableVideoDiffusionPipeline
from PIL import Image
import imageio

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

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

# Generar video
frames = pipe(
    image,
    decode_chunk_size=8,
    num_frames=25,
    motion_bucket_id=127,
    noise_aug_strength=0.02
).frames[0]

# Guardar como GIF
imageio.mimsave("output.gif", frames, fps=6)

# Guardar como MP4
imageio.mimsave("output.mp4", frames, fps=6)
```

### SVD con interfaz Gradio

```python
import gradio as gr
import torch
from diffusers import StableVideoDiffusionPipeline
from PIL import Image
import imageio
import tempfile

pipe = StableVideoDiffusionPipeline.from_pretrained(
    "stabilityai/stable-video-diffusion-img2vid-xt",
    torch_dtype=torch.float16,
)
pipe.enable_model_cpu_offload()

def generate_video(image, motion_bucket, fps, num_frames):
    image = image.resize((1024, 576))

    frames = pipe(
        image,
        decode_chunk_size=4,
        num_frames=num_frames,
        motion_bucket_id=motion_bucket,
    ).frames[0]

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        imageio.mimsave(f.name, frames, fps=fps)
        return f.name

demo = gr.Interface(
    fn=generate_video,
    inputs=[
        gr.Image(type="pil", label="Imagen de entrada"),
        gr.Slider(1, 255, value=127, label="Cantidad de movimiento"),
        gr.Slider(1, 30, value=6, label="FPS"),
        gr.Slider(14, 25, value=25, label="Frames")
    ],
    outputs=gr.Video(label="Generated Video"),
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## AnimateDiff

### Instalación

```bash
pip install diffusers transformers accelerate
```

### Generar video desde texto

```python
import torch
from diffusers import AnimateDiffPipeline, MotionAdapter, DDIMScheduler
import imageio

# Cargar adaptador de movimiento
adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2")

# Cargar pipeline
pipe = AnimateDiffPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    motion_adapter=adapter,
    torch_dtype=torch.float16,
)
pipe.scheduler = DDIMScheduler.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    subfolder="scheduler",
    clip_sample=False,
    timestep_spacing="linspace",
    beta_schedule="linear",
    steps_offset=1,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# Generar
output = pipe(
    prompt="Un gato caminando por un jardín, flores hermosas, día soleado",
    negative_prompt="mala calidad, borroso",
    num_frames=16,
    guidance_scale=7.5,
    num_inference_steps=25,
)

# Guardar
frames = output.frames[0]
imageio.mimsave("animatediff.gif", frames, fps=8)
```

### AnimateDiff con modelo personalizado

```python
from diffusers import AnimateDiffPipeline, MotionAdapter, EulerDiscreteScheduler

adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2")

# Usar un checkpoint personalizado (por ejemplo, RealisticVision)
pipe = AnimateDiffPipeline.from_pretrained(
    "SG161222/Realistic_Vision_V5.1_noVAE",
    motion_adapter=adapter,
    torch_dtype=torch.float16,
)
```

## AnimateDiff en ComfyUI

### Instalar nodos

```bash
cd /workspace/ComfyUI/custom_nodes
git clone https://github.com/Kosinkadink/ComfyUI-AnimateDiff-Evolved.git
git clone https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite.git
```

### Descargar modelos de movimiento

```bash
cd /workspace/ComfyUI/custom_nodes/ComfyUI-AnimateDiff-Evolved/models
wget https://huggingface.co/guoyww/animatediff/resolve/main/mm_sd_v15_v2.ckpt
```

## CogVideoX

### Texto a video

```python
import torch
from diffusers import CogVideoXPipeline
import imageio

pipe = CogVideoXPipeline.from_pretrained(
    "THUDM/CogVideoX-2b",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = "Un dron volando sobre un hermoso paisaje montañoso al atardecer"

video = pipe(
    prompt=prompt,
    num_videos_per_prompt=1,
    num_inference_steps=50,
    num_frames=49,
    guidance_scale=6,
).frames[0]

imageio.mimsave("cogvideo.mp4", video, fps=8)
```

## Escalado de video

### Real-ESRGAN para video

```python
import cv2
import torch
from basicsr.archs.rrdbnet_arch import RRDBNet
from realesrgan import RealESRGANer

model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
upsampler = RealESRGANer(
    scale=4,
    model_path='RealESRGAN_x4plus.pth',
    model=model,
    tile=400,
    tile_pad=10,
    pre_pad=0,
    half=True
)

# Procesar video cuadro por cuadro
cap = cv2.VideoCapture("input.mp4")

# ... mejorar cada fotograma
```

## Interpolación (Videos suaves)

### Interpolación de fotogramas FILM

```python

# Instalar
pip install tensorflow tensorflow_hub

import tensorflow as tf
import tensorflow_hub as hub

model = hub.load("https://tfhub.dev/google/film/1")

def interpolate(frame1, frame2, num_interpolations=3):
    # Devuelve fotogramas interpolados entre frame1 y frame2
    ...
```

### RIFE (Tiempo real)

```bash
pip install rife-ncnn-vulkan-python

from rife_ncnn_vulkan import Rife
rife = Rife(gpu_id=0)

# Interpolar fotogramas
```

## Generación de video por lotes

```python
prompts = [
    "Un cohete lanzándose al espacio",
    "Olas del océano rompiendo contra las rocas",
    "Una mariposa volando entre flores",
]

for i, prompt in enumerate(prompts):
    print(f"Generando {i+1}/{len(prompts)}")
    output = pipe(prompt, num_frames=16)
    imageio.mimsave(f"video_{i:03d}.mp4", output.frames[0], fps=8)
```

## Consejos de memoria

### Para VRAM limitada

```python

# Habilitar descarga a CPU
pipe.enable_model_cpu_offload()

# Habilitar particionado VAE
pipe.enable_vae_slicing()

# Habilitar particionado de atención
pipe.enable_attention_slicing()

# Reducir la cantidad de fotogramas
num_frames = 14  # En lugar de 25
```

### Decodificación por fragmentos

```python
frames = pipe(
    image,
    decode_chunk_size=2,  # Decodificar 2 fotogramas a la vez
    num_frames=25,
).frames[0]
```

## Convertir salida

### GIF a MP4

```bash
ffmpeg -i input.gif -movflags faststart -pix_fmt yuv420p -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" output.mp4
```

### Secuencia de fotogramas a video

```bash
ffmpeg -framerate 8 -i frame_%04d.png -c:v libx264 -pix_fmt yuv420p output.mp4
```

### Agregar audio

```bash
ffmpeg -i video.mp4 -i audio.mp3 -c:v copy -c:a aac -shortest output_with_audio.mp4
```

## Rendimiento

| Modelo      | GPU      | Fotogramas | Tiempo |
| ----------- | -------- | ---------- | ------ |
| SVD-XT      | RTX 3090 | 25         | \~120s |
| SVD-XT      | RTX 4090 | 25         | \~80s  |
| SVD-XT      | A100     | 25         | \~50s  |
| AnimateDiff | RTX 3090 | 16         | \~30s  |
| CogVideoX   | A100     | 49         | \~180s |

## 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 y la demanda. Consulta* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *para las tarifas actuales.*

**Ahorra dinero:**

* Usa **Spot** market para cargas de trabajo flexibles (a menudo 30-50% más barato)
* Paga con **CLORE** tokens
* Compara precios entre diferentes proveedores

## Solución de problemas

### Error OOM

* Reducir num\_frames
* Habilitar descarga a CPU
* Usar decode\_chunk\_size más pequeño

### Video parpadeante

* Aumentar num\_inference\_steps
* Probar un motion\_bucket\_id diferente
* Usar interpolación de fotogramas

### Calidad pobre

* Usar entrada de mayor resolución (SVD)
* Mejores prompts (AnimateDiff)
* Aumentar guidance\_scale