> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/tetes-parlantes/liveportrait.md).

# LivePortrait

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

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [Place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
Tous les exemples de ce guide peuvent être exécutés sur des serveurs GPU loués via [Place de marché CLORE.AI](https://clore.ai/marketplace) le marketplace.
{% endhint %}

## Location sur CLORE.AI

1. Visitez [Place de marché CLORE.AI](https://clore.ai/marketplace)
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](https://github.com/KwaiVGI/LivePortrait)
* **Article :** [Article LivePortrait](https://arxiv.org/abs/2407.03168)
* **HuggingFace :** [KwaiVGI/LivePortrait](https://huggingface.co/KwaiVGI/LivePortrait)
* **Démo :** [Espace HuggingFace](https://huggingface.co/spaces/KwaiVGI/LivePortrait)

## 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 :**

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

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

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

### API Python

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

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

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

```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="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

```python
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 :

```python
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 :**

```python

# 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

```python
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*](https://clore.ai/marketplace) *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](/guides/guides_v2-fr/tetes-parlantes/sadtalker.md) - Alternative pour talking head
* [Wav2Lip](/guides/guides_v2-fr/tetes-parlantes/wav2lip.md) - Meilleure synchronisation labiale
* [XTTS](/guides/guides_v2-fr/audio-et-voix/xtts-coqui.md) - Génération vocale


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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-fr/tetes-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.