Franok / source /training /third /reader.py
yunusemrejr's picture
Publish source, film and evaluations from 699be55df232
2bff5be verified
Raw History Blame Contribute Delete
9.38 kB
"""Fit a separately switchable extractive reader to frozen Franok decoder states."""
import argparse
from contextlib import nullcontext
import json
import math
from pathlib import Path
import time
import numpy as np
import torch
from safetensors.torch import load_file, save_file
from torch.nn import functional as F
from franok.model import Config, Franok
from franok.span import SpanReadout, labels, pack
from .spans import SpanCorpus
def select(rows, threshold):
"""Measure answer-boundary EM and correct abstention separately in both languages."""
metrics = {}
for lang in ("en", "tr"):
group = [r for r in rows if r[0] == lang]
answered = [r for r in group if not r[2]]
impossible = [r for r in group if r[2]]
correct = sum(margin >= threshold and exact for _, margin, _, exact in answered)
null = sum(margin < threshold for _, margin, _, _ in impossible)
metrics[lang] = dict(
answerable=len(answered),
exact=correct,
impossible=len(impossible),
abstained_correctly=null,
answered=sum(margin >= threshold for _, margin, _, _ in answered),
)
return metrics
def utility(metrics):
return float(
np.mean(
[
0.7 * v["exact"] / max(1, v["answerable"])
+ 0.3 * v["abstained_correctly"] / max(1, v["impossible"])
for v in metrics.values()
]
)
)
def encode(model, batch):
device = model.embed.weight.device
ids, legal, meta = [x.to(device) for x in pack(batch)]
with torch.no_grad(), (
torch.autocast("cuda", dtype=torch.bfloat16)
if device.type == "cuda"
else nullcontext()
):
states = model.hidden(ids)
return states.float(), legal, meta
class ReaderTraining:
def __init__(self, model, seed):
self.model = model
self.train = SpanCorpus("train")
self.rng = np.random.default_rng(seed)
self.head = SpanReadout(model.c.width).to(model.embed.weight.device)
self.opt = torch.optim.AdamW(
self.head.parameters(), lr=0.0011, weight_decay=0.015
)
self.steps = self.seen = self.tokens = 0
def update(self, capacity, rate):
upper = int(self.rng.choice((128, 256, 512, 1024), p=(0.17, 0.45, 0.32, 0.06)))
count = max(1, capacity // (2 * upper))
batch = []
for lang in ("en", "tr"):
ids = self.rng.choice(self.train.groups[lang, upper], count, replace=True)
batch.extend(self.train.at(lang, k) for k in ids)
h, legal, meta = encode(self.model, batch)
logits = self.head(h, meta[:, 0], meta[:, 1], legal)
truth = labels(meta, logits.shape[1], self.head.max_span)
loss = F.cross_entropy(logits, truth)
self.opt.zero_grad(set_to_none=True)
loss.backward()
torch.nn.utils.clip_grad_norm_(
self.head.parameters(), 1.0, error_if_nonfinite=True
)
self.opt.param_groups[0]["lr"] = rate
self.opt.step()
self.steps += 1
self.seen += len(batch)
self.tokens += int(meta[:, 1].sum())
return float(loss.detach())
def snapshot(self, directory):
directory.mkdir(parents=True, exist_ok=True)
tmp = directory / "head.next"
save_file(
{
k: v.detach().cpu().contiguous()
for k, v in self.head.state_dict().items()
},
str(tmp),
)
tmp.replace(directory / "head.safetensors")
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--run", type=Path, default=Path("work/third/run"))
parser.add_argument("--out", type=Path, default=Path("work/third/run/reader"))
parser.add_argument("--init", type=Path)
parser.add_argument("--deadline", type=float)
parser.add_argument("--steps", type=int)
parser.add_argument(
"--device", default="cuda" if torch.cuda.is_available() else "cpu"
)
parser.add_argument("--tokens", type=int, default=8192)
args = parser.parse_args()
if args.deadline is None and args.steps is None:
parser.error("Supply a step budget or Unix-time deadline.")
start = time.time()
args.out.mkdir(parents=True, exist_ok=True)
torch.set_num_threads(3)
torch.manual_seed(18435)
device = torch.device(args.device)
cfg = Config(**json.loads((args.run / "config.json").read_text()))
model = Franok(cfg).eval().requires_grad_(False)
model.load_state_dict(load_file(str(args.run / "model.safetensors")))
model.to(device)
state = ReaderTraining(model, 18435)
head = state.head
if args.init:
head.load_state_dict(load_file(str(args.init)))
val = SpanCorpus("val")
# The same article-held-out queries and cached decoder states are used at every measurement.
# This tuning set is separate from the published XQuAD transfer test.
fixed = np.random.default_rng(9559)
validation = []
for lang in ("en", "tr"):
idx = val.files[lang][2]
picks = np.r_[
fixed.choice(np.flatnonzero(idx[:, 3] >= 0), 192, replace=False),
fixed.choice(np.flatnonzero(idx[:, 3] < 0), 64, replace=False),
]
picks = sorted(picks, key=lambda i: idx[i, 2])
for j in range(0, len(picks), 12):
h, legal, meta = encode(model, [val.at(lang, k) for k in picks[j : j + 12]])
validation.append((lang, h.half().cpu(), legal.cpu(), meta.cpu()))
@torch.no_grad()
def evaluate():
rows = []
total_loss = 0.0
for lang, h, legal, meta in validation:
h, legal, meta = (
h.to(device=device, dtype=torch.float32),
legal.to(device),
meta.to(device),
)
logits = head(h, meta[:, 0], meta[:, 1], legal)
truth = labels(meta, logits.shape[1], head.max_span)
top, pred = logits[:, :-1].max(1)
total_loss += float(F.cross_entropy(logits, truth, reduction="sum"))
for margin, empty, exact in zip(
(top - logits[:, -1]).tolist(),
(meta[:, 2] < 0).tolist(),
(pred == truth).tolist(),
):
rows.append((lang, margin, empty, exact))
# Tune a single confidence margin for both languages against a fixed, public utility.
grid = np.arange(-7.0, 7.01, 0.25)
choices = [(t, select(rows, t)) for t in [-100.0, *grid.tolist()]]
# A threshold that abstains on almost every question is unhelpful even if it
# recognizes most impossible examples.
threshold, selected = max(
(
(t, m)
for t, m in choices
if all(v["answered"] >= 0.70 * v["answerable"] for v in m.values())
),
key=lambda x: utility(x[1]),
)
return dict(
nll=total_loss / len(rows),
threshold=float(threshold),
languages=selected,
)
history = []
best = float("inf")
def save():
nonlocal best
result = evaluate()
result.update(step=state.steps, examples=state.seen, tokens=state.tokens)
history.append(result)
if result["nll"] < best:
best = result["nll"]
state.snapshot(args.out)
(args.out / "config.json").write_text(
json.dumps(
dict(
format="franok-span-v1",
width=cfg.width,
hidden=head.text.out_features,
max_span=head.max_span,
threshold=result["threshold"],
input="bos language user question eos user passage assistant",
validation=result,
),
indent=2,
)
+ "\n"
)
(args.out / "training.json").write_text(
json.dumps(
dict(
seed=18435,
history=history,
sampled={l: state.seen // 2 for l in ("en", "tr")},
elapsed_seconds=time.time() - start,
),
indent=2,
)
+ "\n"
)
print(result, flush=True)
save()
started = last = time.time()
while (args.steps is None or state.steps < args.steps) and (
args.deadline is None or time.time() < args.deadline - 7
):
frac = (
state.steps / max(1, args.steps)
if args.steps
else (time.time() - started) / max(1, args.deadline - started)
)
rate = (
0.00060
* min(1, (state.steps + 1) / 12)
* (0.3 + 0.7 * (1 + math.cos(math.pi * min(1, frac))) / 2)
)
loss = state.update(args.tokens, rate)
if state.steps % 100 == 0:
print(dict(step=state.steps, examples=state.seen, nll=loss), flush=True)
if time.time() - last >= 75:
save()
last = time.time()
save()
if state.steps == 0:
raise RuntimeError("Reader deadline expired before a parameter update.")
if __name__ == "__main__":
main()