Recompensa și DPO
După ajustarea fină, modelul scrie povești de la început, dar folosește doar o parte din cuvintele cerute de instrucțiune. În această etapă transformăm problema într-un număr, o recompensă (reward) scrisă în cod. Cu ajutorul recompensei alegem, dintre poveștile scrise chiar de model, perechi formate dintr-o poveste preferată și una respinsă. Perechile devin apoi datele unei noi etape de antrenare, optimizarea directă a preferințelor (direct preference optimization, DPO).
Pagina despre învățarea prin consolidare pentru LLM-uri descrie alinierea modelelor mari, de la modelul de recompensă la DPO. Codul acestei etape se află în trei fișiere noi: reward.py, preferences.py și dpo.py.
La redare, playerul se încarcă de pe YouTube (detalii).
Recompensa
Secțiune intitulată „Recompensa”La modelele mari, recompensa vine de obicei de la un model de recompensă, antrenat pe alegerile unor evaluatori umani, sau de la un program care verifică răspunsul, de exemplu rezultatul unei probleme de matematică. Pentru poveștile noastre, o regulă simplă este suficientă: recompensa este proporția de cuvinte cerute care apar în poveste. Pentru instrucțiunea „Words: rain, cake, jump”, povestea de pe pagina anterioară, care folosește doar „cake”, primește o treime.
Pentru curioșiFormula recompensei
Recompensa este între 0 și 1. Pentru „rain, cake, jump” și o poveste care folosește doar „cake”, .
INSTRUCTIONS = 50
MAX_TOKENS = 200
def words_used(story, words): return sum(bool(re.search(rf"\b{re.escape(w)}(s|es|d|ed|ing)?\b", story, re.I)) for w in words)Pentru fiecare cuvânt cerut, o expresie regulată caută cuvântul întreg, fără terminație sau cu una dintre terminațiile s, es, d, ed și ing, ca „jumped” să conteze pentru „jump”. Secvența \b marchează granița unui cuvânt, așa că „rainbow” nu contează pentru „rain”, iar re.I ignoră diferența dintre literele mari și mici. Exemplul de mai jos aplică funcția câtorva texte scurte.
import re
def words_used(story, words): return sum(bool(re.search(rf"\b{re.escape(w)}(s|es|d|ed|ing)?\b", story, re.I)) for w in words)
words = ["rain", "cake", "jump"]for story in [ "Lily saw a big cake. She ate the cake.", "It was raining. Lily jumped over a puddle and ate two cakes.", "The rainbow was pretty. Lily jumps and bakes a cake.", "Rain cake jump. Rain cake jump.",]: used = words_used(story, words) print(f"{used}/{len(words)} = {used / len(words):.2f} {story}")Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).
Ultimul text primește recompensa maximă, deși nu este o poveste. O recompensă scrisă în cod măsoară doar lucrul pentru care a fost scrisă, iar un model antrenat să obțină recompense mari poate găsi astfel de scurtături. Fenomenul se numește exploatarea recompensei (reward hacking) și apare, la scară mică, în rezultatele de la finalul paginii.
Regula are și limite mai mici: „hurried” nu contează pentru „hurry”, nici „valuable” pentru „value”. Exemplul următor aplică recompensa poveștilor din eșantionul de 60 de documente din TinyStories-Instruct, scrise de GPT-3.5 și GPT-4. Aceste povești folosesc aproape toate cuvintele cerute, iar cele câteva care lipsesc apar de obicei sub o formă pe care regula nu o recunoaște.
with open("instructiuni.txt", encoding="utf-8") as f: docs = [parse(d) for d in f.read().split("<|endoftext|>") if d.strip()]asks = [fields for fields in docs if "Words" in fields and "Story" in fields]
used = asked = 0for fields in asks: words = fields["Words"].split(", ") found = words_used(fields["Story"], words) used, asked = used + found, asked + len(words) if found < len(words): missing = [w for w in words if not words_used(fields["Story"], [w])] print("Lipsesc:", missing)print(f"Povești cu cuvinte cerute: {len(asks)}, cuvinte folosite: {used} din {asked} ({used / asked:.0%})")Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).
Recompensa nu știe nimic despre finalul poveștii. De aceea, măsurăm și câte povești se încheie singure, cu tokenul <|endoftext|>, în cel mult 200 de tokenuri. Această a doua măsură arată dacă antrenarea strică ceva ce recompensa nu vede.
Măsurarea unui model
Secțiune intitulată „Măsurarea unui model”Restul fișierului reward.py măsoară un model salvat pe primele 50 de instrucțiuni din partea de validare a setului TinyStories-Instruct care cer cuvinte.
def load_instructions(path, n): with open(path, encoding="utf-8") as f: docs = [parse(doc) for doc in f.read().split(EOT)] asks = [fields for fields in docs if "Words" in fields and "Story" in fields][:n] return [(instruction(fields), fields["Words"].split(", ")) for fields in asks]
@torch.no_grad()def measure(model, tokenizer, instructions): model.eval() device = next(model.parameters()).device used, ended = 0, 0 for prompt, words in instructions: ids = torch.tensor([tokenizer.encode(prompt)], device=device) out = model.generate(ids, MAX_TOKENS, temperature=0.8, top_k=50, eos_id=tokenizer.eot_id) story = out[0, ids.size(1) :].tolist() used += words_used(tokenizer.decode(story), words) ended += story[-1] == tokenizer.eot_id return used / sum(len(words) for _, words in instructions), ended / len(instructions)
def main(paths): instructions = load_instructions(os.path.join(DATA_DIR, "instruct_valid.txt"), INSTRUCTIONS) asked = sum(len(words) for _, words in instructions) print(f"{len(instructions)} instrucțiuni de validare, {asked} de cuvinte cerute") for path in paths: torch.manual_seed(0) model, tokenizer, _ = load_checkpoint(path, pick_device()) used, ended = measure(model, tokenizer, instructions) name = os.path.basename(os.path.dirname(path)) print(f"{name:<10} cuvinte folosite {used:6.1%} | povești terminate {ended:5.0%}", flush=True)Funcția load_instructions folosește funcțiile parse și instruction din sft.py și întoarce, pentru fiecare document, instrucțiunea și lista cuvintelor cerute. Funcția measure scrie câte o poveste pentru fiecare instrucțiune, cu temperatura 0,8 și filtrul top-k de 50, ca sample.py, și se oprește la tokenul de sfârșit. Apoi adună cuvintele cerute folosite și poveștile al căror ultim token este <|endoftext|>. Înaintea fiecărui model, torch.manual_seed(0) fixează generatorul de numere aleatoare, ca modelele să fie comparate în aceleași condiții.
python reward.py checkpoints/pretrain/model.pt checkpoints/sft/model.ptRezultatele de pe această pagină vin din seria video a laboratorului, cu modelele de pe paginile anterioare.
50 instrucțiuni de validare, 150 de cuvinte cerutepretrain cuvinte folosite 6.0% | povești terminate 80%sft cuvinte folosite 36.7% | povești terminate 70%Modelul preantrenat folosește cuvintele cerute doar întâmplător, în 6% din cazuri. Modelul ajustat folosește 36,7% din cuvintele cerute, de șase ori mai multe, dar încheie puțin mai rar povestea, pentru că scrie povești întregi, de la început. Măsurătoarea este aproximativă: o poveste terminată în plus schimbă a doua măsură cu 2%, iar un cuvânt cerut în plus o schimbă pe prima cu 0,7%.
Perechile de preferințe
Secțiune intitulată „Perechile de preferințe”DPO învață din perechi: pentru aceeași instrucțiune, o poveste preferată (chosen) și una respinsă (rejected). La modelele mari, perechile sunt alese de evaluatori umani sau de un model de recompensă. Aici le alege recompensa. Modelul ajustat scrie patru povești pentru fiecare instrucțiune, povestea cu cele mai multe cuvinte cerute devine povestea preferată, iar cea cu cele mai puține, povestea respinsă. Când toate cele patru povești primesc aceeași recompensă, instrucțiunea este sărită, pentru că nu există o preferință.
SAMPLES = 4
GROUP = 8
def load_asks(path, tokenizer, max_prompt, skip=0): with open(path, encoding="utf-8") as f: docs = [parse(doc) for doc in f.read().split(EOT)][skip:] by_length = {} for fields in docs: if "Words" in fields and "Story" in fields: ids = tokenizer.encode(instruction(fields)) if len(ids) <= max_prompt: by_length.setdefault(len(ids), []).append((ids, fields["Words"].split(", "))) return by_length
def cut(story, eot_id): return story[: story.index(eot_id) + 1] if eot_id in story else story
@torch.no_grad()def make_pairs(model, tokenizer, by_length, n, rng): device = next(model.parameters()).device lengths = [length for length, asks in by_length.items() if len(asks) >= GROUP] pairs, ties = [], 0 while len(pairs) < n: length = lengths[rng.integers(len(lengths))] group = [by_length[length][i] for i in rng.choice(len(by_length[length]), GROUP, replace=False)] prompts = torch.tensor([ids for ids, _ in group], device=device) out = model.generate(prompts.repeat_interleave(SAMPLES, dim=0), MAX_TOKENS, temperature=1.0, top_k=50) for i, (ids, words) in enumerate(group): scored = [] for story in out[i * SAMPLES : (i + 1) * SAMPLES, length:].tolist(): story = cut(story, tokenizer.eot_id) scored.append((words_used(tokenizer.decode(story), words) / len(words), story)) scored.sort(key=lambda s: s[0]) (low, rejected), (high, chosen) = scored[0], scored[-1] if high == low: ties += 1 continue pairs.append({"prompt": ids, "chosen": chosen, "rejected": rejected, "scores": [high, low]}) return pairs[:n], tiesModelul scrie dintr-o dată 32 de povești, câte 4 pentru 8 instrucțiuni, într-un singur lot. Metoda generate nu știe să completeze secvențe de lungimi diferite, așa că instrucțiunile dintr-un lot trebuie să aibă același număr de tokenuri: load_asks le grupează după lungime, iar make_pairs alege la fiecare pas o lungime și 8 instrucțiuni de acea lungime. Temperatura 1,0, mai mare decât 0,8 din sample.py, face poveștile aceleiași instrucțiuni mai diferite, deci mai potrivite pentru comparații.
Metoda generate nu primește aici eos_id, deci scrie câte 200 de tokenuri pentru fiecare poveste. Funcția cut taie povestea după primul <|endoftext|> și păstrează tokenul, pentru ca modelul să învețe și unde se termină o poveste. Poveștile sunt apoi ordonate după recompensă, iar prima și ultima formează perechea.
def main(n_train, n_valid): torch.manual_seed(1337) rng = np.random.default_rng(1337) model, tokenizer, _ = load_checkpoint(os.path.join(CHECKPOINTS, "sft", "model.pt"), pick_device()) model.eval() max_prompt = model.config.block_size - MAX_TOKENS start = time.time() splits = {} for split, path, n, skip in [("train", "instruct_train.txt", n_train, 0), ("valid", "instruct_valid.txt", n_valid, 2000)]: by_length = load_asks(os.path.join(DATA_DIR, path), tokenizer, max_prompt, skip) pairs, ties = make_pairs(model, tokenizer, by_length, n, rng) chosen = np.mean([p["scores"][0] for p in pairs]) rejected = np.mean([p["scores"][1] for p in pairs]) print(f"{split}: {len(pairs)} perechi, {ties} egalități sărite | cuvinte folosite: {chosen:.0%} în cele preferate, " f"{rejected:.0%} în cele respinse | {(time.time() - start) / 60:.1f} min", flush=True) splits[split] = pairs os.makedirs(os.path.dirname(PAIRS_PATH), exist_ok=True) with open(PAIRS_PATH, "w") as f: json.dump(splits, f) print(f"salvate în {os.path.relpath(PAIRS_PATH)}")Instrucțiunile au cel mult 56 de tokenuri (max_prompt, adică 256 − 200), ca instrucțiunea și povestea să încapă împreună în fereastra de context. Implicit, scriptul face 500 de perechi din partea de antrenare și 50 din partea de validare. Perechile de validare vin din documentele aflate după primele 2.000 ale fișierului de validare, ca să nu se suprapună cu cele 50 de instrucțiuni folosite de reward.py. Toate perechile sunt salvate în checkpoints/dpo/preferences.json.
python preferences.pytrain: 500 perechi, 107 egalități sărite | cuvinte folosite: 65% în cele preferate, 21% în cele respinse | 10.4 minvalid: 50 perechi, 8 egalități sărite | cuvinte folosite: 67% în cele preferate, 23% în cele respinse | 11.5 minsalvate în checkpoints/dpo/preferences.jsonScriptul nu are un buget de timp. Pentru cele 550 de perechi, modelul a scris circa 2.700 de povești, în 11,5 minute, pe un cip Apple Silicon (MPS). Pe procesorul obișnuit, aceleași povești pot cere câteva ore. Numărul de perechi este dat de cele două argumente, așa că o încercare rapidă poate folosi mai puține, de exemplu python preferences.py 100 20, cu prețul unor rezultate mai slabe la DPO.
Pentru 107 instrucțiuni de antrenare, cele patru povești au primit aceeași recompensă. Poveștile preferate folosesc, în medie, 65% din cuvintele cerute, iar cele respinse doar 21%. Modelul ajustat poate deci folosi cuvintele cerute, dar nu o face de fiecare dată. DPO trebuie să facă mai probabile poveștile de felul celor preferate.
Pierderea DPO
Secțiune intitulată „Pierderea DPO”Metoda clasică de aliniere, RLHF (reinforcement learning from human feedback), antrenează întâi un model de recompensă pe perechi, apoi optimizează modelul de limbaj prin învățare prin consolidare, de obicei cu PPO. DPO, propus în 2023 de Rafailov și colaboratorii, sare peste ambii pași: modelul învață direct din perechi, cu o funcție de pierdere obișnuită, fără model de recompensă separat și fără să scrie povești în timpul antrenării.
Pentru fiecare pereche, DPO compară cât de probabile sunt cele două povești pentru modelul antrenat și pentru un model de referință (reference model), o copie înghețată a modelului ajustat, care nu se mai schimbă. Pentru fiecare poveste calculăm un câștig: cu cât a crescut, față de referință, logaritmul probabilității poveștii. Marja perechii este diferența dintre câștigul poveștii preferate și câștigul poveștii respinse, înmulțită cu un coeficient β = 0,1. Pierderea este mică atunci când marja este mare și pozitivă, adică atunci când modelul a făcut povestea preferată mai probabilă decât povestea respinsă, față de cât de probabile erau cele două povești la început.
Referința ține modelul aproape de punctul de plecare. Contează doar cât s-a schimbat probabilitatea fiecărei povești, nu cât de probabilă este povestea în sine. Coeficientul β stabilește cât de departe are voie să ajungă modelul: cu un β mic, aceeași pierdere cere o schimbare mai mare față de referință.
Pentru curioșiPierderea DPO
Marja unei perechi este:
Pierderea perechii este:
unde este instrucțiunea, povestea preferată, povestea respinsă, modelul antrenat, modelul de referință, iar funcția sigmoidă. Logaritmul probabilității unei povești este suma logaritmilor probabilităților tokenurilor poveștii. La început, , deci și .
Pierderea are forma pierderii unui model de recompensă din RLHF, în care recompensa unei povești este înlocuită cu . De aici vine și titlul lucrării: modelul de limbaj este, în secret, un model de recompensă.
Exemplul de mai jos calculează pierderea pentru câteva câștiguri ale celor două povești, în logaritmi naturali.
import math
def dpo_loss(margin): return -math.log(1 / (1 + math.exp(-margin))) # -log σ(marja)
beta = 0.1for gain_chosen, gain_rejected in [(0.0, 0.0), (2.0, -1.0), (5.0, -5.0), (10.0, -10.0), (-3.0, 0.0)]: margin = beta * (gain_chosen - gain_rejected) print(f"câștig preferată {gain_chosen:+5.1f}, respinsă {gain_rejected:+5.1f}" f" -> marja {margin:+.2f}, pierderea {dpo_loss(margin):.3f}")Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).
Pierderea scade pe măsură ce marja crește, dar tot mai încet, iar o marjă negativă, cu povestea respinsă favorizată, o face mai mare decât .
Antrenarea cu DPO
Secțiune intitulată „Antrenarea cu DPO”BATCH_SIZE = 16
LR = 1e-5
BETA = 0.1
EVAL_EVERY = 100
DEMO = "Words: rain, cake, jump\nStory:"
def log_probs(model, x, y): logits, _ = model(x) picked = F.log_softmax(logits, dim=-1).gather(-1, y.clamp(min=0).unsqueeze(-1)).squeeze(-1) return (picked * (y != -1)).sum(dim=-1)
def dpo_loss(policy, reference, pairs, pad_id, device): examples = [(p["prompt"] + p["chosen"], len(p["prompt"])) for p in pairs] examples += [(p["prompt"] + p["rejected"], len(p["prompt"])) for p in pairs] x, y = make_batch(examples, pad_id, device) with torch.no_grad(): ref = log_probs(reference, x, y) gain = log_probs(policy, x, y) - ref margin = BETA * (gain[: len(pairs)] - gain[len(pairs) :]) return -F.logsigmoid(margin).mean(), margin
@torch.no_grad()def held_out(policy, reference, pairs, pad_id, device): margins = torch.cat([dpo_loss(policy, reference, pairs[i : i + 32], pad_id, device)[1] for i in range(0, len(pairs), 32)]) return (margins > 0).float().mean().item(), margins.mean().item()Funcția log_probs trece un lot prin model și ia, cu gather, logaritmul probabilității fiecărui token țintă. Lotul este construit cu make_batch din sft.py, așa că țintele sunt -1 pe instrucțiune și pe completare, iar acele poziții sunt înmulțite cu zero. Suma pe fiecare rând dă logaritmul probabilității întregii povești. Apelul y.clamp(min=0) înlocuiește -1 cu 0 doar ca gather să primească un indice valid, iar valorile de pe acele poziții sunt oricum anulate.
Funcția dpo_loss pune în același lot poveștile preferate, apoi pe cele respinse. Referința rulează fără gradienți, gain este câștigul fiecărei povești, iar F.logsigmoid calculează direct , mai stabil numeric decât logaritmul aplicat după sigmoidă. Funcția held_out măsoară, pe perechile de validare, în loturi de câte 32, ce parte dintre perechi au marja pozitivă, adică sunt ordonate corect, și marja medie.
def main(minutes): torch.manual_seed(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() pairs = load_pairs() train, valid = pairs["train"], pairs["valid"] optimizer = torch.optim.AdamW(policy.parameters(), lr=LR, betas=(0.9, 0.95), weight_decay=0.0) print(f"{len(train):,} perechi de antrenare, {len(valid)} păstrate pentru validare", flush=True)
def evaluate(step): accuracy, margin = held_out(policy, reference, valid, tokenizer.pad_id, device) story = write(policy, tokenizer, DEMO, max_new_tokens=120, with_prompt=False) print(f"pasul {step:>5} | validare: ordonate corect {accuracy:.0%}, marja {margin:+.2f}", flush=True) 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: batch = [train[i] for i in torch.randint(len(train), (BATCH_SIZE,)).tolist()] loss, margin = dpo_loss(policy, reference, batch, tokenizer.pad_id, device) optimizer.zero_grad(set_to_none=True) loss.backward() torch.nn.utils.clip_grad_norm_(policy.parameters(), 1.0) optimizer.step() step += 1
if step % 20 == 0: accuracy = (margin > 0).float().mean().item() print(f"pasul {step:>5} | pierdere {loss.item():.3f} | ordonate corect {accuracy:.0%} | " 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:,} pași, {(time.time() - start) / 60:.1f} minute")Modelul antrenat și referința pornesc din același model ajustat. copy.deepcopy face copia, iar requires_grad_(False) o îngheață. Ambele modele rămân în modul de evaluare, fără dropout, ca la pasul 0 să dea exact aceleași probabilități. Rata de învățare, , este de 20 de ori mai mică decât la ajustarea fină, pentru că pașii mari ar îndepărta repede modelul de referință. Fiecare pas folosește 16 perechi alese la întâmplare. La fiecare 100 de pași, scriptul măsoară perechile de validare și scrie o poveste pentru instrucțiunea de test, „Words: rain, cake, jump”.
python dpo.py 2Am omis o parte din liniile afișate la fiecare 20 de pași și două dintre povești.
500 perechi de antrenare, 50 păstrate pentru validarepasul 0 | validare: ordonate corect 0%, marja +0.00 Once upon a time, there was a little girl who loved her house. She had a very important job to her house and she had a special job. She had a special job to her house. Every day, she would jump in the room and jump and jump around and play with her friends. One day, the sun set and the sun began to rain. The little girl was very happy and began to jump to rain. She jumped in and splashed in the wet garden until it was time for her work. When it was ready, the little girl was tired. She ran around the room untilpasul 20 | pierdere 0.594 | ordonate corect 56% | 0.1 minpasul 40 | pierdere 0.471 | ordonate corect 75% | 0.2 minpasul 60 | pierdere 0.239 | ordonate corect 94% | 0.4 minpasul 100 | pierdere 0.115 | ordonate corect 100% | 0.6 minpasul 100 | validare: ordonate corect 66%, marja +0.30pasul 200 | pierdere 0.015 | ordonate corect 100% | 1.2 minpasul 200 | validare: ordonate corect 72%, marja +0.57pasul 300 | pierdere 0.002 | ordonate corect 100% | 1.8 minpasul 300 | validare: ordonate corect 72%, marja +0.97 Once upon a time, there was a colorful cake. It was so happy and pretty. All the fish in the party was very sad. Instead the cake started to rain very hard to rain very hard. It was so dirty that everyone didn't want to rain to get to play. So one day it started to rain very hard, especially tried to jump. The rain made the mess. Everyone was sad and sad for the rain to get to rain. But then something unexpected happened. The rain started to rain very hard. The cake began to rain very hard. Everyone was sad because they hadpasul 343 | validare: ordonate corect 72%, marja +1.07 Once upon a time, there was a little bunny named hop. Bobby lived in a small house near the ground. One day, he went to play in the kitchen to rain. He was wet and he slipped over the table with a big wet cake in the oven. Bobby was sad and started to run to his mommy to help him climb up the eggs. Mommy came into the kitchen and decided to jump in the cake. She found a pan and started to jump in it! Bobby laughed and said, "Mommy, I can jump around and jump and jump and jump even higher and higher. Igata: 343 pași, 2.0 minuteLa pasul 0, modelul și referința sunt identice, deci toate marjele sunt zero și niciuna nu este pozitivă. În 2 minute, scriptul face 343 de pași, adică 5.488 de perechi, aproape 11 treceri prin cele 500 de perechi de antrenare. Pe loturile de antrenare, pierderea scade aproape de zero și toate perechile ajung ordonate corect, deci modelul învață perechile de antrenare aproape pe de rost. Pe perechile de validare, ordonarea corectă urcă doar la 72%, deși marja medie continuă să crească, de la +0,30 la +1,07.
Poveștile pentru instrucțiunea de test folosesc tot mai des cuvintele cerute, dar tot mai mecanic: „The rain started to rain very hard. The cake began to rain very hard.”
Modelul ajustat față de DPO
Secțiune intitulată „Modelul ajustat față de DPO”python reward.py checkpoints/sft/model.pt checkpoints/dpo/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%Modelul aliniat cu DPO folosește de două ori mai multe cuvinte cerute decât modelul ajustat, 72,7% față de 36,7%.
Pe pagina următoare, modelul nu mai învață din perechi scrise o singură dată, înainte de antrenare, ci din poveștile pe care le scrie în timpul antrenării, prin învățare prin consolidare cu GRPO.
Bibliografie
Secțiune intitulată „Bibliografie”- Christiano, P. et al. (2017). Deep reinforcement learning from human preferences. NeurIPS 2017.
- Eldan, R. și Li, Y. (2023). TinyStories: How Small Can Language Models Be and Still Speak Coherent English? Preprint arXiv:2305.07759.
- Ouyang, L. et al. (2022). Training language models to follow instructions with human feedback. NeurIPS 2022.
- Rafailov, R. et al. (2023). Direct Preference Optimization: Your Language Model is Secretly a Reward Model. NeurIPS 2023. ↩︎
- Schulman, J. et al. (2017). Proximal Policy Optimization Algorithms. Preprint arXiv:1707.06347.
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.