Învățare prin consolidare cu GRPO
Pe pagina anterioară, modelul a învățat din perechi de povești scrise o singură dată, înainte de antrenare. În învățarea prin consolidare (reinforcement learning), modelul învață din încercările pe care le face chiar în timpul antrenării: scrie povești, primește recompense, este ajustat spre poveștile cu recompense mari, apoi scrie din nou, cu ponderile noi. Pagina despre învățarea prin consolidare explică ideea în general, iar pagina despre gradientul strategiei și REINFORCE arată cum devine o recompensă un gradient.
Folosim GRPO (group relative policy optimization), metoda propusă în 2024 de Shao și colaboratorii, la DeepSeek, pentru modelul DeepSeekMath, și folosită apoi și pentru modelul de raționament DeepSeek-R1. Pagina despre învățarea prin consolidare pentru LLM-uri descrie metoda la scara modelelor mari. Recompensa este aceeași ca la DPO, proporția de cuvinte cerute care apar în poveste, iar codul se află în fișierul grpo.py.
La redare, playerul se încarcă de pe YouTube (detalii).
Modelul de limbaj ca strategie de decizie
Secțiune intitulată „Modelul de limbaj ca strategie de decizie”În termenii învățării prin consolidare, modelul de limbaj este strategia de decizie (policy). Starea este instrucțiunea, împreună cu tokenurile scrise până atunci, iar acțiunea este următorul token. Un episod este o poveste întreagă, iar recompensa vine o singură dată, la finalul poveștii, după ce words_used numără cuvintele cerute.
Grupuri și avantaje
Secțiune intitulată „Grupuri și avantaje”Recompensa singură nu spune dacă o poveste este bună pentru instrucțiunea primită. Pentru o instrucțiune ușoară, chiar și o poveste obișnuită folosește toate cuvintele cerute, iar pentru una grea, chiar și o poveste reușită poate folosi doar unul. De aceea, GRPO compară fiecare poveste cu alte povești scrise pentru aceeași instrucțiune. Modelul scrie un grup de 8 povești, iar avantajul (advantage) fiecărei povești este recompensa poveștii minus media grupului, împărțită la abaterea standard a grupului.
Poveștile mai bune decât media grupului primesc un avantaj pozitiv și devin mai probabile. Cele mai slabe primesc un avantaj negativ și devin mai puțin probabile. Media grupului joacă rolul liniei de bază din REINFORCE, fără să fie nevoie de un model de valoare (value model) învățat, ca în PPO.
Pentru curioșiAvantajul în GRPO
Pentru un grup de povești, cu recompensele , avantajul poveștii este:
unde este abaterea standard a grupului (PyTorch împarte implicit la ), iar evită împărțirea la zero. Același avantaj se folosește pentru toate tokenurile poveștii .
Exemplul de mai jos calculează avantajele pentru un grup de 8 povești scrise pentru o instrucțiune cu trei cuvinte cerute, apoi pentru un grup în care toate poveștile au aceeași recompensă.
import numpy as np
def advantages(rewards, group=8): groups = rewards.reshape(-1, group) std = groups.std(axis=1, ddof=1, keepdims=True) # ca groups.std(dim=1) din PyTorch return ((groups - groups.mean(axis=1, keepdims=True)) / (std + 1e-4)).reshape(-1)
np.set_printoptions(precision=2, suppress=True)rewards = np.array([1/3, 0, 2/3, 1/3, 1/3, 0, 1/3, 1])print("Recompense:", rewards)print("Avantaje: ", advantages(rewards))print()same = np.full(8, 2/3)print("Recompense egale:", same)print("Avantaje: ", advantages(same))Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).
Povestea cu toate cele trei cuvinte primește cel mai mare avantaj, iar poveștile fără niciun cuvânt cerut, cel mai mic. Poveștile cu un singur cuvânt sunt puțin sub media grupului, deci devin puțin mai puțin probabile. Când toate poveștile primesc aceeași recompensă, toate avantajele sunt zero și grupul nu contribuie la învățare, la fel ca egalitățile sărite la perechile pentru DPO.
Obiectivul
Secțiune intitulată „Obiectivul”Pentru fiecare token al unei povești, obiectivul înmulțește logaritmul probabilității tokenului cu avantajul poveștii. Gradientul acestui produs este gradientul strategiei din REINFORCE: crește probabilitatea tokenurilor din poveștile cu avantaj pozitiv și o scade pe a tokenurilor din poveștile cu avantaj negativ.
Ca la DPO, o copie înghețată a modelului ajustat este modelul de referință. Pentru fiecare token, o estimare a divergenței Kullback-Leibler (KL) măsoară cât s-a îndepărtat modelul antrenat de referință. Estimarea este zero când cele două modele dau tokenului aceeași probabilitate și pozitivă în rest. Obiectivul scade această estimare, înmulțită cu coeficientul 0,05, așa că modelul rămâne aproape de modelul ajustat, care scrie povești coerente. Penalizarea KL este principala apărare a metodei împotriva exploatării recompensei.
Pentru curioșiObiectivul GRPO din laborator
Pentru un fragment de povești, obiectivul maximizat este:
unde este instrucțiunea, povestea, cu tokenuri, modelul antrenat, iar . Estimarea divergenței KL pentru un token este:
unde este modelul de referință. Funcția este zero doar pentru și pozitivă în rest. Este estimarea folosită și în articolul despre GRPO. Funcția de pierdere din cod este .
PROMPTS = 16
GROUP = 8
LR = 2e-5
KL = 0.05
CHUNK = 16
EVAL_EVERY = 4
@torch.no_grad()def rollout(policy, tokenizer, asks, rng): device = next(policy.parameters()).device stories = [] for i in rng.choice(len(asks), PROMPTS, replace=False): ids, words = asks[i] out = policy.generate(torch.tensor([ids] * GROUP, device=device), MAX_TOKENS, temperature=1.0) for story in out[:, len(ids) :].tolist(): story = cut(story, tokenizer.eot_id) stories.append((ids, story, words_used(tokenizer.decode(story), words) / len(words))) return stories
def advantages(reward): groups = reward.view(-1, GROUP) adv = (groups - groups.mean(dim=1, keepdim=True)) / (groups.std(dim=1, keepdim=True) + 1e-4) return adv.view(-1)Funcția rollout alege la întâmplare 16 instrucțiuni și scrie pentru fiecare un grup de 8 povești, într-un singur lot. Temperatura este 1,0, fără filtrul top-k, ca poveștile unui grup să fie cât mai diferite. Ca la perechile pentru DPO, generate scrie câte 200 de tokenuri, iar cut taie povestea după primul <|endoftext|>. Fiecare poveste primește propria recompensă, calculată cu words_used. Funcția advantages așază recompensele în grupuri de câte 8 și calculează avantajele în interiorul fiecărui grup.
def pack(stories, pad_id, device): longest = max(len(ids) + len(story) for ids, story, _ in stories) seq = torch.full((len(stories), longest), pad_id, dtype=torch.long) mask = torch.zeros(len(stories), longest - 1) for row, (ids, story, _) in enumerate(stories): seq[row, : len(ids) + len(story)] = torch.tensor(ids + story) mask[row, len(ids) - 1 : len(ids) + len(story) - 1] = 1 return seq.to(device), mask.to(device)
def token_log_probs(model, seq): logits, _ = model(seq[:, :-1]) return F.log_softmax(logits, dim=-1).gather(-1, seq[:, 1:].unsqueeze(-1)).squeeze(-1)Funcția pack pune instrucțiunile și poveștile într-o matrice completată cu [PAD] și construiește o mască, cu valoarea 1 doar pe pozițiile care prezic tokenurile poveștii. Funcția token_log_probs dă logaritmul probabilității fiecărui token, calculată din tokenurile anterioare. Spre deosebire de log_probs din dpo.py, aici sumele nu se fac imediat, pentru că penalizarea KL se calculează token cu token.
def main(minutes): torch.manual_seed(1337) rng = np.random.default_rng(1337) device = pick_device() policy, tokenizer, _ = load_checkpoint(os.path.join(CHECKPOINTS, "sft", "model.pt"), device) reference = copy.deepcopy(policy).eval().requires_grad_(False) policy.eval() optimizer = torch.optim.AdamW(policy.parameters(), lr=LR, weight_decay=0.0) by_length = load_asks(os.path.join(DATA_DIR, "instruct_train.txt"), tokenizer, policy.config.block_size - MAX_TOKENS) asks = [ask for group in by_length.values() for ask in group] print(f"{len(asks):,} instrucțiuni cu cuvinte cerute | {PROMPTS} pe rundă, câte {GROUP} povești", flush=True)
def evaluate(step): story = write(policy, tokenizer, DEMO, max_new_tokens=120, with_prompt=False) print(textwrap.indent(textwrap.fill(story, width=86), " "), flush=True)
budget = minutes * 60 start = time.time() step = 0 evaluate(step) while time.time() - start < budget: stories = rollout(policy, tokenizer, asks, rng) reward = torch.tensor([r for _, _, r in stories], device=device) adv = advantages(reward) seq, mask = pack(stories, tokenizer.pad_id, device)
drift = 0.0 for rows in torch.randperm(len(stories), device=device).split(CHUNK): logp = token_log_probs(policy, seq[rows]) with torch.no_grad(): ref = token_log_probs(reference, seq[rows]) r = ref - logp kl = torch.exp(r) - r - 1 per_token = (adv[rows, None] * logp - KL * kl) * mask[rows] loss = -(per_token.sum(dim=1) / mask[rows].sum(dim=1)).mean() optimizer.zero_grad(set_to_none=True) loss.backward() torch.nn.utils.clip_grad_norm_(policy.parameters(), 1.0) optimizer.step() drift += (kl.detach() * mask[rows]).sum().item() / len(stories) step += 1
print(f"runda {step:>3} | recompensa {reward.mean().item():.3f} | KL {drift:5.2f} | " f"{(time.time() - start) / 60:.1f} min", flush=True) if step % EVAL_EVERY == 0: evaluate(step)
if step % EVAL_EVERY != 0: evaluate(step) save_checkpoint(os.path.join(RUN_DIR, "model.pt"), policy, tokenizer, step=step) print(f"gata: {step} runde, {(time.time() - start) / 60:.1f} minute")Fiecare rundă a antrenării are trei părți.
- Poveștile sunt scrise de modelul curent: 16 instrucțiuni cu câte 8 povești, deci 128 de povești pe rundă, fiecare cu propria recompensă.
- Avantajele sunt calculate în interiorul fiecărui grup de 8 povești.
- Actualizările folosesc cele 128 de povești amestecate, în fragmente de câte 16. Pentru fiecare fragment, scriptul calculează logaritmii probabilităților sub modelul antrenat și sub referință, estimarea KL și pierderea, apoi face un pas de optimizare. O rundă are deci 8 pași.
Ca la DPO, modelul pornește din modelul ajustat, iar referința este o copie înghețată. Ambele modele rămân în modul de evaluare, fără dropout. Rata de învățare este , iar instrucțiunile vin din partea de antrenare a setului TinyStories-Instruct, cu aceeași limită de 56 de tokenuri ca la DPO. După fiecare rundă, scriptul afișează recompensa medie a poveștilor din rundă și divergența KL medie pe poveste, adică suma estimărilor KL pe tokenurile unei povești, iar la fiecare 4 runde scrie o poveste pentru instrucțiunea de test, „Words: rain, cake, jump”.
Argumentul este bugetul de timp, în minute. O rundă începe doar dacă bugetul nu s-a terminat, așa că ultima rundă poate depăși puțin bugetul.
python grpo.py 10Rezultatul de mai jos vine din seria video a laboratorului, cu modelul ajustat de pe pagina despre ajustarea fină. Am omis povestea de dinaintea primei runde, aceeași ca la pasul 0 al DPO, și două dintre poveștile intermediare.
35,501 instrucțiuni cu cuvinte cerute | 16 pe rundă, câte 8 poveștirunda 1 | recompensa 0.359 | KL 1.53 | 0.6 minrunda 2 | recompensa 0.404 | KL 4.77 | 1.3 minrunda 3 | recompensa 0.539 | KL 6.59 | 1.9 minrunda 4 | recompensa 0.477 | KL 8.58 | 2.5 minrunda 5 | recompensa 0.445 | KL 10.85 | 3.2 minrunda 6 | recompensa 0.448 | KL 11.88 | 3.8 minrunda 7 | recompensa 0.594 | KL 12.49 | 4.4 minrunda 8 | recompensa 0.461 | KL 14.03 | 5.0 min Once upon a time there was a girl who loved to have fun in the sunshine. One day, the girl had a fun idea! She wanted to see what was happening and the girl began to jump. She jumped and jumped until she was never too scared. Then the girl had an idea. She jumped just around the kitchen to the kitchen and jumped a bite. She jumped and played until she reached the kitchen to jump. The girl hopped and jumped. She jumped on circles and laughed as the cake jumped off the floor. The girl jumped and jumped until she jumped so high. It was going sorunda 9 | recompensa 0.448 | KL 15.71 | 5.6 minrunda 10 | recompensa 0.505 | KL 15.64 | 6.2 minrunda 11 | recompensa 0.586 | KL 18.50 | 6.8 minrunda 12 | recompensa 0.589 | KL 17.55 | 7.5 minrunda 13 | recompensa 0.529 | KL 18.14 | 8.1 minrunda 14 | recompensa 0.552 | KL 17.20 | 8.7 minrunda 15 | recompensa 0.607 | KL 17.28 | 9.3 minrunda 16 | recompensa 0.609 | KL 19.64 | 9.9 min Once upon a time there was a big cake. Every day the cake would jump and jump around. All the other things around the house would get a cake. One day a rain started to rain. The rain was very hot and the cake started to rain. The rain was getting wet and wet. The rain was wet. The rain had a big fall. The rain was very wet. The rain made the cake clean by the rain. The rain was wet. The rain was wet. The rain stopped, the rain was wet. The rain came down again and the rain did not move. Itrunda 17 | recompensa 0.648 | KL 18.91 | 10.5 min Once upon a time there was a little girl who loved to play with her toys. One day the girl started to rain very far and she wanted to rain. So, she ran around the room and jumped. She was very dirty and she had to stay outside, so she jumped and jumped in the wind. She threw so much cloth and the water got so tight. The rain made the water wet and the air went down. It was raining very still. The girl jumped and jumped as she jumped as she could. She splashed in the rain and it started to rain. She felt so happy.gata: 17 runde, 10.5 minuteDintre instrucțiunile de antrenare care cer cuvinte, 35.501 au cel mult 56 de tokenuri. O rundă durează circa 37 de secunde pe un cip Apple Silicon (MPS), iar cea mai mare parte din timp merge pe scrierea celor 128 de povești. În 10,5 minute, modelul a scris 2.176 de povești și a făcut 136 de pași de actualizare. Pe un procesor obișnuit, o singură rundă poate dura mai mult decât tot bugetul de 10 minute, iar scriptul se oprește după prima rundă.
Recompensa medie a poveștilor dintr-o rundă crește de la 0,36 la 0,65, cu variații mari de la o rundă la alta, pentru că fiecare rundă are doar 16 instrucțiuni, unele mai ușoare, altele mai grele. Divergența KL crește aproape fără oprire, de la 1,5 la circa 19 pe poveste: penalizarea încetinește îndepărtarea de modelul de referință, dar nu o oprește. Poveștile pentru instrucțiunea de test folosesc tot mai des cuvintele cerute, dar le repetă la fiecare propoziție („The rain was wet. The rain was wet.”).
Modelul ajustat, DPO și GRPO
Secțiune intitulată „Modelul ajustat, DPO și GRPO”python reward.py checkpoints/sft/model.pt checkpoints/dpo/model.pt checkpoints/grpo/model.pt50 instrucțiuni de validare, 150 de cuvinte cerutesft cuvinte folosite 36.7% | povești terminate 70%dpo cuvinte folosite 72.7% | povești terminate 48%grpo cuvinte folosite 56.7% | povești terminate 46%Comparația folosește, pentru toate modelele, aceleași 50 de instrucțiuni de validare și aceeași sămânță, cu temperatura 0,8 și filtrul top-k de 50. De aceea, valorile diferă de recompensa din timpul antrenării, măsurată pe instrucțiuni de antrenare, la temperatura 1,0 și fără filtru. GRPO crește proporția cuvintelor cerute folosite de la 36,7% la 56,7%, mai puțin decât DPO, iar poveștile se încheie la fel de rar ca după DPO, doar în 46% din cazuri.
Cele două metode nu au fost comparate în condiții egale. DPO a învățat din 500 de perechi, alese dintre circa 2.700 de povești, în 343 de pași, iar GRPO din 2.176 de povești, în 136 de pași, într-un timp total apropiat. Cu doar 50 de instrucțiuni, diferențele de câteva procente pot veni și din întâmplare.
La modelele mari, aceeași metodă a dat rezultate mult mai bune cu recompense greu de păcălit, verificate de un program, de exemplu rezultatul corect al unei probleme de matematică. Pagina despre învățarea prin consolidare pentru LLM-uri descrie aceste recompense verificabile (verifiable rewards) și modelele de raționament antrenate cu GRPO.
Bibliografie
Secțiune intitulată „Bibliografie”- DeepSeek-AI (2025). DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. Preprint arXiv:2501.12948. ↩︎
- Schulman, J. et al. (2017). Proximal Policy Optimization Algorithms. Preprint arXiv:1707.06347.
- Shao, Z. et al. (2024). DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models. Preprint arXiv:2402.03300. ↩︎
- Williams, R. J. (1992). Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning, 8(3–4), 229–256.
Cookie-uri
Site-ul folosește Google Analytics pentru statistici de trafic. Cookie-urile de analiză se activează doar după acceptare. Detalii în politica de cookie-uri.