# FaceFusion

Herramienta profesional de intercambio y mejora de rostros.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [CLORE.AI Marketplace](https://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](https://github.com/facefusion/facefusion)
* **Documentación:** [docs.facefusion.io](https://docs.facefusion.io/)
* **Discord:** [Comunidad FaceFusion](https://discord.gg/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:**

```bash
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

```bash

# 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

```bash

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

# Acceder en http://localhost:7860
```

### Línea de comandos

```bash

# 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

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

```bash

# 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

```bash

# 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

```bash

# 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

```python
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

```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="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:**

```bash

# 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

```bash
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:**

```bash

# 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*](https://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](https://docs.clore.ai/guides/guides_v2-es/rostro-e-identidad/instantid) - Preservación de identidad
* [Retrato en vivo](https://docs.clore.ai/guides/guides_v2-es/cabezas-parlantes/liveportrait) - Animación de retratos
* [GFPGAN](https://docs.clore.ai/guides/guides_v2-es/procesamiento-de-imagenes/gfpgan-face-restore) - Restauración facial