> 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'une seule image sur Clore.ai

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 [la 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 [la place de marché CLORE.AI](https://clore.ai/marketplace) la place de marché.
{% endhint %}

## Louer sur CLORE.AI

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

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

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

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

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

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

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

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

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

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

```python

# 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

```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 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*](https://clore.ai/marketplace) *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](/guides/guides_v2-fr/tetes-parlantes/sadtalker.md) - Alternative de tête parlante
* [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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/tetes-parlantes/liveportrait.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.