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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/rostro-e-identidad/facefusion.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.