InstantID

Genera imágenes con cualquier identidad facial a partir de una foto de referencia

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

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

Alquilar en CLORE.AI

1. Visita 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:

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

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

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

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

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

Retrato artístico

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

Personaje de fantasía

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

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

Con control de pose

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

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

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

# 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

# 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 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 - Indicación por imagen

• Stable Diffusion WebUI - extensión InstantID

• ControlNet - Control de pose