ControlNet

Contrôle précis de la génération d'images IA avec ControlNet

Maîtrisez ControlNet pour un contrôle précis de la génération d'images par IA.

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

Location sur CLORE.AI

Visitez CLORE.AI Marketplace
Filtrer par type de GPU, VRAM et prix
Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)
Configurez votre commande :
- Sélectionnez l'image Docker
- Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
- Ajoutez des variables d'environnement si nécessaire
- Entrez la commande de démarrage
Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC
Créez la commande et attendez le déploiement

Accédez à 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 ControlNet ?

ControlNet ajoute un contrôle conditionnel à Stable Diffusion :

Canny - Détection des contours
Profondeur - Cartes de profondeur 3D
Pose - Poses humaines
Gribouillis - Croquis approximatifs
Segmentation - Masques sémantiques
Line Art - Lignes nettes
IP-Adapter - Transfert de style

Exigences

Type de contrôle

VRAM min

Recommandé

ControlNet unique

8 Go

RTX 3070

Multi ControlNet

12Go

RTX 3090

ControlNet SDXL

16Go

RTX 4090

Déploiement rapide avec A1111

Commande :

cd /workspace/stable-diffusion-webui && \
cd extensions && \
git clone https://github.com/Mikubill/sd-webui-controlnet && \
cd .. && \
python launch.py --listen --enable-insecure-extension-access

Télécharger des modèles

cd /workspace/stable-diffusion-webui/extensions/sd-webui-controlnet/models

# ControlNets SD 1.5
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_canny.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11f1p_sd15_depth.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_openpose.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_scribble.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_lineart.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_softedge.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_seg.pth

# ControlNets SDXL
wget https://huggingface.co/diffusers/controlnet-canny-sdxl-1.0/resolve/main/diffusion_pytorch_model.safetensors -O controlnet-canny-sdxl.safetensors

Python avec Diffusers

Contrôle Canny Edge

import torch
from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
from diffusers.utils import load_image
from controlnet_aux import CannyDetector
import cv2
import numpy as np

# Charger ControlNet
controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_canny",
    torch_dtype=torch.float16
)

# Charger le pipeline
pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# Préparer l'image de contrôle
image = load_image("input.jpg")
canny = CannyDetector()
control_image = canny(image)

# Générer
output = pipe(
    prompt="une belle femme dans un jardin, haute qualité",
    negative_prompt="laid, flou",
    image=control_image,
    num_inference_steps=30,
    controlnet_conditioning_scale=1.0
).images[0]

output.save("canny_output.png")

Contrôle de profondeur

from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
from controlnet_aux import MidasDetector
import torch

controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11f1p_sd15_depth",
    torch_dtype=torch.float16
)

pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

# Obtenir la carte de profondeur
depth_estimator = MidasDetector.from_pretrained("lllyasviel/Annotators")
depth_image = depth_estimator(image)

# Générer avec la profondeur
output = pipe(
    prompt="une ville futuriste, science-fiction, détaillée",
    image=depth_image,
    num_inference_steps=30
).images[0]

OpenPose (poses humaines)

from controlnet_aux import OpenposeDetector

# Obtenir la pose
pose_detector = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
pose_image = pose_detector(image)

controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_openpose",
    torch_dtype=torch.float16
)

pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

output = pipe(
    prompt="une ballerine dansant, élégante, éclairage studio",
    image=pose_image,
    num_inference_steps=30
).images[0]

Gribouillis/Croquis

from controlnet_aux import HEDdetector

# Détecter les contours en tant que gribouillis
hed = HEDdetector.from_pretrained("lllyasviel/Annotators")
scribble_image = hed(image, scribble=True)

controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_scribble",
    torch_dtype=torch.float16
)

pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

output = pipe(
    prompt="une peinture détaillée d'un paysage",
    image=scribble_image,
    num_inference_steps=30
).images[0]

Multi-ControlNet

Combiner plusieurs contrôles :

from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
import torch

# Charger plusieurs ControlNets
controlnet_canny = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_canny",
    torch_dtype=torch.float16
)

controlnet_depth = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11f1p_sd15_depth",
    torch_dtype=torch.float16
)

# Créer un pipeline avec plusieurs ControlNets
pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=[controlnet_canny, controlnet_depth],
    torch_dtype=torch.float16
).to("cuda")

# Générer avec plusieurs contrôles
output = pipe(
    prompt="un beau portrait",
    image=[canny_image, depth_image],
    controlnet_conditioning_scale=[1.0, 0.8],  # Ajuster les poids
    num_inference_steps=30
).images[0]

ControlNet SDXL

from diffusers import StableDiffusionXLControlNetPipeline, ControlNetModel
from controlnet_aux import CannyDetector
import torch

# Charger ControlNet SDXL
controlnet = ControlNetModel.from_pretrained(
    "diffusers/controlnet-canny-sdxl-1.0",
    torch_dtype=torch.float16
)

pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

# Préparer l'image canny
canny = CannyDetector()
control_image = canny(image, low_threshold=100, high_threshold=200)

output = pipe(
    prompt="une photographie professionnelle, détaillée, 8k",
    image=control_image,
    controlnet_conditioning_scale=0.5,
    num_inference_steps=30
).images[0]

IP-Adapter (transfert de style)

from diffusers import StableDiffusionPipeline
from transformers import CLIPVisionModelWithProjection
import torch

# Charger IP-Adapter
pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
).to("cuda")

pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="models",
    weight_name="ip-adapter_sd15.bin"
)

pipe.set_ip_adapter_scale(0.6)

# Image de référence de style
style_image = load_image("style_reference.jpg")

output = pipe(
    prompt="un chat assis sur une chaise",
    ip_adapter_image=style_image,
    num_inference_steps=30
).images[0]

Préprocesseurs

Tous les préprocesseurs disponibles :

from controlnet_aux import (
    CannyDetector,           # Détection des contours
    HEDdetector,             # Bord doux/gribouillis
    MidasDetector,           # Estimation de la profondeur
    OpenposeDetector,        # Pose humaine
    MLSDdetector,            # Détection des lignes
    LineartDetector,         # Line art
    LineartAnimeDetector,    # Line art anime
    NormalBaeDetector,       # Cartes normales
    ContentShuffleDetector,  # Mélanger le contenu
    ZoeDetector,             # Meilleure profondeur
    MediapipeFaceDetector,   # Maillage du visage
)

# Exemple d'utilisation
canny = CannyDetector()
canny_image = canny(image, low_threshold=100, high_threshold=200)

depth = MidasDetector.from_pretrained("lllyasviel/Annotators")
depth_image = depth(image)

pose = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
pose_image = pose(image, hand_and_face=True)

Poids de contrôle

Ajuster l'influence par ControlNet :


# Contrôle total
output = pipe(..., controlnet_conditioning_scale=1.0)

# Contrôle partiel (plus de liberté créative)
output = pipe(..., controlnet_conditioning_scale=0.5)

# Guidance très légère
output = pipe(..., controlnet_conditioning_scale=0.3)

Contrôle par étape


# Contrôler uniquement pendant certaines étapes
output = pipe(
    prompt="...",
    image=control_image,
    controlnet_conditioning_scale=1.0,
    control_guidance_start=0.0,  # Commencer au début
    control_guidance_end=0.5,    # Arrêter à 50 % des étapes
    num_inference_steps=30
).images[0]

Inpaint avec ControlNet

from diffusers import StableDiffusionControlNetInpaintPipeline, ControlNetModel
import torch

controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_canny",
    torch_dtype=torch.float16
)

pipe = StableDiffusionControlNetInpaintPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

output = pipe(
    prompt="une voiture de sport rouge",
    image=init_image,
    mask_image=mask,
    control_image=canny_image,
    num_inference_steps=30
).images[0]

Traitement par lots

import os
from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
from controlnet_aux import CannyDetector
from PIL import Image
import torch

controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_canny",
    torch_dtype=torch.float16
)

pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

canny = CannyDetector()

input_dir = "./inputs"
output_dir = "./outputs"
os.makedirs(output_dir, exist_ok=True)

prompt = "belle peinture de paysage, détaillée, artistique"

for filename in os.listdir(input_dir):
    if filename.lower().endswith(('.png', '.jpg', '.jpeg')):
        image = Image.open(os.path.join(input_dir, filename))
        control_image = canny(image)

        output = pipe(
            prompt=prompt,
            image=control_image,
            num_inference_steps=30
        ).images[0]

        output.save(os.path.join(output_dir, f"cn_{filename}"))

Guide des types de contrôle

Contrôle

Idéal pour

Atout

Canny

Architecture, objets

0.8-1.0

Profondeur

Scènes 3D, perspective

0.6-0.8

Pose

Personnes, personnages

0.8-1.0

Gribouillis

Croquis, concepts

0.6-0.8

Line Art

Illustrations

0.7-0.9

Softedge

Guidance générale

0.5-0.7

Seg

Composition de la scène

0.6-0.8

Performances

Configuration

GPU

Résolution

Temps

CN unique SD1.5

RTX 3090

512x512

~3s

Multi CN SD1.5

RTX 3090

512x512

~5s

CN unique SDXL

RTX 4090

1024x1024

~8s

Optimisation de la mémoire


# Activer l'attention mémoire-efficiente
pipe.enable_xformers_memory_efficient_attention()

# Déchargement CPU
pipe.enable_model_cpu_offload()

# Découpage de l'attention
pipe.enable_attention_slicing()

Dépannage

Effet de contrôle faible

Augmentez controlnet_conditioning_scale
Vérifier la qualité de sortie du préprocesseur
Utiliser une image de contrôle à plus haute résolution

Artefacts

Réduire l'échelle de contrôle
Utiliser un préprocesseur plus doux (softedge vs canny)
Ajouter un prompt négatif pour les artefacts

Problèmes de VRAM

Utiliser le déchargement CPU
Reduce resolution
Utiliser un ControlNet à la fois

Estimation des coûts

Tarifs typiques du marché 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. Vérifiez 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 jetons
Comparer les prix entre différents fournisseurs

Prochaines étapes

Stable Diffusion WebUI
Flux de travail ComfyUI
Entraînement Kohya

PrécédentRestauration de visage GFPGAN SuivantSegmenter tout

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagLocation sur CLORE.AI

hashtagAccédez à votre serveur

hashtagQu'est-ce que ControlNet ?

hashtagExigences

hashtagDéploiement rapide avec A1111

hashtagTélécharger des modèles

hashtagPython avec Diffusers

hashtagContrôle Canny Edge

hashtagContrôle de profondeur

hashtagOpenPose (poses humaines)

hashtagGribouillis/Croquis

hashtagMulti-ControlNet

hashtagControlNet SDXL

hashtagIP-Adapter (transfert de style)

hashtagPréprocesseurs

hashtagPoids de contrôle

hashtagContrôle par étape

hashtagInpaint avec ControlNet

hashtagTraitement par lots

hashtagGuide des types de contrôle

hashtagPerformances

hashtagOptimisation de la mémoire

hashtagDépannage

hashtagEffet de contrôle faible

hashtagArtefacts

hashtagProblèmes de VRAM

hashtagEstimation des coûts

hashtagProchaines étapes

Location sur CLORE.AI

Accédez à votre serveur

Qu'est-ce que ControlNet ?

Exigences

Déploiement rapide avec A1111

Télécharger des modèles

Python avec Diffusers

Contrôle Canny Edge

Contrôle de profondeur

OpenPose (poses humaines)

Gribouillis/Croquis

Multi-ControlNet

ControlNet SDXL

IP-Adapter (transfert de style)

Préprocesseurs

Poids de contrôle

Contrôle par étape

Inpaint avec ControlNet

Traitement par lots

Guide des types de contrôle

Performances

Optimisation de la mémoire

Dépannage

Effet de contrôle faible

Artefacts

Problèmes de VRAM

Estimation des coûts

Prochaines étapes