Text Classification
Laya
Safetensors
English
ledgar
lexglue
legal
contracts
calibrated
selective-prediction
Eval Results (legacy)
Instructions to use VibeHash/laya-ledgar with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Laya
How to use VibeHash/laya-ledgar with Laya:
# No code snippets available yet for this library. # To use this model, check the repository files and the library's documentation. # Want to help? PRs adding snippets are welcome at: # https://github.com/huggingface/huggingface.js
- Notebooks
- Google Colab
- Kaggle
File size: 6,161 Bytes
779ff0b | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 | """Fine-tune Laya on a task's training set with Laya's own `finetune`.
The settings are Laya's defaults with the changes a task's module names, all fixed before any fine-tuned model of
that task is scored:
- `head_max_len` 512 instead of 192, so that every option keeps its own words. At 192 Laya cuts long option lists
short until some of them read the same.
- `target_error` 0.01 instead of 0.10. Laya fits a confidence threshold on training rows it held back, so that the
answers above it are about 99% right. The rest are meant for a person.
- `max_len`, `epochs`, `loss` and `dev_rows` only where the task's module says why.
Laya holds back 400 training rows (its `calib_max`) to fit its temperature and that threshold, and trains on the
rest.
A task with `dev_rows` also keeps that many training rows out of the run, and every other row with the same text,
so they are new to the model. They go to `dev.jsonl` in the run folder, and `layatasks.evaluate --dev` scores them.
That judges a run without reading the test.
Run it with `python -m layatasks.train <task> --seed 0`.
"""
from __future__ import annotations
import argparse
import dataclasses
import json
import os
import random
import time
from pathlib import Path
from layatasks import task as tasks
from layatasks.common import data_dir, normalise, read_jsonl, run_dir, sha256_file, write_json, write_jsonl
BASE_REPO = "convaiinnovations/laya"
BASE_REVISION = "85cc74ddae6109077ebe2853a9b3077fb6606a78"
BASE_WEIGHTS_SHA256 = "891102d372688fc2a094dac56a384bc537b87c63f21f9f3dac0be2b7cbc8d86c"
BASE_FILES = ["rl_agent_config.json", "model.safetensors", "tokenizer/*", "encoder/*"]
def base_dir(path: str | None = None) -> str:
"""The pinned base checkpoint: downloaded from the Hub at `BASE_REVISION`, or a local copy of it.
Either way its weights must match `BASE_WEIGHTS_SHA256`, so a local copy cannot quietly be another revision.
A local copy can also be named by `LAYA_BASE`.
"""
path = path or os.environ.get("LAYA_BASE") or None
if path is None:
from huggingface_hub import snapshot_download
path = snapshot_download(BASE_REPO, revision=BASE_REVISION, allow_patterns=BASE_FILES)
got = sha256_file(Path(path) / "model.safetensors")
if got != BASE_WEIGHTS_SHA256:
raise RuntimeError("base weights in %s are %s, expected %s" % (path, got, BASE_WEIGHTS_SHA256))
return str(path)
EFFECTIVE_BATCH = 64
DEV_SEED = 20261118
def split_dev(rows, n: int, seed: int = DEV_SEED):
"""`(train, dev)`: `n` rows drawn with a fixed seed, and training without any row whose text matches one of them.
Contracts repeat boilerplate, so a dev row whose text stays in training would measure recall, not the model.
"""
order = list(range(len(rows)))
random.Random(seed).shuffle(order)
dev = [rows[i] for i in sorted(order[:n])]
texts = {normalise(r["state"]) for r in dev}
keep = set(order[n:])
train = [r for i, r in enumerate(rows) if i in keep and normalise(r["state"]) not in texts]
return train, dev
def config(task, seed: int, micro_batch: int = 8):
"""Laya's settings with the task's changes. `micro_batch` only splits each step of 64 rows into smaller pieces
when the GPU runs out of memory; the step itself, and so the learning, stays the same size."""
from laya.train import TrainConfig
if micro_batch < 1 or EFFECTIVE_BATCH % micro_batch:
raise ValueError("micro_batch must divide %d, got %r" % (EFFECTIVE_BATCH, micro_batch))
return TrainConfig(seed=seed, epochs=task.epochs, max_len=task.max_len, head_max_len=task.head_max_len,
target_error=task.target_error, loss=task.loss, micro_batch=micro_batch,
grad_accum=EFFECTIVE_BATCH // micro_batch)
def main() -> None:
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
parser.add_argument("task", choices=tasks.TASKS)
parser.add_argument("--seed", type=int, default=0)
parser.add_argument("--name", default=None, help="run name (default: seed<N>)")
parser.add_argument("--base", default=None, help="a local copy of the base checkpoint (default: download it)")
parser.add_argument("--micro-batch", type=int, default=8,
help="rows a forward pass (default 8); lower it if the GPU runs out of memory")
args = parser.parse_args()
from laya.train import finetune
task = tasks.load(args.task).TASK
if task.test_sha256 is None:
raise SystemExit("%s: the test file is not locked yet; run layatasks.data and pin its hash first" % task.name)
name = args.name or "seed%d" % args.seed
out = run_dir(task.name, name)
out.mkdir(parents=True, exist_ok=True)
cfg = config(task, args.seed, args.micro_batch)
base = base_dir(args.base)
data = data_dir(task.name) / "train.jsonl"
dev = None
if task.dev_rows:
rows = read_jsonl(data)
kept, dev_part = split_dev(rows, task.dev_rows)
data = out / "train_rows.jsonl"
write_jsonl(data, kept)
write_jsonl(out / "dev.jsonl", dev_part)
dev = {"rows": len(dev_part), "seed": DEV_SEED, "train_rows": len(kept),
"dropped_same_text": len(rows) - len(kept) - len(dev_part)}
print("dev: %d rows kept out, %d more dropped for sharing their text; training on %d"
% (dev["rows"], dev["dropped_same_text"], dev["train_rows"]))
t = time.perf_counter()
summary = finetune(str(data), base, str(out / "model"), config=cfg)
seconds = time.perf_counter() - t
summary.pop("output_dir", None)
write_json(out / "train.json", json.loads(json.dumps({
"task": task.name, "name": name, "seed": args.seed, "seconds": seconds, "dev": dev,
"base": {"repo": BASE_REPO, "revision": BASE_REVISION, "weights_sha256": BASE_WEIGHTS_SHA256},
"config": dataclasses.asdict(cfg), "summary": summary}, default=str)))
print("trained %s/%s in %.0f s; model in %s" % (task.name, name, seconds, out / "model"))
if __name__ == "__main__":
os.environ.setdefault("HF_HUB_DISABLE_SYMLINKS_WARNING", "1")
main()
|