Retrato en vivo

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

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

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

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

Alquiler en CLORE.AI

1. Visitar 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

• Artículo: Artículo de LivePortrait

• HuggingFace: KwaiVGI/LivePortrait

• Demostración: Espacio de HuggingFace

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:

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

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

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

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

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:

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:

# 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

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

• Wav2Lip - Mejor sincronización labial

• XTTS - Generación de voz