ICLight

Reclairage d'images assisté par IA avec IC-Light sur les GPU Clore.ai

Rééclairez n’importe quelle image avec un contrôle d’éclairage optimisé par l’IA.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Tous les exemples de ce guide peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI la place de marché.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

2. Filtrer par type de GPU, VRAM et prix

3. Choisissez À la demande (tarif fixe) ou Spot (prix d’enchère)

4. Configurez votre commande :

   • Sélectionnez l’image Docker

   • Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)

   • Ajoutez des variables d’environnement si nécessaire

   • Saisissez la commande de démarrage

5. Sélectionnez le paiement : CLORE, BTCou USDT/USDC

6. Créez la commande et attendez le déploiement

Accédez à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces web : utilisez l’URL du port HTTP

• SSH : ssh -p <port> root@<proxy-address>

Qu’est-ce qu’IC-Light ?

IC-Light par lllyasviel permet :

• Rééclairer des images à partir de descriptions textuelles

• Modifier la direction et la couleur de l’éclairage

• Ajouter ou supprimer des ombres

• Créer des effets d’éclairage de studio

• Rééclairage du premier plan/de l’arrière-plan

Ressources

• GitHub : lllyasviel/IC-Light

• HuggingFace : lllyasviel/IC-Light

• Démo : HuggingFace Space

• Article : Basé sur l’architecture ControlNet

Matériel recommandé

Composant	Minimum	Recommandé	Optimal
GPU	RTX 3060 12 Go	RTX 4080 16 Go	RTX 4090 24 Go
VRAM	8 Go	12 Go	16 Go
CPU	4 cœurs	8 cœurs	16 cœurs
RAM	16 Go	32 Go	64 Go
Stockage	30 Go SSD	50 Go NVMe	100 Go NVMe
Internet	100 Mbps	500 Mbps	1 Gbps

Déploiement rapide sur CLORE.AI

Image Docker :

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

Ports :

22/tcp
7860/http

Commande :

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

Accès à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Allez à la Mes commandes page

2. Cliquez sur votre commande

3. Trouvez l’ http_pub URL (par ex. : abc123.clorecloud.net)

Utilisez https://YOUR_HTTP_PUB_URL à la place de localhost dans les exemples ci-dessous.

Installation

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

# Les modèles se téléchargent automatiquement au premier lancement

Ce que vous pouvez créer

Photographie de produits

• Éclairage parfait pour le commerce en ligne

• Images de catalogue cohérentes

• Résultats de qualité studio sans studio

Amélioration des portraits

• Corriger un mauvais éclairage sur les photos

• Ajouter des effets d’éclairage dramatiques

• Créer des portraits professionnels

Projets créatifs

• Transformation d’ambiance

• Conversion du jour à la nuit

• Effets d’éclairage artistiques

Production vidéo

• Faire correspondre l’éclairage entre les scènes

• Créer des séquences prêtes pour les VFX

• Corriger les problèmes d’éclairage sur le lieu de prise de vue

Supports marketing

• Création d’images phares

• Visuels de marque cohérents

• Retouche photo rapide

Utilisation de base

Rééclairage du premier plan (mode FC)

Rééclairez le sujet en conservant l’arrière-plan :

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

# Charger le modèle
model = ICLightFC.from_pretrained("lllyasviel/IC-Light-FC")
model.to("cuda")

# Charger l’image
image = Image.open("portrait.jpg")

# Rééclairer avec une invite textuelle
result = model.relight(
    image=image,
    prompt="golden hour sunlight from the left",
    num_inference_steps=25
)

result.save("relit_portrait.jpg")

Conditionné par l’arrière-plan (mode FBC)

Rééclairez le premier plan pour correspondre au nouvel arrière-plan :

from ic_light import ICLightFBC
from PIL import Image

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

# Charger le premier plan et le nouvel arrière-plan
foreground = Image.open("person.png")  # Avec arrière-plan transparent
background = Image.open("sunset_scene.jpg")

# Rééclairer pour correspondre à l’arrière-plan
result = model.relight(
    foreground=foreground,
    background=background,
    prompt="warm sunset lighting",
    num_inference_steps=25
)

result.save("composited.jpg")

Invites d’éclairage

Éclairage basé sur la direction

prompts = [
    "bright light from the left side",
    "soft light from above",
    "dramatic backlight from behind",
    "rim lighting from the right",
    "front facing diffused light",
    "low angle light from below"
]

Éclairage basé sur la couleur

prompts = [
    "warm golden sunlight",
    "cool blue twilight",
    "neon pink light",
    "green ambient light",
    "orange sunset glow",
    "white studio lighting"
]

Éclairage basé sur l’environnement

prompts = [
    "outdoor daylight, bright sun",
    "indoor window light, soft shadows",
    "night city lights, neon reflections",
    "candlelight, warm flickering",
    "cloudy day, diffused lighting",
    "studio softbox, professional"
]

Traitement par lots

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}")

Plusieurs variantes d’éclairage

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}")

Interface Gradio

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="Image d’entrée"),
        gr.Textbox(
            label="Invite d’éclairage",
            value="professional studio lighting",
            placeholder="Décrivez l’éclairage souhaité..."
        ),
        gr.Slider(10, 50, value=25, step=5, label="Étapes"),
        gr.Number(value=-1, label="Seed (-1 pour aléatoire)")
    ],
    outputs=gr.Image(label="Image rééclairée"),
    title="IC-Light - Rééclairage d’images par IA",
    Changez l’éclairage de n’importe quelle image avec des descriptions textuelles. Exécuté sur des serveurs GPU CLORE.AI.
    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)

Intégration ComfyUI

IC-Light est disponible sous forme de nœuds ComfyUI :

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

Flux de travail ComfyUI

1. Chargez votre image

2. Ajoutez le nœud IC-Light Loader

3. Connectez au nœud IC-Light Apply

4. Définissez l’invite d’éclairage

5. Connectez à KSampler

6. Sortie vers Save Image

Avec suppression de l’arrière-plan

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

# Supprimer d’abord l’arrière-plan
original = Image.open("photo.jpg")
foreground = remove(original)

# Charger le nouvel arrière-plan
background = Image.open("studio_bg.jpg")

# Rééclairer pour faire correspondre
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")

Performances

Mode	Résolution	GPU	Vitesse
FC (premier plan)	512x512	RTX 3090	3 s
FC (premier plan)	512x512	RTX 4090	2 s
FBC (composition)	512x512	RTX 4090	3 s
FC (premier plan)	1024x1024	A100	4 s

Variantes de modèle

Modèle	Description	Cas d’utilisation
IC-Light-FC	Cohérent avec le premier plan	Rééclairage d’une seule image
IC-Light-FBC	Cohérent entre premier plan et arrière-plan	Composition avec des arrière-plans

Problèmes courants et solutions

L’éclairage ne change pas

Problème : Le résultat ressemble à l’entrée

Solutions :

• Utilisez des invites d’éclairage plus descriptives

• Augmentez les étapes d’inférence à 30-40

• Essayez différentes valeurs de seed

• Utilisez un contraste plus fort dans l’invite (par ex. : "dramatique" vs "doux")

# Invite plus descriptive
result = model.relight(
    image=image,
    prompt="projecteur dramatique extrêmement lumineux depuis le coin supérieur gauche, ombres sombres sur le côté droit",
    num_inference_steps=35
)

Artefacts sur le visage/les détails

Problème : Le visage ou les détails semblent déformés

Solutions :

• Réduisez la force/l’échelle de guidance

• Utilisez davantage d’étapes d’inférence

• Gardez les changements d’éclairage subtils

• Post-traiter avec une restauration du visage

Problèmes de décalage des couleurs

Problème : Changements de couleur indésirables

Solutions :

• Soyez précis sur la couleur dans l’invite

• Ajoutez "préserver les couleurs d’origine" à l’invite

• Utilisez des descriptions d’éclairage neutres en couleur

• Correction des couleurs en post-traitement

Changements d’arrière-plan

Problème : L’arrière-plan change alors que seul le premier plan devrait

Solutions :

• Utiliser le mode FC (cohérence du premier plan)

• Prétraiter avec suppression de l’arrière-plan

• Utiliser un masque pour isoler le sujet

Résultats incohérents

Problème : Le même prompt donne des résultats très différents

Solutions :

• Définir une graine fixe pour la reproductibilité

• Augmenter le nombre d’étapes d’inférence pour plus de stabilité

• Utiliser des prompts plus simples et plus directs

# Résultats cohérents avec une graine fixe
result = model.relight(
    image=image,
    prompt=prompt,
    num_inference_steps=30,
    generator=torch.Generator("cuda").manual_seed(42)
)

Dépannage

Le relighting paraît irréaliste

• Faire correspondre la direction de l’éclairage avec la scène

• Utiliser une intensité lumineuse appropriée

• Tenir compte des ombres dans l’image originale

Arrière-plan affecté

• Utiliser correctement le masque du premier plan

• Segmenter d’abord le sujet de l’arrière-plan

• Ajuster les paramètres de décroissance de la lumière

Sortie trop sombre/claire

• Ajuster les valeurs d’intensité lumineuse

• Utiliser une sortie HDR si disponible

• Post-traiter avec des courbes

Le modèle ne se charge pas

• Télécharger tous les points de contrôle requis

• Vérifier l’intégrité du fichier

• Vérifier la compatibilité CUDA

Estimation des coûts

Tarifs typiques de la place de marché CLORE.AI (en 2024) :

GPU	Tarif horaire	Tarif journalier	Session de 4 heures
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 Go	~$0.17	~$4.00	~$0.70
A100 80 Go	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Consultez la place de marché CLORE.AI pour connaître les tarifs actuels.

Économiser de l’argent :

• Utilisez le Spot marché pour les tâches interrompables — environ un tiers des serveurs proposent un prix spot inférieur au tarif à la demande (médiane ~13 % de remise), les autres s’alignent dessus

• Payez avec des CLORE jetons

• Comparer les prix entre différents fournisseurs

Étapes suivantes

• TripoSR - Convertir des images relightées en 3D

• Stable Diffusion - Générer des images à relighter

• ComfyUI - Intégration avancée du flux de travail

• Fooocus - Génération d’images simple