> 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-fr/traitement-dimages/iclight.md).

# 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.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
Tous les exemples de ce guide peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace) la place de marché.
{% endhint %}

## Louer sur CLORE.AI

1. Visitez [la place de marché CLORE.AI](https://clore.ai/marketplace)
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**, **BTC**ou **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](https://github.com/lllyasviel/IC-Light)
* **HuggingFace :** [lllyasviel/IC-Light](https://huggingface.co/lllyasviel/IC-Light)
* **Démo :** [HuggingFace Space](https://huggingface.co/spaces/lllyasviel/IC-Light)
* **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 :**

```bash
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

```bash
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 :

```python
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 :

```python
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

```python
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

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

### Éclairage basé sur l’environnement

```python
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

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

## Plusieurs variantes d’éclairage

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

## Interface Gradio

```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="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 :

```bash
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

```python
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")

```python

# 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

```python

# 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*](https://clore.ai/marketplace) *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](/guides/guides_v2-fr/generation-3d/triposr.md) - 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](/guides/guides_v2-fr/generation-dimages/fooocus-simple-sd.md) - Génération d’images simple


---

# 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-fr/traitement-dimages/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.