GLINER2-NOTES.md

GLiNER2 scripts: tested runs, findings and dead ends

Notes behind train-gliner2.py and classify-gliner2.py. The README has what you need to run them; this file records what was tried, what worked, what did not, and the exact runs the README numbers come from. Much of it was run and written up by coding agents (Claude) and checked by a person.

Tested commands

Each README command was run from the branch before merge (t4-small, 2026-09-23):

Command	Result	Time	Cost
train, biglam/blbooksgenre title_genre_classifiction, defaults	zero-shot 0.793 → fine-tuned 0.925 (174-row carve-out)	149 s training	~$0.02
classify with that model, same dataset	1,736 rows labelled	20 s	<$0.01
classify zero-shot, fancyzhx/ag_news test, 4 labels	7,600 rows labelled	96 s	~$0.02
train, fancyzhx/ag_news, --max-train-samples 2000 --epochs 2	0.733 → 0.873 (2,000 test rows)	137 s training, 298 s whole Job	~$0.03

The ag_news README row (0.718 → 0.852) and this run (0.733 → 0.873) differ because the 2,000 scored test rows are a different random sample. Expect roughly 0.72 → 0.85–0.87.

Larger or fixed label sets

For tens of labels that are always scored together (a taxonomy, a fixed tag list), and for data you keep in a bucket instead of a Hub dataset:

hf jobs uv run --flavor a10g-small --timeout 2h --secrets HF_TOKEN \
  -v hf://buckets/username/my-bucket:/bucket \
  https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-gliner2.py \
  --train-file /bucket/train.jsonl \
  --eval-file calibration=/bucket/calibration.jsonl --eval-file development=/bucket/development.jsonl \
  --labels-file /bucket/labels.json --label-column labels --label-augmentation off \
  --base-model fastino/gliner2.5-base-v1 \
  --no-push --output-dir /bucket/runs/gliner2 --export-predictions /bucket/runs/gliner2/predictions

• --labels-file fixes the label set and its order for training, zero-shot and evaluation, so a label that is rare or missing in the training data is still an option.
• --label-augmentation off: gliner2's trainer by default renames labels to "label 1", "label 2", … in half the rows and drops up to half of them, which helps a general zero-shot model. With a fixed label set it cost 2–3 points of top-1 on the 52-tag example.
• --eval-file NAME=PATH (repeatable) scores each split in full and in file order.
• --export-predictions writes every row's probability and raw logit for every label, so you can fit your own temperature or thresholds on one split and check them on another.
• --no-push keeps the model in --output-dir instead of creating a Hub repo.

Measured table notes

On the T4, TREC and IMDB ran out of memory at the default batch size of 16, and the script restarted them at batch size 4 with 4 gradient accumulation steps. Before that fallback existed, the TREC run "completed" with 1,006 of 1,020 steps skipped and scored 0.576 / 0.484, barely above zero-shot. Many labels are also slow: TREC trained at 9 rows/s against 55 rows/s for the 2-label task, because every label is part of the input. For hundreds of labels, use train-classifier.py. Prediction was not the limit: the 300 IMDB reviews were scored at batch size 32 on the T4 with no fallback.

The same BL books run (seed 42) scored 0.925 on a T4, 0.937 on an A10G in fp32 and 0.931 on an A10G in bf16 — one or two eval rows apart, so hardware and precision are not a way to gain accuracy, but they are one more thing to hold constant when you compare runs.

Two upstream options are deliberately absent: in gliner2 2.0.0, gradient checkpointing crashes with the 2.5 models, and a LoRA run trained but its final checkpoint did not load for scoring (LoRA also did not fix the 56-label out-of-memory case on a T4).

The BL books row is the mean and range of five seeds; the other rows are one seed each. Read the range before you compare two runs: --seed also picks the carve-out rows, and the zero-shot model never changes, so its 3-point spread is what 174 eval rows do to the number on their own. A difference smaller than that between two runs is not a result. Use a dataset with a fixed --eval-split, and as many eval rows as you can get, when you want to compare runs.

The ag_news, go_emotions and TREC rows are deliberately small runs (capped training rows, 2–3 epochs) that test the script, not tuned results. The BL books row trains on the full 1,562 titles; its eval is a 10% carve-out, so it is not comparable with published numbers for that dataset.

A larger label set: 52 Hub task tags

train-gliner2.py was used to fine-tune a tagger that suggests a Hub dataset's task tags from its column names and first row (the worked example in the README).

• 16,000 training datasets, 1,000 calibration and 3,000 development datasets; calibration and development are newer datasets from owners not in the training data.
• gliner2.5-base-v1, --labels-file (52 tags), multi-label, --label-augmentation off, 5 epochs, rtx-pro-6000, about 17 minutes of training.
• Development top-1 in the owner's tags: base 0.695 / 0.686 (two seeds), small 0.653, zero-shot 0.102. Always answering "text-generation" scores 0.320, so zero-shot is below a constant guess.
• --label-augmentation upstream (gliner2's default) scored 0.664: turning it off added 2–3 points.
• The two seeds differ by about 1 point, almost all of it on one owner's 33 near-identical datasets that the model labels tabular-regression or tabular-classification depending on the seed.
• Owner tags are noisy: in a hand-checked sample, about 1 in 10 datasets was missing a tag that fits.

How it was set up, if you want to do something similar with your own label list:

• Input text: the dataset's column names and types, then its first row, built from the dataset viewer's preview and cut to about 370 tokens. Keep the exact same builder for training and prediction; a small difference in the text is a different input.
• Labels: a fixed --labels-file of 52 tags, multi-label (labels is a list per row), with --label-augmentation off.
• Split by time and owner: the evaluation rows are newer datasets from owners who are not in the training data, so the score is not inflated by near-duplicate datasets from the same owner.
• Two eval files (--eval-file calibration=… --eval-file development=…) and --export-predictions: thresholds are chosen on one file and checked on the other.

Choosing a model size

Base model	Params	Use it when	Hub-tags top-1	CPU latency per row (free Space, 2 vCPU)	GPU (L4, fp16)
fastino/gliner2.5-small-v1	74M	speed matters most	0.653	~0.3 s	~19 ms
fastino/gliner2.5-base-v1	194M	English text; the best accuracy per second	0.690	~0.7–1 s	~19 ms
fastino/gliner2.5-multi-v1 (default)	287M	non-English or mixed-language text	not measured	—	—
fastino/GLiNER2.5-Decide	486M	English classification; best zero-shot	not measured	—	—

On a GPU, base and small are equally fast per row; the difference only shows on a CPU. For speed on a CPU, use plain fp32 PyTorch (see below for what did not work).

GLiNER2.5-Decide on BL books: 0.851 zero-shot (default 0.767), 0.943 fine-tuned (default 0.931). Train it on a10g-small; a t4-small ran out of memory.

Speed and quantization

Per-row latency at batch size 1, fine-tuned 52-label models:

Model	L4 (fp16)	T4 (fp16)	Apple M1 Pro CPU	Free CPU Space (2 vCPU)
gliner2.5-small	~19 ms	—	—	~0.3 s
gliner2.5-base	~19 ms	~27 ms	~0.19 s	~0.7–1 s

• On a GPU, small and base take the same time per row; fixed overhead dominates.
• Dynamic int8 did not work. Agreement of the top label with fp32 on 64 rows: ONNX Runtime default 6%, torch.ao Linear 1.6%, per-channel 58%, MatMul-only per-channel 59%, skipping the feed-forward down-projection 91%, attention layers only 94%. Speed-up was at most 1.2×. The fp32 margins between the top two labels were healthy, so activation outliers in the fine-tuned encoder are the likely cause. Calibrated static int8, or keeping sensitive layers in full precision, might work; it was not tried.
• ONNX: gliner2 2.0.0 has no export. Exporting only the encoder matches fp32 exactly, but ran 1.8× slower than PyTorch on an Apple M1.
• bf16 on a CPU keeps the same answers but was 6× slower on an M1.
• On HF CPU Jobs, os.cpu_count() reports the host's cores, not the Job's vCPUs. Set torch's thread count explicitly or the run oversubscribes and stalls.

Behaviour details

• Single-label and multi-label, auto-detected from the label column (a list per row is multi-label). An empty list is kept as a valid "none of these" answer.

• Several tasks in one model. Repeat --label-column and each column becomes a task; the model answers all of them in one pass. classify-gliner2.py then writes one predicted_<task> and one predicted_<task>_confidence column per task.

• Evaluation split and metrics match train-classifier.py and train-setfit.py (--eval-split, else validation, else test, else a carve-out; accuracy + macro F1), so the rungs are comparable. Multi-label tasks report micro/macro F1 and exact match.

• Label names are part of the prompt. Real names (Fiction, Sports) work; integer codes make zero-shot meaningless, and the script warns. Brackets are stripped from label names because GLiNER2 rejects them at inference.

• It does not train on nothing. The GLiNER2 trainer catches a CUDA out-of-memory error, skips the batch and carries on, so an undersized GPU looks like a healthy job that produces an untrained model. After 5 out-of-memory steps the script restarts itself at a quarter of the batch size, with 4× the gradient accumulation, so the effective batch size stays the same. It goes down to batch size 1, then stops before anything is pushed. The model card's reproduce command records the batch size that worked. Memory grows with batch size × number of labels × text length.

• The launch config ships with the script. Both scripts carry a [tool.hf-jobs] header (t4-small, a 1 hour timeout, the HF_TOKEN secret). With hf CLI 1.32 or newer, hf jobs uv run <script-url> <args> is enough, and --dry-run shows what it resolves to. Flags still win, and the examples here keep them so they also work on older CLIs — which ignore the header and stop the Job after 30 minutes, before the model is pushed. Pass --timeout explicitly (the examples use 1h; a large run needs more) whenever you cannot be sure which CLI launches the job.

• Outputs are private by default. train-gliner2.py creates a private model repo and classify-gliner2.py a private dataset; pass --public to opt out. If the target repo already exists and is public, both scripts stop before doing any work. (--private is still accepted, and does nothing.)

• Local files, several eval splits, exported predictions. Instead of a Hub dataset, train-gliner2.py can read JSON Lines files, for example from a bucket mounted with -v:

  hf jobs uv run --flavor a10g-small --timeout 2h --secrets HF_TOKEN \
    -v hf://buckets/username/my-bucket:/bucket \
    https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-gliner2.py \
    --train-file /bucket/train.jsonl \
    --eval-file calibration=/bucket/calibration.jsonl --eval-file development=/bucket/development.jsonl \
    --labels-file /bucket/labels.json --label-column labels --label-augmentation off \
    --no-push --output-dir /bucket/runs/gliner2 --export-predictions /bucket/runs/gliner2/predictions
  

  • --eval-file NAME=PATH (repeatable): each file is an eval split, scored zero-shot and fine-tuned, in full and in file order.
  • --labels-file: a JSON list or one label per line. It fixes the label set and its order for training, zero-shot and evaluation; a label in the data that is not in the file stops the run.
  • --export-predictions DIR: writes DIR/{base,finetuned}-<split>/predictions.jsonl, one line per row: {"row": i, "probabilities": {task: {label: p}}, "logits": {task: {label: logit}}} with every label. Probabilities are gliner2's (softmax for a single-label task, a sigmoid per label for multi-label); logits are the raw per-label scores. Exporting also switches off the --max-eval-samples cap for a Hub eval split.
  • --no-push: no Hub repo is created or written; the model stays in --output-dir/final.
  • --label-augmentation off: gliner2's trainer by default renames the labels to "label 1", "label 2", ... in half of the training rows and drops up to half of the labels (upstream). With a fixed label set that is always scored in full, off trains on the real, complete label set every time; label-order shuffling stays on.
  • A run_manifest.json (all arguments except the token, the label-augmentation config, precision, device and package versions, then the results) is written to --output-dir, the export directory and the model folder.

• Pick the GPU by label count and text length. A t4-small fit short texts with 2, 4 and 28 labels at the default batch size. The 56-label TREC task and 2,000-character IMDB reviews both fell back to batch size 4, and IMDB did so on the A10G too. a10g-small (24 GB) trains about 2.3× faster and fit the 56-label TREC run at the default batch size, in 509s against 1,761s on the T4 at batch size 4. --precision auto uses bf16 on Ampere or newer GPUs (A10G, L4) and fp32 on a T4; on the A10G bf16 and fp32 ran at the same speed (62s and 59s), so bf16 there buys memory, not time.

• Texts are truncated to --max-text-chars (default 2000), with a count.

• It is a GLiNER2 checkpoint, loaded with gliner2.classification.Classifier.from_pretrained(repo), not AutoModelForSequenceClassification. gliner2 pins transformers<5, which keeps huggingface_hub below 1.0 inside the Job. The hf CLI 1.32 or newer that reads the [tool.hf-jobs] header is a separate install on your own machine, so the two versions do not conflict.

Dead ends

• Gradient checkpointing crashes with the GLiNER2.5 models in gliner2 2.0.0.
• A LoRA run trained, but its final checkpoint did not load for scoring, and LoRA did not fix the 56-label out-of-memory case on a T4.
• Before the out-of-memory restart existed, a TREC run "completed" with 1,006 of 1,020 steps skipped and scored barely above zero-shot. Check the logs for OOM at step when a result looks flat.