IP-Adapter

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

Usa imágenes como indicaciones para la generación con Stable Diffusion.

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

IP-Adapter permite el uso de imágenes como indicaciones:

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

• Combinar con indicaciones de texto

• Transferencia de estilo y transferencia de contenido

• Funciona con SD 1.5 y SDXL

Tipos de adaptadores

Adaptador	Caso de uso	VRAM
IP-Adapter	Indicación de imagen general	8GB
IP-Adapter-Plus	Mayor calidad	10GB
IP-Adapter-Face	Enfocado en rostros	10GB
IP-Adapter-Full-Face	Detalles completos del rostro	12GB

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 && \
python ip_adapter_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

Indicación de imagen básica

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 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"
)

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

# Generar contenido nuevo 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 de rostros

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 pintado, óleo sobre lienzo, calidad de museo",
    ip_adapter_image=face_image,
    num_inference_steps=30
).images[0]

image.save("portrait.png")

Combinando 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 mezclando ambas
image = pipe(
    prompt="pintura de paisaje",
    ip_adapter_image=images,
    num_inference_steps=30
).images[0]

Control de escala

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

# Escala baja = más influencia de la indicación de texto

# Escala alta = más 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 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 IP-Adapter"),
        gr.Slider(10, 50, value=30, step=1, label="Pasos")
    ],
    outputs=gr.Image(label="Imagen generada"),
    title="IP-Adapter Image Prompting"
)

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 en 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ístico

# 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 de 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	~5s
SDXL + IP-Adapter	RTX 3090	~12s
SDXL + IP-Adapter	RTX 4090	~8s
SDXL + IP-Adapter-Plus	RTX 4090	~10s

Solución de problemas

Estilo no aplicado

• Aumenta ip_adapter_scale

• Usa una imagen de referencia más clara

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

Demasiada influencia de la referencia

• Disminuye ip_adapter_scale

• Indicador de texto más específico

• Aumentar guidance_scale

Problemas de memoria

• Habilitar descarga a CPU

• Usa SD 1.5 en lugar de SDXL

• Reducir la resolución

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

• InstantID - Identidad facial

• ControlNet - Control de estructura

• Stable Diffusion WebUI - extensión IP-Adapter