LivePortrait

Créez des portraits animés réalistes à partir d'images uniques sur Clore.ai

Créez des portraits animés réalistes à partir d'images uniques.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via Place de marché CLORE.AI.

Tous les exemples de ce guide peuvent être exécutés sur des serveurs GPU loués via Place de marché CLORE.AI le marketplace.

Location sur CLORE.AI

1. Visitez Place de marché CLORE.AI

2. Filtrer par type de GPU, VRAM et prix

3. Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)

4. Configurez votre commande :

   • Sélectionner l'image Docker

   • Définir les ports (TCP pour SSH, HTTP pour les interfaces web)

   • Ajouter des variables d'environnement si nécessaire

   • Entrer la commande de démarrage

5. Sélectionner le paiement : CLORE, BTC, ou USDT/USDC

6. Créer la commande et attendre le déploiement

Accéder à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces web : utilisez l'URL du port HTTP

• SSH : ssh -p <port> root@<adresse-proxy>

Qu'est-ce que LivePortrait ?

LivePortrait par Kuaishou permet :

• Animer n'importe quel portrait avec une vidéo de conduite

• Photo unique vers animation vidéo

• Transfert d'expression et de pose

• Inférence compatible en temps réel

Ressources

• GitHub : KwaiVGI/LivePortrait

• Article : Article LivePortrait

• HuggingFace : KwaiVGI/LivePortrait

• Démo : Espace HuggingFace

Matériel recommandé

Composant	Minimum	Recommandé	Optimal
GPU	RTX 3070 8GB	RTX 4080 16GB	RTX 4090 24GB
VRAM	8 Go	16Go	24 Go
CPU	4 cœurs	8 cœurs	16 cœurs
RAM	16Go	32Go	64Go
Stockage	30Go SSD	50Go NVMe	100Go NVMe
Internet	100 Mbps	500 Mbps	1 Gbps

Déploiement rapide sur CLORE.AI

Image Docker :

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

Ports :

22/tcp
7860/http

Commande :

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

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Aller à Mes commandes page

2. Cliquez sur votre commande

3. Trouvez l' http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://VOTRE_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Installation

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

# Télécharger les modèles pré-entraînés
huggingface-cli download KwaiVGI/LivePortrait --local-dir pretrained_weights

Ce que vous pouvez créer

Avatars virtuels

• Influenceurs IA et présentateurs virtuels

• Avatars pour le service client

• Présentateurs éducatifs

Création de contenu

• Contenu pour les réseaux sociaux

• Matériel marketing

• Concepts de clips musicaux

Divertissement

• Animer des photos historiques

• Animations de personnages

• Expériences interactives

Utilisations professionnelles

• Avatars pour visioconférence

• Assistants de présentation

• Simulations de formation

Utilisation de base

Ligne de commande

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

API Python

from liveportrait import LivePortraitPipeline

# Initialiser le pipeline
pipeline = LivePortraitPipeline(
    device="cuda",
    model_path="./pretrained_weights"
)

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

result.save("animated_portrait.mp4")

Portrait avec contrôle d'expression

from liveportrait import LivePortraitPipeline
import cv2

pipeline = LivePortraitPipeline(device="cuda")

# Contrôler des expressions spécifiques
expressions = {
    "smile": 0.8,
    "eyebrow_raise": 0.3,
    "head_pitch": -5,  # degrés
    "head_yaw": 10
}

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

result.save("expression_controlled.mp4")

Traitement par lot

import os
from liveportrait import LivePortraitPipeline

pipeline = LivePortraitPipeline(device="cuda")

# Animer plusieurs portraits avec la même vidéo de conduite
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"Processing {i+1}/{len(portraits)}: {portrait}")

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

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

Interface 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="Image du portrait"),
        gr.Video(label="Vidéo de conduite")
    ],
    outputs=gr.Video(label="Portrait animé"),
    title="LivePortrait - Animer n'importe quel portrait",
    description="Téléchargez un portrait et une vidéo de conduite pour créer une vidéo animée. Exécuté sur des serveurs GPU CLORE.AI."
)

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

Animation en temps réel via webcam

import cv2
from liveportrait import LivePortraitPipeline

pipeline = LivePortraitPipeline(device="cuda")

# Charger le portrait source
source = cv2.imread("portrait.jpg")
pipeline.set_source(source)

# Ouvrir la webcam
cap = cv2.VideoCapture(0)

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

    # Animer avec la trame actuelle comme vidéo de conduite
    animated = pipeline.animate_frame(frame)

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

cap.release()
cv2.destroyAllWindows()

Intégration avec la synthèse vocale (TTS)

Créer des avatars parlants avec synthèse vocale :

from liveportrait import LivePortraitPipeline
from TTS.api import TTS

# Générer la parole
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
tts.tts_to_file(
    text="Hello! Welcome to our presentation.",
    file_path="speech.wav",
    speaker_wav="reference_voice.wav",
    language="en"
)

# Générer une vidéo de conduite synchronisée avec les lèvres à partir de l'audio

# (Utiliser un outil de synchronisation labiale séparé ou une vidéo de conduite préexistante)

# Animer le portrait
pipeline = LivePortraitPipeline(device="cuda")
result = pipeline.animate(
    source_image="presenter.jpg",
    driving_video="lip_sync_driving.mp4"
)
result.save("talking_avatar.mp4")

Performances

Résolution	GPU	IPS	Latence
256x256	RTX 3070	30	33 ms
256x256	RTX 4090	60+	16 ms
512x512	RTX 4090	30	33 ms
512x512	A100	45	22 ms

Problèmes courants et solutions

Visage non détecté

Problème : "Aucun visage détecté dans l'image source"

Solutions :

• Assurez-vous que le visage est clairement visible et de face

• Utilisez un bon éclairage dans l'image source

• Recadrez l'image pour vous concentrer sur le visage

• Taille minimale du visage : 128x128 pixels

Le mouvement ne correspond pas

Problème : L'animation ne suit pas la vidéo de conduite

Solutions :

• Utilisez des vidéos de conduite avec des mouvements faciaux clairs

• Assurez-vous que la vidéo de conduite a une orientation de visage similaire

• Essayez différentes vidéos de conduite

Problèmes de qualité

Problème : La sortie semble floue ou déformée

Solutions :

# Utiliser des paramètres de meilleure qualité
result = pipeline.animate(
    source_image=source,
    driving_video=driving,
    output_size=512,  # Résolution supérieure
    enhance_face=True  # Activer l'amélioration du visage
)

Latence en temps réel

Problème : L'animation webcam est lente

Solutions :

• Utilisez une résolution de sortie plus petite (256x256)

• Activez l'optimisation TensorRT

• Utilisez une RTX 4090 ou mieux pour le temps réel

pipeline = LivePortraitPipeline(
    device="cuda",
    use_tensorrt=True  # Activer TensorRT
)

Problèmes de synchronisation audio

Problème : Les mouvements des lèvres ne correspondent pas à l'audio

Solutions :

• Utilisez la génération audio-vers-vidéo de conduite

• Ajustez le timing de la vidéo en post-traitement

• Utilisez Wav2Lip pour une meilleure synchronisation labiale

Dépannage

Visage non détecté

• Assurez-vous que le visage est clairement visible dans la source

• Utilisez des photos de face

• Vérifiez la résolution de l'image (512+ recommandé)

L'animation semble non naturelle

• La source et la vidéo de conduite doivent avoir des angles de visage similaires

• Évitez les expressions extrêmes dans la vidéo de conduite

• Utilisez des clips de conduite plus courts

La vidéo de sortie est corrompue

• Installez ffmpeg : apt install ffmpeg

• Vérifiez la compatibilité du format de sortie

• Assurez-vous d'avoir suffisamment d'espace disque

Erreurs CUDA

• Installez une version de PyTorch compatible

• Vérifiez que la version CUDA correspond aux exigences

Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

GPU	Tarif horaire	Tarif journalier	Session de 4 heures
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

Les prix varient selon le fournisseur et la demande. Vérifiez Place de marché CLORE.AI pour les tarifs actuels.

Économisez de l'argent :

• Utilisez Spot market pour les charges de travail flexibles (souvent 30-50% moins cher)

• Payer avec CLORE tokens

• Comparer les prix entre différents fournisseurs

Étapes suivantes

• SadTalker - Alternative pour talking head

• Wav2Lip - Meilleure synchronisation labiale

• XTTS - Génération vocale