> 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/procesamiento-de-imagenes/iclight.md).

# ICLight

Reiluminación de imágenes impulsada por IA con IC-Light en GPUs de Clore.ai

Reilumina cualquier imagen con control de iluminación impulsado por IA.

{% 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 %}

{% hint style="info" %}
Todos los ejemplos de esta guía se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace) mercado.
{% 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 de oferta)
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 pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera el despliegue

### Accede a tu servidor

* Encuentra los datos de conexión en **Mis pedidos**
* Interfaces web: usa la URL del puerto HTTP
* SSH: `ssh -p <port> root@<proxy-address>`

## ¿Qué es IC-Light?

IC-Light de lllyasviel permite:

* Reiluminar imágenes con descripciones de texto
* Cambiar la dirección y el color de la iluminación
* Añadir o eliminar sombras
* Crear efectos de iluminación de estudio
* Reiluminación de primer plano/fondo

## Recursos

* **GitHub:** [lllyasviel/IC-Light](https://github.com/lllyasviel/IC-Light)
* **Hugging Face:** [lllyasviel/IC-Light](https://huggingface.co/lllyasviel/IC-Light)
* **Demo:** [Espacio de Hugging Face](https://huggingface.co/spaces/lllyasviel/IC-Light)
* **Artículo:** Basado en la arquitectura de ControlNet

## Hardware recomendado

| Componente     | Mínimo        | Recomendado   | Óptimo        |
| -------------- | ------------- | ------------- | ------------- |
| GPU            | RTX 3060 12GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM           | 8GB           | 12GB          | 16GB          |
| CPU            | 4 núcleos     | 8 núcleos     | 16 núcleos    |
| RAM            | 16GB          | 32GB          | 64GB          |
| Almacenamiento | 30GB SSD      | 50GB NVMe     | 100GB NVMe    |
| Internet       | 100 Mbps      | 500 Mbps      | 1 Gbps        |

## Despliegue rápido en CLORE.AI

**Imagen de Docker:**

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

**Puertos:**

```
22/tcp
7860/http
```

**Comando:**

```bash
cd /workspace && \\
git clone https://github.com/lllyasviel/IC-Light.git && \\
cd IC-Light && \\
pip install -r requirements.txt && \\
python gradio_demo.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 de abajo.

## Instalación

```bash
git clone https://github.com/lllyasviel/IC-Light.git
cd IC-Light
pip install -r requirements.txt

# Los modelos se descargan automáticamente en la primera ejecución
```

## Lo que puedes crear

### Fotografía de producto

* Iluminación perfecta para comercio electrónico
* Imágenes de catálogo coherentes
* Resultados de calidad de estudio sin estudio

### Mejora de retratos

* Corrige la mala iluminación en fotos
* Añade efectos de iluminación dramáticos
* Crea retratos profesionales

### Proyectos creativos

* Transformación del ambiente
* Conversión de día a noche
* Efectos de iluminación artísticos

### Producción de video

* Iguala la iluminación entre escenas
* Crea metraje listo para VFX
* Corrige problemas de iluminación en exteriores

### Materiales de marketing

* Creación de imágenes principales
* Imágenes de marca coherentes
* Retoque fotográfico rápido

## Uso básico

### Reiluminación de primer plano (modo FC)

Reilumina el sujeto manteniendo intacto el fondo:

```python
import torch
from PIL import Image
from diffusers import StableDiffusionPipeline
from ic_light import ICLightFC

# Cargar modelo
model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

# Cargar imagen
image = Image.open("portrait.jpg")

# Reiluminar con prompt de texto
result = model.relight(
    image=image,
    prompt="luz solar de la hora dorada desde la izquierda",
    num_inference_steps=25
)

result.save("relit_portrait.jpg")
```

### Condicionado por el fondo (modo FBC)

Reilumina el primer plano para que coincida con el nuevo fondo:

```python
from ic_light import ICLightFBC
from PIL import Image

model = ICLightFBC.from_pretrained("lllyasviel/IC-Light-FBC")
model.to("cuda")

# Cargar primer plano y nuevo fondo
foreground = Image.open("person.png")  # Con fondo transparente
background = Image.open("sunset_scene.jpg")

# Reiluminar para que coincida con el fondo
result = model.relight(
    foreground=foreground,
    background=background,
    prompt="iluminación cálida de atardecer",
    num_inference_steps=25
)

result.save("composited.jpg")
```

## Prompts de iluminación

### Iluminación basada en la dirección

```python
prompts = [
    "luz brillante desde el lado izquierdo",
    "luz suave desde arriba",
    "contraluz dramático desde atrás",
    "iluminación de borde desde la derecha",
    "luz difusa frontal",
    "luz de ángulo bajo desde abajo"
]
```

### Iluminación basada en el color

```python
prompts = [
    "luz solar dorada y cálida",
    "crepúsculo azul frío",
    "luz rosa neón",
    "luz ambiental verde",
    "resplandor naranja de atardecer",
    "iluminación de estudio blanca"
]
```

### Iluminación basada en el entorno

```python
prompts = [
    "luz diurna exterior, sol brillante",
    "luz de ventana interior, sombras suaves",
    "luces urbanas nocturnas, reflejos de neón",
    "luz de velas, titilante cálida",
    "día nublado, iluminación difusa",
    "softbox de estudio, profesional"
]
```

## Procesamiento por lotes

```python
import os
from PIL import Image
from ic_light import ICLightFC

model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

input_dir = "./images"
output_dir = "./relit"
os.makedirs(output_dir, exist_ok=True)

lighting_prompt = "iluminación profesional de estudio, sombras suaves"

for filename in os.listdir(input_dir):
    if not filename.endswith(('.jpg', '.png')):
        continue

    image = Image.open(os.path.join(input_dir, filename))

    result = model.relight(
        image=image,
        prompt=lighting_prompt,
        num_inference_steps=25
    )

    result.save(os.path.join(output_dir, f"relit_{filename}"))
    print(f"Procesado: {filename}")
```

## Múltiples variaciones de iluminación

```python
from ic_light import ICLightFC
from PIL import Image
import os

model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

image = Image.open("product.jpg")

lighting_variations = {
    "daylight": "luz diurna natural brillante, fondo blanco limpio",
    "dramatic": "iluminación lateral dramática, sombras oscuras",
    "warm": "hora dorada cálida, resplandor naranja suave",
    "cool": "iluminación azul fría, estética moderna",
    "studio": "softbox profesional de estudio, iluminación uniforme"
}

os.makedirs("./variations", exist_ok=True)

for name, prompt in lighting_variations.items():
    result = model.relight(
        image=image,
        prompt=prompt,
        num_inference_steps=25
    )
    result.save(f"./variations/{name}.jpg")
    print(f"Generado: {name}")
```

## Interfaz de Gradio

```python
import gradio as gr
from PIL import Image
from ic_light import ICLightFC

model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

def relight_image(image, prompt, steps, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    result = model.relight(
        image=image,
        prompt=prompt,
        num_inference_steps=steps,
        generator=generator
    )

    return result

demo = gr.Interface(
    fn=relight_image,
    inputs=[
        gr.Image(type="pil", label="Imagen de entrada"),
        gr.Textbox(
            label="Prompt de iluminación",
            value="iluminación profesional de estudio",
            placeholder="Describe la iluminación deseada..."
        ),
        gr.Slider(10, 50, value=25, step=5, label="Pasos"),
        gr.Number(value=-1, label="Semilla (-1 para aleatorio)")
    ],
    outputs=gr.Image(label="Imagen reiluminada"),
    title="IC-Light - Reiluminación de imágenes con IA",
    description="Cambia la iluminación de cualquier imagen con descripciones de texto. Ejecutándose en servidores GPU de CLORE.AI.",
    examples=[
        ["example.jpg", "luz solar de la hora dorada desde la izquierda", 25, -1],
        ["example.jpg", "iluminación de borde dramática, fondo oscuro", 25, -1],
        ["example.jpg", "luz suave de ventana, sombras suaves", 25, -1]
    ]
)

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

## Integración con ComfyUI

IC-Light está disponible como nodos de ComfyUI:

```bash
cd ComfyUI/custom_nodes
git clone https://github.com/kijai/ComfyUI-IC-Light.git
```

### Flujo de trabajo de ComfyUI

1. Carga tu imagen
2. Añade el nodo IC-Light Loader
3. Conecta al nodo IC-Light Apply
4. Establece el prompt de iluminación
5. Conecta a KSampler
6. Salida a Guardar imagen

## Con eliminación de fondo

```python
from ic_light import ICLightFBC
from rembg import remove
from PIL import Image

# Elimina primero el fondo
original = Image.open("photo.jpg")
foreground = remove(original)

# Cargar nuevo fondo
background = Image.open("studio_bg.jpg")

# Reiluminar para que coincida
model = ICLightFBC.from_pretrained("lllyasviel/IC-Light-FBC")
model.to("cuda")

result = model.relight(
    foreground=foreground,
    background=background,
    prompt="iluminación de estudio que coincida con el fondo",
    num_inference_steps=25
)

result.save("composited.jpg")
```

## Rendimiento

| Modo              | Resolución | GPU      | Velocidad |
| ----------------- | ---------- | -------- | --------- |
| FC (primer plano) | 512x512    | RTX 3090 | 3 s       |
| FC (primer plano) | 512x512    | RTX 4090 | 2 s       |
| FBC (composición) | 512x512    | RTX 4090 | 3 s       |
| FC (primer plano) | 1024x1024  | A100     | 4 s       |

## Variantes del modelo

| Modelo       | Descripción                            | Caso de uso                      |
| ------------ | -------------------------------------- | -------------------------------- |
| IC-Light-FC  | Consistente en primer plano            | Reiluminación de una sola imagen |
| IC-Light-FBC | Consistente entre primer plano y fondo | Composición con fondos           |

## Problemas comunes y soluciones

### La iluminación no cambia

**Problema:** La salida se parece a la entrada

**Soluciones:**

* Usa prompts de iluminación más descriptivos
* Aumenta los pasos de inferencia a 30-40
* Prueba distintos valores de semilla
* Usa un contraste más fuerte en el prompt (p. ej., "dramático" frente a "suave")

```python

# Prompt más descriptivo
result = model.relight(
    image=image,
    prompt="foco dramático extremadamente brillante desde la parte superior izquierda, sombras oscuras en el lado derecho",
    num_inference_steps=35
)
```

### Artefactos en el rostro/detalles

**Problema:** El rostro o los detalles se ven distorsionados

**Soluciones:**

* Reduce la escala de fuerza/guía
* Usa más pasos de inferencia
* Mantén los cambios de iluminación sutiles
* Posprocesa con restauración facial

### Problemas de cambio de color

**Problema:** Cambios de color no deseados

**Soluciones:**

* Sé específico sobre el color en el prompt
* Añade "preservar los colores originales" al prompt
* Usa descripciones de iluminación neutras en color
* Corrección de color posterior al proceso

### Cambios en el fondo

**Problema:** El fondo cambia cuando solo el primer plano debería

**Soluciones:**

* Usar modo FC (primer plano consistente)
* Preprocesar con eliminación de fondo
* Usar una máscara para aislar el sujeto

### Resultados inconsistentes

**Problema:** El mismo prompt da resultados muy diferentes

**Soluciones:**

* Establecer una semilla fija para la reproducibilidad
* Aumentar los pasos de inferencia para mayor estabilidad
* Usar prompts más simples y directos

```python

# Resultados consistentes con semilla fija
result = model.relight(
    image=image,
    prompt=prompt,
    num_inference_steps=30,
    generator=torch.Generator("cuda").manual_seed(42)
)
```

## Solución de problemas

### La reiluminación se ve antinatural

* Hacer coincidir la dirección de la iluminación con la escena
* Usar una intensidad de luz adecuada
* Considerar las sombras en la imagen original

### Fondo afectado

* Usar correctamente la máscara del primer plano
* Segmentar primero el sujeto del fondo
* Ajustar la configuración de atenuación de la luz

### Salida demasiado oscura/brillante

* Ajustar los valores de intensidad de la luz
* Usar salida HDR si está disponible
* Posprocesar con curvas

### El modelo no se carga

* Descargar todos los checkpoints requeridos
* Verificar la integridad del archivo
* Verificar la compatibilidad con CUDA

## 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 40 GB | \~$0.17         | \~$4.00       | \~$0.70           |
| A100 80 GB | \~$0.25         | \~$6.00       | \~$1.00           |

*Los precios varían según el proveedor y la demanda. Consulte* [*Marketplace de CLORE.AI*](https://clore.ai/marketplace) *las tarifas actuales.*

**Ahorra dinero:**

* Usa el **Spot** mercado para trabajo interrumpible: aproximadamente un tercio de los servidores cotizan spot por debajo de la tarifa bajo demanda (mediana \~13% de descuento), el resto la iguala
* Paga con **CLORE** tokens
* Compara precios entre diferentes proveedores

## Próximos pasos

* [TripoSR](/guides/guides_v2-es/generacion-3d/triposr.md) - Convertir imágenes reiluminadas a 3D
* Stable Diffusion - Generar imágenes para reiluminar
* ComfyUI - Integración avanzada de flujos de trabajo
* [Fooocus](/guides/guides_v2-es/generacion-de-imagenes/fooocus-simple-sd.md) - Generación de imágenes sencilla


---

# 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/procesamiento-de-imagenes/iclight.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.