# 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](https://docs.clore.ai/guides/guides_v2-de/3d-generierung/triposr) - Konvertieren Sie neu beleuchtete Bilder in 3D
* Stable Diffusion - Bilder zum Neubeleuchten erzeugen
* ComfyUI - Erweiterte Workflow-Integration
* [Fooocus](https://docs.clore.ai/guides/guides_v2-de/bildgenerierung/fooocus-simple-sd) - Einfache Bildgenerierung