# InstantID

Genera imágenes con cualquier identidad facial usando solo una foto de referencia.

{% 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 InstantID?

InstantID preserva la identidad facial:

* Usa cualquier rostro de referencia
* Zero-shot: no se necesita entrenamiento
* Funciona con cualquier estilo/indicación
* Mejor que el entrenamiento LoRA

## Requisitos

| Modo         | VRAM  | Recomendado |
| ------------ | ----- | ----------- |
| Básico       | 12GB  | RTX 4080    |
| Alta calidad | 16GB  | RTX 4090    |
| Con Pose     | 16GB+ | RTX 4090    |

## Despliegue rápido

**Imagen Docker:**

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

**Puertos:**

```
22/tcp
7860/http
```

**Comando:**

```bash
pip install diffusers transformers accelerate opencv-python insightface onnxruntime-gpu && \
huggingface-cli download InstantX/InstantID --local-dir ./checkpoints && \
python instantid_app.py
```

## 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
pip install diffusers transformers accelerate
pip install opencv-python insightface onnxruntime-gpu
pip install huggingface_hub

# Descargar modelos
huggingface-cli download InstantX/InstantID --local-dir ./checkpoints
```

## Uso básico

```python
import torch
import cv2
import numpy as np
from PIL import Image
from diffusers import StableDiffusionXLPipeline, DDIMScheduler
from insightface.app import FaceAnalysis

# Inicializar el analizador de rostros
app = FaceAnalysis(name='antelopev2', root='./', providers=['CUDAExecutionProvider'])
app.prepare(ctx_id=0, det_size=(640, 640))

# Cargar pipeline
pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16
).to("cuda")

# Cargar componentes de InstantID
from diffusers import ControlNetModel

controlnet = ControlNetModel.from_pretrained(
    "./checkpoints/ControlNetModel",
    torch_dtype=torch.float16
)

# Cargar IP-Adapter para rostro
pipe.load_ip_adapter(
    "./checkpoints",
    subfolder="",
    weight_name="ip-adapter.bin"
)

# Procesar rostro de referencia
face_image = cv2.imread("reference_face.jpg")
faces = app.get(face_image)
face_emb = faces[0].normed_embedding

# Generar con identidad facial
image = pipe(
    prompt="retrato de una persona como astronauta, fondo espacial",
    negative_prompt="feo, borroso, baja calidad",
    ip_adapter_image_embeds=[torch.tensor(face_emb).unsqueeze(0)],
    num_inference_steps=30,
    guidance_scale=7.5
).images[0]

image.save("output.png")
```

## Usando Diffusers Pipeline

```python
from diffusers import StableDiffusionXLInstantIDPipeline, DDIMScheduler
from insightface.app import FaceAnalysis
import torch
import cv2

# Cargar analizador de rostros
app = FaceAnalysis(name='antelopev2', providers=['CUDAExecutionProvider'])
app.prepare(ctx_id=0)

# Cargar pipeline
pipe = StableDiffusionXLInstantIDPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    controlnet="./checkpoints/ControlNetModel",
    torch_dtype=torch.float16
).to("cuda")

pipe.load_ip_adapter_instantid("./checkpoints/ip-adapter.bin")

# Obtener embedding del rostro
face_image = cv2.imread("face.jpg")
face_info = app.get(face_image)[0]

face_emb = face_info.normed_embedding
face_kps = face_info.kps

# Generar
image = pipe(
    prompt="pintura de retrato en acuarela, artística",
    face_emb=face_emb,
    face_kps=face_kps,
    num_inference_steps=30
).images[0]

image.save("portrait.png")
```

## Ejemplos de estilos

### Retrato profesional

```python
prompt = "retrato corporativo profesional, iluminación de estudio, fondo gris, atuendo de negocios"
negative = "caricatura, anime, ilustración, borroso"
```

### Retrato artístico

```python
prompt = "retrato en óleo al estilo de Rembrandt, iluminación dramática, calidad de museo"
negative = "foto, realista, moderno"
```

### Personaje de fantasía

```python
prompt = "personaje elfo de fantasía, orejas puntiagudas, bosque mágico de fondo, iluminación etérea"
negative = "orejas humanas, ropa moderna, realista"
```

### Estilo anime

```python
prompt = "retrato de personaje anime, estilo Studio Ghibli, detallado, hermoso"
negative = "realista, foto, render 3D"
```

## Con control de pose

```python
from diffusers.utils import load_image

# Cargar referencia de pose
pose_image = load_image("pose_reference.jpg")

# Generar con rostro Y pose
image = pipe(
    prompt="persona en pose de acción, dinámica, alta calidad",
    face_emb=face_emb,
    face_kps=face_kps,
    image=pose_image,  # Referencia de pose
    controlnet_conditioning_scale=0.8,
    num_inference_steps=30
).images[0]
```

## Interfaz Gradio

```python
import gradio as gr
import torch
import cv2
import numpy as np
from diffusers import StableDiffusionXLInstantIDPipeline
from insightface.app import FaceAnalysis

app = FaceAnalysis(name='antelopev2', providers=['CUDAExecutionProvider'])
app.prepare(ctx_id=0)

pipe = StableDiffusionXLInstantIDPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    controlnet="./checkpoints/ControlNetModel",
    torch_dtype=torch.float16
).to("cuda")

pipe.load_ip_adapter_instantid("./checkpoints/ip-adapter.bin")

def generate(face_image, prompt, negative_prompt, strength, steps):
    # Convertir al formato cv2
    face_cv = cv2.cvtColor(np.array(face_image), cv2.COLOR_RGB2BGR)

    # Obtener información del rostro
    faces = app.get(face_cv)
    if len(faces) == 0:
        return None, "¡No se detectó ningún rostro!"

    face_info = faces[0]
    face_emb = face_info.normed_embedding
    face_kps = face_info.kps

    # Generar
    image = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        face_emb=face_emb,
        face_kps=face_kps,
        ip_adapter_scale=strength,
        num_inference_steps=steps
    ).images[0]

    return image, "¡Éxito!"

demo = gr.Interface(
    fn=generate,
    inputs=[
        gr.Image(type="pil", label="Rostro de referencia"),
        gr.Textbox(label="Prompt", value="retrato profesional"),
        gr.Textbox(label="Prompt negativo", value="feo, borroso"),
        gr.Slider(0.1, 1.0, value=0.8, label="Fuerza de identidad"),
        gr.Slider(10, 50, value=30, step=1, label="Pasos")
    ],
    outputs=[
        gr.Image(label="Imagen generada"),
        gr.Textbox(label="Estado")
    ],
    title="InstantID - Generación que preserva la identidad"
)

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

## Intercambio de rostros por lotes

```python
import os
from pathlib import Path

def batch_generate(face_image_path, prompts, output_dir):
    # Cargar rostro
    face_cv = cv2.imread(face_image_path)
    face_info = app.get(face_cv)[0]
    face_emb = face_info.normed_embedding
    face_kps = face_info.kps

    os.makedirs(output_dir, exist_ok=True)

    for i, prompt in enumerate(prompts):
        print(f"Generando {i+1}/{len(prompts)}: {prompt[:50]}...")

        image = pipe(
            prompt=prompt,
            negative_prompt="feo, borroso, deformado",
            face_emb=face_emb,
            face_kps=face_kps,
            num_inference_steps=30
        ).images[0]

        image.save(f"{output_dir}/output_{i:03d}.png")

# Uso
prompts = [
    "astronauta con traje espacial, fondo de la Tierra",
    "caballero medieval con armadura",
    "científico en laboratorio",
    "chef en la cocina del restaurante",
    "atleta en el campo deportivo"
]

batch_generate("my_face.jpg", prompts, "./outputs")
```

## Control de fuerza de identidad

```python

# Baja fuerza: más estilo, menos identidad
image_stylized = pipe(
    prompt=prompt,
    face_emb=face_emb,
    ip_adapter_scale=0.4,  # Bajo
    num_inference_steps=30
).images[0]

# Alta fuerza: más identidad, menos estilo
image_faithful = pipe(
    prompt=prompt,
    face_emb=face_emb,
    ip_adapter_scale=0.9,  # Alto
    num_inference_steps=30
).images[0]
```

## Optimización de memoria

```python

# Habilitar optimizaciones
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()

# O use descarga secuencial para VRAM muy baja
pipe.enable_sequential_cpu_offload()
```

## Rendimiento

| Modo     | GPU      | Tiempo por imagen |
| -------- | -------- | ----------------- |
| Básico   | RTX 4090 | \~8s              |
| Con Pose | RTX 4090 | \~12s             |
| Básico   | RTX 3090 | \~15s             |
| Básico   | A100     | \~5s              |

## Solución de problemas

### No se detectó rostro

* Asegúrate de que la cara sea claramente visible
* Buena iluminación en la imagen de referencia
* El rostro debe estar de frente

### Identidad no preservada

* Aumenta ip\_adapter\_scale
* Use una foto de referencia más clara
* Evite ángulos extremos

### Estilo no aplicado

* Disminuye ip\_adapter\_scale
* Prompt más descriptivo
* Aumentar guidance\_scale

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

* [IP-Adapter](/guides/guides_v2-es/rostro-e-identidad/ip-adapter.md) - Indicación por imagen
* Stable Diffusion WebUI - extensión InstantID
* [ControlNet](/guides/guides_v2-es/procesamiento-de-imagenes/controlnet-advanced.md) - Control de pose


---

# 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/instantid.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.