> 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

Permutation et amélioration professionnelles de visages sur les GPU Clore.ai

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

{% 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 %}

## 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 FaceFusion ?

FaceFusion propose :

* É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 12 Go | RTX 4080 16 Go | RTX 4090 24 Go |
| VRAM      | 8 Go           | 16 Go          | 24GB           |
| CPU       | 8 cœurs        | 16 cœurs       | 32 cœurs       |
| RAM       | 16 Go          | 32 Go          | 64 Go          |
| Stockage  | SSD de 50 Go   | NVMe de 100 Go | NVMe de 200 Go |
| 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
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. 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

# Installer FaceFusion
pip install facefusion

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

## Ce que vous pouvez créer

### Divertissement

* Préparation du doublage de films
* Contenu créé par des 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 :** Utilisez 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 à http://localhost:7860
```

### Ligne de commande

```bash

# Échange de visage sur une 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 sur une 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

# Initialisation
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 complet de visage sur 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"Traitement : {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="Visage source"),
        gr.Image(type="filepath", label="Image cible"),
        gr.Checkbox(label="Améliorer le résultat", value=True)
    ],
    outputs=gr.Image(label="Résultat"),
    title="FaceFusion - Échange de visages",
    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 | 2GB  |
| simswap\_256         | Meilleur | Moyen       | 6 Go |
| simswap\_512         | Meilleur | Lent        | 10GB |

### 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.5s  |
| Image unique  | 1024x1024  | RTX 4090 | 0.3s  |
| 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 bien visible
* Le visage doit mesurer au moins 64x64 pixels
* Utilisez des photos de face ou avec un léger angle
* Un bon éclairage est requis

### Échange de mauvaise qualité

**Problème :** Le résultat paraît artificiel

**Solutions :**

```bash

# Utilisez un meilleur modèle et 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 :**

* Utilisez le fournisseur d'exécution CUDA
* Augmentez le nombre de threads
* Utilisez le modèle fp16 pour la vitesse
* Traitez sur A100 pour de meilleures performances

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

### Discordance des couleurs

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

**Solutions :**

* Activez la correction des couleurs du visage
* Faites correspondre l'éclairage entre la source et la cible
* Appliquez un étalonnage des couleurs en post-traitement

### Problèmes de mémoire

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

**Solutions :**

```bash

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

## Dépannage

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

* Utilisez des images sources à plus haute résolution
* Assurez un bon éclairage dans les deux images
* Essayez différents modèles d'amélioration du visage

### "Aucun visage détecté"

* Le visage doit être clairement visible
* Évitez les profils de côté
* Vérifiez que l'image n'est pas trop petite

### Traitement vidéo bloqué

* Les grandes vidéos nécessitent plus de RAM
* Traitez par segments plus petits
* Utilisez un stockage SSD pour les fichiers temporaires

### Les modèles ne se téléchargent pas

* Vérifiez la connexion Internet
* Lancez avec `--download-models` indicateur
* Téléchargez manuellement depuis HuggingFace

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

* [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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/visage-et-identite/facefusion.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.