FaceFusion

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

Herramienta profesional de intercambio y mejora facial.

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

Alquilar en CLORE.AI

1. Visita Marketplace de CLORE.AI

2. Filtra por tipo de GPU, VRAM y precio

3. Elige Bajo demanda (tarifa fija) o Spot (precio ofertado)

4. Configura tu pedido:

   • Selecciona la imagen de Docker

   • Configura los puertos (TCP para SSH, HTTP para interfaces web)

   • Añade variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona el método de pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera al 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 de 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	SSD de 50 GB	NVMe de 100 GB	NVMe de 200 GB
Internet	100 Mbps	500 Mbps	1 Gbps

Despliegue rápido en CLORE.AI

Imagen de Docker:

pytorch/pytorch:2.11.0-cuda12.8-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. Ve a Mis pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (p. ej., abc123.clorecloud.net)

Usa https://YOUR_HTTP_PUB_URL en lugar de localhost en los ejemplos a continuación.

Instalación

# Instala 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 de películas

• Contenido hecho por fans

• Creación de memes

Profesional

• Prueba virtual de moda

• Marketing personalizado

• Protección de la privacidad en videos

Proyectos creativos

• Instalaciones artísticas

• Efectos para videoclips

• Producción de cortometrajes

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

Uso básico

Interfaz web

# Inicia la interfaz web
facefusion run --ui-layouts default

# Accede en http://localhost:7860

Línea de comandos

# Intercambio de rostros en una sola imagen
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

# Mejora la calidad facial
facefusion headless-run \
    --target-path input.jpg \
    --output-path enhanced.jpg \
    --face-enhancer-model gfpgan_1.4 \
    --face-enhancer-blend 80

Múltiples rostros

# Intercambia 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 de origen
source = "my_face.jpg"

# Imágenes de destino
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 de origen"),
        gr.Image(type="filepath", label="Imagen de destino"),
        gr.Checkbox(label="Mejorar resultado", value=True)
    ],
    outputs=gr.Image(label="Resultado"),
    title="FaceFusion - Intercambio de rostros",
    description="Intercambio profesional de rostros en servidores 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	2 GB
simswap_256	Mejor	Medio	6GB
simswap_512	Mejor	Lento	10GB

Modelos de mejora

Modelo	Calidad	Velocidad
gfpgan_1.4	Excelente	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ó ningún rostro en origen/destino"

Soluciones:

• Asegúrate de que el rostro sea claramente visible

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

• Usa fotos frontales o con un ligero ángulo

• Se requiere buena iluminación

Intercambio de mala calidad

Problema: El resultado se ve poco natural

Soluciones:

# Usa un modelo mejor 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: Tarda demasiado en video

Soluciones:

• Usa el proveedor de ejecución CUDA

• Aumenta el número de hilos

• Usa un modelo fp16 para mayor velocidad

• Procesa en A100 para obtener 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:

• Activa la corrección de color del rostro

• Iguala la iluminación entre origen y destino

• Posprocesa con gradación de color

Problemas de memoria

Problema: Memoria insuficiente en video

Soluciones:

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

Solución de problemas

La calidad del intercambio de rostros es mala

• Usa imágenes de origen de mayor resolución

• Asegúrate de que haya buena iluminación en ambas imágenes

• Prueba diferentes modelos de mejora facial

"No se detectó ningún rostro"

• El rostro debe verse con claridad

• Evita los perfiles laterales

• Comprueba que la imagen no sea demasiado pequeña

Procesamiento de video atascado

• Los videos grandes necesitan más RAM

• Procesa en segmentos más pequeños

• Usa almacenamiento SSD para archivos temporales

Los modelos no se descargan

• Comprueba la conexión a internet

• Ejecuta con --download-models bandera

• Descárgalos manualmente desde HuggingFace

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a partir 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 Marketplace de CLORE.AI las tarifas actuales.

Ahorra dinero:

• Usa el Spot mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de ~13% de descuento), el resto lo iguala

• Paga con CLORE tokens

• Compara precios entre distintos proveedores

Siguientes pasos

• InstantID - Preservación de la identidad

• LivePortrait - Animación de retratos

• GFPGAN - Restauración facial