> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/rostro-e-identidad/facefusion.md).

# FaceFusion

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

Herramienta profesional de intercambio y mejora facial.

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

## Alquilar en CLORE.AI

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

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

```bash

# 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

```bash

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

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

### Línea de comandos

```bash

# 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

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

# 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

```bash

# 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

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

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

```bash

# 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

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

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

```bash

# 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*](https://clore.ai/marketplace) *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](/guides/guides_v2-es/rostro-e-identidad/instantid.md) - Preservación de la identidad
* [LivePortrait](/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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.