# IP-Adapter

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

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

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

```bash
pip install diffusers transformers accelerate
```

## Indicación de imagen básica

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

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

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

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

```python

# 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

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

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

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

```python

# 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

```python

# 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

```python

# 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

```python
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*](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

* [InstantID](/guides/guides_v2-es/rostro-e-identidad/instantid.md) - Identidad facial
* [ControlNet](/guides/guides_v2-es/procesamiento-de-imagenes/controlnet-advanced.md) - Control de estructura
* Stable Diffusion WebUI - extensión IP-Adapter


---

# 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/ip-adapter.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.