FAI engineeringLaboration· ca 75 min· sandlåda på servern

Labb: LoRA på ett litet nät — träna bara adaptrarna

Implementera en LoRA-adapter (W + BA, rank r), frysa basmodellen, träna bara adaptrarna på en ny uppgift och jämföra parameterantal och resultat med full finjustering.

Lär ut: LoRA — Low-Rank Adaptation

Kräver: Matrisfaktorisering och lågrangsapproximationTräna ett neuronnät i PyTorch

Teori

ΔW = BA där B är d×r och A är r×k. Med r ≪ min(d,k) är antalet tränade parametrar r(d+k) i stället för dk. B initieras till noll så att modellen startar oförändrad.

Deluppgifter

LoRALinear — LoRALinear(base: nn.Linear, r, alpha) — fryser base, lägger till A (r×in, liten normal) och B (out×r, nollor), forward = base(x) + (alpha/r)·(x Aᵀ) Bᵀ.
apply_lora — apply_lora(model, r, alpha) byter ut alla nn.Linear i ett nn.Sequential; trainable_params(model).
finjustera — finetune(model, X, y, steps, lr) tränar bara parametrar med requires_grad; merge(lora_layer) returnerar en nn.Linear med W + (alpha/r)BA.

Godkänt när: lora_acc >= 0.85

Startkoden

körs i en isolerad sandlåda på servern

import torch
import torch.nn as nn


class LoRALinear(nn.Module):
    def __init__(self, base: nn.Linear, r=4, alpha=8):
        super().__init__()
        self.base = base
        for p in self.base.parameters():
            p.requires_grad = False
        self.r, self.alpha = r, alpha
        # TODO: self.A = nn.Parameter(torch.randn(r, base.in_features) * 0.01); self.B = nn.Parameter(torch.zeros(base.out_features, r))
        ...

    def forward(self, x):
        # TODO: base(x) + (alpha / r) * (x @ A.T) @ B.T
        ...


def apply_lora(model: nn.Sequential, r=4, alpha=8):
    # TODO: ersätt varje nn.Linear i model med LoRALinear
    ...


def trainable_params(model):
    return sum(p.numel() for p in model.parameters() if p.requires_grad)


def total_params(model):
    return sum(p.numel() for p in model.parameters())


def finetune(model, X, y, steps=300, lr=1e-2):
    # TODO: Adam över [p for p in model.parameters() if p.requires_grad], CrossEntropyLoss
    ...


def merge(layer: LoRALinear) -> nn.Linear:
    # TODO: ny nn.Linear med weight = base.weight + (alpha/r) * B @ A, bias = base.bias
    ...

Du skriver koden, tester du inte ser avgör om den håller. Skapa ett gratis konto för att köra labben.

Prova diagnosen Skapa konto gratis

Förväntade resultat

LoRA med r=4 tränar < 10 % av parametrarna och når ≥ 0,85 accuracy på den skiftade uppgiften; merge ger samma utdata som adapter-modellen.

Vanliga fel

B initierat slumpmässigt → modellen ändras redan före träning.
Glömmer frysa basvikterna (requires_grad=False).
Skalning alpha/r saknas i merge.