Finjustering med LoRA och QLoRA
Efteråt kan du räkna de träningsbara vikterna i ett LoRA-par, räkna ett skalat framåtpass och den matchande sammanslagningen för hand, läsa av en inlärningstakt på ett schema med uppvärmning och nedtrappning, och behålla den kontrollpunkt som har lägst valideringsförlust och fortfarande klarar kontrollen på den gamla uppgiften.
- Nivå
- Navigatör
- Tid
- 26 h
- Förkunskap
- R08-201

Hoppa till
Efter kursen kan du
Eleven kan implementera ett reproducerbart skript för träning och utvärdering av LoRA med fasta random seeds som minskar valideringsförlusten på en toy task och samtidigt klarar regressionstester för katastrofal glömska.
Hela uppdateringen och adapterbudgeten
Full finjustering uppdaterar varje vikt i de matriser du valt. PEFT, parameter-efficient fine-tuning, fryser de vikterna och tränar ett litet tillägg. LoRA, low-rank adaptation, är formen av PEFT i den här lektionen. För en matris W med d_in kolumner och d_out rader består adaptern av två matriser: A har formen r gånger d_in, och B har formen d_out gånger r. Antalet träningsbara vikter är r gånger d_in plus r gånger d_out. På en kvadratisk matris blir det 2 gånger r gånger d. Framåtpasset lägger en skalad produkt till det frysta resultatet: y är W x plus (alpha delat med r) gånger B gånger (A x).
Ta en kvadratisk matris med d = 1024 och rank r = 8. Hela matrisen har 1024 gånger 1024 = 1 048 576 vikter. A har 8 gånger 1024 = 8 192 vikter, B har samma 8 192, och paret har 16 384. Det är 1/64 av hela matrisen. En räkning som stannar vid r gånger d ger 8 192 och saknar B. I lektionen är 1 MiB lika med 1 048 576 byte. Varje träningsbar vikt kostar 12 byte: 2 för BF16-värdet, 2 för BF16-gradienten, 4 för Adams första moment och 4 för det andra. En fryst BF16-vikt kostar 2 byte och har inga moment. Full finjustering av den här enda matrisen kostar 1 048 576 gånger 12 = 12 582 912 byte, alltså 12 MiB. LoRA lagrar den frysta basen på 1 048 576 gånger 2 = 2 097 152 byte och adaptern på 16 384 gånger 12 = 196 608 byte. Summan är 2 293 760 byte, alltså 2,1875 MiB.
Rank, alpha, målmoduler och dropout
Alpha sätter skalan framför B (A x). Med alpha = 16 och r = 8 blir skalan 16/8 = 2. Om r höjs till 16 och alpha stannar på 16 sjunker skalan till 1, och antalet träningsbara vikter på den kvadratiska matrisen dubblas från 16 384 till 32 768. Målmodulerna är de matriser som får ett par. Ett litet block här har två lager, och varje lager har q, k, v och o, åtta matriser tillsammans. Om du siktar på q och v får du 4 par: 4 gånger 16 384 = 65 536 träningsbara vikter. Om du siktar på alla åtta får du 8 gånger 16 384 = 131 072. Den frysta basen är ändå alla åtta matriserna i båda fallen, eftersom en matris utan par används som W och lämnas orörd.
Dropout ligger bara på adaptergrenen, och bara under träning. Lektionen använder inverterad dropout med p = 0,5: varje behållen koordinat i x delas med 1 minus p, en multiplikation med 2, och varje släppt koordinat blir 0. Vid utvärdering är masken av och x går in i A oförändrad. B lagras som nollor vid steg 0, och A dras en gång med seed satt till 7, så en andra körning med samma seed drar samma A. När B är noll blir produkten B (A x) nollvektorn och y lika med W x. Siffrorna i det genomräknade passet är ett senare B, det som sparats med en kontrollpunkt, så den produkten har poster som skiljer sig från noll.
4-bitarsbasen, schemat och ett samlat steg
QLoRA behåller samma A, samma B och samma skala. Det som ändras är lagringen av W. Varje fryst vikt är en 4-bitarskod, en halv byte, plus en skala på 2 byte som delas av 64 vikter. Skalan lägger till 2/64 = 1/32 byte per vikt. För 1024-matrisen tar koderna 524 288 byte och skalorna tar 1 048 576 delat med 64, gånger 2, vilket är 32 768 byte. Adaptern tar fortfarande 196 608 byte, eftersom A och B ligger kvar i BF16 med Adam-moment. Den lagrade summan är 524 288 + 32 768 + 196 608 = 753 664 byte, alltså 0,71875 MiB. Under multiplikationen för den matrisen bygger körningen också en tillfällig BF16-kopia av W, 2 097 152 byte, och släpper kopian när multiplikationen är klar. Gradienterna uppdaterar A och B. 4-bitarskoderna ligger kvar som de lästes in.
Schemat har 80 steg och en topp på inlärningstakten vid 0,0002. Steg 1 till och med 8 är uppvärmning: takten är 0,0002 gånger s delat med 8. Steg 4 är 0,0001. Steg 8 är 0,0002. Steg 9 till och med 80 faller linjärt mot noll: takten är 0,0002 gånger (80 minus s) delat med 72. Steg 44 ger (80 minus 44) delat med 72 = 36/72 = 1/2, så takten är 0,0001. Steg 80 ger 0. Gradientackumulering samlar flera mikrobatcher före en uppdatering. Här rymmer varje mikrobatch 2 rader och antalet ackumuleringar är 4, så den effektiva batchen är 8. Optimeraren ser medelvärdet av de fyra mikrobatchgradienterna och tar ett steg.
Kontrollpunkten du behåller, sedan sammanslagningen
Läs träningsförlust, valideringsförlust och poäng på den gamla uppgiften vid samma steg. Den gamla uppgiften är fyra promptar som den frysta modellen redan svarade rätt på, och poängen är hur många av de fyra som fortfarande är rätt. Regeln har två delar. Behåll steget med lägst valideringsförlust. Kräv sedan att poängen på den gamla uppgiften där är minst 3 av 4. I den sparade körningen är raderna steg 20: träning 1,60, validering 1,70, gammal uppgift 4; steg 40: träning 0,90, validering 1,00, gammal uppgift 4; steg 60: träning 0,40, validering 1,20, gammal uppgift 2; steg 80: träning 0,10, validering 1,80, gammal uppgift 1. Lägst valideringsförlust är 1,00 vid steg 40, och poängen där är 4, så steg 40 är det du behåller. Steg 80 har lägst träningsförlust och faller på båda delarna.
En sammanslagning skriver in adaptern i basen: W prim är W plus (alpha delat med r) gånger B A, med produkten i BF16. Inferensen laddar sedan W prim och lämnar A och B oladdade. Om både den sammanslagna matrisen och paret laddas läggs samma produkt till en gång till. Adapterfilen för 1024-matrisen, A och B i FP16 utan moment, är 16 384 gånger 2 = 32 768 byte. Den sammanslagna filen packad med 4-bitarsregeln är koderna plus skalorna, 524 288 + 32 768 = 557 056 byte. Seed 7, satt innan A dras och innan raderna blandas, gör att förlusten vid steg 40 upprepas när samma skript körs en andra gång.
Ett pass, en sammanslagning och ett steg, för hand
Använd 2 gånger 2-matrisen W = [[1, 0], [0, 1]] och indata x = [3, 1]. Då är W x = [3, 1]. Ranken är r = 1 och alpha = 2, så skalan alpha delat med r är 2. A = [[1, -1]] och kontrollpunktens B = [[2], [1]]. A x = 1 gånger 3 plus minus 1 gånger 1 = 2. B gånger den skalären är [4, 2]. Gånger skalan blir det [8, 4]. Lägg till W x: y = [3 plus 8, 1 plus 4] = [11, 5]. Antalet träningsbara vikter i det lilla paret är 1 gånger (2 plus 2) = 4, samma storlek som hela matrisen. 1024-matrisen är stället där andelen blir 1/64. Det lilla paret är stället där varje produkt syns.
Produkten B A är [[2, -2], [1, -1]]. Gånger skalan blir det [[4, -4], [2, -2]]. Lägg till W: W prim = [[5, -4], [2, -1]]. Kontrollera med samma x: 5 gånger 3 plus minus 4 gånger 1 = 11, och 2 gånger 3 plus minus 1 gånger 1 = 5. Den sammanslagna multiplikationen träffar y. Vid steg 0 är B = [[0], [0]], den tillagda vektorn är [0, 0], och y är lika med [3, 1].
Dropout under träning använder p = 0,5 och den givna masken som släpper den andra koordinaten i x. Den behållna koordinaten multipliceras med 2, så adaptern ser [6, 0]. A gånger den vektorn är 6. B gånger 6 är [12, 6]. Gånger skalan blir det [24, 12]. Då är y = [3 plus 24, 1 plus 12] = [27, 13]. Utvärdering använder passet utan dropout, y = [11, 5].
En koordinat i B börjar ackumuleringen på 0,010. De fyra mikrobatchgradienterna är 4, 0, 2 och 2. Medelvärdet är 8/4 = 2. Steget tas vid schemats steg 4, där takten är 0,0001. Ändringen är minus 0,0001 gånger 2 = minus 0,0002, och koordinaten blir 0,010 minus 0,0002 = 0,0098. Fyra mikrobatcher gav en uppdatering. Regeln för kontrollpunkter behåller steg 40 på de sparade raderna.
Kolla på papper
För r = 4 på en 1024 gånger 1024-matris, skriv antalet träningsbara vikter och andelen av 1 048 576. Utgå från W, x och A i det genomräknade passet, byt B mot [[1], [0]], behåll alpha = 2 och dropout av, och skriv y och W prim. Skriv inlärningstakten vid steg 8 och vid steg 62. Starta samma koordinat på 0,010, ta fyra mikrobatchgradienter 1, 1, 1 och 1, stega med takten vid steg 4, och skriv det nya värdet. På de sparade raderna, skriv steget du behåller och dess poäng på den gamla uppgiften. Skriv den lagrade QLoRA-summan i byte för en 1024-matris med r = 8, och storleken på den sammanslagna 4-bitarsfilen för den matrisen.
Antalet träningsbara vikter är 4 gånger 1024 gånger 2 = 8 192, och 8 192 delat med 1 048 576 är 1/128. A x stannar på 2, B gånger 2 är [2, 0], skalan ger [4, 0], och y = [7, 1]. B A = [[1, -1], [0, 0]], gånger skalan blir [[2, -2], [0, 0]], och W prim = [[3, -2], [0, 1]]. Takten vid steg 8 är 0,0002. Vid steg 62 är (80 minus 62) delat med 72 = 18/72 = 1/4, så takten är 0,00005. Medelgradienten är 1, ändringen är minus 0,0001, och koordinaten blir 0,0099. Du behåller steg 40, med poäng 4 av 4 på den gamla uppgiften. Den lagrade QLoRA-summan är 753 664 byte. Den sammanslagna 4-bitarsfilen är 557 056 byte.
Kontrollfrågor
På en 1024 gånger 1024-matris med r = 8, hur många vikter är träningsbara, och hur stor andel av hela matrisen är det?
16 384, vilket är 1/64 av hela matrisen.
I det genomräknade passet med dropout av, vad är y, och vad är den sammanslagna matrisen W prim?
y är [11, 5]. W prim är [[5, -4], [2, -1]].
Vilken inlärningstakt gäller vid steg 4 och vid steg 44, och vad blir adapterkoordinaten efter den genomräknade ackumuleringen som började på 0,010?
Takten är 0,0001 vid båda stegen. Koordinaten blir 0,0098.
Vilket sparat steg behåller du, vilken poäng har det på den gamla uppgiften, och hur många byte använder lagrad QLoRA för en 1024-matris med r = 8?
Behåll steg 40, med poäng 4 av 4 på den gamla uppgiften. Lagrad QLoRA använder 753 664 byte.
Ett LoRA-par på en d gånger d-matris tränar 2 r d vikter och lägger (alpha delat med r) gånger B A x till den frysta produkten. QLoRA lagrar den frysta matrisen som 4-bitarskoder plus skalor, medan A och B ligger kvar i BF16. Behåll steget med lägst valideringsförlust vars poäng på den gamla uppgiften är minst 3 av 4, och slå ihop med W prim lika med W plus (alpha delat med r) gånger B A innan du packar filen.
Slutuppgift
Lämna in ett skript för träning och utvärdering av LoRA i PyTorch/PEFT som körs på en liten fixture-modell för CPU/GPU i den isolerade runnern; automatiserade tester verifierar att antalet träningsbara parametrar matchar exakt LoRA-matematik (r * d), att förlusten minskar deterministiskt och att exporten av adaptern lyckas.
Begrepp i kursen
Kursen har inga egna begrepp i ordlistan ännu. Begrepp från tidigare kurser används här också.
Första lektionen är öppen att läsa. Resten av kursens lektioner skrivs, och prov och diplom kommer senare. Till väntelistan