# LivePortrait

Crea retratos animados realistas a partir de imágenes únicas.

{% 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 %}

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

## Alquiler en CLORE.AI

1. Visitar [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 por puja)
4. Configure su pedido:
   * Seleccione la imagen de Docker
   * Establezca puertos (TCP para SSH, HTTP para interfaces web)
   * Agregue variables de entorno si es necesario
   * Ingrese el comando de inicio
5. Seleccione el pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Cree el pedido y espere el despliegue

### Acceda a su servidor

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

## ¿Qué es LivePortrait?

LivePortrait de Kuaishou permite:

* Animar cualquier retrato con un video conductor
* De foto única a animación de video
* Transferencia de expresión y pose
* Inferencia con capacidad 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)
* **Demostración:** [Espacio de HuggingFace](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.5.1-cuda12.4-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 su servicio

Después del despliegue, encuentre su `http_pub` URL en **Mis pedidos**:

1. Ir a **Mis pedidos** página
2. Haga clic en su pedido
3. Encuentre la `http_pub` URL (por ejemplo, `abc123.clorecloud.net`)

Use `https://YOUR_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos de abajo.

## 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 para atención al cliente
* Presentadores educativos

### Creación de contenido

* Contenido para redes sociales
* Materiales de marketing
* Conceptos para 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 conductor
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 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 conductor")
    ],
    outputs=gr.Video(label="Retrato animado"),
    title="LivePortrait - Anima cualquier retrato",
    description="Sube un retrato y un video conductor para crear un video animado. Ejecutándose 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 fuente
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 con el fotograma actual como conductor
    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

Crear 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! Bienvenido a nuestra presentación.",
    file_path="speech.wav",
    speaker_wav="reference_voice.wav",
    language="en"
)

# Generar video conductor sincronizado con labios a partir del audio

# (Usando una herramienta separada de sincronización labial o video conductor preexistente)

# 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

### Rostro no detectado

**Problema:** "No se detectó rostro en la imagen fuente"

**Soluciones:**

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

### El movimiento no coincide

**Problema:** La animación no sigue el video conductor

**Soluciones:**

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

### Problemas de calidad

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

**Soluciones:**

```python

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

### Retraso en tiempo real

**Problema:** La animación de la cámara web tiene lag

**Soluciones:**

* Usa una resolución de salida más pequeña (256x256)
* Habilita la optimización TensorRT
* Usa 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 conductor a partir del audio
* Ajusta el tiempo del video en postprocesamiento
* Usa Wav2Lip para mejor sincronización labial

## Solución de problemas

### Rostro no detectado

* Asegúrate de que el rostro sea claramente visible en la fuente
* Usa fotos de frente
* Verifica la resolución de la imagen (se recomienda 512+)

### La animación parece antinatural

* El video fuente y el conductor deben tener ángulos faciales similares
* Evita expresiones extremas en el video conductor
* Usa clips conductores 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
* Verifica que la versión de CUDA coincida con los requisitos

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

**Ahorre dinero:**

* Use **Spot** mercado para cargas de trabajo flexibles (a menudo 30-50% más barato)
* Pague con **CLORE** tokens
* Compare precios entre diferentes 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: 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:

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

The question should be specific, self-contained, and written in natural language.
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.