Træning og Optimering

Træning af generative modeller indebærer optimering af ofte ustabile og komplekse tab-landskaber. Dette afsnit introducerer tabsfunktioner tilpasset hver modeltype, optimeringsstrategier til at stabilisere træningen samt metoder til finjustering af fortrænede modeller til specifikke anvendelser.

Centrale tabsfunktioner

Forskellige familier af generative modeller anvender forskellige tabsformuleringer afhængigt af, hvordan de modellerer datadistributioner.

GAN-tab

Minimax-tab (original GAN)

Adversarial opsætning mellem generator $G$ og discriminator $D$ (eksempel med pythorch-biblioteket):

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)

Anvender L2-tab i stedet for log-tab for at forbedre stabilitet og gradientflow:

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)

Minimerer Earth Mover (EM) distance; erstatter diskriminator med en "kritiker" og anvender vægtklipning eller gradientstraf for Lipschitz-kontinuitet:

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

VAE-tab

Evidence Lower Bound (ELBO)

Kombinerer rekonstruktion og regularisering. KL-divergensleddet opfordrer den latente posterior til at forblive tæt på prioren (typisk standard normalfordeling):

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

Tab for diffusionsmodellers tab

Tab for støjforudsigelse

Modeller lærer at fjerne tilføjet Gaussisk støj gennem en diffusionsplan. Varianter anvender hastighedsforudsigelse (f.eks. v-prediction i Stable Diffusion v2) eller hybride mål:

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)

Optimeringsteknikker

Træning af generative modeller er ofte ustabil og følsom over for hyperparametre. Flere teknikker anvendes for at sikre konvergens og kvalitet.

Optimeringsalgoritmer og planlæggere

• Adam / AdamW: adaptive gradientoptimeringsalgoritmer er standardvalget. Brug $\beta_1=0.5,\ \beta_2=0.999$ til GANs;
• RMSprop: anvendes nogle gange i WGAN-varianter;
• Learning rate scheduling:
  • Opvarmningsfaser for transformere og diffusionsmodeller;
  • Cosinusfald eller ReduceLROnPlateau for stabil konvergens.

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

Stabiliseringsmetoder

• Gradientklipning: undgå eksploderende gradienter i RNN'er eller dybe UNets;

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

• Spektral normalisering: anvendt på diskriminatorlag i GANs for at håndhæve Lipschitz-betingelser;

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

• Label smoothing: blødgør hårde labels (f.eks. real = 0,9 i stedet for 1,0) for at reducere overkonfidens;
• To-tids-skala opdateringsregel (TTUR): brug forskellige læringsrater for generator og diskriminator for at forbedre konvergens;
• Mixed-precision træning: udnytter FP16 (via NVIDIA Apex eller PyTorch AMP) for hurtigere træning på moderne GPU'er.

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()

Finjustering af fortrænede generative modeller

Fortrænede generative modeller (f.eks. Stable Diffusion, LLaMA, StyleGAN2) kan finjusteres til domænespecifikke opgaver ved hjælp af lettere træningsstrategier.

Transfer learning-teknikker

• Fuld finjustering: gen-træn alle modellens vægte. Højt beregningsforbrug, men maksimal fleksibilitet;

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

• Lag-genfrysning / gradvis optøning: start med at fryse de fleste lag og optø derefter gradvist udvalgte lag for bedre finjustering. Dette undgår katastrofal glemsel. Frysning af tidlige lag hjælper med at bevare generelle træk fra fortræning (som kanter eller ordmønstre), mens optøning af senere lag gør det muligt for modellen at lære opgavespecifikke træk;

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 / adapter-lag: indsættelse af lav-rang trænbare lag uden opdatering af basismodellens parametre;

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 / tekstuel inversion (diffusionsmodeller):
  • Finjustering på et lille antal emnespecifikke billeder.
  • Brug diffusers pipeline:

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

• Prompt tuning / 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)

Almindelige anvendelsestilfælde

• Stiltilpasning: finjustering på anime-, tegneserie- eller kunstneriske datasæt;
• Branchespecifik tilpasning: tilpasning af LLM'er til juridiske, medicinske eller virksomhedsdomæner;
• Personalisering: tilpasning af identitet eller stemme ved brug af små referencesæt.

Resumé

• Brug modelspecifikke tabfunktioner, der matcher træningsmål og modelstruktur;
• Optimer med adaptive metoder, stabiliseringsteknikker og effektiv planlægning;
• Finjuster fortrænede modeller ved hjælp af moderne low-rank eller prompt-baserede transferstrategier for at reducere omkostninger og øge domænetilpasning.