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

# ICLight

Beleuchte jedes Bild neu mit KI-gestützter Lichtsteuerung.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marktplatz](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
Alle Beispiele in diesem Leitfaden können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marktplatz](https://clore.ai/marketplace) Marktplatz ausgeführt werden.
{% endhint %}

## Mieten auf CLORE.AI

1. Besuchen [CLORE.AI Marktplatz](https://clore.ai/marketplace)
2. Nach GPU-Typ, VRAM und Preis filtern
3. Wählen **On-Demand** (fester Tarif) oder **Spot** (Gebotspreis)
4. Konfigurieren Sie Ihre Bestellung:
   * Docker-Image auswählen
   * Ports festlegen (TCP für SSH, HTTP für Web-UIs)
   * Bei Bedarf Umgebungsvariablen hinzufügen
   * Startbefehl eingeben
5. Zahlung auswählen: **CLORE**, **BTC**, oder **USDT/USDC**
6. Bestellung erstellen und auf Bereitstellung warten

### Zugriff auf Ihren Server

* Verbindungsdetails finden in **Meine Bestellungen**
* Weboberflächen: Verwenden Sie die HTTP-Port-URL
* SSH: `ssh -p <port> root@<proxy-address>`

## Was ist IC-Light?

IC-Light von lllyasviel ermöglicht:

* Bilder mit Textbeschreibungen neu zu beleuchten
* Lichtrichtung und Farbe zu ändern
* Schatten hinzuzufügen oder zu entfernen
* Studio-Lichteffekte zu erzeugen
* Vordergrund-/Hintergrund-Neubeleuchtung

## Ressourcen

* **GitHub:** [lllyasviel/IC-Light](https://github.com/lllyasviel/IC-Light)
* **HuggingFace:** [lllyasviel/IC-Light](https://huggingface.co/lllyasviel/IC-Light)
* **Demo:** [HuggingFace Space](https://huggingface.co/spaces/lllyasviel/IC-Light)
* **Paper:** Basierend auf der ControlNet-Architektur

## Empfohlene Hardware

| Komponente | Minimum       | Empfohlen     | Optimal       |
| ---------- | ------------- | ------------- | ------------- |
| GPU        | RTX 3060 12GB | RTX 4080 16GB | RTX 4090 24GB |
| VRAM       | 8GB           | 12GB          | 16GB          |
| CPU        | 4 Kerne       | 8 Kerne       | 16 Kerne      |
| RAM        | 16GB          | 32GB          | 64GB          |
| Speicher   | 30GB SSD      | 50GB NVMe     | 100GB NVMe    |
| Internet   | 100 Mbps      | 500 Mbps      | 1 Gbps        |

## Schnelle Bereitstellung auf CLORE.AI

**Docker-Image:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel
```

**Ports:**

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

**Befehl:**

```bash
cd /workspace && \
git clone https://github.com/lllyasviel/IC-Light.git && \
cd IC-Light && \
pip install -r requirements.txt && \
python gradio_demo.py
```

## Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre `http_pub` URL in **Meine Bestellungen**:

1. Gehen Sie zu **Meine Bestellungen** Seite
2. Klicken Sie auf Ihre Bestellung
3. Finden Sie die `http_pub` URL (z. B. `abc123.clorecloud.net`)

Verwenden Sie `https://IHRE_HTTP_PUB_URL` anstatt `localhost` in den Beispielen unten.

## Installation

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

# Modelle werden beim ersten Lauf automatisch heruntergeladen
```

## Was Sie erstellen können

### Produktfotografie

* Perfekte Beleuchtung für E-Commerce
* Konsistente Katalogbilder
* Studioqualität ohne Studio

### Porträtverbesserung

* Schlechte Beleuchtung in Fotos korrigieren
* Dramatische Lichteffekte hinzufügen
* Professionelle Bewerbungsfotos erstellen

### Kreative Projekte

* Stimmungswandel
* Tag-zu-Nacht-Konvertierung
* Künstlerische Lichteffekte

### Videoproduktion

* Beleuchtung zwischen Szenen angleichen
* VFX-taugliches Filmmaterial erstellen
* Beleuchtungsprobleme am Drehort beheben

### Marketingmaterialien

* Hero-Bild-Erstellung
* Konsistente Markenbilder
* Schnelle Fotoretusche

## Grundlegende Verwendung

### Vordergrund-Neubeleuchtung (FC-Modus)

Subjekt neu beleuchten, Hintergrund unverändert:

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

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

# Bild laden
image = Image.open("portrait.jpg")

# Mit Textprompt neu beleuchten
result = model.relight(
    image=image,
    prompt="golden hour sunlight from the left",
    num_inference_steps=25
)

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

### Hintergrundkonditioniert (FBC-Modus)

Vordergrund neu beleuchten, um zum neuen Hintergrund zu passen:

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

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

# Vordergrund und neuen Hintergrund laden
foreground = Image.open("person.png")  # Mit transparentem Hintergrund
background = Image.open("sunset_scene.jpg")

# Neu beleuchten, damit es zum Hintergrund passt
result = model.relight(
    foreground=foreground,
    background=background,
    prompt="warm sunset lighting",
    num_inference_steps=25
)

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

## Licht-Prompts

### Richtungsbasierte Beleuchtung

```python
prompts = [
    "helles Licht von der linken Seite",
    "weiches Licht von oben",
    "dramatisches Gegenlicht von hinten",
    "Kantenlicht von der rechten Seite",
    "frontales diffuses Licht",
    "niederiger Winkel von unten"
]
```

### Farbbasierte Beleuchtung

```python
prompts = [
    "warmes goldenes Sonnenlicht",
    "kühles blaues Zwielicht",
    "neonrosa Licht",
    "grünes Umgebungslicht",
    "oranger Sonnenuntergangsglanz",
    "weißes Studiolicht"
]
```

### Umgebungsbasierte Beleuchtung

```python
prompts = [
    "Tageslicht im Freien, heller Sonnenschein",
    "Innenraumfensterlicht, weiche Schatten",
    "nächtliche Stadtlichter, Neonreflexionen",
    "Kerzenlicht, warmes Flackern",
    "bewölkter Tag, diffuses Licht",
    "Studio-Softbox, professionell"
]
```

## Stapelverarbeitung

```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 = "professional studio lighting, soft shadows"

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"Processed: {filename}")
```

## Mehrere Lichtvariationen

```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": "bright natural daylight, clean white background",
    "dramatic": "dramatic side lighting, dark shadows",
    "warm": "warm golden hour, soft orange glow",
    "cool": "cool blue lighting, modern aesthetic",
    "studio": "professional studio softbox, even lighting"
}

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"Generated: {name}")
```

## Gradio-Oberfläche

```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="Eingabebild"),
        gr.Textbox(
            label="Licht-Prompt",
            value="professional studio lighting",
            placeholder="Beschreiben Sie die gewünschte Beleuchtung..."
        ),
        gr.Slider(10, 50, value=25, step=5, label="Schritte"),
        gr.Number(value=-1, label="Seed (-1 für zufällig)")
    ],
    outputs=gr.Image(label="Neu beleuchtetes Bild"),
    title="IC-Light - KI-Bild-Neubeleuchtung",
    description="Ändern Sie die Beleuchtung in jedem Bild mit Textbeschreibungen. Läuft auf CLORE.AI GPU-Servern.",
    examples=[
        ["example.jpg", "golden hour sunlight from the left", 25, -1],
        ["example.jpg", "dramatic rim lighting, dark background", 25, -1],
        ["example.jpg", "soft window light, gentle shadows", 25, -1]
    ]
)

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

## ComfyUI-Integration

IC-Light ist als ComfyUI-Knoten verfügbar:

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

### ComfyUI-Workflow

1. Laden Sie Ihr Bild
2. Fügen Sie den IC-Light Loader-Knoten hinzu
3. Verbinden Sie den IC-Light Apply-Knoten
4. Licht-Prompt festlegen
5. Mit KSampler verbinden
6. Ausgabe zu Save Image

## Mit Hintergrundentfernung

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

# Entfernen Sie zuerst den Hintergrund
original = Image.open("photo.jpg")
foreground = remove(original)

# Neuen Hintergrund laden
background = Image.open("studio_bg.jpg")

# Neu beleuchten, um anzupassen
model = ICLightFBC.from_pretrained("lllyasviel/IC-Light-FBC")
model.to("cuda")

result = model.relight(
    foreground=foreground,
    background=background,
    prompt="studio lighting matching background",
    num_inference_steps=25
)

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

## Leistung

| Modus            | Auflösung | GPU      | Geschwindigkeit |
| ---------------- | --------- | -------- | --------------- |
| FC (Vordergrund) | 512x512   | RTX 3090 | 3s              |
| FC (Vordergrund) | 512x512   | RTX 4090 | 2s              |
| FBC (Composit)   | 512x512   | RTX 4090 | 3s              |
| FC (Vordergrund) | 1024x1024 | A100     | 4s              |

## Modellvarianten

| Modell       | Beschreibung                       | Einsatzgebiet                 |
| ------------ | ---------------------------------- | ----------------------------- |
| IC-Light-FC  | Vordergrund-konsistent             | Einzelbild-Neubeleuchtung     |
| IC-Light-FBC | Vordergrund-Hintergrund-konsistent | Compositing mit Hintergründen |

## Häufige Probleme & Lösungen

### Beleuchtung ändert sich nicht

**Problem:** Ausgabe sieht dem Eingabebild ähnlich

**Lösungen:**

* Verwenden Sie beschreibendere Licht-Prompts
* Erhöhen Sie die Inferenzschritte auf 30–40
* Probieren Sie verschiedene Seed-Werte
* Verwenden Sie stärkeren Kontrast im Prompt (z. B. „dramatisch“ vs. „weich“)

```python

# Beschreibenderer Prompt
result = model.relight(
    image=image,
    prompt="extremely bright dramatic spotlight from upper left, dark shadows on right side",
    num_inference_steps=35
)
```

### Artefakte im Gesicht/Details

**Problem:** Gesicht oder Details sehen verzerrt aus

**Lösungen:**

* Stärke/Guidance-Scale verringern
* Mehr Inferenzschritte verwenden
* Lichtänderungen subtil halten
* Nachbearbeitung mit Gesichtsrestauration

### Farbverschiebungsprobleme

**Problem:** Ungewollte Farbänderungen

**Lösungen:**

* Seien Sie im Prompt spezifisch bezüglich der Farbe
* Fügen Sie „originale Farben bewahren" zum Prompt hinzu
* Verwenden Sie farbneutrale Lichtbeschreibungen
* Farben in der Nachbearbeitung korrigieren

### Hintergrundänderungen

**Problem:** Hintergrund ändert sich, obwohl nur der Vordergrund sollte

**Lösungen:**

* Verwenden Sie den FC-Modus (vordergrund-konsistent)
* Vorverarbeitung mit Hintergrundentfernung
* Maske verwenden, um das Motiv zu isolieren

### Inkonsistente Ergebnisse

**Problem:** Gleicher Prompt liefert sehr unterschiedliche Ergebnisse

**Lösungen:**

* Fester Seed für Reproduzierbarkeit setzen
* Inferenzschritte für Stabilität erhöhen
* Einfachere, direktere Prompts verwenden

```python

# Konsistente Ergebnisse mit festem Seed
result = model.relight(
    image=image,
    prompt=prompt,
    num_inference_steps=30,
    generator=torch.Generator("cuda").manual_seed(42)
)
```

## Fehlerbehebung

### Neubeleuchtung sieht unnatürlich aus

* Lichtrichtung an die Szene anpassen
* Geeignete Lichtintensität verwenden
* Berücksichtigen Sie Schatten im Originalbild

### Hintergrund beeinflusst

* Vordergrundmaske richtig verwenden
* Motiv zuerst vom Hintergrund segmentieren
* Lichtabfall-Einstellungen anpassen

### Ausgabe zu dunkel/hell

* Lichtintensitätswerte anpassen
* HDR-Ausgabe verwenden, wenn verfügbar
* Nachbearbeitung mit Kurven

### Modell lädt nicht

* Laden Sie alle erforderlichen Checkpoints herunter
* Dateiintegrität prüfen
* CUDA-Kompatibilität verifizieren

## Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (Stand 2024):

| GPU       | Stundensatz | Tagessatz | 4-Stunden-Session |
| --------- | ----------- | --------- | ----------------- |
| 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           |

*Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie* [*CLORE.AI Marktplatz*](https://clore.ai/marketplace) *für aktuelle Tarife.*

**Geld sparen:**

* Verwenden Sie **Spot** Markt für flexible Arbeitslasten (oft 30–50% günstiger)
* Bezahlen mit **CLORE** Token
* Preise bei verschiedenen Anbietern vergleichen

## Nächste Schritte

* [TripoSR](/guides/guides_v2-de/3d-generierung/triposr.md) - Konvertieren Sie neu beleuchtete Bilder in 3D
* Stable Diffusion - Bilder zum Neubeleuchten erzeugen
* ComfyUI - Erweiterte Workflow-Integration
* [Fooocus](/guides/guides_v2-de/bildgenerierung/fooocus-simple-sd.md) - Einfache Bildgenerierung


---

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

```
GET https://docs.clore.ai/guides/guides_v2-de/bildverarbeitung/iclight.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.