Trening og optimalisering

Trening av generative modeller innebærer optimalisering av ofte ustabile og komplekse tapslandskap. Denne delen introduserer tapsfunksjoner tilpasset hver modelltype, optimaliseringsstrategier for å stabilisere treningen, og metoder for finjustering av forhåndstrente modeller for tilpassede bruksområder.

Sentrale tapsfunksjoner

Ulike familier av generative modeller bruker ulike tapsformuleringer avhengig av hvordan de modellerer datadistribusjoner.

GAN-tap

Minimax-tap (original GAN)

Adversarialt oppsett mellom generator $G$ og diskriminator $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)

Bruker L2-tap i stedet for log-tap for å forbedre stabilitet og gradientflyt:

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)-avstand; erstatter diskriminator med en "kritiker" og bruker vektklipping eller gradientstraff for Lipschitz-kontinuitet:

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

VAE-tap

Evidence Lower Bound (ELBO)

Kombinerer rekonstruksjon og regularisering. KL-divergensleddet oppmuntrer den latente posterioren til å forbli nær prioren (vanligvis 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

Tap for diffusjonsmodell

Tap for støyforutsigelse

Modeller lærer å fjerne tilsatt Gaussisk støy gjennom en diffusjonsplan. Varianter bruker hastighetsforutsigelse (for eksempel v-prediksjon 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)

Optimaliseringsteknikker

Trening av generative modeller er ofte ustabilt og følsomt for hyperparametere. Flere teknikker benyttes for å sikre konvergens og kvalitet.

Optimaliseringsmetoder og planleggere

• Adam / AdamW: adaptive gradientoptimalisatorer er standardvalget. Bruk $\beta_1=0.5,\ \beta_2=0.999$ for GANs;
• RMSprop: noen ganger brukt i WGAN-varianter;
• Læringsrateplanlegging:
  • Oppvarmingsfaser for transformere og diffusjonsmodeller;
  • Cosine decay 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

• Gradientklipping: unngå eksploderende gradienter i RNN-er eller dype UNets;

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

• Spektral normalisering: brukt på diskriminatorlag i GAN-er for å håndheve Lipschitz-betingelser;

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

• Label smoothing: mykner opp harde etiketter (f.eks. ekte = 0,9 i stedet for 1,0) for å redusere overkonfidens;
• To-tids-skala oppdateringsregel (TTUR): bruk ulike læringsrater for generator og diskriminator for å forbedre konvergens;
• Trening med blandet presisjon: utnytter FP16 (via NVIDIA Apex eller PyTorch AMP) for raskere trening 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 av forhåndstrente generative modeller

Forhåndstrente generative modeller (f.eks. Stable Diffusion, LLaMA, StyleGAN2) kan finjusteres for domenespesifikke oppgaver ved bruk av lettere treningsstrategier.

Overføringsteknikker for læring

• Full finjustering: tren alle modellens vekter på nytt. Høy beregningskostnad, men maksimal fleksibilitet;

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

• Lagvis frysing / gradvis opplåsing: start med å fryse de fleste lagene, og lås deretter gradvis opp utvalgte lag for bedre finjustering. Dette unngår katastrofal glemsel. Å fryse tidlige lag bidrar til å bevare generelle trekk fra forhåndstreningen (som kanter eller ordmønstre), mens opplåsing av senere lag lar modellen lære oppgavespesifikke trekk;

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 / adapterlag: injiserer lav-rang trenbare lag uten å oppdatere basismodellens parametere;

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 / tekstuell inversjon (diffusjonsmodeller):
  • Finjustering på et lite antall motivspesifikke bilder.
  • Bruk 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)

Vanlige bruksområder

• Stiltilpasning: finjustering på anime-, tegneserie- eller kunstneriske datasett;
• Bransjespesifikk tilpasning: tilpasning av LLM-er til juridiske, medisinske eller bedriftsdomener;
• Personalisering: tilpasset identitet eller stemmekondisjonering ved bruk av små referansesett.

Sammendrag

• Bruk modellspecifikke tapsfunksjoner som samsvarer med treningsmål og modellstruktur;
• Optimaliser med adaptive metoder, stabiliseringsteknikker og effektiv planlegging;
• Finjuster forhåndstrente modeller ved hjelp av moderne lav-rang eller prompt-baserte overføringsstrategier for å redusere kostnader og øke domenetilpasning.