Stable Diffusion est un modèle de génération d'images basé sur une approche de diffusion latente. Ce processus implique entre 50 et 100 étapes d'échantillonnage itératif, où chaque étape nécessite une propagation forward dans le réseau U-Net. L'un des principaux points de contention en termes de performance réside dans la mécanique d'attention (Attention Mechanism) du module Transformer, qui présente une complexité de calcul en O(n²) (n étant la longueur de la séquence).

Compréhension des Coûts de Calcul

La fonction d'attention standardisée (Multi-Head Attention) peut être implémentée comme suit :

def attention_sans_nucleus(Q, K, V, masque=None):
    d_k = Q.size(-1)
    scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)
    if masque is not None:
        scores = scores.masked_fill(masque == 0, -1e9)
    attn = F.softmax(scores, dim=-1)
    sortie = torch.matmul(attn, V)
    return sortie, attn

Pour une image de 512x512 pixels, le modèle Stable Diffusion v1-4 travaille avec une séquence de 4096 éléments (64x64). Chaque étape de calcul implique une quantité significative de multiplications matircielles :

• Multiplications Matricielles : 12 couches Transformer × 4 têtes × (4096² × 128) = 12,8 milliards d'opérations
• Accès à la Mémoire : Une utilisation intensive des bandes passantes de la mémoire GPU due aux lectures et écritures répétées des matrices Q, K et V

Données de Performance Réelles

Des tests effectués sur une carte NVIDIA RTX 3090 (512x512 pixels, 50 étapes de diffusion) montrent les résultats suivants :

La mécanique d'attention non seulement domine le temps de calcul, mais est également responsable d'une augmentation linéaire de l'utilisation de la mémoire GPU au fil des étapes d'échantillonnage.

Cache KV : Une Technique Classique d'Optimisation

Le cache KV (Key-Value Cache) réduit la charge de calcul en stockant les matrices Key et Value générées à chaque étape, évitant ainsi les recalculs inutiles.

Principe et Implémentation

Sans cache KV, les matrices QKV sont recalculées à chaque étape :

for etape in range(nb_etapes):
    etats_caches = unet(etats_caches, etape, etats_cache_encodeur)

En activant le cache KV, la complexité est réduite de O(T×n²) à O(T×n) :

cache = {"cles_valeurs_passes": None}
for etape in range(nb_etapes):
    etats_caches = unet(
        etats_caches,
        etape,
        etats_cache_encodeur,
        past_key_values=cache["cles_valeurs_passes"],
        use_cache=True
    )
    cache["cles_valeurs_passes"] = etats_caches.past_key_values

Défis et Solutions

1. Gestion du Cache :

• Organisation des Données : Utiliser des tuples imbriqués pour stocker les paires clé-valeur de chaque couche et tête attentionnelle.
• Exemple de Structure :

cles_valeurs_passes = (
    # Couche Transformer 1
    (
        torch.Tensor([batch, têtes, longueur_séquence, dimension]),  # Cache des Clés
        torch.Tensor([batch, têtes, longueur_séquence, dimension])   # Cache des Valeurs
    ),
    # Couche Transformer 2
    (
        torch.Tensor([batch, têtes, longueur_séquence, dimension]),
        torch.Tensor([batch, têtes, longueur_séquence, dimension])
    ),
    # ... et ainsi de suite
)

2. Optimisation de la Mémoire :

• Utilisation de l'Arrondi Flottant : Stocker les caches en FP16 au lieu de FP32 pour réduire la consommation de mémoire.
• Découpage de l'Attention : Activer le découpement des opérations d'attention pour réduire la charge sur la mémoire GPU.

pipe.enable_attention_slicing(taille_tranche="auto")

3. Gestion des Transactions en Temps Réel :

• Pool de Cache : Implémenter une gestion de pool de cache pour allouer et libérer efficacement les ressources mémoire.

PagedAttention : Une Solution Révolutionnaire pour la Fragmentation de la Mémoire

La PagedAttention améliore la gestion de la mémoire en découpant les caches KV en blocs fixes, inspirée du管理de la mémoire virtuelle dans les systèmes d'exploitation.

Caractéristiques Innovantes

1. Allocation de Blocs :

• Découpage des caches KV en blocs de taille fixe (par exemple, 64 tokens par bloc).
• Alignement des blocs avec les pages de mémoire GPU (généralement de 256 Ko à 4 Mo).

2. Gestion des Adresses :

• Utilisation d'une table de pages pour mapper les indices virtuels des tokens aux blocs physiques.
• Affectation de pages vides pour les tokens non utilisés, réduisant ainsi la consommation de mémoire.

3. Calculs d'Attention Optimisés :

• Collecte dynamique des blocs KV utiles à partir de la table de pages.
• Copie de mémoire en lots pour réduire les appels coûteux vers le noyau GPU.
• Partage de la mémoire entre différentes requêtes pour maximiser l'utilisation des ressources.

Comparaison des Performances

Sur une carte NVIDIA A100, une comparaison entre les caches KV标准 et PagedAttention pour Stable Diffusion v1-4 (batch size=4, 512×512 pixels, 20 étapes de diffusion) donne les résultats suivants :

Exemple d'Implémentation

from transformers import AutoModelForCausalLM
from diffusers import StableDiffusionPipeline
import torch

# Chargement du modèle text_encoder optimisé
text_encoder = AutoModelForCausalLM.from_pretrained(
"CompVis/stable-diffusion-v1-4/text_encoder",
device_map="auto",
torch_dtype=torch.float16,
enable_paged_attention=True
)

# Initialisation du pipeline Stable Diffusion
pipe = StableDiffusionPipeline.from_pretrained(
"CompVis/stable-diffusion-v1-4",
text_encoder=text_encoder,
torch_dtype=torch.float16
).to("cuda")

# Activation du cache KV dans le U-Net
pipe.unet.set_use_memory_efficient_attention_xformers(True)

# Génération d'images en lot
prompts = [
"un astronaute chevauchant un cheval sur Mars",
"un coucher de soleil sur les montagnes en haute qualité",
"un chat mignon portant un chapeau, art digital",
"un paysage urbain futuriste avec des voitures volantes"
]

# Paramètres de génération
sampling_params = SamplingParams(
temperature=0.7,
top_p=0.9,
max_tokens=512
)

# Génération d'images optimisée
images = pipe(prompts, num_inference_steps=20).images
for i, img in enumerate(images):
img.save(f"resultat_pagedattention_{i}.png")