LivePortrait

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

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

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

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

Alquilar en CLORE.AI

1. Visita Marketplace de CLORE.AI

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

• Artículo: Artículo de LivePortrait

• HuggingFace: KwaiVGI/LivePortrait

• Demo: Espacio de Hugging Face

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:

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

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

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

API de 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

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

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

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

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:

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:

# 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

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 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 - Cabeza parlante alternativa

• Wav2Lip - Mejor sincronización labial

• XTTS - Generación de voz