# ICLight

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

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](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 [CLORE.AI Marketplace](https://clore.ai/marketplace) le marketplace.
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://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](https://github.com/lllyasviel/IC-Light)
* **HuggingFace :** [lllyasviel/IC-Light](https://huggingface.co/lllyasviel/IC-Light)
* **Démo :** [Espace HuggingFace](https://huggingface.co/spaces/lllyasviel/IC-Light)
* **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 :**

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

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

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

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

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

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

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

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

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

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

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

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

```python

# 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

```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 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*](https://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](https://docs.clore.ai/guides/guides_v2-fr/generation-3d/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](https://docs.clore.ai/guides/guides_v2-fr/generation-dimages/fooocus-simple-sd) - Génération d'image simple