LivePortrait

Créez des portraits animés réalistes à partir d'une seule image 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 la place de marché CLORE.AI.

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

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

2. Filtrez par type de GPU, VRAM et prix

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

4. Configurez votre commande :

   • Sélectionnez l'image Docker

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

   • Ajoutez des variables d'environnement si nécessaire

   • Entrez la commande de démarrage

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

6. Créez la commande et attendez le déploiement

Accédez à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces web : utilisez l'URL du port HTTP

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

Qu'est-ce que LivePortrait ?

LivePortrait de Kuaishou permet :

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

• Animation d'une photo unique en vidéo

• Transfert d'expression et de pose

• Inférence en temps réel

Ressources

• GitHub : KwaiVGI/LivePortrait

• Article : Article LivePortrait

• HuggingFace : KwaiVGI/LivePortrait

• Démo : HuggingFace Space

Matériel recommandé

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

Déploiement rapide sur CLORE.AI

Image Docker :

pytorch/pytorch:2.11.0-cuda12.8-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. Accédez à Mes commandes la page

2. Cliquez sur votre commande

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

Utilisez https://YOUR_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 de service client

• Présentateurs éducatifs

Création de contenu

• Contenu pour les réseaux sociaux

• Supports marketing

• Concepts de clips musicaux

Divertissement

• Animez des photos historiques

• Animations de personnages

• Expériences interactives

Usages professionnels

• 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 des expressions

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 lots

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"Traitement de {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 - Animez n'importe quel portrait",
    description="Téléversez un portrait et une vidéo de conduite pour créer une vidéo animée. Exécution sur les serveurs GPU CLORE.AI."
)

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

Animation webcam en temps réel

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 l'image 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

Créez des avatars parlants avec la 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 sur les lèvres à partir de l'audio

# (En utilisant un outil séparé de synchronisation labiale ou une vidéo de conduite préfabriquée)

# 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	FPS	Latence
256x256	RTX 3070	30	33ms
256x256	RTX 4090	60+	16ms
512x512	RTX 4090	30	33ms
512x512	A100	45	22ms

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 soit clairement visible et de face

• Utilisez un bon éclairage dans l'image source

• Recadrez l'image pour centrer 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 nets

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

• Essayez différentes vidéos de conduite

Problèmes de qualité

Problème : Le résultat est flou ou déformé

Solutions :

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

Latence en temps réel

Problème : L'animation webcam est saccadée

Solutions :

• Utilisez une résolution de sortie plus faible (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 de vidéo de conduite à partir de l'audio

• 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 soit clairement visible dans la source

• Utilisez des photos de face

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

L'animation paraît artificielle

• 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 extraits de conduite plus courts

Vidéo de sortie 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 compatible de PyTorch

• Vérifiez que la version de CUDA correspond aux exigences

Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 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 40 Go	~$0.17	~$4.00	~$0.70
A100 80 Go	~$0.25	~$6.00	~$1.00

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

Économisez de l'argent :

• Utilisez le Spot marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane ~13 % de remise), les autres s'alignent dessus

• Payez avec CLORE jetons

• Comparez les prix entre différents fournisseurs

Étapes suivantes

• SadTalker - Alternative de tête parlante

• Wav2Lip - Meilleure synchronisation labiale

• XTTS - Génération vocale