FaceFusion

Échange de visages professionnel et amélioration sur les GPU Clore.ai

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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

1. Visitez 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

• Documentation : docs.facefusion.io

• Discord : Communauté 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 :

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

# 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

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

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

Ligne de commande

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

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

# 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

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

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

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

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 :

# 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

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 :

# 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 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 - Préservation de l'identité

• LivePortrait - Animation de portrait

• GFPGAN - Restauration du visage