> 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/visage-et-identite/facefusion.md).

# FaceFusion

Outil professionnel d'échange et d'amélioration de visages.

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

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](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é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@<adresse-proxy>`

## Qu'est-ce que FaceFusion ?

FaceFusion fournit :

* Échange de visages de haute qualité
* Amélioration du visage
* Modification de l'âge
* Transfert d'expression
* Traitement vidéo

## Ressources

* **GitHub :** [facefusion/facefusion](https://github.com/facefusion/facefusion)
* **Documentation :** [docs.facefusion.io](https://docs.facefusion.io/)
* **Discord :** [Communauté FaceFusion](https://discord.gg/facefusion)

## Matériel recommandé

| Composant | Minimum       | Recommandé    | Optimal       |
| --------- | ------------- | ------------- | ------------- |
| GPU       | RTX 3060 12GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM      | 8 Go          | 16Go          | 24 Go         |
| CPU       | 8 cœurs       | 16 cœurs      | 32 cœurs      |
| RAM       | 16Go          | 32Go          | 64Go          |
| Stockage  | 50 Go SSD     | 100Go NVMe    | 200 Go 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
pip install facefusion && \
facefusion run --ui-layouts default
```

## Accéder à votre service

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

1. Aller à la **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

# Installer FaceFusion
pip install facefusion

# Ou depuis la source
git clone https://github.com/facefusion/facefusion.git
cd facefusion
pip install -r requirements.txt
```

## Ce que vous pouvez créer

### Divertissement

* Préparation de doublage de film
* Contenu créé par les fans
* Création de mèmes

### Professionnel

* Essayage virtuel pour la mode
* Marketing personnalisé
* Protection de la vie privée dans les vidéos

### Projets créatifs

* Installations artistiques
* Effets pour clips musicaux
* Production de courts métrages

**Important :** Utiliser toujours de manière responsable et avec consentement.

## Utilisation de base

### Interface Web

```bash

# Démarrer l'interface Web
facefusion run --ui-layouts default

# Accéder sur http://localhost:7860
```

### Ligne de commande

```bash

# Échange de visage sur image unique
facefusion headless-run \
    --source-paths source_face.jpg \
    --target-path target_image.jpg \
    --output-path result.jpg \
    --face-swapper-model inswapper_128

# Échange de visage vidéo
facefusion headless-run \
    --source-paths source_face.jpg \
    --target-path input_video.mp4 \
    --output-path output_video.mp4 \
    --face-swapper-model inswapper_128 \
    --execution-providers cuda
```

### API Python

```python
from facefusion import core
from facefusion.processors.frame.face_swapper import FaceSwapper

# Initialiser
swapper = FaceSwapper(
    model="inswapper_128",
    device="cuda"
)

# Traiter l'image
result = swapper.process(
    source_image="source_face.jpg",
    target_image="target.jpg"
)

result.save("swapped.jpg")
```

## Amélioration du visage

```bash

# Améliorer la qualité du visage
facefusion headless-run \
    --target-path input.jpg \
    --output-path enhanced.jpg \
    --face-enhancer-model gfpgan_1.4 \
    --face-enhancer-blend 80
```

## Visages multiples

```bash

# Échanger des visages spécifiques
facefusion headless-run \
    --source-paths face1.jpg face2.jpg \
    --target-path group_photo.jpg \
    --output-path result.jpg \
    --face-selector-mode reference \
    --reference-face-position 0 1
```

## Traitement vidéo

```bash

# Échange de visage complet dans une vidéo avec amélioration
facefusion headless-run \
    --source-paths source_face.jpg \
    --target-path input_video.mp4 \
    --output-path output_video.mp4 \
    --face-swapper-model inswapper_128 \
    --face-enhancer-model gfpgan_1.4 \
    --execution-providers cuda \
    --execution-thread-count 4 \
    --video-encoder libx264 \
    --video-quality 18
```

## Traitement par lots

```python
import os
from facefusion import core
from facefusion.processors.frame.face_swapper import FaceSwapper

swapper = FaceSwapper(model="inswapper_128", device="cuda")

# Visage source
source = "my_face.jpg"

# Images cibles
targets = [f for f in os.listdir("./targets") if f.endswith(('.jpg', '.png'))]

os.makedirs("./results", exist_ok=True)

for target in targets:
    print(f"Processing: {target}")

    result = swapper.process(
        source_image=source,
        target_image=f"./targets/{target}"
    )

    result.save(f"./results/swapped_{target}")
```

## Interface personnalisée Gradio

```python
import gradio as gr
from facefusion.processors.frame.face_swapper import FaceSwapper

swapper = FaceSwapper(model="inswapper_128", device="cuda")

def swap_faces(source_image, target_image, enhance):
    result = swapper.process(
        source_image=source_image,
        target_image=target_image,
        enhance=enhance
    )
    return result

demo = gr.Interface(
    fn=swap_faces,
    inputs=[
        gr.Image(type="filepath", label="Source Face"),
        gr.Image(type="filepath", label="Target Image"),
        gr.Checkbox(label="Enhance Result", value=True)
    ],
    outputs=gr.Image(label="Result"),
    title="FaceFusion - Face Swapping",
    description="Échange de visages professionnel sur les serveurs CLORE.AI"
)

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

## Paramètres de qualité

### Modèles d'échange

| Modèle               | Qualité  | Vitesse     | VRAM |
| -------------------- | -------- | ----------- | ---- |
| inswapper\_128       | Bon      | Rapide      | 4 Go |
| inswapper\_128\_fp16 | Bon      | Plus rapide | 2Go  |
| simswap\_256         | Meilleur | Moyen       | 6 Go |
| simswap\_512         | Meilleur | Lent        | 10Go |

### Modèles d'amélioration

| Modèle         | Qualité   | Vitesse |
| -------------- | --------- | ------- |
| gfpgan\_1.4    | Excellent | Moyen   |
| codeformer     | Meilleur  | Lent    |
| gpen\_bfr\_512 | Bon       | Rapide  |

## Performances

| Tâche         | Résolution | GPU      | Temps |
| ------------- | ---------- | -------- | ----- |
| Image unique  | 1024x1024  | RTX 3090 | 0,5 s |
| Image unique  | 1024x1024  | RTX 4090 | 0,3 s |
| Vidéo (1 min) | 1080p      | RTX 4090 | 5 min |
| Vidéo (1 min) | 1080p      | A100     | 3 min |

## Problèmes courants et solutions

### Visage non détecté

**Problème :** "Aucun visage trouvé dans la source/la cible"

**Solutions :**

* Assurez-vous que le visage est clairement visible
* Le visage doit mesurer au moins 64x64 pixels
* Utiliser des photos frontales ou légèrement de three-quarter
* Bonne éclairage requis

### Échange de mauvaise qualité

**Problème :** Le résultat semble non naturel

**Solutions :**

```bash

# Utiliser un meilleur modèle et une amélioration
facefusion headless-run \
    --source-paths source.jpg \
    --target-path target.jpg \
    --output-path result.jpg \
    --face-swapper-model simswap_256 \
    --face-enhancer-model gfpgan_1.4 \
    --face-enhancer-blend 80
```

### Traitement vidéo lent

**Problème :** Prend trop de temps pour la vidéo

**Solutions :**

* Utiliser le fournisseur d'exécution CUDA
* Augmenter le nombre de threads
* Utiliser un modèle fp16 pour la vitesse
* Traiter sur A100 pour de meilleures performances

```bash
facefusion headless-run \
    --execution-providers cuda \
    --execution-thread-count 8 \
    --face-swapper-model inswapper_128_fp16
```

### Incohérence de couleur

**Problème :** Le visage échangé a une couleur différente

**Solutions :**

* Activer la correction de couleur du visage
* Faire correspondre l'éclairage entre la source et la cible
* Post-traiter avec étalonnage des couleurs

### Problèmes de mémoire

**Problème :** Mémoire insuffisante pour la vidéo

**Solutions :**

```bash

# Réduire l'utilisation de la mémoire
facefusion headless-run \
    --video-memory-strategy tolerant \
    --execution-thread-count 2
```

## Dépannage

### Qualité d'échange de visage médiocre

* Utiliser des images source de plus haute résolution
* Assurer un bon éclairage dans les deux images
* Essayer différents modèles d'améliorateur de visage

### "Aucun visage détecté"

* Le visage doit être clairement visible
* Éviter les profils latéraux
* Vérifier que l'image n'est pas trop petite

### Traitement vidéo bloqué

* Les grandes vidéos nécessitent plus de RAM
* Traiter en segments plus petits
* Utiliser un stockage SSD pour les fichiers temporaires

### Modèles non téléchargés

* Vérifier la connexion Internet
* Exécuter avec `--download-models` option
* Télécharger manuellement depuis HuggingFace

## 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* [*CLORE.AI Marketplace*](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** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* [InstantID](/guides/guides_v2-fr/visage-et-identite/instantid.md) - Préservation de l'identité
* [LivePortrait](/guides/guides_v2-fr/tetes-parlantes/liveportrait.md) - Animation de portrait
* [GFPGAN](/guides/guides_v2-fr/traitement-dimages/gfpgan-face-restore.md) - Restauration du visage


---

# 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/visage-et-identite/facefusion.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.