INSTALLER stablediffusion cpp POUR DE LA GÉNÉRATION D'IMAGE EN LOCAL VIA IA !

SYNTHÈSE STRUCTURÉE

Installation des dépendances et prérequis matériels

Adrien commence par rappeler l’importance de vérifier la pile graphique avant toute installation : “vous devez vous assurer que si vous disposez d’une carte Nvidia, la pile CUDA et les pilotes, tout ça soit fonctionnel et installé. Et si vous avez une carte AMD, bah tout est inclus dans l’installe avec l’API Vulcan.”

Les dépendances installées incluent git, cmake, gcc, gcc-c++, et pour les cartes AMD : glslc, vulkan-headers, shaderc et spirv-headers. Pour les cartes Nvidia, il faudra installer CUDA et NVCC. Sur Ubuntu/Debian, les commandes sont fournies dans le tutoriel associé.

Création d’un utilisateur dédié et arborescence

Pour isoler le service, Adrien crée un utilisateur sdcpp ajouté au groupe render pour accéder à la carte graphique. Il crée ensuite une arborescence dans /opt/sdcpp avec deux dossiers : bin pour les binaires et models pour les modèles. Les droits sont attribués à l’utilisateur sdcpp sur ce dossier.

Récupération et compilation de Stable Diffusion CPP

Le dépôt est cloné avec l’option --recursive pour récupérer les sous-modules GGML et autres dépendances nécessaires au traitement d’images. Adrien précise : “contrairement à Whisper CPP ou Lama CPP, on va récupérer les sous-modules GGML, Lib et cetera pour traiter les images.”

La compilation se prépare avec :

cmake -B build -D SD_VULKAN=ON

Pour les cartes Nvidia, la commande équivalente est :

cmake -B build -D SD_CUDA=ON -D CMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc

La compilation est lancée avec cmake --build build --config Release -j $(nproc) pour utiliser tous les cœurs CPU disponibles.

Téléchargement d’un modèle quantifié

Adrien recommande les modèles de l’éditeur “G-Research” (probablement une erreur de transcription pour “G-Research” ou “G-rid AI”), et utilise le modèle RealVisXL en version quantifiée Q4K : “il va prendre que 2 Go 8 sur le disque et une fois chargé dans la VAM, il prendra 3 à 4 Go max.”

Le téléchargement se fait avec wget et le modèle est déplacé dans /opt/sdcpp/models.

Configuration de l’environnement et SELinux

Le fichier .bashrc de l’utilisateur sdcpp est modifié pour ajouter les variables d’environnement :

export PATH=/opt/sdcpp/bin:$PATH
export LD_LIBRARY_PATH=/opt/sdcpp/bin:$LD_LIBRARY_PATH

Sur Fedora avec SELinux actif, Adrien applique les commandes suivantes :

semanage fcontext -a -t bin_t /opt/sdcpp/bin
restorecon -Rv /opt/sdcpp/bin

Lancement du serveur Stable Diffusion CPP

Le serveur se lance avec la commande :

sd-server -m /opt/sdcpp/models/realvisxl_v40.safetensors --listen-ip 0.0.0.0 --listen-port 8082

Adrien choisit le port 8082 car “le 8081 on l’a utilisé pour Whisper CPP et le 8080 pour la MAS CPP”. Le serveur détecte automatiquement la carte AMD RX 7600 et charge le modèle.

Test avec curl et script Python

Pour tester l’API, une requête curl peut être envoyée :

curl -X POST http://localhost:8082/v1/images/generations -H "Content-Type: application/json" -d '{"prompt": "un beau pingouin Linux", "size": "512x512"}'

Adrien fournit également deux fichiers dans son dépôt : image_generation.py et image_generation.conf. Le script Python ouvre une invite de commande interactive pour générer des images. La configuration permet de définir l’adresse IP, le port, la taille de l’image et le dossier de sortie.

Performance et temps de génération

Sur la machine de démonstration avec une AMD RX 7600, la génération d’une image 512x512 prend environ 2 minutes 15 secondes. Adrien précise : “au boulot, quand on a fait ça sur une RTX 6000 ADA, ça nous prend 8 secondes pour générer une image par contre au format 1024 par 1024.” Le temps dépend donc fortement du matériel et du modèle utilisé.

Création du service systemd

Un fichier de service est créé dans /etc/systemd/system/sdcpp.service en copiant celui de Whisper CPP. Le service est configuré avec :

[Unit]
Description=Stable Diffusion CPP
After=network.target

[Service]
User=sdcpp
WorkingDirectory=/opt/sdcpp
Environment=LD_LIBRARY_PATH=/opt/sdcpp/bin
ExecStart=/opt/sdcpp/bin/sd-server -m /opt/sdcpp/models/realvisxl_v40.safetensors --listen-ip 0.0.0.0 --listen-port 8082
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Après systemctl daemon-reload, le service se lance avec systemctl start sdcpp et les logs sont consultables via journalctl -f -u sdcpp.service.

CONCEPTS CLÉS

• Stable Diffusion CPP : Implémentation C++ haute performance des modèles de génération d’images par diffusion, compatible avec l’API OpenAI.
• Quantification Q4K : Technique de compression d’un modèle réduisant sa taille sur disque et en mémoire, au prix d’une légère perte de qualité.
• Vulkan : API graphique multiplateforme utilisée pour accélérer les calculs sur GPU AMD.
• CUDA : Plateforme de calcul parallèle de Nvidia pour l’accélération GPU.
• SELinux : Système de contrôle d’accès obligatoire (MAC) intégré à Fedora, nécessitant des étiquettes de contexte pour les nouveaux binaires.

CONCLUSION

Cette vidéo démontre qu’il est tout à fait possible de déployer une solution de génération d’images en local avec Stable Diffusion CPP, sans dépendre de services cloud. L’approche d’Adrien est pragmatique : installation propre avec un utilisateur dédié, service systemd pour la persistance, et compatibilité avec l’API OpenAI pour une intégration facile dans des solutions existantes. Le principal compromis reste la performance, qui dépend fortement du matériel GPU disponible. Pour les administrateurs système, cette approche offre une alternative souveraine et économique aux services commerciaux, avec la possibilité de choisir des modèles adaptés à ses besoins et à sa puissance de calcul.