FaceFusion

Professional face swapping and enhancement tool.

All examples can be run on GPU servers rented through CLORE.AI Marketplace.

Renting on CLORE.AI

1. Visit CLORE.AI Marketplace

2. Filter by GPU type, VRAM, and price

3. Choose On-Demand (fixed rate) or Spot (bid price)

4. Configure your order:

   • Select Docker image

   • Set ports (TCP for SSH, HTTP for web UIs)

   • Add environment variables if needed

   • Enter startup command

5. Select payment: CLORE, BTC, or USDT/USDC

6. Create order and wait for deployment

Access Your Server

• Find connection details in My Orders

• Web interfaces: Use the HTTP port URL

• SSH: ssh -p <port> root@<proxy-address>

What is FaceFusion?

FaceFusion provides:

• High-quality face swapping

• Face enhancement

• Age modification

• Expression transfer

• Video processing

Resources

• GitHub: facefusion/facefusion

• Documentation: docs.facefusion.io

• Discord: FaceFusion Community

Recommended Hardware

Component	Minimum	Recommended	Optimal
GPU	RTX 3060 12GB	RTX 4080 16GB	RTX 4090 24GB
VRAM	8GB	16GB	24GB
CPU	8 cores	16 cores	32 cores
RAM	16GB	32GB	64GB
Storage	50GB SSD	100GB NVMe	200GB NVMe
Internet	100 Mbps	500 Mbps	1 Gbps

Quick Deploy on CLORE.AI

Docker Image:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Ports:

22/tcp
7860/http

Command:

pip install facefusion && \
facefusion run --ui-layouts default

Accessing Your Service

After deployment, find your http_pub URL in My Orders:

1. Go to My Orders page

2. Click on your order

3. Find the http_pub URL (e.g., abc123.clorecloud.net)

Use https://YOUR_HTTP_PUB_URL instead of localhost in examples below.

Installation

# Install FaceFusion
pip install facefusion

# Or from source
git clone https://github.com/facefusion/facefusion.git
cd facefusion
pip install -r requirements.txt

What You Can Create

Entertainment

• Movie dubbing preparation

• Fan-made content

• Meme creation

Professional

• Virtual try-on for fashion

• Personalized marketing

• Privacy protection in videos

Creative Projects

• Art installations

• Music video effects

• Short film production

Important: Always use responsibly and with consent.

Basic Usage

Web Interface

# Start web UI
facefusion run --ui-layouts default

# Access at http://localhost:7860

Command Line

# Single image face swap
facefusion headless-run \
    --source-paths source_face.jpg \
    --target-path target_image.jpg \
    --output-path result.jpg \
    --face-swapper-model inswapper_128

# Video face swap
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

Python API

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

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

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

result.save("swapped.jpg")

Face Enhancement

# Enhance face quality
facefusion headless-run \
    --target-path input.jpg \
    --output-path enhanced.jpg \
    --face-enhancer-model gfpgan_1.4 \
    --face-enhancer-blend 80

Multiple Faces

# Swap specific faces
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

Video Processing

# Full video face swap with enhancement
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

Batch Processing

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

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

# Source face
source = "my_face.jpg"

# Target images
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}")

Gradio Custom Interface

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="Professional face swapping on CLORE.AI servers"
)

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

Quality Settings

Swap Models

Model	Quality	Speed	VRAM
inswapper_128	Good	Fast	4GB
inswapper_128_fp16	Good	Faster	2GB
simswap_256	Better	Medium	6GB
simswap_512	Best	Slow	10GB

Enhancement Models

Model	Quality	Speed
gfpgan_1.4	Great	Medium
codeformer	Best	Slow
gpen_bfr_512	Good	Fast

Performance

Task	Resolution	GPU	Time
Single image	1024x1024	RTX 3090	0.5s
Single image	1024x1024	RTX 4090	0.3s
Video (1 min)	1080p	RTX 4090	5 min
Video (1 min)	1080p	A100	3 min

Common Problems & Solutions

Face Not Detected

Problem: "No face found in source/target"

Solutions:

• Ensure face is clearly visible

• Face should be at least 64x64 pixels

• Use frontal or slight angle photos

• Good lighting required

Poor Quality Swap

Problem: Result looks unnatural

Solutions:

# Use better model and enhancement
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

Video Processing Slow

Problem: Takes too long for video

Solutions:

• Use CUDA execution provider

• Increase thread count

• Use fp16 model for speed

• Process on A100 for best performance

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

Color Mismatch

Problem: Swapped face has different color

Solutions:

• Enable face color correction

• Match lighting between source and target

• Post-process with color grading

Memory Issues

Problem: Out of memory on video

Solutions:

# Reduce memory usage
facefusion headless-run \
    --video-memory-strategy tolerant \
    --execution-thread-count 2

Troubleshooting

Face swap quality poor

• Use higher resolution source images

• Ensure good lighting in both images

• Try different face enhancer models

"No face detected"

• Face must be clearly visible

• Avoid side profiles

• Check image isn't too small

Video processing stuck

• Large videos need more RAM

• Process in smaller segments

• Use SSD storage for temp files

Models not downloading

• Check internet connection

• Run with --download-models flag

• Manually download from HuggingFace

Cost Estimate

Typical CLORE.AI marketplace rates (as of 2024):

GPU	Hourly Rate	Daily Rate	4-Hour Session
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

Prices vary by provider and demand. Check CLORE.AI Marketplace for current rates.

Save money:

• Use Spot market for flexible workloads (often 30-50% cheaper)

• Pay with CLORE tokens

• Compare prices across different providers

Next Steps

• InstantID - Identity preservation

• LivePortrait - Portrait animation

• GFPGAN - Face restoration