Träning och Optimering

Att träna generativa modeller innebär att optimera ofta instabila och komplexa förlustlandskap. Denna sektion introducerar förlustfunktioner anpassade för varje modelltyp, optimeringsstrategier för att stabilisera träningen samt metoder för finjustering av förtränade modeller för specifika användningsområden.

Centrala förlustfunktioner

Olika familjer av generativa modeller använder särskilda förlustformuleringar beroende på hur de modellerar datadistributioner.

GAN-förluster

Minimax-förlust (ursprunglig GAN)

Adversariell uppställning mellan generator $G$ och diskriminator $D$ (exempel 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)

Använder L2-förlust istället för log-förlust för att förbättra stabilitet och gradientflöde:

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)

Minimerar Earth Mover (EM)-avstånd; ersätter diskriminatorn med en "kritiker" och använder viktklippning eller gradientstraff för Lipschitz-kontinuitet:

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

VAE-förlust

Evidence Lower Bound (ELBO)

Kombinerar rekonstruktion och regularisering. KL-divergenstermen uppmuntrar den latenta posteriordelen att förbli nära priorfördelningen (vanligtvis standardnormal):

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

Förlustfunktioner för diffusionsmodeller

Brusprediktionsförlust

Modeller lär sig att avbrusa tillagt Gaussiskt brus över ett diffusionsschema. Varianter använder hastighetsprediktion (t.ex. v-prediktion i Stable Diffusion v2) eller hybrida 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)

Optimeringstekniker

Träning av generativa modeller är ofta instabil och känslig för hyperparametrar. Flera tekniker används för att säkerställa konvergens och kvalitet.

Optimerare och schemaläggare

• Adam / AdamW: adaptiva gradientoptimerare är standardvalet. Använd $\beta_1=0.5,\ \beta_2=0.999$ för GANs;
• RMSprop: används ibland i WGAN-varianter;
• Schemaläggning av inlärningshastighet:
  • Uppvärmningsfaser för transformatorer och diffusionsmodeller;
  • Cosinusavtagande eller ReduceLROnPlateau för 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

• Gradientklippning: undvik exploderande gradienter i RNN:er eller djupa UNets;

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

• Spektral normalisering: tillämpas på diskriminatorlager i GANs för att upprätthålla Lipschitz-villkor;

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

• Label smoothing: mjukar upp hårda etiketter (t.ex. verklig = 0,9 istället för 1,0) för att minska överdriven säkerhet;
• Tvåtidsskaleuppdateringsregel (TTUR): använd olika inlärningshastigheter för generator och diskriminator för att förbättra konvergens;
• Träning med blandad precision: utnyttjar FP16 (via NVIDIA Apex eller PyTorch AMP) för snabbare träning på moderna 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 förtränade generativa modeller

Förtränade generativa modeller (t.ex. Stable Diffusion, LLaMA, StyleGAN2) kan finjusteras för domänspecifika uppgifter med hjälp av lättare träningsstrategier.

Överföringsinlärningstekniker

• Fullständig finjustering: träna om alla modellvikter. Hög beräkningskostnad men maximal flexibilitet;

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

• Lageromfrysning / gradvis upptining: börja med att frysa de flesta lager, och tina sedan gradvis upp utvalda lager för bättre finjustering. Detta undviker katastrofal glömska. Att frysa tidiga lager hjälper till att bevara generella egenskaper från förträningen (såsom kanter eller ordmönster), medan upptining av senare lager låter modellen lära sig uppgiftsspecifika egenskaper;

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 / adapterlager: injicera lågrankiga träningsbara lager utan att uppdatera grundmodellens parametrar;

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 / textuell inversion (diffusionsmodeller):
  • Finjustering på ett fåtal ämnesspecifika bilder.
  • Använd 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)

Vanliga användningsområden

• Stilanpassning: finjustering på anime-, serie- eller konstnärliga datamängder;
• Branschspecifik anpassning: anpassning av LLM:er till juridiska, medicinska eller företagsdomäner;
• Personalisering: anpassad identitet eller röstkonditionering med små referensuppsättningar.

Sammanfattning

• Använd modellspecifika förlustfunktioner som matchar träningsmål och modellstruktur;
• Optimera med adaptiva metoder, stabiliseringstekniker och effektiv schemaläggning;
• Finjustera förtränade modeller med moderna låg-rank- eller promptbaserade överföringsstrategier för att minska kostnader och öka domänanpassning.