> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/cabezas-parlantes/liveportrait.md).

# LivePortrait

Crea retratos animados realistas a partir de una sola imagen en Clore.ai

Crea retratos animados realistas a partir de imágenes individuales.

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

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

## Alquilar en CLORE.AI

1. Visita [Marketplace de CLORE.AI](https://clore.ai/marketplace)
2. Filtra por tipo de GPU, VRAM y precio
3. Elige **Bajo demanda** (tarifa fija) o **Spot** (precio ofertado)
4. Configura tu pedido:
   * Selecciona la imagen de Docker
   * Configura los puertos (TCP para SSH, HTTP para interfaces web)
   * Añade variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona el método de pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera al 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>`

## ¿Qué es LivePortrait?

LivePortrait de Kuaishou permite:

* Anima cualquier retrato con un video de control
* Animación de foto única a video
* Transferencia de expresión y pose
* Inferencia capaz en tiempo real

## Recursos

* **GitHub:** [KwaiVGI/LivePortrait](https://github.com/KwaiVGI/LivePortrait)
* **Artículo:** [Artículo de LivePortrait](https://arxiv.org/abs/2407.03168)
* **HuggingFace:** [KwaiVGI/LivePortrait](https://huggingface.co/KwaiVGI/LivePortrait)
* **Demo:** [Espacio de Hugging Face](https://huggingface.co/spaces/KwaiVGI/LivePortrait)

## Hardware recomendado

| Componente     | Mínimo       | Recomendado   | Óptimo        |
| -------------- | ------------ | ------------- | ------------- |
| GPU            | RTX 3070 8GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM           | 8GB          | 16GB          | 24GB          |
| CPU            | 4 núcleos    | 8 núcleos     | 16 núcleos    |
| RAM            | 16GB         | 32GB          | 64GB          |
| Almacenamiento | 30GB SSD     | 50GB NVMe     | 100GB NVMe    |
| Internet       | 100 Mbps     | 500 Mbps      | 1 Gbps        |

## Despliegue rápido en CLORE.AI

**Imagen de Docker:**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
```

**Puertos:**

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

**Comando:**

```bash
cd /workspace && \\
git clone https://github.com/KwaiVGI/LivePortrait.git && \\
cd LivePortrait && \\
pip install -r requirements.txt && \\
python app.py
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis pedidos**:

1. Ve a **Mis pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (p. ej., `abc123.clorecloud.net`)

Usa `https://YOUR_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos a continuación.

## Instalación

```bash
git clone https://github.com/KwaiVGI/LivePortrait.git
cd LivePortrait
pip install -r requirements.txt

# Descargar modelos preentrenados
huggingface-cli download KwaiVGI/LivePortrait --local-dir pretrained_weights
```

## Lo que puedes crear

### Avatares virtuales

* Influencers de IA y presentadores virtuales
* Avatares de atención al cliente
* Presentadores educativos

### Creación de contenido

* Contenido para redes sociales
* Materiales de marketing
* Conceptos de videos musicales

### Entretenimiento

* Animar fotos históricas
* Animaciones de personajes
* Experiencias interactivas

### Usos profesionales

* Avatares para videoconferencias
* Asistentes de presentaciones
* Simulaciones de entrenamiento

## Uso básico

### Línea de comandos

```bash
python inference.py \\
    --source_image path/to/portrait.jpg \\
    --driving_video path/to/driving.mp4 \\
    --output_path output.mp4
```

### API de Python

```python
from liveportrait import LivePortraitPipeline

# Inicializar la canalización
pipeline = LivePortraitPipeline(
    device="cuda",
    model_path="./pretrained_weights"
)

# Animar retrato
result = pipeline.animate(
    source_image="portrait.jpg",
    driving_video="driving.mp4"
)

result.save("animated_portrait.mp4")
```

## Retrato con control de expresiones

```python
from liveportrait import LivePortraitPipeline
import cv2

pipeline = LivePortraitPipeline(device="cuda")

# Controlar expresiones específicas
expressions = {
    "smile": 0.8,
    "eyebrow_raise": 0.3,
    "head_pitch": -5,  # grados
    "head_yaw": 10
}

result = pipeline.animate_with_expression(
    source_image="portrait.jpg",
    expressions=expressions,
    num_frames=60,
    fps=30
)

result.save("expression_controlled.mp4")
```

## Procesamiento por lotes

```python
import os
from liveportrait import LivePortraitPipeline

pipeline = LivePortraitPipeline(device="cuda")

# Animar múltiples retratos con el mismo video de control
portraits = [
    "portrait1.jpg",
    "portrait2.jpg",
    "portrait3.jpg"
]

driving = "speech_driving.mp4"
output_dir = "./animated"
os.makedirs(output_dir, exist_ok=True)

for i, portrait in enumerate(portraits):
    print(f"Procesando {i+1}/{len(portraits)}: {portrait}")

    result = pipeline.animate(
        source_image=portrait,
        driving_video=driving
    )

    result.save(f"{output_dir}/animated_{i:03d}.mp4")
```

## Interfaz de Gradio

```python
import gradio as gr
from liveportrait import LivePortraitPipeline
import tempfile

pipeline = LivePortraitPipeline(device="cuda")

def animate(source_image, driving_video):
    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        result = pipeline.animate(
            source_image=source_image,
            driving_video=driving_video
        )
        result.save(f.name)
        return f.name

demo = gr.Interface(
    fn=animate,
    inputs=[
        gr.Image(type="filepath", label="Imagen del retrato"),
        gr.Video(label="Video de control")
    ],
    outputs=gr.Video(label="Retrato animado"),
    title="LivePortrait - Anima cualquier retrato",
    description="Sube un retrato y un video de control para crear un video animado. Se ejecuta en servidores GPU de CLORE.AI."
)

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

## Animación en tiempo real con cámara web

```python
import cv2
from liveportrait import LivePortraitPipeline

pipeline = LivePortraitPipeline(device="cuda")

# Cargar retrato de origen
source = cv2.imread("portrait.jpg")
pipeline.set_source(source)

# Abrir cámara web
cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # Animar usando el fotograma actual como control
    animated = pipeline.animate_frame(frame)

    cv2.imshow("LivePortrait", animated)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()
```

## Integración con TTS

Crea avatares parlantes con texto a voz:

```python
from liveportrait import LivePortraitPipeline
from TTS.api import TTS

# Generar voz
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
tts.tts_to_file(
    text="¡Hola! Bienvenidos a nuestra presentación.",
    file_path="speech.wav",
    speaker_wav="reference_voice.wav",
    language="en"
)

# Generar video de control de sincronización labial a partir del audio

# (Usando una herramienta separada de sincronización labial o un video de control ya hecho)

# Animar retrato
pipeline = LivePortraitPipeline(device="cuda")
result = pipeline.animate(
    source_image="presenter.jpg",
    driving_video="lip_sync_driving.mp4"
)
result.save("talking_avatar.mp4")
```

## Rendimiento

| Resolución | GPU      | FPS | Latencia |
| ---------- | -------- | --- | -------- |
| 256x256    | RTX 3070 | 30  | 33ms     |
| 256x256    | RTX 4090 | 60+ | 16ms     |
| 512x512    | RTX 4090 | 30  | 33ms     |
| 512x512    | A100     | 45  | 22ms     |

## Problemas comunes y soluciones

### Cara no detectada

**Problema:** "No se detectó ninguna cara en la imagen de origen"

**Soluciones:**

* Asegúrate de que la cara sea claramente visible y esté de frente
* Usa buena iluminación en la imagen de origen
* Recorta la imagen para enfocar la cara
* Tamaño mínimo de cara: 128x128 píxeles

### El movimiento no coincide

**Problema:** La animación no sigue el video de control

**Soluciones:**

* Usa videos de control con movimientos faciales claros
* Asegúrate de que el video de control tenga una orientación facial similar
* Prueba con diferentes videos de control

### Problemas de calidad

**Problema:** La salida se ve borrosa o distorsionada

**Soluciones:**

```python

# Usa ajustes de mayor calidad
result = pipeline.animate(
    source_image=source,
    driving_video=driving,
    output_size=512,  # Mayor resolución
    enhance_face=True  # Habilitar mejora facial
)
```

### Retardo en tiempo real

**Problema:** La animación con cámara web va con retraso

**Soluciones:**

* Usa una resolución de salida más pequeña (256x256)
* Habilita la optimización TensorRT
* Usa una RTX 4090 o mejor para tiempo real

```python
pipeline = LivePortraitPipeline(
    device="cuda",
    use_tensorrt=True  # Habilitar TensorRT
)
```

### Problemas de sincronización de audio

**Problema:** Los movimientos de los labios no coinciden con el audio

**Soluciones:**

* Usa generación de video de control a partir de audio
* Ajusta la sincronización del video en el postprocesamiento
* Usa Wav2Lip para una mejor sincronización labial

## Solución de problemas

### Cara no detectada

* Asegúrate de que la cara sea claramente visible en la fuente
* Usa fotos de frente
* Comprueba la resolución de la imagen (se recomiendan 512+)

### La animación se ve poco natural

* La imagen de origen y el video de control deben tener ángulos faciales similares
* Evita expresiones extremas en el video de control
* Usa clips de control más cortos

### Video de salida corrupto

* Instala ffmpeg: `apt install ffmpeg`
* Verifica la compatibilidad del formato de salida
* Asegúrate de tener suficiente espacio en disco

### Errores de CUDA

* Instala una versión compatible de PyTorch
* Comprueba que la versión de CUDA coincida con los requisitos

## Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a partir 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* [*Marketplace de CLORE.AI*](https://clore.ai/marketplace) *las tarifas actuales.*

**Ahorra dinero:**

* Usa el **Spot** mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de \~13% de descuento), el resto lo iguala
* Paga con **CLORE** tokens
* Compara precios entre distintos proveedores

## Siguientes pasos

* [SadTalker](/guides/guides_v2-es/cabezas-parlantes/sadtalker.md) - Cabeza parlante alternativa
* [Wav2Lip](/guides/guides_v2-es/cabezas-parlantes/wav2lip.md) - Mejor sincronización labial
* [XTTS](/guides/guides_v2-es/audio-y-voz/xtts-coqui.md) - Generación de voz


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/cabezas-parlantes/liveportrait.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.