ICLight

Relighting d'image assisté par IA avec IC-Light sur Clore.ai

Réalumez n'importe quelle image avec un contrôle d'éclairage alimenté par l'IA.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Tous les exemples de ce guide peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace le marketplace.

Location sur CLORE.AI

1. Visitez CLORE.AI Marketplace

2. Filtrer par type de GPU, VRAM et prix

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

4. Configurez votre commande :

   • Sélectionner l'image Docker

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

   • Ajouter des variables d'environnement si nécessaire

   • Saisir la commande de démarrage

5. Sélectionner le paiement : CLORE, BTC, ou USDT/USDC

6. Créer la commande et attendre le déploiement

Accéder à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces web : utilisez l'URL du port HTTP

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

Qu'est-ce que IC-Light ?

IC-Light par lllyasviel permet de :

• Réalumer des images avec des descriptions textuelles

• Changer la direction et la couleur de l'éclairage

• Ajouter ou supprimer des ombres

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

• Réalumage premier plan/arrière-plan

Ressources

• GitHub : lllyasviel/IC-Light

• HuggingFace : lllyasviel/IC-Light

• Démo : Espace HuggingFace

• Article : Basé sur l'architecture ControlNet

Matériel recommandé

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

Déploiement rapide sur CLORE.AI

Image Docker :

pytorch/pytorch:2.5.1-cuda12.4-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éder à votre service

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

1. Allez sur Mes commandes page

2. Cliquez sur votre commande

3. Trouvez le http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://VOTRE_HTTP_PUB_URL au lieu 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 produit

• Éclairage parfait pour le e-commerce

• Images de catalogue cohérentes

• Résultats de qualité studio sans studio

Amélioration de portrait

• Corriger un mauvais éclairage sur des photos

• Ajouter des effets d'éclairage dramatiques

• Créer des portraits professionnels

Projets créatifs

• Transformation d'ambiance

• Conversion jour-en-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 site

Matériels marketing

• Création d'images principales

• Imagerie de marque cohérente

• Retouche photo rapide

Utilisation de base

Réalumage du premier plan (mode FC)

Réalumer le sujet en laissant l'arrière-plan intact :

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éalumer avec un prompt textuel
result = model.relight(
    image=image,
    prompt="lumière du coucher de soleil à gauche",
    num_inference_steps=25
)

result.save("relit_portrait.jpg")

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

Réalumer le premier plan pour correspondre à un 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éalumer pour correspondre à l'arrière-plan
result = model.relight(
    foreground=foreground,
    background=background,
    prompt="éclairage chaud de coucher de soleil",
    num_inference_steps=25
)

result.save("composited.jpg")

Prompts d'éclairage

Éclairage basé sur la direction

prompts = [
    "lumière vive venant du côté gauche",
    "lumière douce venant d'en haut",
    "contre-jour dramatique venant de l'arrière",
    "lumière de bord venant de la droite",
    "lumière diffusée de face",
    "lumière basse angle venant d'en dessous"
]

Éclairage basé sur la couleur

prompts = [
    "lumière dorée et chaude du soleil",
    "crépuscule bleu et frais",
    "lumière néon rose",
    "lumière ambiante verte",
    "lueur orange du coucher de soleil",
    "éclairage studio blanc"
]

Éclairage basé sur l'environnement

prompts = [
    "lumière du jour extérieure, soleil brillant",
    "lumière de fenêtre intérieure, ombres douces",
    "lumières de la ville la nuit, reflets néon",
    "lumière de bougie, scintillement chaud",
    "jour nuageux, éclairage diffus",
    "softbox de studio, professionnel"
]

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 = "éclairage professionnel de studio, ombres douces"

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"Traité : {filename}")

Variations d'éclairage multiples

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": "lumière naturelle du jour brillante, fond blanc propre",
    "dramatic": "éclairage latéral dramatique, ombres profondes",
    "warm": "heure dorée chaude, douce lueur orange",
    "cool": "éclairage bleu froid, esthétique moderne",
    "studio": "softbox de studio professionnel, éclairage uniforme"
}

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"Généré : {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="Prompt d'éclairage",
            value="éclairage professionnel de studio",
            placeholder="Décrivez l'éclairage souhaité..."
        ),
        gr.Slider(10, 50, value=25, step=5, label="Étapes"),
        gr.Number(value=-1, label="Graine (-1 pour aléatoire)")
    ],
    outputs=gr.Image(label="Image ré-éclairée"),
    title="IC-Light - Rééclairage d'image par IA",
    description="Changez l'éclairage de n'importe quelle image avec des descriptions textuelles. Fonctionne sur des serveurs GPU CLORE.AI.",
    examples=[
        ["example.jpg", "lumière du coucher de soleil à gauche", 25, -1],
        ["example.jpg", "lumière de bord dramatique, fond sombre", 25, -1],
        ["example.jpg", "lumière douce de fenêtre, ombres légères", 25, -1]
    ]
)

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

Intégration ComfyUI

IC-Light est disponible en tant que 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 Loader IC-Light

3. Connectez au nœud Apply IC-Light

4. Définissez le prompt d'éclairage

5. Connectez au KSampler

6. Sortie vers Save Image

Avec suppression d'arrière-plan

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

# Retirer 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éalumer pour correspondre
model = ICLightFBC.from_pretrained("lllyasviel/IC-Light-FBC")
model.to("cuda")

result = model.relight(
    foreground=foreground,
    background=background,
    prompt="éclairage de studio correspondant à l'arrière-plan",
    num_inference_steps=25
)

result.save("composited.jpg")

Performance

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

Variantes de modèle

Modèle	Description	Cas d'utilisation
IC-Light-FC	Cohérence du premier plan	Réalumage d'image unique
IC-Light-FBC	Cohérence premier plan-arrière-plan	Compositing avec arrière-plans

Problèmes courants et solutions

L'éclairage ne change pas

Problème : La sortie ressemble à l'entrée

Solutions :

• Utilisez des prompts d'éclairage plus descriptifs

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

• Essayez différentes valeurs de graine

• Utilisez un contraste plus marqué dans le prompt (par ex., "dramatique" vs "doux")

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

Artefacts sur le visage/détails

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

Solutions :

• Réduire la strength/échelle de guidage

• Utiliser plus d'étapes d'inférence

• Garder les changements d'éclairage subtils

• Post-traiter avec restauration de visage

Problèmes de décalage de couleur

Problème : Changements de couleur indésirables

Solutions :

• Soyez précis sur la couleur dans le prompt

• Ajoutez « préserver les couleurs d'origine » au prompt

• Utilisez des descriptions d'éclairage neutres en couleur

• Post-traitez avec correction colorimétrique

Changements d'arrière-plan

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

Solutions :

• Utilisez le mode FC (premier plan cohérent)

• Prétraitez avec suppression d'arrière-plan

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

• Fixez une graine pour la reproductibilité

• Augmentez les étapes d'inférence pour plus de stabilité

• Utilisez 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 réalumage semble non naturel

• Faites correspondre la direction de la lumière à la scène

• Utilisez une intensité lumineuse appropriée

• Prenez en compte les ombres dans l'image originale

Arrière-plan affecté

• Utilisez correctement le masque du premier plan

• Segmentez d'abord le sujet de l'arrière-plan

• Ajustez les paramètres d'atténuation de la lumière

Sortie trop sombre/clair

• Ajustez les valeurs d'intensité lumineuse

• Utilisez la sortie HDR si disponible

• Post-traitez avec des courbes

Modèle ne se charge pas

• Téléchargez tous les checkpoints requis

• Vérifiez l'intégrité des fichiers

• Vérifiez la compatibilité CUDA

Estimation des coûts

Tarifs typiques du marketplace CLORE.AI (à partir de 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 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Consultez CLORE.AI Marketplace pour les tarifs actuels.

Économisez de l'argent :

• Utilisez Spot market pour les charges de travail flexibles (souvent 30-50% moins cher)

• Payer avec CLORE tokens

• Comparez les prix entre différents fournisseurs

Étapes suivantes

• TripoSR - Convertir les images ré-éclairées en 3D

• Stable Diffusion - Générer des images à ré-éclairer

• ComfyUI - Intégration avancée de workflow

• Fooocus - Génération d'image simple