Entraînement et Optimisation

L'entraînement des modèles génératifs implique l'optimisation de paysages de perte souvent instables et complexes. Cette section présente des fonctions de perte adaptées à chaque type de modèle, des stratégies d'optimisation pour stabiliser l'entraînement, ainsi que des méthodes d'ajustement fin de modèles préentraînés pour des cas d'utilisation personnalisés.

Fonctions de perte principales

Différentes familles de modèles génératifs utilisent des formulations de perte distinctes selon la manière dont elles modélisent les distributions de données.

Pertes des GAN

Perte minimax (GAN original)

Configuration adversariale entre le générateur $G$ et le discriminateur $D$ (exemple avec la bibliothèque pythorch) :

loss_D = -torch.mean(torch.log(D(real_data)) + torch.log(1. - D(fake_data)))
loss_G = -torch.mean(torch.log(D(fake_data)))

Least squares GAN (LSGAN)

Utilise la perte L2 au lieu de la perte logarithmique afin d'améliorer la stabilité et le flux du gradient :

loss_D = 0.5 * torch.mean((D(real_data) - 1) ** 2 + D(fake_data) ** 2)
loss_G = 0.5 * torch.mean((D(fake_data) - 1) ** 2)

Wasserstein GAN (WGAN)

Minimise la distance Earth Mover (EM) ; remplace le discriminateur par un « critique » et utilise le découpage des poids ou une pénalité de gradient pour assurer la continuité de Lipschitz :

loss = torch.mean(D(fake_data)) - torch.mean(D(real_data)) + gradient_penalty

Perte VAE

Evidence Lower Bound (ELBO)

Combine la reconstruction et la régularisation. Le terme de divergence KL encourage la distribution latente postérieure à rester proche de la distribution a priori (généralement normale standard) :

recon_loss = F.binary_cross_entropy(recon_x, x, reduction='sum')
kl_div = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
loss = recon_loss + kl_div

Fonctions de perte pour les modèles de diffusion

Perte de prédiction du bruit

Les modèles apprennent à débruiter le bruit gaussien ajouté selon un calendrier de diffusion. Certaines variantes utilisent la prédiction de vélocité (par exemple, v-prediction dans Stable Diffusion v2) ou des objectifs hybrides :

noise = torch.randn_like(x)
x_t = q_sample(x, t, noise)
pred_noise = model(x_t, t)
loss = F.mse_loss(pred_noise, noise)

Techniques d'optimisation

L'entraînement des modèles génératifs est souvent instable et sensible aux hyperparamètres. Plusieurs techniques sont utilisées pour garantir la convergence et la qualité.

Optimiseurs et planificateurs

• Adam / AdamW : les optimiseurs de gradient adaptatif sont la norme de facto. Utiliser $\beta_1=0.5,\ \beta_2=0.999$ pour les GANs ;
• RMSprop : parfois utilisé dans les variantes de WGAN ;
• Planification du taux d'apprentissage :
  • Phases de warm-up pour les transformers et les modèles de diffusion ;
  • Décroissance cosinus ou ReduceLROnPlateau pour une convergence stable.

optimizer = torch.optim.Adam(model.parameters(), lr=2e-4, betas=(0.5, 0.999))
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100)

Méthodes de stabilisation

• Clipping du gradient : éviter l'explosion des gradients dans les RNN ou les UNet profonds ;

torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

• Normalisation spectrale : appliquée aux couches du discriminateur dans les GANs pour imposer des contraintes de Lipschitz ;

from torch.nn.utils import spectral_norm
layer = spectral_norm(nn.Linear(100, 100))

• Lissage des étiquettes : adoucit les étiquettes strictes (par exemple, réel = 0,9 au lieu de 1,0) pour réduire la surconfiance ;
• Règle de mise à jour à deux échelles de temps (TTUR) : utilisation de taux d'apprentissage différents pour le générateur et le discriminateur afin d'améliorer la convergence ;
• Entraînement en précision mixte : exploite FP16 (via NVIDIA Apex ou PyTorch AMP) pour un entraînement plus rapide sur les GPU modernes.

scaler = torch.cuda.amp.GradScaler()
with torch.cuda.amp.autocast():
    output = model(input)
    loss = loss_fn(output, target)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

Ajustement fin des modèles génératifs pré-entraînés

Les modèles génératifs pré-entraînés (par exemple, Stable Diffusion, LLaMA, StyleGAN2) peuvent être ajustés pour des tâches spécifiques à un domaine en utilisant des stratégies d'entraînement allégées.

Techniques d'apprentissage par transfert

• Ajustement complet : réentraîner tous les poids du modèle. Coût de calcul élevé mais flexibilité maximale ;

model = AutoModel.from_pretrained('model-name')
model.train()
optimizer = torch.optim.Adam(model.parameters(), lr=5e-5)

• Re-gel des couches / dégel progressif : commencer par geler la plupart des couches, puis dégeler progressivement certaines couches pour un meilleur ajustement fin. Cette méthode évite l'oubli catastrophique. Geler les premières couches permet de conserver les caractéristiques générales issues du pré-entraînement (comme les contours ou les motifs de mots), tandis que dégeler les couches ultérieures permet au modèle d'apprendre des caractéristiques spécifiques à la tâche ;

for param in model.parameters():
    param.requires_grad = False
# Unfreeze final transformer block or decoder
for param in model.transformer.block[-1].parameters():
    param.requires_grad = True

• LoRA / couches adaptatrices : injection de couches entraînables de faible rang sans mise à jour des paramètres du modèle de base ;

from peft import get_peft_model, LoraConfig, TaskType

config = LoraConfig(task_type=TaskType.SEQ_2_SEQ_LM, r=8, lora_alpha=16, lora_dropout=0.1)
model = get_peft_model(base_model, config)

• DreamBooth / inversion textuelle (modèles de diffusion) :
  • Ajustement fin sur un petit nombre d’images spécifiques à un sujet.
  • Utilisation du pipeline diffusers :

from diffusers import StableDiffusionPipeline
pipeline = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4")
pipeline.train(texts, images)  # pseudo-call: use DreamBooth training scripts in practice

• Ajustement d’invite / p-tuning :

from peft import PromptTuningConfig, get_peft_model
config = PromptTuningConfig(task_type=TaskType.CAUSAL_LM, num_virtual_tokens=20)
model = get_peft_model(base_model, config)

Cas d'utilisation courants

• Adaptation de style : ajustement fin sur des ensembles de données d'anime, de bande dessinée ou artistiques ;
• Ajustement spécifique à l'industrie : adaptation des LLMs aux domaines juridiques, médicaux ou d'entreprise ;
• Personnalisation : conditionnement d'identité ou de voix personnalisé à l'aide de petits ensembles de référence.

Résumé

• Utiliser des fonctions de perte spécifiques au modèle qui correspondent aux objectifs d'entraînement et à la structure du modèle ;
• Optimiser avec des méthodes adaptatives, des techniques de stabilisation et une planification efficace ;
• Ajuster finement les modèles préentraînés en utilisant des stratégies modernes de transfert à faible rang ou basées sur des prompts pour réduire les coûts et augmenter l'adaptabilité au domaine.