ICLight

KI-gestimmtes Bild-Relighting mit IC-Light auf Clore.ai GPUs

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

Alle Beispiele können auf GPU-Servern ausgeführt werden, die über CLORE.AI Marktplatz.

Alle Beispiele in diesem Leitfaden können auf GPU-Servern ausgeführt werden, die über CLORE.AI Marktplatz Marktplatz ausgeführt werden.

Mieten auf CLORE.AI

1. Besuchen CLORE.AI Marktplatz

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

• HuggingFace: lllyasviel/IC-Light

• Demo: HuggingFace Space

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

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

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:

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:

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

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

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

Umgebungsbasierte Beleuchtung

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

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

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

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:

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

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“)

# 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

# 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 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 - Konvertieren Sie neu beleuchtete Bilder in 3D

• Stable Diffusion - Bilder zum Neubeleuchten erzeugen

• ComfyUI - Erweiterte Workflow-Integration

• Fooocus - Einfache Bildgenerierung