| name | spatial-decodable-image-generation |
| description | Accélérer la génération d'images auto-régressive par détection spéculative spatiale (SSD) pour une inference plus rapide. |
| version | 1.1.0 |
| author | EVA |
| license | Privée EVA St-Étienne |
| platforms | ["linux","macos","windows"] |
| metadata | {"EVA":{"tags":["computer-vision","image-generation","speculative-decoding","SSD","autoregressive","machine-learning"],"related_skills":["persistent-world-model-design","ai-foundations-exploration","comfyui"]}} |
Génération d'Images par Détection Spéculative Spatiale (SSD)
Vue d'ensemble
La détection spéculative spatiale (Spatially Speculative Decoding — SSD) est une technique avancée qui accélère la génération d'images auto-régressive en prédisant simultanément plusieurs pixels adjacents dans une structure 2D. Contrairement au décodage auto-régressif pixel par pixel (séquentiel), SSD exploite la redondance spatiale naturelle des images pour générer des blocs entiers de pixels en une seule passe, réduisant drastiquement le nombre d'itérations d'inférence.
Cette compétence s'appuie sur les principes du décodage spéculatif appliqué à la génération d'images.
Quand l'utiliser
À utiliser lorsque l'utilisateur demande :
- D'accélérer un pipeline de génération d'images auto-régressif.
- D'optimiser un modèle de type Image GPT, PixelCNN, ou ViT génératif.
- De réduire la latence d'inférence pour la génération d'images haute résolution.
- D'explorer des techniques de décodage spéculatif au-delà du domaine textuel.
1. Principe du Décodage Spéculatif Spatial
1.1 Concept Fondamental
Le décodage auto-régressif standard génère une image pixel par pixel ou patch par patch :
Image complète = [P₁] → [P₂] → [P₃] → ... → [Pₙ] (n étapes séquentielles)
Avec SSD, on prédit un bloc de pixels à la fois :
Image complète = [P₁ P₂ P₃ P₄] → [P₅ P₆ P₇ P₈] → ... (n/4 étapes)
Le modèle spéculatif (petit et rapide) propose des blocs entiers, tandis que le modèle principal (grand et précis) les valide. Si un bloc est accepté, on économise plusieurs étapes d'inférence ; s'il est rejeté, on revient à la position sûre et on régénère.
1.2 Architecture du Système
Entrée (bruit / condition)
↓
[Modèle Spéculatif Léger] → proposition de blocs de pixels
↓
[Modèle Principal (Target)] → validation des blocs proposés
↓
[Acceptation/Rejet] → Mise à jour de l'image générée
↓
Image finale
2. Implémentation d'un Pipeline SSD
2.1 Modèle Spéculatif Spatial
import torch
import torch.nn as nn
class SpatialSpeculator(nn.Module):
"""Modèle spéculatif léger qui propose des blocs de pixels."""
def __init__(self, block_size: int = 4, latent_dim: int = 128):
super().__init__()
self.block_size = block_size
self.context_encoder = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, padding=1),
nn.ReLU(),
nn.Conv2d(64, latent_dim, kernel_size=3, padding=1),
)
self.block_predictor = nn.Sequential(
nn.Linear(latent_dim, latent_dim * 2),
nn.ReLU(),
nn.Linear(latent_dim * 2, block_size * block_size * 3),
)
def forward(self, context: torch.Tensor) -> torch.Tensor:
"""Propose un bloc de pixels à partir du contexte.
Args:
context (torch.Tensor): Contexte d'image existant (B, 3, H, W)
Returns:
torch.Tensor: Bloc de pixels proposé (B, 3, block_size, block_size)
"""
features = self.context_encoder(context).mean(dim=[2, 3])
block_flat = self.block_predictor(features)
return block_flat.view(-, , .block_size, .block_size)
2.2 Mécanisme d'Acceptation/Rejet
def speculative_acceptance(
target_model: nn.Module,
proposed_block: torch.Tensor,
context: torch.Tensor,
temperature: float = 1.0,
) -> tuple[torch.Tensor, bool]:
"""Valide un bloc proposé selon la distribution du modèle cible.
Args:
target_model: Le modèle principal (target) précis mais lent.
proposed_block: Bloc de pixels proposé par le spéculateur.
context: Contexte d'image existant.
temperature: Température pour l'échantillonnage.
Returns:
Tuple (bloc accepté ou régénéré, booléen d'acceptation).
"""
with torch.no_grad():
target_logits = target_model(context)
target_probs = torch.softmax(target_logits / temperature, dim=-1)
spec_logits = speculator(context)
spec_probs = torch.softmax(spec_logits / temperature, dim=-1)
acceptance_ratio = target_probs / (spec_probs + 1e-8)
if torch.rand(1) < acceptance_ratio.min():
return proposed_block, True
else:
target_block = target_model.sample(context, temperature=temperature)
return target_block, False
3. Optimisations et Réglages
3.1 Taille de Blot Recommandée
| Résolution Image | Taille de Blot SSD | Facteur d'Accélération Estimé |
|---|
| 64×64 | 2×2 pixels | 2× – 3× |
| 128×128 | 4×4 pixels | 3× – 5× |
| 256×256 | 4×4 ou 8×8 pixels | 4× – 8× |
| 512×512 | 8×8 pixels | 5× – 10× |
3.2 Trade-off Précision / Vitesse
Le paramètre clé est la température d'échantillonnage :
- Température basse (< 0.5) : Taux d'acceptation élevé, mais qualité réduite.
- Température moyenne (0.8–1.2) : Bon équilibre recommandé.
- Température haute (> 1.5) : Taux d'acceptation faible, mais meilleure diversité.
4. Pièges Courants
-
Effondrement du spéculateur :
- Erreur : Le modèle spéculatif apprend à toujours proposer la même valeur moyenne.
- Correction : Entraînez le spéculateur avec une perte de diversité et variez le bloc_size.
-
Rejet en cascade :
- Erreur : Le rejet d'un bloc force la régénération de toute la séquence suivante.
- Correction : Implémentez un mécanisme de « rejet partiel » où seuls les pixels invalides du bloc sont régénérés.
-
Surcharge mémoire du spéculateur :
- Erreur : Le spéculateur a une taille comparable au modèle principal, annulant le bénéfice.
- Correction : Limitez le spéculateur à ≤ 10% des paramètres du modèle cible.
Liste de vérification
