IP-Adapter

Usa imágenes como prompts para Stable Diffusion con IP-Adapter

Usa imágenes como prompts para la generación de Stable Diffusion.

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

Alquilar en CLORE.AI

1. Visita Marketplace de CLORE.AI

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 IP-Adapter?

IP-Adapter permite la indicación con imágenes:

• Usa imágenes de referencia para guiar la generación

• Combínalo con indicaciones de texto

• Transferencia de estilo y de contenido

• Funciona con SD 1.5 y SDXL

Tipos de adaptador

Adaptador	Caso de uso	VRAM
IP-Adapter	Indicación general con imágenes	8GB
IP-Adapter-Plus	Mayor calidad	10GB
IP-Adapter-Face	Enfocado en rostros	10GB
IP-Adapter-Full-Face	Detalles faciales completos	12GB

Despliegue rápido

Imagen de Docker:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

Puertos:

22/tcp
7860/http

Comando:

pip install diffusers transformers accelerate && \\
python ip_adapter_app.py

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

pip install diffusers transformers accelerate

Indicación básica con imágenes

from diffusers import AutoPipelineForText2Image
from diffusers.utils import load_image
import torch

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

# Cargar IP-Adapter
pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="sdxl_models",
    weight_name="ip-adapter_sdxl.bin"
)

# Cargar imagen de referencia
ip_image = load_image("reference.jpg")

# Generar con una indicación de imagen
image = pipe(
    prompt="un gato en el mismo estilo",
    ip_adapter_image=ip_image,
    num_inference_steps=30
).images[0]

image.save("output.png")

Transferencia de estilo

from diffusers import AutoPipelineForText2Image
from diffusers.utils import load_image
import torch

pipe = AutoPipelineForText2Image.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
).to("cuda")

pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="models",
    weight_name="ip-adapter_sd15.bin"
)

# Imagen de referencia de estilo (por ejemplo, una pintura de Van Gogh)
style_image = load_image("van_gogh_starry_night.jpg")

# Generar nuevo contenido en ese estilo
image = pipe(
    prompt="un horizonte urbano moderno",
    ip_adapter_image=style_image,
    num_inference_steps=30,
    guidance_scale=7.5
).images[0]

image.save("city_van_gogh.png")

Adaptador facial

Para generación enfocada en rostros:

from diffusers import AutoPipelineForText2Image
from diffusers.utils import load_image
import torch

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

# Cargar adaptador específico para rostros
pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="sdxl_models",
    weight_name="ip-adapter-plus-face_sdxl_vit-h.bin"
)

# Rostro de referencia
face_image = load_image("face_reference.jpg")

# Generar retrato
image = pipe(
    prompt="retrato pictórico, óleo sobre lienzo, calidad de museo",
    ip_adapter_image=face_image,
    num_inference_steps=30
).images[0]

image.save("portrait.png")

Combinación de múltiples imágenes

from diffusers import AutoPipelineForText2Image
from diffusers.utils import load_image
import torch

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

pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="sdxl_models",
    weight_name="ip-adapter_sdxl.bin"
)

# Múltiples imágenes de referencia
images = [
    load_image("style1.jpg"),
    load_image("style2.jpg")
]

# Generar combinando ambas
image = pipe(
    prompt="pintura de paisaje",
    ip_adapter_image=images,
    num_inference_steps=30
).images[0]

Control de escala

# Establecer la fuerza del adaptador
pipe.set_ip_adapter_scale(0.6)  # 0.0 a 1.0

# Escala baja = mayor influencia de la indicación de texto

# Escala alta = mayor influencia de la indicación de imagen

# Escalado por imagen con múltiples imágenes
pipe.set_ip_adapter_scale([0.7, 0.3])

Con ControlNet

from diffusers import (
    AutoPipelineForText2Image,
    ControlNetModel
)
from diffusers.utils import load_image
import torch

# Cargar ControlNet
controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_canny",
    torch_dtype=torch.float16
)

pipe = AutoPipelineForText2Image.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

# Cargar IP-Adapter
pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="models",
    weight_name="ip-adapter_sd15.bin"
)

# Imagen de estilo
style_image = load_image("style.jpg")

# Imagen de control (mapa de bordes)
control_image = load_image("edges.png")

image = pipe(
    prompt="ilustración detallada",
    image=control_image,
    ip_adapter_image=style_image,
    num_inference_steps=30
).images[0]

Interfaz de Gradio

import gradio as gr
import torch
from diffusers import AutoPipelineForText2Image
from diffusers.utils import load_image

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

pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="sdxl_models",
    weight_name="ip-adapter_sdxl.bin"
)

def generate(reference_image, prompt, negative_prompt, scale, steps):
    pipe.set_ip_adapter_scale(scale)

    image = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        ip_adapter_image=reference_image,
        num_inference_steps=steps
    ).images[0]

    return image

demo = gr.Interface(
    fn=generate,
    inputs=[
        gr.Image(type="pil", label="Imagen de referencia"),
        gr.Textbox(label="Prompt", value="alta calidad"),
        gr.Textbox(label="Prompt negativo", value="feo, borroso"),
        gr.Slider(0.0, 1.0, value=0.6, label="Escala de IP-Adapter"),
        gr.Slider(10, 50, value=30, step=1, label="Pasos")
    ],
    outputs=gr.Image(label="Imagen generada"),
    title="Indicación de imágenes con IP-Adapter"
)

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

Transferencia de estilo por lotes

from diffusers import AutoPipelineForText2Image
from diffusers.utils import load_image
import torch
import os

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

pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="sdxl_models",
    weight_name="ip-adapter_sdxl.bin"
)

# Referencia de estilo
style_image = load_image("art_style.jpg")

# Sujetos a generar
subjects = [
    "un paisaje montañoso",
    "una ciudad de noche",
    "un bosque en otoño",
    "un atardecer sobre el océano",
    "un pueblo nevado"
]

output_dir = "./styled_outputs"
os.makedirs(output_dir, exist_ok=True)

for i, subject in enumerate(subjects):
    print(f"Generando {i+1}/{len(subjects)}: {subject}")

    image = pipe(
        prompt=subject,
        ip_adapter_image=style_image,
        num_inference_steps=30
    ).images[0]

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

Casos de uso

Estilo de fotografía de producto

# Referencia: foto profesional de producto
style = load_image("product_photo_reference.jpg")

image = pipe(
    prompt="zapatillas rojas sobre fondo blanco",
    ip_adapter_image=style,
    num_inference_steps=30
).images[0]

Transferencia de estilo artística

# Referencia: pintura famosa
style = load_image("monet_painting.jpg")

image = pipe(
    prompt="retrato de una mujer en un jardín",
    ip_adapter_image=style,
    num_inference_steps=30
).images[0]

Consistencia de marca

# Referencia: imagen de la guía de estilo de la marca
style = load_image("brand_style.jpg")

prompts = [
    "banner principal del sitio web",
    "publicación en redes sociales",
    "encabezado del boletín por correo electrónico"
]

for prompt in prompts:
    image = pipe(prompt=prompt, ip_adapter_image=style).images[0]

Optimización de memoria

pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()

# Para VRAM muy limitada
pipe.enable_sequential_cpu_offload()

Rendimiento

Modelo	GPU	Tiempo
SD 1.5 + IP-Adapter	RTX 3090	~5 s
SDXL + IP-Adapter	RTX 3090	~12 s
SDXL + IP-Adapter	RTX 4090	~8s
SDXL + IP-Adapter-Plus	RTX 4090	~10 s

Solución de problemas

El estilo no se aplicó

• Aumenta ip_adapter_scale

• Usa una imagen de referencia más nítida

• Asegúrate de que el adaptador se haya cargado correctamente

Demasiada influencia de la referencia

• Disminuye ip_adapter_scale

• Prompt de texto más específico

• Aumenta guidance_scale

Problemas de memoria

• Habilita la descarga a CPU

• Usa SD 1.5 en lugar de SDXL

• Menor resolución

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 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 - Identidad facial

• ControlNet - Control de estructura

• Extensión IP-Adapter para Stable Diffusion WebUI