> 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/generation-dimages/invokeai.md).

# InvokeAI

Exécutez la suite professionnelle Stable Diffusion InvokeAI avec canevas basé sur des nœuds sur les GPU Clore.ai

InvokeAI est une boîte à outils Stable Diffusion de qualité professionnelle, dotée d'un éditeur de canvas avancé basé sur des nœuds, d'une prise en charge complète de SDXL/SD1.5/SD2.x, de ControlNet, d'IP-Adapter, de la gestion de LoRA et d'une interface Web soignée. Elle est conçue pour les artistes et les professionnels créatifs qui ont besoin d'un contrôle précis sur leur flux de génération d'images. Les GPU à grande VRAM de CLORE.AI vous permettent d'exécuter SDXL en pleine résolution avec plusieurs ControlNets simultanément.

{% 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 %}

## Exigences du serveur

| Paramètre | Minimum               | Recommandé               |
| --------- | --------------------- | ------------------------ |
| RAM       | 12 Go                 | 32 Go+                   |
| VRAM      | 6 Go                  | 12 Go+                   |
| Disque    | 40 Go                 | 200 Go+                  |
| GPU       | NVIDIA GTX 1060 6 Go+ | RTX 3090, RTX 4090, A100 |

{% hint style="info" %}
Pour SDXL (1024×1024) sans compromis, 12 Go de VRAM sont recommandés. Pour SD1.5 (512×512 ou 768×768), 6 Go de VRAM suffisent. Plus de VRAM = résolution plus élevée, génération plus rapide et davantage de ControlNets simultanés.
{% endhint %}

## Déploiement rapide sur CLORE.AI

**Image Docker :** `ghcr.io/invoke-ai/invokeai:latest`

**Ports :** `22/tcp`, `9090/http`

**Variables d'environnement :**

| Variable        | Exemple     | Description                                       |
| --------------- | ----------- | ------------------------------------------------- |
| `INVOKEAI_ROOT` | `/invokeai` | Répertoire racine pour les modèles et les sorties |

## Configuration étape par étape

### 1. Louez un serveur GPU sur CLORE.AI

Visitez [la place de marché CLORE.AI](https://clore.ai/marketplace) et recherchez :

* **Travail créatif à budget limité**: RTX 3080/3090 (10–24 Go de VRAM)
* **SDXL professionnel**: RTX 4090 (24 Go de VRAM)
* **Qualité maximale**: A100 80 Go — exécutez plusieurs modèles simultanément

### 2. Connectez-vous en SSH à votre serveur

```bash
ssh -p <PORT> root@<SERVER_IP>
```

### 3. Créez la structure de répertoires InvokeAI

```bash
mkdir -p /root/invokeai
```

### 4. Téléchargez l'image Docker InvokeAI

```bash
docker pull ghcr.io/invoke-ai/invokeai:latest
```

### 5. Lancez InvokeAI

**Lancement de base :**

```bash
docker run -d \
  --name invokeai \
  --gpus all \
  -p 9090:9090 \
  -v /root/invokeai:/invokeai \
  -e INVOKEAI_ROOT=/invokeai \
  ghcr.io/invoke-ai/invokeai:latest \
  invokeai-web --host 0.0.0.0 --port 9090
```

**Avec un répertoire racine personnalisé et des ressources accrues :**

```bash
docker run -d \
  --name invokeai \
  --gpus all \
  --shm-size 8g \
  -p 9090:9090 \
  -v /root/invokeai:/invokeai \
  -v /root/models:/root/models \
  -e INVOKEAI_ROOT=/invokeai \
  ghcr.io/invoke-ai/invokeai:latest \
  invokeai-web --host 0.0.0.0 --port 9090
```

**Avec un GPU spécifique (serveur multi-GPU) :**

```bash
docker run -d \
  --name invokeai \
  --gpus '"device=0"' \
  -p 9090:9090 \
  -v /root/invokeai:/invokeai \
  -e INVOKEAI_ROOT=/invokeai \
  -e CUDA_VISIBLE_DEVICES=0 \
  ghcr.io/invoke-ai/invokeai:latest \
  invokeai-web --host 0.0.0.0 --port 9090
```

### 6. Attendez l'initialisation

```bash
docker logs -f invokeai
```

Recherchez : `Uvicorn en cours d'exécution sur http://0.0.0.0:9090`

### 7. Accédez via le proxy HTTP CLORE.AI

Ouvrez votre tableau de bord CLORE.AI et trouvez l' `http_pub` URL pour le port 9090 :

```
https://<order-id>-9090.clore.ai/
```

Cela ouvre l'interface Web complète d'InvokeAI dans votre navigateur.

### 8. Téléchargez votre premier modèle

Dans l'interface utilisateur d'InvokeAI :

1. Cliquez sur **Gestionnaire de modèles** (icône cube dans la barre latérale gauche)
2. Cliquez sur **Ajouter un modèle → HuggingFace**
3. Entrez l'ID du modèle (par ex. : `stabilityai/stable-diffusion-xl-base-1.0`)
4. Cliquez sur **Ajouter le modèle**

Ou téléchargez directement depuis CivitAI :

1. Accédez à **Gestionnaire de modèles → Ajouter un modèle → URL**
2. Collez l'URL de téléchargement CivitAI
3. Définissez le type de modèle (Checkpoint, LoRA, etc.)

***

## Exemples d'utilisation

### Exemple 1 : Génération d'image de base via l'interface Web

1. Ouvrez InvokeAI à votre URL http\_pub CLORE.AI
2. Cliquez sur **Texte vers image** dans le sélecteur de workflow
3. Entrez un prompt : `« un dragon majestueux juché sur une montagne de cristal, art numérique, 4k »`
4. Définissez le prompt négatif : `« flou, basse qualité, filigrane »`
5. Réglez la résolution sur `1024x1024` (SDXL) ou `512x512` (SD1.5)
6. Cliquez sur **Invoked**

### Exemple 2 : Utilisation du canvas basé sur des nœuds

L'éditeur de workflow est la fonctionnalité phare d'InvokeAI :

1. Cliquez sur **Workflows** dans la barre de navigation supérieure
2. Cliquez sur **Nouveau workflow**
3. Ajoutez des nœuds : **Texte → Image**, connectez-le à **Enregistrer l'image**
4. Ajoutez un **ControlNet** nœud pour une génération guidée :
   * Clic droit → Ajouter un nœud → **ControlNet**
   * Connectez votre image de référence
   * Sélectionnez le processeur : `Canny`, `Profondeur`, `Pose`, etc.
5. Cliquez sur **Invoked** pour exécuter l'ensemble du pipeline

### Exemple 3 : Utilisation de LoRA

1. Téléchargez une LoRA depuis CivitAI (via Gestionnaire de modèles → importation par URL)
2. Dans le panneau de génération, trouvez **LoRA** la section
3. Cliquez sur **+** et sélectionnez votre LoRA
4. Définissez le poids (0,5–1,0 typiquement)
5. Ajoutez le mot déclencheur au prompt (indiqué sur la page du modèle CivitAI)

Exemple de prompt avec déclencheur LoRA :

```
portrait d'une femme, <lora:detail-tweaker:0.8>, hyperréaliste, éclairage de studio
```

### Exemple 4 : Utilisation d'IP-Adapter pour le transfert de style

1. Activez **IP-Adapter** dans le panneau de génération
2. Téléchargez une image de style de référence
3. Définissez le poids (0,5 = influence subtile, 1,0 = forte influence)
4. Générez avec n'importe quel prompt — la sortie correspondra au style de référence

### Exemple 5 : Utilisation de l'API (sans interface)

InvokeAI expose une API REST pour une utilisation programmatique :

```python
import requests
import time
import base64

BASE_URL = "http://localhost:9090"  # ou votre URL http_pub CLORE.AI

# Lister les modèles disponibles
models = requests.get(f"{BASE_URL}/api/v1/models").json()
print("Modèles disponibles :", [m["name"] for m in models.get("items", [])])

# Mettre une génération en file d'attente
payload = {
    "batch": {
        "graph": {
            "nodes": {
                "text_encoder": {
                    "type": "compel",
                    "id": "text_encoder",
                    "prompt": "une ville futuriste au coucher du soleil, photoréaliste",
                },
                "noise": {
                    "type": "noise",
                    "id": "noise",
                    "width": 1024,
                    "height": 1024,
                    "seed": 42,
                },
                "denoise_latents": {
                    "type": "denoise_latents",
                    "id": "denoise_latents",
                    "steps": 30,
                    "cfg_scale": 7.5,
                    "scheduler": "dpmpp_2m",
                },
                "l2i": {
                    "type": "l2i",
                    "id": "l2i",
                },
            },
            "edges": [],
        }
    }
}

# Plus simple : utilisez l'API de file d'attente
response = requests.post(f"{BASE_URL}/api/v1/queue/default/enqueue_batch", json=payload)
print(response.status_code)
```

***

## Configuration

### Fichier de configuration invokeai.yaml

Situé à `/root/invokeai/invokeai.yaml`:

```yaml
InvokeAI :
  Serveur Web :
    host: 0.0.0.0
    port: 9090
    allow_origins: []
    
  Fonctionnalités :
    esrgan: true          # mise à l'échelle ESRGAN
    internet_available: true
    
  Mémoire/Performances :
    ram: 12.0             # RAM max pour le cache des modèles (Go)
    vram: 0.25            # Fraction de VRAM pour le cache des modèles
    lazy_offload: true    # Décharger les modèles vers le CPU lorsqu'ils ne sont pas utilisés
    
  Chemins :
    models_path: /invokeai/models
    db_path: /invokeai/databases/invokeai.db
    outdir: /invokeai/outputs
```

### Paramètres recommandés par GPU

**RTX 3090 / 4090 (24 Go de VRAM) :**

```yaml
Mémoire/Performances :
  ram: 24.0
  vram: 0.5   # Conserver 50 % pour le modèle actif
  lazy_offload: false  # Ne pas décharger — VRAM suffisante
```

**RTX 3080 (10 Go de VRAM) :**

```yaml
Mémoire/Performances :
  ram: 16.0
  vram: 0.25
  lazy_offload: true
```

**GPU plus petits (6-8 Go de VRAM) :**

```yaml
Mémoire/Performances :
  ram: 8.0
  vram: 0.1
  lazy_offload: true
```

***

## Conseils de performance

### 1. Utilisez SDXL-Turbo ou SDXL-Lightning pour une génération rapide

Au lieu de la base SDXL (25–50 étapes), utilisez :

* **SDXL-Turbo**: 1–4 étapes, génération en temps réel
* **SDXL-Lightning**: 4–8 étapes, qualité proche de SDXL

Téléchargez via Gestionnaire de modèles → HuggingFace :

* `stabilityai/sdxl-turbo`
* `ByteDance/SDXL-Lightning`

### 2. Choisissez le bon ordonnanceur

| Ordonnanceur   | Qualité    | Vitesse | Idéal pour         |
| -------------- | ---------- | ------- | ------------------ |
| `euler_a`      | Bon        | Rapide  | Usage général      |
| `dpmpp_2m`     | Excellente | Rapide  | Photoréaliste      |
| `dpmpp_2m_sde` | Excellente | Moyen   | Haute précision    |
| `ddim`         | Bon        | Rapide  | Inpainting         |
| `lms`          | Bon        | Rapide  | Styles artistiques |

### 3. Activez l'optimisation mémoire xFormers

InvokeAI l'active automatiquement lorsqu'elle est disponible. Vérifiez dans les logs :

```
xFormers est disponible
```

### 4. Utilisez le cache des modèles

Conservez vos modèles les plus utilisés dans le cache. Dans invokeai.yaml :

```yaml
ram: 32.0  # Plus grand = plus de modèles mis en cache
```

### 5. Découpez pour les grandes résolutions

Pour des images plus grandes que ce que votre VRAM permet (par ex. 2048×2048 sur GPU 12 Go) :

* Utilisez **VAE découpé** dans l'éditeur de workflow
* Ou générez en 1024×1024 puis suréchantillonnez avec **ESRGAN**

***

## Dépannage

### Problème : "CUDA out of memory"

```
RuntimeError: CUDA out of memory
```

**Solutions :**

1. Réduisez la résolution (1024→768 ou 512)
2. Réduisez la taille du lot à 1
3. Activez le déchargement différé dans invokeai.yaml
4. Utilisez un modèle plus petit (SD1.5 au lieu de SDXL)

### Problème : interface Web inaccessible

```bash
# Vérifiez si le conteneur est en cours d'exécution
docker ps | grep invokeai

# Vérifiez les erreurs dans les journaux
docker logs invokeai 2>&1 | tail -50

# Vérifiez le mappage des ports
docker port invokeai
```

Assurez-vous que le port 9090 figure dans la configuration des ports de votre commande CLORE.AI.

### Problème : l'échec du téléchargement du modèle à l'intérieur du conteneur

```bash
# Téléchargement manuel via exec
docker exec -it invokeai bash
cd /invokeai/models/main
wget "https://civitai.com/api/download/models/XXX" -O mymodel.safetensors
```

### Problème : génération lente (< 1 it/s)

* Vérifiez l'utilisation du GPU : `docker exec -it invokeai nvidia-smi`
* Assurez-vous que xFormers est activé dans les logs
* Essayez `euler_a` ordonnanceur (le plus rapide)

### Problème : images noires/cassées

Il s'agit généralement d'un problème de VAE. Essayez :

1. Gestionnaire de modèles → Modifier le modèle → Remplacer le VAE par `sdxl-vae-fp16-fix`
2. Ou ajoutez `--fp32-vae` option

### Problème : le conteneur ne démarre pas

```bash
docker logs invokeai
# Courant : le port 9090 est déjà utilisé
# Correction :
docker stop $(docker ps -q --filter "publish=9090")
docker start invokeai
```

***

## Liens

* [GitHub](https://github.com/invoke-ai/InvokeAI)
* [Documentation](https://invoke-ai.github.io/InvokeAI/)
* [Docker Hub / GHCR](https://github.com/invoke-ai/InvokeAI/pkgs/container/invokeai)
* [CivitAI (modèles)](https://civitai.com)
* [la place de marché CLORE.AI](https://clore.ai/marketplace)

***

## Recommandations GPU Clore.ai

| Cas d’utilisation  | GPU recommandé   | Coût estimé sur Clore.ai                  |
| ------------------ | ---------------- | ----------------------------------------- |
| Développement/Test | RTX 3090 (24 Go) | 0,07–0,21 $/gpu/h                         |
| Production         | RTX 4090 (24 Go) | 0,14–0,42 $/gpu/h                         |
| Grande échelle     | A100 80 Go       | [bare metal](https://clore.ai/bare-metal) |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.


---

# 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/generation-dimages/invokeai.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.