> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/rostro-e-identidad/ip-adapter.md).

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

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [Marketplace de CLORE.AI](https://clore.ai/marketplace)
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:**

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

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

## Indicación básica con 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")

# 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

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

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

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

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

## Control de escala

```python

# 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

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

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

```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ística

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

```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 | \~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*](https://clore.ai/marketplace) *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](/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
* Extensión IP-Adapter para Stable Diffusion WebUI


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/rostro-e-identidad/ip-adapter.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.