> 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

KI-gestütztes Neubeleuchten von Bildern mit IC-Light auf Clore.ai-GPUs

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 gemietet werden.
{% endhint %}

## Mieten auf CLORE.AI

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

### Auf deinen Server zugreifen

* Verbindungsdetails finden in **Meine Bestellungen**
* Weboberflächen: Verwende 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 beleuchten
* Lichtrichtung und -farbe ändern
* Schatten hinzufügen oder entfernen
* Studio-Lichteffekte erstellen
* Neubeleuchtung von Vorder- und Hintergrund

## 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:** Basiert auf der ControlNet-Architektur

## Empfohlene Hardware

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

## Schnellbereitstellung auf CLORE.AI

**Docker-Image:**

```
pytorch/pytorch:2.11.0-cuda12.8-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
```

## Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine `http_pub` URL in **Meine Bestellungen**:

1. Gehe zu **Meine Bestellungen** Seite
2. Klicke auf deine Bestellung
3. Finde die `http_pub` URL (z. B. `abc123.clorecloud.net`)

Verwende `https://YOUR_HTTP_PUB_URL` anstelle von `localhost` in den folgenden Beispielen.

## Installation

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

# Modelle werden beim ersten Start automatisch heruntergeladen
```

## Was du erstellen kannst

### Produktfotografie

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

### Porträtverbesserung

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

### Kreative Projekte

* Stimmungswandel
* Umwandlung von Tag zu Nacht
* Künstlerische Lichteffekte

### Videoproduktion

* Beleuchtung über verschiedene Szenen hinweg anpassen
* VFX-taugliches Material erstellen
* Probleme mit der Beleuchtung vor Ort beheben

### Marketingmaterialien

* Erstellung von Hero-Bildern
* Konsistente Markenbilder
* Schnelle Fotoretusche

## Grundlegende Verwendung

### Vordergrund-Neubeleuchtung (FC-Modus)

Motiv neu beleuchten, ohne den Hintergrund zu verändern:

```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 Text-Prompt neu beleuchten
result = model.relight(
    image=image,
    prompt="golden hour sunlight from the left",
    num_inference_steps=25
)

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

### Hintergrund-konditionierter Modus (FBC-Modus)

Vordergrund neu beleuchten, damit er zum neuen Hintergrund passt:

```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 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",
    "Randlicht von rechts",
    "frontales diffuses Licht",
    "Licht aus niedriger Perspektive von unten"
]
```

### Farbbasierte Beleuchtung

```python
prompts = [
    "warmes goldenes Sonnenlicht",
    "kühles blaues Zwielicht",
    "neonpinkes Licht",
    "grünes Umgebungslicht",
    "oranges Abendglühen",
    "weißes Studio-Licht"
]
```

### Umgebungsbasierte Beleuchtung

```python
prompts = [
    "Tageslicht im Freien, helle Sonne",
    "Fensterlicht im Innenraum, weiche Schatten",
    "Stadtlichter bei Nacht, Neonreflexionen",
    "Kerzenlicht, warm flackernd",
    "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 = "professionelle Studio-Beleuchtung, weiche Schatten"

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"Verarbeitet: {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": "helles natürliches Tageslicht, sauberer weißer Hintergrund",
    "dramatic": "dramatische Seitenbeleuchtung, dunkle Schatten",
    "warm": "warmes goldenes Stundenlicht, weiches orangefarbenes Leuchten",
    "cool": "kühles blaues Licht, moderne Ästhetik",
    "studio": "professionelle Studio-Softbox, gleichmäßige Beleuchtung"
}

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"Generiert: {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="professionelle Studio-Beleuchtung",
            placeholder="Beschreibe 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="Ändere 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. Lade dein Bild
2. IC-Light-Loader-Knoten hinzufügen
3. Mit dem IC-Light-Apply-Knoten verbinden
4. Licht-Prompt festlegen
5. Mit KSampler verbinden
6. Ausgabe an Save Image

## Mit Hintergrundentfernung

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

# Zuerst den Hintergrund entfernen
original = Image.open("photo.jpg")
foreground = remove(original)

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

# Anpassen durch Neu-Beleuchtung
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 | 3 s             |
| FC (Vordergrund)  | 512x512   | RTX 4090 | 2 s             |
| FBC (Komposition) | 512x512   | RTX 4090 | 3 s             |
| FC (Vordergrund)  | 1024x1024 | A100     | 4 s             |

## Modellvarianten

| Modell       | Beschreibung                           | Anwendungsfall                        |
| ------------ | -------------------------------------- | ------------------------------------- |
| IC-Light-FC  | Vordergrund konsistent                 | Neubeleuchtung eines einzelnen Bildes |
| IC-Light-FBC | Vordergrund und Hintergrund konsistent | Komposition mit Hintergründen         |

## Häufige Probleme & Lösungen

### Beleuchtung ändert sich nicht

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

**Lösungen:**

* Verwende ausführlichere Licht-Prompts
* Erhöhe die Inferenzschritte auf 30-40
* Probiere verschiedene Seed-Werte aus
* Verwende stärkeren Kontrast im Prompt (z. B. "dramatisch" statt "weich")

```python

# Ausführlicherer Prompt
result = model.relight(
    image=image,
    prompt="extrem helles dramatisches Spotlight von oben links, dunkle Schatten auf der rechten Seite",
    num_inference_steps=35
)
```

### Artefakte im Gesicht/bei Details

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

**Lösungen:**

* Stärke/Guidance-Scale reduzieren
* Mehr Inferenzschritte verwenden
* Beleuchtungsänderungen subtil halten
* Nachbearbeitung mit Gesichtsrestaurierung

### Probleme mit Farbverschiebungen

**Problem:** Unerwünschte Farbänderungen

**Lösungen:**

* Sei im Prompt konkret bezüglich der Farbe
* Füge "originale Farben beibehalten" zum Prompt hinzu
* Verwende farbneutrale Lichtbeschreibungen
* Farbkorrektur nach der Nachbearbeitung

### Hintergrundänderungen

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

**Lösungen:**

* FC-Modus verwenden (Vordergrund konsistent)
* Vorverarbeitung mit Hintergrundentfernung
* Maske verwenden, um das Motiv zu isolieren

### Inkonsistente Ergebnisse

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

**Lösungen:**

* Festes Seed für Reproduzierbarkeit festlegen
* Inference-Schritte für mehr 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

### Das Neubeleuchten wirkt unnatürlich

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

### Hintergrund betroffen

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

### Ausgabe zu dunkel/zu hell

* Werte der Lichtintensität anpassen
* HDR-Ausgabe verwenden, falls verfügbar
* Mit Gradationskurven nachbearbeiten

### Modell lädt nicht

* Alle erforderlichen Checkpoints herunterladen
* Dateiintegrität prüfen
* CUDA-Kompatibilität überprüfen

## Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise (Stand 2024):

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

*Die Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie* [*CLORE.AI-Marktplatz*](https://clore.ai/marketplace) *die aktuellen Preise.*

**Sparen Sie Geld:**

* Nutzen Sie den **Spot** Markt für unterbrechbare Arbeit — etwa ein Drittel der Server bietet Spot-Preise unter On-Demand (Median ca. 13 % Rabatt), der Rest ist gleich teuer
* Bezahlen Sie mit **CLORE** Token
* Preise verschiedener Anbieter vergleichen

## Nächste Schritte

* [TripoSR](/guides/guides_v2-de/3d-generierung/triposr.md) - Neu beleuchtete Bilder in 3D umwandeln
* Stable Diffusion - Bilder zum Neubeleuchten generieren
* ComfyUI - Erweiterte Workflow-Integration
* [Fooocus](/guides/guides_v2-de/bildgenerierung/fooocus-simple-sd.md) - Einfache Bilderzeugung


---

# 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-de/bildverarbeitung/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.