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.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

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

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.

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

ssh -p <PORT> root@<SERVER_IP>

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

mkdir -p /root/invokeai

4. Téléchargez 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 un 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é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 :

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:

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

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

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

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

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 :

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

# 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

# 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

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

• Documentation

• Docker Hub / GHCR

• CivitAI (modèles)

• la place de marché CLORE.AI

---

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

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