Un ghid complet pentru reglarea fină a modelelor de limbi mari

Modele mari de limbaj (LLM) precum GPT-4, LaMDA, PaLM și alții au luat lumea cu asalt cu capacitatea lor remarcabilă de a înțelege și de a genera text asemănător omului pe o gamă largă de subiecte. Aceste modele sunt antrenate în prealabil pe seturi de date masive care cuprind miliarde de cuvinte de pe internet, cărți și alte surse.

Această fază de pre-antrenament oferă modelelor cunoștințe generale extinse despre limbaj, subiecte, abilități de raționament și chiar anumite părtiniri prezente în datele de antrenament. Cu toate acestea, în ciuda amplorii lor incredibile, acestor LLM-uri pre-instruite le lipsește expertiza specializată pentru domenii sau sarcini specifice.

Aici intervine reglarea fină – procesul de adaptare a unui LLM pre-instruit pentru a excela într-o anumită aplicație sau caz de utilizare. Prin antrenarea în continuare a modelului pe un set de date mai mic, specific unei sarcini, îi putem regla capacitățile pentru a se alinia cu nuanțele și cerințele domeniului respectiv.

Reglajul fin este analog cu transferul cunoștințelor ample ale unui generalist înalt educat pentru a crea un expert în materie specializat într-un anumit domeniu. În acest ghid, vom explora ce, de ce și cum de reglare fină a LLM-urilor.

Reglarea fină a modelelor de limbă mari

Ce este reglajul fin?

În centrul său, reglaj fin implică luarea unui model mare pre-antrenat și actualizarea parametrilor acestuia folosind o a doua fază de antrenament pe un set de date adaptat sarcinii sau domeniului țintă. Acest lucru permite modelului să învețe și să interiorizeze nuanțele, modelele și obiectivele specifice acelei zone mai înguste.

În timp ce pre-instruirea captează o înțelegere largă a limbii dintr-un corpus de text uriaș și divers, reglarea fină specializează această competență generală. Este asemănător cu a lua un om renascentist și a-l transforma într-un expert în industrie.

Greutățile modelului pre-antrenat, care codifică cunoștințele sale generale, sunt folosite ca punct de plecare sau inițializare pentru procesul de reglare fină. Modelul este apoi instruit în continuare, dar de data aceasta pe exemple direct relevante pentru aplicația finală.

Prin expunerea modelului la această distribuție de date specializată și ajustarea parametrilor modelului în consecință, facem LLM-ul mai precis și mai eficient pentru cazul de utilizare țintă, beneficiind în același timp de capacitățile largi pre-antrenate ca bază.

De ce ajustați LLM-urile?

Există mai multe motive esențiale pentru care este posibil să doriți să reglați fin un model de limbă mare:

1. Personalizare domeniu: Fiecare domeniu, de la juridic la medicină la inginerie software, are propriile convenții de limbaj, jargon și contexte nuanțate. Reglarea fină vă permite să personalizați un model general pentru a înțelege și a produce text adaptat domeniului specific.
2. Specializarea sarcinilor: LLM-urile pot fi reglate fin pentru diverse sarcini de procesare a limbajului natural, cum ar fi rezumarea textului, traducerea automată, răspunsul la întrebări și așa mai departe. Această specializare crește performanța la sarcina țintă.
3. Conformitatea datelor: Industriile foarte reglementate, cum ar fi asistența medicală și finanțele, au cerințe stricte de confidențialitate a datelor. Reglarea fină permite instruirea LLM-urilor cu privire la datele organizaționale proprietare, protejând în același timp informațiile sensibile.
4. Date limitate etichetate: Obținerea de seturi mari de date etichetate pentru modele de antrenament de la zero poate fi o provocare. Reglarea fină permite obținerea unor performanțe puternice ale sarcinilor din exemple limitate supravegheate prin valorificarea capacităților modelului pre-antrenat.
5. Actualizare model: Pe măsură ce noi date devin disponibile în timp într-un domeniu, puteți ajusta mai mult modelele pentru a încorpora cele mai recente cunoștințe și capabilități.
6. Atenuarea prejudecăților: LLM-urile pot identifica părtinirile societale din datele ample de pre-formare. Reglarea fină a seturilor de date organizate poate ajuta la reducerea și corectarea acestor părtiniri nedorite.

În esență, reglarea fină face o punte între un model general și larg și cerințele concentrate ale unei aplicații specializate. Îmbunătățește acuratețea, siguranța și relevanța rezultatelor modelului pentru cazurile de utilizare vizate.

Reglarea fină a modelelor de limbă mari

Abordări de reglare fină

Există două strategii principale atunci când vine vorba de reglarea fină a modelelor de limbaj mari:

1) Reglare fină a modelului complet

În abordarea completă de reglare fină, toți parametrii (greutăți și părtiniri) ai modelului pre-antrenat sunt actualizați în timpul celei de-a doua etape de antrenament. Modelul este expus la setul de date etichetat specific sarcinii, iar procesul de instruire standard optimizează întregul model pentru acea distribuție a datelor.

Acest lucru permite modelului să facă ajustări mai cuprinzătoare și să se adapteze holistic la sarcina sau domeniul țintă. Cu toate acestea, reglarea fină completă are câteva dezavantaje:

• Necesită resurse de calcul semnificative și timp pentru antrenament, similar fazei de pre-antrenament.
• Cerințele de stocare sunt mari, deoarece trebuie să păstrați o copie separată reglată fin a modelului pentru fiecare sarcină.
• Există riscul de „uitare catastrofală”, în cazul în care reglarea fină face ca modelul să piardă unele capacități generale învățate în timpul pre-antrenamentului.

În ciuda acestor limitări, reglarea fină completă rămâne o tehnică puternică și utilizată pe scară largă atunci când resursele permit și sarcina țintă diferă semnificativ de limbajul general.

2) Metode eficiente de reglare fină

Pentru a depăși provocările de calcul ale reglajului complet, cercetătorii au dezvoltat strategii eficiente care actualizează doar un mic subset al parametrilor modelului în timpul reglajului fin. Aceste tehnici eficiente din punct de vedere parametric ating un echilibru între specializare și reducerea cerințelor de resurse.

Unele metode populare eficiente de reglare fin includ:

Prefix-Tuning: Aici, un număr mic de vectori specifici sarcinii sau „prefixe” sunt introduși și antrenați pentru a condiționa atenția modelului pre-antrenat pentru sarcina țintă. Numai aceste prefixe sunt actualizate în timpul reglajului fin.

LoRA (adaptare la rang scăzut): LoRA injectează matrice antrenabile de rang scăzut în fiecare strat al modelului pre-antrenat în timpul reglajului fin. Aceste mici ajustări ale rangului ajută la specializarea modelului cu mult mai puțini parametri antrenabili decât reglajul fin complet.

Sigur, pot oferi o explicație detaliată a LoRA (Low-Rank Adaptation) împreună cu formularea matematică și exemplele de cod. LoRA este o tehnică populară de reglare fină eficientă în funcție de parametri (PEFT) care a câștigat o tracțiune semnificativă în domeniul adaptării modelului de limbaj mare (LLM).

Ce este LoRA?

LoRA este o metodă de reglare fină care introduce un număr mic de parametri antrenabili în LLM pre-antrenat, permițând adaptarea eficientă la sarcinile din aval, păstrând în același timp majoritatea cunoștințelor modelului original. În loc să ajusteze toți parametrii LLM, LoRA injectează matrici de rang scăzut specifice sarcinii în straturile modelului, permițând economii semnificative de calcul și memorie în timpul procesului de reglare fină.

Formularea matematică

LoRA (Low-Rank Adaptation) este o metodă de reglare fină pentru modelele de limbaj mari (LLM) care introduce o actualizare de rang scăzut a matricelor de greutate. Pentru o matrice de greutate 0∈W0​∈Rd×k, LoRA adaugă o matrice de rang scăzut $BA$, Cu A∈Rr×k și B∈Rd×r, În cazul în care $r$ este rangul. Această abordare reduce semnificativ numărul de parametri antrenabili, permițând adaptarea eficientă la sarcinile din aval cu resurse de calcul minime. Matricea de greutate actualizată este dată de W=W0​+B⋅A.

Această actualizare de rang scăzut poate fi interpretată ca modificarea matricei de greutate inițială $W_{0}$ prin adăugarea unei matrice de rang scăzut $BA$. Avantajul cheie al acestei formulări este că, în loc să actualizeze toți parametrii $d \times k$ în $W_{0}$, LoRA trebuie doar să optimizeze parametrii $r \times (d + k)$ în $A$ și $B $, reducând semnificativ numărul de parametri antrenabili.

Iată un exemplu în Python care utilizează peft bibliotecă pentru a aplica LoRA unui LLM pre-instruit pentru clasificarea textului:

</div>
<div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color="">from</span> transformers <span class="token" data-darkreader-inline-color="">import</span> AutoModelForSequenceClassification
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color="">from</span> peft <span class="token" data-darkreader-inline-color="">import</span> get_peft_model<span class="token" data-darkreader-inline-color="">,</span> LoraConfig<span class="token" data-darkreader-inline-color="">,</span> TaskType
</code></div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Load pre-trained model</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">model <span class="token" data-darkreader-inline-color="">=</span> AutoModelForSequenceClassification<span class="token" data-darkreader-inline-color="">.</span>from_pretrained<span class="token" data-darkreader-inline-color="">(</span><span class="token" data-darkreader-inline-color="">"bert-base-uncased"</span><span class="token" data-darkreader-inline-color="">,</span> num_labels<span class="token" data-darkreader-inline-color="">=</span><span class="token" data-darkreader-inline-color="">2</span><span class="token" data-darkreader-inline-color="">)</span>
</code></div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Define LoRA configuration</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">peft_config <span class="token" data-darkreader-inline-color="">=</span> LoraConfig<span class="token" data-darkreader-inline-color="">(</span>task_type<span class="token" data-darkreader-inline-color="">=</span>TaskType<span class="token" data-darkreader-inline-color="">.</span>SEQ_CLS<span class="token" data-darkreader-inline-color="">, </span>r<span class="token" data-darkreader-inline-color="">=</span><span class="token" data-darkreader-inline-color="">8</span><span class="token" data-darkreader-inline-color="">,</span>  <span class="token" data-darkreader-inline-color=""># Rank of the low-rank update</span>
lora_alpha<span class="token" data-darkreader-inline-color="">=</span><span class="token" data-darkreader-inline-color="">16</span><span class="token" data-darkreader-inline-color="">,</span></code><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Scaling factor for the low-rank update</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">    target_modules<span class="token" data-darkreader-inline-color="">=</span><span class="token" data-darkreader-inline-color="">[</span><span class="token" data-darkreader-inline-color="">"q_lin"</span><span class="token" data-darkreader-inline-color="">,</span> <span class="token" data-darkreader-inline-color="">"v_lin"</span><span class="token" data-darkreader-inline-color="">]</span><span class="token" data-darkreader-inline-color="">,</span>  <span class="token" data-darkreader-inline-color=""># Apply LoRA to the query and value layers</span>
<span class="token" data-darkreader-inline-color="">)</span>
</code></div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Create the LoRA-enabled model</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">model <span class="token" data-darkreader-inline-color="">=</span> get_peft_model<span class="token" data-darkreader-inline-color="">(</span>model<span class="token" data-darkreader-inline-color="">,</span> peft_config<span class="token" data-darkreader-inline-color="">)</span>
</code></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># Fine-tune the model with LoRA</span>
</code></div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""></div>
<div class="code-block__code !my-0 !rounded-t-lg !text-sm !leading-relaxed" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><code class="language-python" data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color=""><span class="token" data-darkreader-inline-color=""># ... (training code omitted for brevity)</span></code></div>
</div>
<div data-darkreader-inline-bgimage="" data-darkreader-inline-bgcolor="" data-darkreader-inline-color="">

În acest exemplu, încărcăm un model BERT pre-antrenat pentru clasificarea secvenței și definim o configurație LoRA. The r parametrul specifică rangul actualizării de rang scăzut și lora_alpha este un factor de scalare pentru actualizare. The target_modules parametrul indică ce straturi ale modelului ar trebui să primească actualizări de rang scăzut. După crearea modelului compatibil LoRA, putem continua cu procesul de reglare fină utilizând procedura standard de antrenament.

Straturi adaptoare: Similar cu LoRA, dar în loc de actualizări de rang scăzut, straturi subțiri de „adaptor” sunt inserate în fiecare bloc transformator al modelului pre-antrenat. Sunt antrenați doar parametrii acestor câteva noi straturi compacte.

Acordare promptă: Această abordare păstrează complet înghețat modelul pre-antrenat. În schimb, înglobările „prompte” care pot fi antrenate sunt introduse ca intrare pentru a activa cunoștințele pre-antrenate ale modelului pentru sarcina țintă.

Aceste metode eficiente pot oferi reduceri de calcul de până la 100 de ori în comparație cu reglarea fină completă, obținând în același timp performanțe competitive pentru multe sarcini. De asemenea, reduc nevoile de stocare evitând duplicarea completă a modelului.

Cu toate acestea, performanța lor poate rămâne în urma reglajului complet pentru sarcini care sunt foarte diferite de limbajul general sau necesită o specializare mai holistică.

Procesul de reglare fină

Indiferent de strategia de reglare fină, procesul general de specializare a unui LLM urmează un cadru general:

1. Pregătirea setului de date: va trebui să obțineți sau să creați un set de date etichetat care mapează intrările (prompt-urile) la ieșirile dorite pentru sarcina dvs. țintă. Pentru sarcinile de generare de text, cum ar fi rezumarea, acesta ar fi text de intrare în perechile de ieșire rezumate.
2. Divizarea setului de date: Urmând cele mai bune practici, împărțiți setul de date etichetat în seturi de tren, de validare și de testare. Aceasta separă datele pentru antrenamentul modelului, reglarea hiperparametrului și evaluarea finală.
3. Reglarea hiperparametrului: Parametrii precum rata de învățare, dimensiunea lotului și programul de antrenament trebuie ajustați pentru cea mai eficientă reglare fină a datelor dvs. Aceasta implică de obicei un mic set de validare.
4. Formare model: Folosind hiperparametrii reglați, rulați procesul de optimizare a reglajului fin pe setul de antrenament complet până când performanța modelului pe setul de validare încetează să se îmbunătățească (oprire timpurie).
5. Evaluare: Evaluați performanța modelului ajustat pe setul de testare reținut, cuprinzând în mod ideal exemple din lumea reală pentru cazul de utilizare țintă, pentru a estima eficacitatea în lumea reală.
6. Implementare și monitorizare: Odată satisfăcător, modelul reglat fin poate fi implementat pentru a deduce noile intrări. Este esențial să-i monitorizezi performanța și acuratețea de-a lungul timpului pentru deviația conceptului.

În timp ce acest lucru subliniază procesul general, multe nuanțe pot afecta succesul reglajului pentru un anumit LLM sau sarcină. Strategiile precum învățarea curriculară, reglarea fină a mai multor sarcini și indicarea în câteva momente pot spori și mai mult performanța.

În plus, metodele eficiente de reglare fină implică considerații suplimentare. De exemplu, LoRA necesită tehnici precum condiționarea ieșirilor modelului pre-antrenat printr-un strat de combinare. Reglarea promptă are nevoie de prompturi concepute cu atenție pentru a activa comportamentele potrivite.

Ajustare avansată: includerea feedback-ului uman

În timp ce reglarea fină standard supravegheată folosind seturi de date etichetate este eficientă, o frontieră interesantă este formarea LLM-urilor direct folosind preferințele și feedbackul uman. Această abordare „human-in-the-loop” folosește tehnicile din învățarea prin întărire:

PPO (Optimizarea politicii proximale): Aici, LLM este tratat ca un agent de învățare de întărire, rezultatele sale fiind „acțiuni”. Un model de recompensă este antrenat pentru a prezice evaluările umane sau scorurile de calitate pentru aceste rezultate. PPO optimizează apoi LLM pentru a genera rezultate care maximizează scorurile modelului de recompensă.

RLHF (Învățare de consolidare din feedbackul uman): Aceasta extinde PPO prin încorporarea directă a feedback-ului uman în procesul de învățare. În loc de un model de recompensă fix, recompensele provin din evaluări umane iterative asupra rezultatelor LLM în timpul reglajului fin.

Deși sunt intensive din punct de vedere computațional, aceste metode permit modelarea comportamentului LLM mai precis pe baza caracteristicilor dorite evaluate de oameni, dincolo de ceea ce poate fi capturat într-un set de date static.

Companii precum Anthropic au folosit RLHF pentru a-și impregna modelele lingvistice, cum ar fi Claude, cu o mai bună sinceritate, etică și conștientizare a siguranței, dincolo de competența sarcinii.

Riscuri potențiale și limitări

Deși extrem de puternice, reglarea LLM-urilor nu este lipsită de riscuri care trebuie gestionate cu atenție:

Amplificare bias: dacă datele de reglare fin conțin părtiniri sociale legate de sex, rasă, vârstă sau alte atribute, modelul poate amplifica aceste părtiniri nedorite. Curatarea seturilor de date reprezentative și nepărtinitoare este crucială.

Deriva faptică: Chiar și după reglarea fină a datelor de înaltă calitate, modelele lingvistice pot „halucina” fapte incorecte sau rezultate incompatibile cu exemplele de instruire în timpul conversațiilor sau solicitărilor mai lungi. Pot fi necesare metode de recuperare a faptelor.

Provocări de scalabilitate: Reglarea fină completă a modelelor uriașe precum GPT-3 necesită resurse de calcul imense, care pot fi imposibil de realizat pentru multe organizații. Reglarea fină eficientă atenuează parțial acest lucru, dar are compromisuri.

Uitare catastrofală: În timpul reglajului complet, modelele pot experimenta o uitare catastrofală, unde își pierd unele capacități generale învățate în timpul antrenamentului prealabil. Poate fi necesară învățarea cu mai multe sarcini.

Riscuri IP și confidențialitate: Datele proprietare utilizate pentru reglare fină se pot scurge în rezultatele modelului de limbă publicate public, prezentând riscuri. Tehnicile diferențiate de atenuare a pericolelor legate de confidențialitate și informații sunt domenii active de cercetare.

În general, deși este extrem de utilă, reglarea fină este un proces nuanțat care necesită atenție în ceea ce privește calitatea datelor, considerente de identitate, atenuarea riscurilor și echilibrarea compromisurilor performanță-eficiență pe baza cerințelor cazurilor de utilizare.

Viitorul: personalizarea modelului lingvistic la scară

Privind în viitor, progresele în tehnicile de reglare fină și adaptare a modelelor vor fi esențiale pentru deblocarea întregului potențial al modelelor de limbaj mari în diverse aplicații și domenii.

Metode mai eficiente care permit reglarea fină a modelelor și mai mari, cum ar fi PaLM, cu resurse limitate, ar putea democratiza accesul. Automatizarea conductelor de creare a seturilor de date și inginerie promptă ar putea eficientiza specializarea.

Tehnicile auto-supravegheate de ajustare a datelor brute fără etichete pot deschide noi frontiere. Iar abordările compoziționale pentru a combina submodele ajustate, antrenate pe diferite sarcini sau date, ar putea permite construirea de modele foarte personalizate la cerere.

În cele din urmă, pe măsură ce LLM-urile devin mai omniprezente, capacitatea de a le personaliza și de a le specializa fără probleme pentru fiecare caz de utilizare imaginabil va fi critică. Reglajul fin și strategiile de adaptare a modelelor aferente sunt pași esenți în realizarea viziunii modelelor de limbaj mari ca asistenți AI flexibili, siguri și puternici, care sporesc capacitățile umane în fiecare domeniu și demers.