InvokeAI

Exécuter InvokeAI, boîte à outils professionnelle Stable Diffusion avec canevas basé sur des nœuds, sur les GPU Clore.ai

InvokeAI est une boîte à outils Stable Diffusion de qualité professionnelle offrant un éditeur avancé basé sur un canevas à nœuds, une prise en charge complète de SDXL/SD1.5/SD2.x, ControlNet, IP-Adapter, gestion des LoRA et une interface web soignée. Il est conçu pour les artistes et les professionnels créatifs qui ont besoin d’un contrôle précis de 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.

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

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 6GB+	RTX 3090, RTX 4090, A100

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ément.

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 CLORE.AI Marketplace et recherchez :

• Travail créatif à petit budget: RTX 3080/3090 (10–24 Go VRAM)

• SDXL professionnel: RTX 4090 (24 Go VRAM)

• Qualité maximale: A100 80GB — exécutez plusieurs modèles simultanément

2. SSH sur votre serveur

ssh -p <PORT> root@<SERVER_IP>

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

mkdir -p /root/invokeai

4. Récupérez l’image Docker InvokeAI

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

5. Lancez InvokeAI

Lancement de base :

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 :

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 GPU spécifique (serveur multi-GPU) :

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

docker logs -f invokeai

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

7. Accès via le proxy HTTP de CLORE.AI

Ouvrez votre tableau de bord CLORE.AI et trouvez le 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’UI d’InvokeAI :

1. Cliquez Gestionnaire de modèles (icône cube dans la barre latérale gauche)

2. Cliquez Ajouter un modèle → HuggingFace

3. Entrez l’identifiant du modèle (par exemple, stabilityai/stable-diffusion-xl-base-1.0)

4. Cliquez Ajouter le modèle

Ou téléchargez directement depuis CivitAI :

1. Allez sur 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 basique via l’interface web

1. Ouvrez InvokeAI à votre URL http_pub CLORE.AI

2. Cliquez Texte vers Image dans le sélecteur de flux de travail

3. Saisissez une invite : "un dragon majestueux perché sur une montagne de cristal, art numérique, 4k"

4. Définir l’invite négative : "flou, basse qualité, filigrane"

5. Définir la résolution sur 1024x1024 (SDXL) ou 512x512 (SD1.5)

6. Cliquez Lancer

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

L’éditeur de flux de travail est la fonctionnalité signature d’InvokeAI :

1. Cliquez Flux de travail dans la navigation supérieure

2. Cliquez Nouveau flux de travail

3. Ajouter des nœuds : Texte → Image, connecter à Enregistrer l’image

4. Ajouter 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électionner le processeur : Canny, Profondeur, Pose, etc.

5. Cliquez Lancer pour exécuter l’ensemble du pipeline

Exemple 3 : Utilisation des 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 section

3. Cliquez + et sélectionnez votre LoRA

4. Définir le poids (0.5–1.0 typique)

5. Ajouter le mot déclencheur dans l’invite (indiqué sur la page du modèle CivitAI)

Exemple d’invite avec déclencheur LoRA :

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

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

1. Activer IP-Adapter dans le panneau de génération

2. Téléversez une image de style de référence

3. Définir le poids (0.5 = influence subtile, 1.0 = influence forte)

4. Générez avec n’importe quelle invite — 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 :

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 en file une génération
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:

InvokeAI :
  Serveur Web :
    host: 0.0.0.0
    port: 9090
    allow_origins: []
    
  Fonctionnalités :
    esrgan: true          # Upscaling ESRGAN
    internet_available: true
    
  Mémoire/Performance :
    ram: 12.0             # RAM max pour le cache des modèles (Go)
    vram: 0.25            # Fraction de la VRAM pour le cache des modèles
    lazy_offload: true    # Décharger les modèles sur 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 selon le GPU

RTX 3090 / 4090 (24 Go VRAM) :

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

RTX 3080 (10 Go VRAM) :

Mémoire/Performance :
  ram: 16.0
  vram: 0.25
  lazy_offload: true

GPUs plus petits (6-8 Go VRAM) :

Mémoire/Performance :
  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 du SDXL de base (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. Choisir le bon scheduler

Scheduler	Qualité	Vitesse	Idéal pour
euler_a	Bon	Rapide	Usage général
dpmpp_2m	Excellent	Rapide	Photoréaliste
dpmpp_2m_sde	Excellent	Moyen	Détail élevé
ddim	Bon	Rapide	Inpainting
lms	Bon	Rapide	Styles artistiques

3. Activez l’optimisation mémoire xFormers

InvokeAI active cela automatiquement lorsqu’il est disponible. Vérifiez dans les logs :

xFormers est disponible

4. Utilisez la mise en cache des modèles

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

ram: 32.0  # Plus grand = plus de modèles 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 en tuiles dans l’éditeur de flux de travail

• Ou générez en 1024×1024 puis remontez en qualité avec ESRGAN

---

Dépannage

Problème : "CUDA out of memory"

RuntimeError : CUDA out of memory

Solutions :

1. Baisser la résolution (1024→768 ou 512)

2. Réduire la taille de lot à 1

3. Activer le déchargement paresseux (lazy offloading) dans invokeai.yaml

4. Utiliser un modèle plus petit (SD1.5 au lieu de SDXL)

Problème : Interface web inaccessible

# Vérifier si le conteneur est en cours d’exécution
docker ps | grep invokeai

# Vérifier les logs pour des erreurs
docker logs invokeai 2>&1 | tail -50

# Vérifier le mappage de ports
docker port invokeai

Assurez-vous que le port 9090 est répertorié dans la configuration des ports de votre commande CLORE.AI.

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

# Télécharger manuellement 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 scheduler (le plus rapide)

Problème : Images noires/cassées

Généralement un problème de VAE. Essayez :

1. Gestionnaire de modèles → Éditer le modèle → Changer le VAE en sdxl-vae-fp16-fix

2. Ou ajoutez --fp32-vae drapeau

Problème : Le conteneur ne démarre pas

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

---

Liens

• GitHub

• Documentation

• Docker Hub / GHCR

• CivitAI (Modèles)

• CLORE.AI Marketplace

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24GB)	~$0.12/gpu/hr
Production	RTX 4090 (24GB)	~$0.70/gpu/hr
Grande échelle	A100 80GB	~$1.20/gpu/hr

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.