FaceFusion

Intercambio y mejora profesional de rostros en GPUs de Clore.ai

Herramienta profesional de intercambio y mejora de rostros.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

Alquilar en CLORE.AI

1. Visita CLORE.AI Marketplace

2. Filtrar por tipo de GPU, VRAM y precio

3. Elegir Bajo demanda (tarifa fija) o Spot (precio de puja)

4. Configura tu pedido:

   • Selecciona imagen Docker

   • Establece puertos (TCP para SSH, HTTP para interfaces web)

   • Agrega variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera el despliegue

Accede a tu servidor

• Encuentra los detalles de conexión en Mis Pedidos

• Interfaces web: Usa la URL del puerto HTTP

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

¿Qué es FaceFusion?

FaceFusion ofrece:

• Intercambio de rostros de alta calidad

• Mejora facial

• Modificación de edad

• Transferencia de expresiones

• Procesamiento de video

Recursos

• GitHub: facefusion/facefusion

• Documentación: docs.facefusion.io

• Discord: Comunidad FaceFusion

Hardware recomendado

Componente	Mínimo	Recomendado	Óptimo
GPU	RTX 3060 12GB	RTX 4080 16GB	RTX 4090 24GB
VRAM	8GB	16GB	24GB
CPU	8 núcleos	16 núcleos	32 núcleos
RAM	16GB	32GB	64GB
Almacenamiento	50GB SSD	100GB NVMe	200GB NVMe
Internet	100 Mbps	500 Mbps	1 Gbps

Despliegue rápido en CLORE.AI

Imagen Docker:

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

Puertos:

22/tcp
7860/http

Comando:

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

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis Pedidos:

1. Ir a Mis Pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Instalación

# Instalar FaceFusion
pip install facefusion

# O desde el código fuente
git clone https://github.com/facefusion/facefusion.git
cd facefusion
pip install -r requirements.txt

Lo que puedes crear

Entretenimiento

• Preparación de doblaje cinematográfico

• Contenido hecho por fans

• Creación de memes

Profesional

• Prueba virtual de moda

• Marketing personalizado

• Protección de privacidad en videos

Proyectos creativos

• Instalaciones artísticas

• Efectos para videoclips musicales

• Producción de cortometrajes

Importante: Úsese siempre de forma responsable y con consentimiento.

Uso básico

Interfaz web

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

# Acceder en http://localhost:7860

Línea de comandos

# Intercambio de rostros en imagen única
facefusion headless-run \
    --source-paths source_face.jpg \
    --target-path target_image.jpg \
    --output-path result.jpg \
    --face-swapper-model inswapper_128

# Intercambio de rostros en video
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 de Python

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

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

# Procesar imagen
result = swapper.process(
    source_image="source_face.jpg",
    target_image="target.jpg"
)

result.save("swapped.jpg")

Mejora facial

# Mejorar calidad del rostro
facefusion headless-run \
    --target-path input.jpg \
    --output-path enhanced.jpg \
    --face-enhancer-model gfpgan_1.4 \
    --face-enhancer-blend 80

Múltiples rostros

# Intercambiar rostros específicos
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

Procesamiento de video

# Intercambio completo de rostros en video con mejora
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

Procesamiento por lotes

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

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

# Rostro fuente
source = "my_face.jpg"

# Imágenes objetivo
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}")

Interfaz personalizada de 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="Rostro fuente"),
        gr.Image(type="filepath", label="Imagen objetivo"),
        gr.Checkbox(label="Mejorar resultado", value=True)
    ],
    outputs=gr.Image(label="Resultado"),
    title="FaceFusion - Intercambio de rostros",
    description="Intercambio de rostros profesional en los servidores de CLORE.AI"
)

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

Ajustes de calidad

Modelos de intercambio

Modelo	Calidad	Velocidad	VRAM
inswapper_128	Bueno	Rápido	4GB
inswapper_128_fp16	Bueno	Más rápido	2GB
simswap_256	Mejor	Medio	6GB
simswap_512	Mejor	Lento	10GB

Modelos de mejora

Modelo	Calidad	Velocidad
gfpgan_1.4	Genial	Medio
codeformer	Mejor	Lento
gpen_bfr_512	Bueno	Rápido

Rendimiento

Tarea	Resolución	GPU	Tiempo
Imagen única	1024x1024	RTX 3090	0.5s
Imagen única	1024x1024	RTX 4090	0.3s
Video (1 min)	1080p	RTX 4090	5 min
Video (1 min)	1080p	A100	3 min

Problemas comunes y soluciones

Rostro no detectado

Problema: "No se encontró rostro en fuente/objetivo"

Soluciones:

• Asegúrate de que la cara sea claramente visible

• El rostro debe tener al menos 64x64 píxeles

• Use fotos frontales o con un ligero ángulo

• Se requiere buena iluminación

Intercambio de mala calidad

Problema: El resultado parece antinatural

Soluciones:

# Use mejor modelo y mejora
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

Procesamiento de video lento

Problema: Toma demasiado tiempo para video

Soluciones:

• Use el proveedor de ejecución CUDA

• Aumente el número de hilos

• Use un modelo fp16 para velocidad

• Procese en A100 para el mejor rendimiento

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

Desajuste de color

Problema: El rostro intercambiado tiene un color diferente

Soluciones:

• Habilite la corrección del color del rostro

• Haga coincidir la iluminación entre fuente y objetivo

• Postprocese con gradación de color

Problemas de memoria

Problema: Memoria insuficiente en video

Soluciones:

# Reducir uso de memoria
facefusion headless-run \
    --video-memory-strategy tolerant \
    --execution-thread-count 2

Solución de problemas

Calidad de intercambio facial pobre

• Use imágenes fuente de mayor resolución

• Asegure buena iluminación en ambas imágenes

• Pruebe diferentes modelos de mejora facial

"No se detectó rostro"

• El rostro debe ser claramente visible

• Evite perfiles de lado

• Compruebe que la imagen no sea demasiado pequeña

Procesamiento de video atascado

• Los videos grandes necesitan más RAM

• Procese en segmentos más pequeños

• Use almacenamiento SSD para archivos temporales

Los modelos no se descargan

• Compruebe la conexión a Internet

• Ejecútelo con --download-models bandera

• Descargue manualmente desde HuggingFace

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

GPU	Tarifa por hora	Tarifa diaria	Sesión de 4 horas
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

Los precios varían según el proveedor y la demanda. Consulta CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

• Usa Spot market para cargas de trabajo flexibles (a menudo 30-50% más barato)

• Paga con CLORE tokens

• Compara precios entre diferentes proveedores

Próximos pasos

• InstantID - Preservación de identidad

• Retrato en vivo - Animación de retratos

• GFPGAN - Restauración facial