Sync from GitHub via hub-sync

GLINER2-NOTES.md

@@ -0,0 +1,161 @@
+# 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:
+
+```bash
+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.
+
+## 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](https://huggingface.co/docs/hub/jobs-configuration#define-the-launch-config-in-the-script) (`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`:
+
+  ```bash
+  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.

README.md

@@ -1,6 +1,6 @@
 ---
 viewer: false
-tags: [uv-script, classification, fine-tuning, few-shot, setfit, vllm, structured-outputs, hf-jobs]
+tags: [uv-script, classification, fine-tuning, few-shot, zero-shot, setfit, gliner2, vllm, structured-outputs, hf-jobs]
 ---
 
 # Classification Scripts
@@ -9,8 +9,10 @@ Text classification on [HF Jobs](https://huggingface.co/docs/huggingface_hub/gui
 
 | Script | What it does |
 |--------|--------------|
-| [`train-classifier.py`](#fine-tune-a-classifier-train-classifierpy) | **Fine-tune** an encoder into a classifier (default: [LFM2.5-Encoder-350M](https://huggingface.co/LiquidAI/LFM2.5-Encoder-350M)) and push it to the Hub |
+| [`classify-gliner2.py`](#zero-shot-first-then-fine-tune-gliner2) | **Label a dataset** with GLiNER2: zero-shot from label names, or with a `train-gliner2.py` model |
+| [`train-gliner2.py`](#zero-shot-first-then-fine-tune-gliner2) | **Fine-tune** [GLiNER2](https://github.com/fastino-ai/GLiNER2), a small model (74M–287M) that already classifies zero-shot, and report the zero-shot score next to the fine-tuned one |
 | [`train-setfit.py`](#few-shot-with-setfit-train-setfitpy) | **Few-shot** train a classifier from 8-64 labels per class with [SetFit](https://github.com/huggingface/setfit) — runs on CPU or GPU |
+| [`train-classifier.py`](#fine-tune-a-classifier-train-classifierpy) | **Fine-tune** an encoder into a classifier (default: [LFM2.5-Encoder-350M](https://huggingface.co/LiquidAI/LFM2.5-Encoder-350M)) and push it to the Hub |
 | [`classify-dataset.py`](#zero-shot-classification-classify-datasetpy) | **Zero-shot** classify a dataset with an instruction LLM (SmolLM3 + vLLM, structured outputs) |
 | `classify-dataset-sglang.py` | Zero-shot variant on SGLang (reasoning-aware `<think>` models) |
 
@@ -18,64 +20,118 @@ Pick by how many labels you have:
 
 | Labels you have | Use | Hardware |
 |---|---|---|
-| none | `classify-dataset.py` to bootstrap labels, or for one-off jobs | GPU |
+| none | `classify-gliner2.py --labels ...` for a cheap first pass; `classify-dataset.py` when the task needs an LLM's reasoning | small GPU (CPU works at ~1.4 rows/s); GPU |
 | ~8-64 per class | `train-setfit.py` | CPU supported; GPU for faster training |
-| a few thousand | `train-classifier.py` | GPU |
+| a few hundred to a few thousand | `train-gliner2.py`, which also shows you what zero-shot already gets | small GPU (`t4-small`) |
+| a few thousand or more | `train-classifier.py` | GPU |
 
 The rungs chain: bootstrap labels with `classify-dataset.py`, review them, then train a small
 dedicated model on what you kept.
 
-## Fine-tune a classifier (`train-classifier.py`)
+## Zero-shot first, then fine-tune (GLiNER2)
 
-Fine-tunes a text-classification encoder on any Hub dataset and pushes the trained model
-back to the Hub — download, train, evaluate, push, and reload-verify in one job.
+Label a dataset with your own list of labels, see how far zero-shot gets you, then fine-tune a
+small model on your labels, in minutes and for a few cents on one GPU. The result is a model
+that returns a label and a probability for every row, and is small enough to run on a CPU.
 
-- **Default model**: [LiquidAI/LFM2.5-Encoder-350M](https://huggingface.co/LiquidAI/LFM2.5-Encoder-350M) — a bidirectional encoder that beats ModernBERT-base on GLUE/SuperGLUE and handles 8,192-token documents. Any Hub encoder works via `--model` (ModernBERT, BERT, DeBERTa, …).
-- **Single-label and multi-label**, auto-detected from the label column (`ClassLabel`/string/int → cross-entropy; list of labels → BCE + per-label threshold tuning).
-- **Round-trippable artifacts**: standard architectures produce standard models; encoders without a classification head (like LFM2.5) get a generic mean-pooling head pushed as custom code, so `AutoModelForSequenceClassification.from_pretrained(..., trust_remote_code=True)` always works.
+[GLiNER2](https://github.com/fastino-ai/GLiNER2) is a small encoder that reads the label names
+as part of its input, so it classifies with no training at all, and fine-tuning teaches it what
+your labels mean in your data. (For entity extraction with the original GLiNER library, see
+[`uv-scripts/gliner`](https://huggingface.co/datasets/uv-scripts/gliner).) Two scripts:
 
-```bash
-# single-label (ag_news has a ClassLabel column)
-hf jobs uv run --flavor a10g-small --secrets HF_TOKEN \
-  https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-classifier.py \
-  fancyzhx/ag_news username/news-classifier
+- **`train-gliner2.py`** scores the base model zero-shot, fine-tunes it on your labels, and
+  scores it again on the same held-out rows. The model card reports both next to the
+  majority-class floor, so you can see what the labels bought you.
+- **`classify-gliner2.py`** labels a whole dataset. Pass `--labels` for zero-shot, or `--model`
+  with a `train-gliner2.py` output; the tasks and labels are read from the model repo.
+  Labels are passed as separate words; quote a label with spaces:
+  `--labels World Sports Business "Science and technology"`. A fine-tuned model is passed
+  by repo id: `--model username/gliner2-blbooks-genre`.
 
-# multi-label (go_emotions has a list-of-labels column)
-hf jobs uv run --flavor a10g-small --secrets HF_TOKEN \
-  https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-classifier.py \
-  google-research-datasets/go_emotions username/emotion-classifier --label-column labels
+### Quick start
+
+```bash
+# fine-tune: British Library book titles -> Fiction / Non-fiction
+hf jobs uv run --flavor t4-small --timeout 1h --secrets HF_TOKEN \
+  https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-gliner2.py \
+  biglam/blbooksgenre username/gliner2-blbooks-genre \
+  --dataset-config title_genre_classifiction --text-column title
+
+# label a dataset with that model
+hf jobs uv run --flavor t4-small --timeout 1h --secrets HF_TOKEN \
+  https://huggingface.co/datasets/uv-scripts/classification/raw/main/classify-gliner2.py \
+  biglam/blbooksgenre username/blbooks-genre-predictions \
+  --dataset-config title_genre_classifiction --text-column title --model username/gliner2-blbooks-genre
+
+# or skip training: zero-shot from label names
+hf jobs uv run --flavor t4-small --timeout 1h --secrets HF_TOKEN \
+  https://huggingface.co/datasets/uv-scripts/classification/raw/main/classify-gliner2.py \
+  fancyzhx/ag_news username/ag-news-topics --split test \
+  --labels World Sports Business "Science and technology" --task-name topic
 ```
 
-Key options: `--model`, `--max-length` (512 default; up to 8192 with
-`--gradient-checkpointing` and a small `--batch-size` on a10g/a100), `--epochs`, `--lr`,
-`--batch-size`, `--max-samples` (smoke runs), `--eval-split` (auto-detects
-validation/test, or holds out 10% of train). Run `uv run train-classifier.py --help` for all.
+The second command labels the same rows the model was trained on, so it shows the workflow, not
+the model's accuracy; the held-out scores are on the model card. For real use, point it at data
+the model has not seen. Outputs are **private by default** (`--public` to opt out).
 
-### Worked example: classify dataset cards by task
+These commands use the default base model, `fastino/gliner2.5-multi-v1` (multilingual). For
+English text, `--base-model fastino/gliner2.5-base-v1` is smaller and faster;
+`gliner2.5-small-v1` is the fastest and loses about 4 points on the 52-tag example. See [Choosing a model size](#choosing-a-model-size).
 
-[`davanstrien/dataset-cards-with-task-categories`](https://huggingface.co/datasets/davanstrien/dataset-cards-with-task-categories)
-contains 21k Hub dataset cards (frontmatter stripped) labelled with their `task_categories`
-metadata — a real multi-label task over long documents:
+### What it buys you
 
-```bash
-hf jobs uv run --flavor a10g-small --secrets HF_TOKEN \
-  https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-classifier.py \
-  davanstrien/dataset-cards-with-task-categories username/dataset-card-task-classifier \
-  --label-column labels --max-length 1024 --batch-size 8 --grad-accum 2
-```
+| Dataset | Task | Labels | Train rows × epochs | Train time | Train cost | Metric | Majority floor | Zero-shot | Fine-tuned |
+|---|---|---|---|---|---|---|---|---|---|
+| [`biglam/blbooksgenre`](https://huggingface.co/datasets/biglam/blbooksgenre) (book titles) | single-label | 2 | 1,562 × 5 | 141s | $0.02 | accuracy | 0.747 | 0.767 (0.753–0.782) | **0.907** (0.897–0.925) |
+| [`fancyzhx/ag_news`](https://huggingface.co/datasets/fancyzhx/ag_news) | single-label | 4 | 2,000 × 2 | 125s | $0.01 | accuracy | 0.268 | 0.718 | **0.852** |
+| [`google-research-datasets/go_emotions`](https://huggingface.co/datasets/google-research-datasets/go_emotions) | multi-label | 28 | 2,000 × 2 | 216s | $0.02 | micro F1 | — | 0.265 | **0.464** |
+| [`SetFit/TREC-QC`](https://huggingface.co/datasets/SetFit/TREC-QC), two tasks in one model | single-label ×2 | 6 + 50 | 5,452 × 3 | 1,761s | $0.20 | accuracy | 0.276 / 0.246 | 0.542 / 0.468 | **0.954 / 0.876** |
+| same, on `a10g-small`, default batch size, bf16 | single-label ×2 | 6 + 50 | 5,452 × 3 | 509s | $0.14 | accuracy | 0.276 / 0.246 | not run | **0.944 / 0.872** |
+| [`stanfordnlp/imdb`](https://huggingface.co/datasets/stanfordnlp/imdb) (reviews; 15% truncated at 2,000 characters) | single-label | 2 | 1,000 × 1 | 122s | $0.01 | accuracy | 0.500 | 0.777 | **0.840** |
+| Hub dataset task tags ([worked example](#worked-example-tagging-hub-datasets)), `--base-model fastino/gliner2.5-base-v1 --label-augmentation off`, on `rtx-pro-6000` | single-label choice from a fixed set | 52 | 16,000 × 5 | 17 min | ~$1.50 | top-1 in the owner's tags | 0.320 (always "text-generation") | 0.102 | **0.690** (2 seeds: 0.695 / 0.686) |
 
-The output model predicts likely task categories from a card's prose — e.g. for suggesting
-metadata on datasets that lack it.
+Most rows are single, deliberately small runs that test the script, not tuned results. Seed ranges,
+out-of-memory history and GPU comparisons are in [GLINER2-NOTES.md](GLINER2-NOTES.md).
 
-### Training a standard encoder instead
+### Choosing a model size
 
-`--model answerdotai/ModernBERT-base` (or any encoder with a native classification head)
-produces a plain, vLLM-servable model — pair it with
-[`uv-scripts/vllm`](https://huggingface.co/datasets/uv-scripts/vllm)'s
-`classify-dataset.py` for large-scale batch inference with the model you just trained.
+| 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   | —                                        | —              |
+
+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 the notes for what did not work (int8, ONNX).
+
+### Larger or fixed label sets
+
+For tens of labels scored together (a taxonomy, a fixed tag list), or data in a bucket, see
+[Larger or fixed label sets](GLINER2-NOTES.md#larger-or-fixed-label-sets) in the notes:
+`--labels-file`, `--label-augmentation off`, local `--train-file`/`--eval-file` and `--export-predictions`.
+
+### Worked example: tagging Hub datasets
+
+A GLiNER2.5-base model fine-tuned with this script on 16,000 Hub datasets suggests task tags for
+a dataset from its column names and first row, among the 52 tags the Hub offers. Its first
+suggestion matches one of the owner's tags 69% of the time on 3,000 newer datasets from owners it
+never saw. Owners' tags are a noisy target, so the true rate is higher.
+[Model](https://huggingface.co/davanstrien/hub-task-tagger-gliner2.5-base) · [Demo](https://huggingface.co/spaces/davanstrien/hub-task-tagger) · [Notes on how it was trained](GLINER2-NOTES.md#a-larger-label-set-52-hub-task-tags)
+
+### Good to know
+
+- **Single-label and multi-label** are auto-detected from the label column; repeat `--label-column` to train several tasks in one model.
+- **Label names are part of the prompt.** Real names (`Fiction`, `Sports`) work; integer codes make zero-shot meaningless.
+- **Out of GPU memory, it restarts at a smaller batch size** and stops before pushing if even batch size 1 fails. Many labels or long texts want an `a10g-small`.
+- **Always pass `--timeout`.** Older `hf` CLIs ignore the scripts' `[tool.hf-jobs]` header and stop the Job after 30 minutes.
+
+More behaviour details, tested commands, findings and dead ends: [GLINER2-NOTES.md](GLINER2-NOTES.md).
 
 ## Few-shot with SetFit (`train-setfit.py`)
 
+An alternative when you have only a handful of labelled examples per class (8-64) and want a sentence-transformer model.
+
 Trains a [SetFit](https://github.com/huggingface/setfit) classifier from a handful of labelled
 examples per class. SetFit finetunes a sentence-transformer body on contrastive pairs, then fits a
 logistic regression head on the resulting embeddings.
@@ -191,6 +247,55 @@ it suggests undersampling where applicable and estimates whether that would fit
 > **Note**: a SetFit model is a sentence-transformer body plus a scikit-learn head. Load it with
 > `SetFitModel.from_pretrained(repo)`, not `AutoModelForSequenceClassification`.
 
+## Fine-tune a classifier (`train-classifier.py`)
+
+Fine-tunes a text-classification encoder on any Hub dataset and pushes the trained model
+back to the Hub — download, train, evaluate, push, and reload-verify in one job.
+
+- **Default model**: [LiquidAI/LFM2.5-Encoder-350M](https://huggingface.co/LiquidAI/LFM2.5-Encoder-350M) — a bidirectional encoder that beats ModernBERT-base on GLUE/SuperGLUE and handles 8,192-token documents. Any Hub encoder works via `--model` (ModernBERT, BERT, DeBERTa, …).
+- **Single-label and multi-label**, auto-detected from the label column (`ClassLabel`/string/int → cross-entropy; list of labels → BCE + per-label threshold tuning).
+- **Round-trippable artifacts**: standard architectures produce standard models; encoders without a classification head (like LFM2.5) get a generic mean-pooling head pushed as custom code, so `AutoModelForSequenceClassification.from_pretrained(..., trust_remote_code=True)` always works.
+
+```bash
+# single-label (ag_news has a ClassLabel column)
+hf jobs uv run --flavor a10g-small --secrets HF_TOKEN \
+  https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-classifier.py \
+  fancyzhx/ag_news username/news-classifier
+
+# multi-label (go_emotions has a list-of-labels column)
+hf jobs uv run --flavor a10g-small --secrets HF_TOKEN \
+  https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-classifier.py \
+  google-research-datasets/go_emotions username/emotion-classifier --label-column labels
+```
+
+Key options: `--model`, `--max-length` (512 default; up to 8192 with
+`--gradient-checkpointing` and a small `--batch-size` on a10g/a100), `--epochs`, `--lr`,
+`--batch-size`, `--max-samples` (smoke runs), `--eval-split` (auto-detects
+validation/test, or holds out 10% of train). Run `uv run train-classifier.py --help` for all.
+
+### Worked example: classify dataset cards by task
+
+[`davanstrien/dataset-cards-with-task-categories`](https://huggingface.co/datasets/davanstrien/dataset-cards-with-task-categories)
+contains 21k Hub dataset cards (frontmatter stripped) labelled with their `task_categories`
+metadata — a real multi-label task over long documents:
+
+```bash
+hf jobs uv run --flavor a10g-small --secrets HF_TOKEN \
+  https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-classifier.py \
+  davanstrien/dataset-cards-with-task-categories username/dataset-card-task-classifier \
+  --label-column labels --max-length 1024 --batch-size 8 --grad-accum 2
+```
+
+The output model predicts likely task categories from a card's prose — e.g. for suggesting
+metadata on datasets that lack it.
+
+### Training a standard encoder instead
+
+`--model answerdotai/ModernBERT-base` (or any encoder with a native classification head)
+produces a plain, vLLM-servable model — pair it with
+[`uv-scripts/vllm`](https://huggingface.co/datasets/uv-scripts/vllm)'s
+`classify-dataset.py` for large-scale batch inference with the model you just trained.
+
 ---
 
 # Zero-shot classification (`classify-dataset.py`)

classify-gliner2.py

@@ -0,0 +1,461 @@
+# /// script
+# requires-python = ">=3.11,<3.14"
+# dependencies = [
+#     "gliner2[local]==2.0.0",
+#     "protobuf",
+#     "sentencepiece",
+#     "datasets>=4.0.0,<6",
+#     "huggingface-hub",
+# ]
+#
+# [tool.hf-jobs]
+# flavor = "t4-small"
+# timeout = "1h"
+# secrets = ["HF_TOKEN"]
+# ///
+"""
+Classify a text column of a Hub dataset with GLiNER2 — zero-shot, or with your fine-tuned model.
+
+GLiNER2 is a small encoder (74M to 287M parameters) that reads the label names as part of its
+input. That gives two ways to use this script:
+
+1. Zero-shot: pass the label names with --labels. No training and no LLM. A t4-small does about
+   33 rows/s; cpu-basic works but manages about 1.4 rows/s, so keep CPU for a few hundred rows.
+2. Fine-tuned: pass --model with a repo produced by `train-gliner2.py`. The tasks and labels are
+   read from the model repo, so no --labels flag is needed.
+
+Zero-shot on HF Jobs:
+
+    hf jobs uv run --flavor t4-small --timeout 1h --secrets HF_TOKEN \\
+        https://huggingface.co/datasets/uv-scripts/classification/raw/main/classify-gliner2.py \\
+        fancyzhx/ag_news username/ag-news-gliner2 \\
+        --labels World Sports Business "Science and technology" --max-samples 1000
+
+With a fine-tuned model:
+
+    hf jobs uv run --flavor t4-small --timeout 1h --secrets HF_TOKEN \\
+        https://huggingface.co/datasets/uv-scripts/classification/raw/main/classify-gliner2.py \\
+        biglam/blbooksgenre username/blbooks-genre-predictions \\
+        --dataset-config title_genre_classifiction --text-column title \\
+        --model username/gliner2-blbooks-genre
+
+Output: the original columns, plus `predicted_<task>` (a label, or a list of labels for a
+multi-label task) and `predicted_<task>_confidence` for every task. The output dataset is
+PRIVATE unless you pass --public.
+
+Pass `--timeout` to `hf jobs uv run` for a big dataset: CLIs older than 1.32 ignore the
+[tool.hf-jobs] header above and stop the job after 30 minutes, before anything is pushed.
+"""
+
+import argparse
+import json
+import logging
+import os
+import shlex
+import sys
+import time
+from collections import Counter
+
+os.environ.setdefault("TQDM_DISABLE", "1")
+
+import datasets
+import torch
+from datasets import Features, List, Value, load_dataset
+from gliner2.classification import (
+    ClassificationConfig,
+    ClassificationSchema,
+    Classifier,
+)
+from huggingface_hub import DatasetCard, HfApi, hf_hub_download, login
+from huggingface_hub.utils import (
+    EntryNotFoundError,
+    RepositoryNotFoundError,
+    disable_progress_bars,
+)
+
+
+def configure_logging() -> logging.Logger:
+    """Keep Jobs logs readable: root at WARNING, only this script's logger at INFO."""
+    logging.basicConfig(
+        level=logging.WARNING,
+        format="%(asctime)s | %(levelname)s | %(message)s",
+        datefmt="%H:%M:%S",
+    )
+    for noisy in ("httpx", "urllib3", "filelock", "huggingface_hub"):
+        logging.getLogger(noisy).setLevel(logging.WARNING)
+    disable_progress_bars()
+    if hasattr(datasets, "disable_progress_bars"):
+        datasets.disable_progress_bars()
+
+    script_logger = logging.getLogger("classify-gliner2")
+    script_logger.setLevel(logging.INFO)
+    return script_logger
+
+
+logger = configure_logging()
+
+SCRIPT_URL = (
+    "https://huggingface.co/datasets/uv-scripts/classification/raw/main/classify-gliner2.py"
+)
+DEFAULT_MODEL = "fastino/gliner2.5-multi-v1"
+
+# Written into the model repo by train-gliner2.py: the tasks and labels the model was trained on.
+SCHEMA_FILENAME = "classification_schema.json"
+
+# GLiNER2 puts label names into the model prompt verbatim and rejects these strings.
+FORBIDDEN_IN_LABELS = ("(", ")", "[P]", "[L]", "[C]", "[E]", "[R]", "[DESCRIPTION]", "[EXAMPLE]", "[OUTPUT]")
+
+
+def check_labels(labels: list) -> None:
+    for label in labels:
+        for token in FORBIDDEN_IN_LABELS:
+            if token in label:
+                sys.exit(
+                    f"Label {label!r} contains {token!r}, which GLiNER2 does not allow in a label "
+                    "name. Rephrase it, for example with a dash instead of brackets."
+                )
+    if len(set(labels)) != len(labels):
+        sys.exit(f"--labels contains a duplicate: {labels}")
+    if len(labels) < 2:
+        sys.exit("Pass at least two --labels.")
+
+
+def exit_model_not_found(model_id: str) -> None:
+    sys.exit(
+        f"Cannot read the model '{model_id}'. Check the repo ID. If the repo is private or gated, "
+        "make sure HF_TOKEN has access to it."
+    )
+
+
+def check_model_access(api: HfApi, model_id: str) -> None:
+    """Stop with a clear message, before loading any data, if the model repo cannot be read."""
+    if os.path.isdir(model_id):
+        return
+    try:
+        api.model_info(model_id)
+    except RepositoryNotFoundError:
+        exit_model_not_found(model_id)
+
+
+def load_trained_tasks(model_id: str):
+    """Read the tasks that train-gliner2.py recorded in the model repo, or return None."""
+    local_file = os.path.join(model_id, SCHEMA_FILENAME)
+    if os.path.isfile(local_file):
+        path = local_file
+    elif os.path.isdir(model_id):
+        return None
+    else:
+        try:
+            path = hf_hub_download(model_id, SCHEMA_FILENAME)
+        except EntryNotFoundError:
+            return None
+        except RepositoryNotFoundError:
+            # Also raised for a gated repo the token has not been granted.
+            exit_model_not_found(model_id)
+    with open(path) as handle:
+        return json.load(handle)["tasks"]
+
+
+def resolve_tasks(args) -> list:
+    """Decide which tasks to run: --labels wins, otherwise the model repo's recorded tasks."""
+    if args.labels:
+        check_labels(args.labels)
+        return [{"name": args.task_name, "labels": args.labels, "multi_label": args.multi_label}]
+
+    tasks = load_trained_tasks(args.model)
+    if tasks is None:
+        sys.exit(
+            f"No --labels given, and '{args.model}' has no {SCHEMA_FILENAME}. Pass the label "
+            "names with --labels, or use a model trained with train-gliner2.py."
+        )
+    logger.info("Using the %d task(s) recorded in %s.", len(tasks), args.model)
+    return tasks
+
+
+def build_schema(tasks: list) -> ClassificationSchema:
+    schema = ClassificationSchema()
+    for task in tasks:
+        if task["multi_label"]:
+            schema.multi(task["name"], task["labels"])
+        else:
+            schema.single(task["name"], task["labels"])
+    return schema
+
+
+def label_counts_table(tasks: list, counts_by_task: dict, total: int) -> str:
+    lines = ["| Task | Label | Rows | Share |", "|---|---|---|---|"]
+    for task in tasks:
+        for label, count in counts_by_task[task["name"]].most_common():
+            lines.append(f"| `{task['name']}` | {label} | {count} | {count / total:.1%} |")
+    return "\n".join(lines)
+
+
+# The smallest Jobs flavor for each GPU, keyed by a fragment of the GPU's name. "L40" comes
+# before "L4" because the first match wins.
+GPU_NAME_TO_FLAVOR = {"T4": "t4-small", "A10G": "a10g-small", "L40": "l40sx1", "L4": "l4x1", "A100": "a100-large"}
+
+
+def jobs_flavor() -> str:
+    """Return the Jobs hardware flavor, or "" when it is not known.
+
+    The docs say ACCELERATOR holds the flavor ("a10g-small"). On the t4-small and a10g-small
+    jobs that tested this script it held a bare "gpu", which is not a valid --flavor. So use
+    ACCELERATOR when it looks like a flavor, and otherwise name the smallest flavor that has
+    this GPU. A larger flavor of the same GPU reproduces the same result.
+    """
+    hardware = os.environ.get("ACCELERATOR") or ""
+    looks_like_flavor = "-" in hardware or any(character.isdigit() for character in hardware)
+    if looks_like_flavor:
+        return hardware
+    if not torch.cuda.is_available():
+        return ""
+    gpu_name = torch.cuda.get_device_name(0)
+    for fragment, flavor in GPU_NAME_TO_FLAVOR.items():
+        if fragment in gpu_name:
+            return flavor
+    return ""
+
+
+def build_reproduce_command(args) -> str:
+    flavor = jobs_flavor() or "t4-small"
+    parts = [
+        f"hf jobs uv run --flavor {flavor} --timeout 1h --secrets HF_TOKEN \\",
+        f"  {SCRIPT_URL} \\",
+        f"  {shlex.quote(args.input_dataset)} {shlex.quote(args.output_dataset)}",
+    ]
+    flags = []
+    if args.model != DEFAULT_MODEL:
+        flags.append(f"--model {shlex.quote(args.model)}")
+    if args.labels:
+        quoted = " ".join(shlex.quote(label) for label in args.labels)
+        flags.append(f"--labels {quoted}")
+        if args.task_name != "label":
+            flags.append(f"--task-name {shlex.quote(args.task_name)}")
+        if args.multi_label:
+            flags.append("--multi-label")
+    if args.dataset_config:
+        flags.append(f"--dataset-config {shlex.quote(args.dataset_config)}")
+    if args.text_column != "text":
+        flags.append(f"--text-column {shlex.quote(args.text_column)}")
+    if args.split != "train":
+        flags.append(f"--split {shlex.quote(args.split)}")
+    if args.max_samples:
+        flags.append(f"--max-samples {args.max_samples}")
+    if args.max_text_chars != 2000:
+        flags.append(f"--max-text-chars {args.max_text_chars}")
+    if args.public:
+        flags.append("--public")
+    if flags:
+        parts[-1] += " \\"
+        parts.append("  " + " ".join(flags))
+    return "\n".join(parts)
+
+
+def build_card(args, tasks, counts_by_task, total, seconds, zero_shot: bool) -> str:
+    """Dataset card with the canonical uv-scripts provenance stamp."""
+    on_jobs = os.environ.get("JOB_ID") is not None
+    hardware = jobs_flavor()
+    if on_jobs:
+        origin = "Produced on [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs)"
+        if hardware:
+            origin += f" (`{hardware}`)"
+    else:
+        origin = "Generated"
+
+    tags = ["uv-script", "gliner2", "text-classification"]
+    if on_jobs:
+        tags.append("hf-jobs")
+    tag_lines = "\n".join(f"- {tag}" for tag in tags)
+
+    if zero_shot:
+        how = (
+            "The model was used **zero-shot**: it was given only the label names and has never "
+            "seen labelled examples of this task. Treat the labels as a first pass to review, "
+            "not as ground truth."
+        )
+    else:
+        how = (
+            "The model was fine-tuned for these tasks. Its model card reports the held-out "
+            "scores. They apply only where this data resembles the training data."
+        )
+
+    column_lines = []
+    for task in tasks:
+        kind = "list of labels" if task["multi_label"] else "one label"
+        column_lines.append(f"- `predicted_{task['name']}`: {kind} from {task['labels']}")
+        note = " (empty when no label was selected)" if task["multi_label"] else ""
+        column_lines.append(f"- `predicted_{task['name']}_confidence`: model confidence in [0, 1]{note}")
+    column_block = "\n".join(column_lines)
+
+    return f"""---
+tags:
+{tag_lines}
+---
+
+# {args.output_dataset.split("/")[-1]}
+
+[`{args.input_dataset}`](https://huggingface.co/datasets/{args.input_dataset}) (split `{args.split}`,
+{total} rows) with the `{args.text_column}` column classified by
+[`{args.model}`](https://huggingface.co/{args.model}), a [GLiNER2](https://github.com/fastino-ai/GLiNER2) model.
+
+{how}
+
+## Added columns
+
+{column_block}
+
+Texts were truncated to {args.max_text_chars} characters before classification.
+The confidence is not calibrated. Check it against a labelled sample before you use it as a filter.
+
+## Label distribution
+
+{label_counts_table(tasks, counts_by_task, total)}
+
+Classified {total} rows in {round(seconds)} seconds ({total / max(seconds, 1e-9):.0f} rows/s).
+
+## Reproduction
+
+{origin} with the [`classify-gliner2.py`]({SCRIPT_URL}) recipe from [uv-scripts](https://huggingface.co/uv-scripts). Run it yourself:
+
+```bash
+{build_reproduce_command(args)}
+```
+"""
+
+
+def main(args) -> None:
+    token = args.hf_token or os.environ.get("HF_TOKEN")
+    if not token:
+        sys.exit("No HF token. Pass --hf-token or run with --secrets HF_TOKEN.")
+    login(token=token)
+
+    # push_to_hub(private=True) leaves an existing repo's visibility alone, so check before the work.
+    api = HfApi(token=token)
+    output_exists = api.repo_exists(args.output_dataset, repo_type="dataset")
+    if not args.public and output_exists and not api.repo_info(args.output_dataset, repo_type="dataset").private:
+        sys.exit(
+            f"{args.output_dataset} already exists and is public. Pass --public to push there "
+            "anyway, or choose a new dataset name."
+        )
+
+    check_model_access(api, args.model)
+    tasks = resolve_tasks(args)
+    for task in tasks:
+        logger.info("Task '%s': %s", task["name"], task["labels"])
+
+    logger.info("Loading %s (split %s)", args.input_dataset, args.split)
+    dataset = load_dataset(args.input_dataset, args.dataset_config, split=args.split)
+    if args.text_column not in dataset.column_names:
+        sys.exit(f"Text column '{args.text_column}' not found. Columns are: {dataset.column_names}.")
+    for task in tasks:
+        for column in (f"predicted_{task['name']}", f"predicted_{task['name']}_confidence"):
+            if column in dataset.column_names:
+                sys.exit(f"The dataset already has a '{column}' column. Pass a different --task-name.")
+    if args.max_samples and len(dataset) > args.max_samples:
+        dataset = dataset.select(range(args.max_samples))
+    logger.info("Rows to classify: %d", len(dataset))
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    if device == "cpu":
+        logger.warning("No GPU found; classifying on CPU. Expect about 1-2 rows per second on cpu-basic.")
+    # from_pretrained(device=...) does not move the weights in gliner2 2.0.0; .to() does.
+    classifier = Classifier.from_pretrained(args.model).to(device=device).eval()
+    schema = build_schema(tasks)
+    config = ClassificationConfig(batch_size=args.batch_size)
+
+    counts_by_task = {task["name"]: Counter() for task in tasks}
+    empty_texts = 0
+
+    def classify_batch(batch: dict) -> dict:
+        nonlocal empty_texts
+        texts = []
+        for value in batch[args.text_column]:
+            text = "" if value is None else str(value)
+            if not text.strip():
+                empty_texts += 1
+                # The model needs some input; a missing text gets a prediction we then blank out.
+                text = "-"
+            texts.append(text[: args.max_text_chars])
+
+        results = classifier.batch_classify(texts, schema, config=config)
+
+        new_columns = {}
+        for task in tasks:
+            name = task["name"]
+            predictions = []
+            confidences = []
+            for value, result in zip(batch[args.text_column], results):
+                if value is None or not str(value).strip():
+                    predictions.append([] if task["multi_label"] else None)
+                    confidences.append(None)
+                    continue
+                if task["multi_label"]:
+                    labels = list(result.selected(name))
+                    predictions.append(labels)
+                    counts_by_task[name].update(labels or ["(none selected)"])
+                else:
+                    label = result.value(name)
+                    predictions.append(label)
+                    counts_by_task[name][label] += 1
+                confidence = result.confidence(name)
+                confidences.append(None if confidence is None else float(confidence))
+            new_columns[f"predicted_{name}"] = predictions
+            new_columns[f"predicted_{name}_confidence"] = confidences
+        return new_columns
+
+    # Declare the output types. Otherwise the first map batch sets them, and a batch where
+    # every confidence is None (no label selected, or no text) types the column as null and
+    # the next batch fails to write.
+    output_features = Features(dataset.features)
+    for task in tasks:
+        name = task["name"]
+        output_features[f"predicted_{name}"] = List(Value("string")) if task["multi_label"] else Value("string")
+        output_features[f"predicted_{name}_confidence"] = Value("float64")
+
+    started = time.time()
+    # One map batch holds several model batches, so progress is logged at a useful rate.
+    dataset = dataset.map(
+        classify_batch,
+        batched=True,
+        batch_size=args.batch_size * 8,
+        features=output_features,
+        load_from_cache_file=False,
+    )
+    seconds = time.time() - started
+    logger.info("Classified %d rows in %.0f seconds.", len(dataset), seconds)
+    if empty_texts:
+        logger.warning("%d rows had no text and were left unlabelled.", empty_texts)
+    for task in tasks:
+        logger.info("Task '%s' distribution: %s", task["name"], dict(counts_by_task[task["name"]].most_common(10)))
+
+    dataset.push_to_hub(args.output_dataset, private=not args.public)
+    card = build_card(args, tasks, counts_by_task, len(dataset), seconds, zero_shot=bool(args.labels))
+    DatasetCard(card).push_to_hub(args.output_dataset, repo_type="dataset")
+    logger.info("Pushed to https://huggingface.co/datasets/%s", args.output_dataset)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("input_dataset", help="Input dataset ID")
+    parser.add_argument("output_dataset", help="Output dataset ID (username/dataset-name)")
+    parser.add_argument("--model", default=DEFAULT_MODEL, help=f"GLiNER2 model: a base checkpoint for zero-shot, or a train-gliner2.py output (default: {DEFAULT_MODEL})")
+    parser.add_argument("--labels", nargs="+", help="Label names for zero-shot classification. Overrides the tasks recorded in the model repo.")
+    parser.add_argument("--task-name", default="label", help="Name of the --labels task; sets the output column names (default: label)")
+    parser.add_argument("--multi-label", action="store_true", help="With --labels: allow several labels, or none, per text")
+    parser.add_argument("--dataset-config", help="Dataset config name")
+    parser.add_argument("--text-column", default="text", help="Text column (default: text)")
+    parser.add_argument("--split", default="train", help="Split to classify (default: train)")
+    parser.add_argument("--max-samples", type=int, help="Classify only the first N rows")
+    parser.add_argument("--max-text-chars", type=int, default=2000, help="Truncate texts to this many characters (default: 2000)")
+    parser.add_argument("--batch-size", type=int, default=32, help="Model batch size (default: 32)")
+    parser.add_argument("--public", action="store_true", help="Make the output dataset public (default: private)")
+    parser.add_argument("--private", action="store_true", help="Accepted for older commands; private is now the default")
+    parser.add_argument("--hf-token", help="HF token (or set HF_TOKEN)")
+    args = parser.parse_args()
+    if args.public and args.private:
+        parser.error("Pass --public or --private, not both.")
+    return args
+
+
+if __name__ == "__main__":
+    main(parse_args())

train-gliner2.py

@@ -0,0 +1,1279 @@
+# /// script
+# requires-python = ">=3.11,<3.14"
+# dependencies = [
+#     "gliner2[train]==2.0.0",
+#     "protobuf",
+#     "sentencepiece",
+#     "datasets>=4.0.0,<6",
+#     "scikit-learn",
+#     "huggingface-hub",
+# ]
+#
+# [tool.hf-jobs]
+# flavor = "t4-small"
+# timeout = "1h"
+# secrets = ["HF_TOKEN"]
+# ///
+"""
+Fine-tune GLiNER2 into a text classifier — a small model (74M to 287M parameters, depending on
+the base checkpoint) that already works zero-shot.
+
+GLiNER2 reads the label names as part of its input, so it classifies with no training at all.
+This script measures that zero-shot score first, fine-tunes on your labels, then measures
+again on the same held-out rows. The model card reports both numbers, so you can see what the
+labels bought you. One model can answer several questions at once: pass --label-column more
+than once and each column becomes a task.
+
+Run on HF Jobs (t4-small is enough for a few thousand short texts):
+
+    hf jobs uv run --flavor t4-small --timeout 1h --secrets HF_TOKEN \\
+        https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-gliner2.py \\
+        biglam/blbooksgenre username/gliner2-blbooks-genre \\
+        --dataset-config title_genre_classifiction --text-column title
+
+The output model repo is PRIVATE unless you pass --public.
+
+The [tool.hf-jobs] header above gives `hf` CLI 1.32+ the defaults (t4-small, a 1 hour timeout,
+the HF_TOKEN secret), so there `hf jobs uv run <script> <args>` is enough. Flags always win:
+pass `--flavor a10g-small` for more memory and bf16, or `--timeout 3h` for a big run. Older CLIs
+ignore the header, and Jobs then stops after 30 minutes; the model is pushed at the end. Pass
+`--timeout` explicitly whenever you are not sure which CLI will launch the job.
+
+Local files instead of a Hub dataset (for example files in a bucket mounted at /bucket):
+
+    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 \\
+        --no-push --output-dir /bucket/runs/gliner2 \\
+        --export-predictions /bucket/runs/gliner2/predictions
+
+- --train-file / --eval-file NAME=PATH read JSON Lines files (repeat --eval-file for several
+  eval splits). Every eval file is scored in full, in file order, with no cap.
+- --labels-file fixes the label set, and its order, for training, zero-shot and evaluation.
+  Every label in the data must be in it. Needs exactly one --label-column.
+- --export-predictions DIR writes DIR/{base,finetuned}-{split}/predictions.jsonl, one line per
+  eval row: {"row": i, "probabilities": {task: {label: p}}, "logits": {task: {label: logit}}},
+  with every label present. "row" is the row's position in its eval file (or split).
+- --no-push keeps the model in --output-dir/final and uploads nothing. A run manifest (all
+  arguments, the label-augmentation config and package versions) is written to --output-dir,
+  the export directory and the model folder.
+- --label-augmentation off turns off gliner2's synthetic label names and label dropping during
+  training, so the model always sees the real, complete label set (see resolve_sampling_config).
+
+Metrics match `train-classifier.py` and `train-setfit.py` (accuracy + macro F1 on a held-out
+split), so the three are directly comparable at equal eval settings.
+
+NOTE: the output is a GLiNER2 checkpoint. It loads with
+`gliner2.classification.Classifier.from_pretrained(repo)`, NOT `AutoModelForSequenceClassification`.
+Apply it to a whole dataset with the sibling `classify-gliner2.py`.
+"""
+
+import argparse
+import dataclasses
+import importlib.metadata
+import json
+import logging
+import os
+import shlex
+import sys
+import time
+from collections import Counter
+
+# tqdm reads TQDM_DISABLE when it is imported, so this must be set before any third-party import
+# pulls tqdm in. Jobs logs have no TTY, so progress bars arrive as hundreds of near-identical lines.
+# (The gliner2 trainer passes disable=False to its own bar, so its training bar still prints.)
+os.environ.setdefault("TQDM_DISABLE", "1")
+
+import datasets
+import torch
+from datasets import ClassLabel, Dataset, load_dataset
+from gliner2 import AutoExtractor
+from gliner2.classification import (
+    ClassificationConfig,
+    ClassificationSchema,
+    Classifier,
+)
+from gliner2.processor import SamplingConfig
+from gliner2.training.data import Classification, InputExample
+from gliner2.training.trainer import ExtractorTrainer, TrainingConfig
+from huggingface_hub import HfApi, login
+from huggingface_hub.utils import disable_progress_bars
+from sklearn.metrics import accuracy_score, f1_score
+from sklearn.preprocessing import MultiLabelBinarizer
+
+
+def configure_logging() -> logging.Logger:
+    """Keep Jobs logs readable: root at WARNING, only this script's logger at INFO."""
+    logging.basicConfig(
+        level=logging.WARNING,
+        format="%(asctime)s | %(levelname)s | %(message)s",
+        datefmt="%H:%M:%S",
+    )
+    for noisy in ("httpx", "urllib3", "filelock", "huggingface_hub"):
+        logging.getLogger(noisy).setLevel(logging.WARNING)
+    disable_progress_bars()
+    if hasattr(datasets, "disable_progress_bars"):
+        datasets.disable_progress_bars()
+
+    script_logger = logging.getLogger("train-gliner2")
+    script_logger.setLevel(logging.INFO)
+    return script_logger
+
+
+logger = configure_logging()
+
+SCRIPT_URL = (
+    "https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-gliner2.py"
+)
+DEFAULT_BASE_MODEL = "fastino/gliner2.5-multi-v1"
+
+# The file this script adds to the model repo. It records the tasks and label names the model
+# was trained on, so classify-gliner2.py can rebuild the same schema without any flags.
+SCHEMA_FILENAME = "classification_schema.json"
+
+# Written next to the model, in --output-dir and in the export directory: the arguments,
+# label-augmentation config and package versions of the run.
+MANIFEST_FILENAME = "run_manifest.json"
+
+# A column added to every eval split before any row is dropped, so exported predictions can
+# name each row's position in the original file or split.
+ROW_COLUMN = "__row__"
+
+# After this many out-of-memory training steps, stop and retry smaller. See StopOnRepeatedOOM.
+MAX_OOM_STEPS = 5
+
+# GLiNER2 puts label names into the model prompt verbatim. Its inference schema rejects these
+# strings, but its trainer accepts them — so a label like "manuscripts (documents)" trains
+# without complaint and then cannot be predicted. We clean labels once, before either side.
+RESERVED_MARKERS = ("[P]", "[L]", "[C]", "[E]", "[R]", "[DESCRIPTION]", "[EXAMPLE]", "[OUTPUT]")
+
+
+def clean_label(label: str) -> str:
+    """Make one label name safe for the GLiNER2 prompt."""
+    cleaned = label.replace("(", " ").replace(")", " ")
+    cleaned = " ".join(cleaned.split())
+    if not cleaned:
+        sys.exit(f"Label {label!r} is empty after cleaning. Rename it in the dataset.")
+    for marker in RESERVED_MARKERS:
+        if marker in cleaned:
+            sys.exit(
+                f"Label {label!r} contains {marker!r}, which GLiNER2 reserves for its prompt. "
+                "Rename it in the dataset."
+            )
+    return cleaned
+
+
+def is_multi_label_column(dataset: Dataset, column: str) -> bool:
+    """A list-valued column is a multi-label task."""
+    feature = dataset.features.get(column)
+    # A Sequence/list feature carries an inner `feature`.
+    return getattr(feature, "feature", None) is not None
+
+
+def label_feature(dataset: Dataset, column: str):
+    """Return the ClassLabel that types this column, or None if the labels are plain values."""
+    feature = dataset.features.get(column)
+    inner = getattr(feature, "feature", None)
+    if isinstance(feature, ClassLabel):
+        return feature
+    if isinstance(inner, ClassLabel):
+        return inner
+    return None
+
+
+def decode_label(value, class_label) -> str:
+    """Turn one raw label value into its cleaned name."""
+    if class_label is not None:
+        return clean_label(class_label.int2str(int(value)))
+    return clean_label(str(value))
+
+
+def decode_column(dataset: Dataset, column: str) -> list:
+    """Return the gold labels for a column: a name per row, or a sorted list of names per row.
+
+    Decoding uses this split's OWN feature. A named --eval-split can order its ClassLabel
+    differently from the train split, and decoding through the train names would silently
+    score against the wrong table.
+    """
+    class_label = label_feature(dataset, column)
+    multi = is_multi_label_column(dataset, column)
+    decoded = []
+    for value in dataset[column]:
+        if multi:
+            names = {decode_label(item, class_label) for item in (value or [])}
+            decoded.append(sorted(names))
+        else:
+            decoded.append(decode_label(value, class_label))
+    return decoded
+
+
+def drop_unlabelled_rows(dataset: Dataset, columns: list, text_column: str, split_name: str) -> Dataset:
+    """Remove rows with no text, or with a missing or blank single-label value.
+
+    An empty LIST in a multi-label column is kept: "none of these labels" is a valid answer,
+    and the model needs to see it to learn when to select nothing.
+    """
+    # In a ClassLabel column, -1 is the Hub convention for "no label" (common in test splits).
+    typed_columns = [column for column in columns if isinstance(dataset.features.get(column), ClassLabel)]
+
+    def is_usable(example) -> bool:
+        text = example[text_column]
+        if text is None or not str(text).strip():
+            return False
+        for column in columns:
+            value = example[column]
+            if isinstance(value, list):
+                continue
+            if value is None:
+                return False
+            if isinstance(value, str) and not value.strip():
+                return False
+            if column in typed_columns and value < 0:
+                return False
+        return True
+
+    kept = dataset.filter(is_usable)
+    dropped = len(dataset) - len(kept)
+    if dropped:
+        logger.warning(
+            "Dropped %d %s rows with no text or a missing label (%d remain).",
+            dropped, split_name, len(kept),
+        )
+    if len(kept) == 0:
+        sys.exit(
+            f"No '{split_name}' rows are left after dropping rows with no text or a missing label "
+            f"({len(dataset)} before). Check --text-column and --label-column, or pick another split."
+        )
+    return kept
+
+
+def pick_eval_split(dataset_id, config, train_split, requested):
+    """Resolve which split to evaluate on, matching train-classifier.py's precedence."""
+    if requested:
+        if requested == train_split:
+            sys.exit(
+                f"--eval-split and --train-split are both '{requested}'. Evaluating on the "
+                "training data would report a meaningless score."
+            )
+        return requested
+
+    available = datasets.get_dataset_split_names(dataset_id, config)
+    for candidate in ("validation", "test"):
+        if candidate in available and candidate != train_split:
+            logger.info("Using the '%s' split for evaluation.", candidate)
+            return candidate
+    return None
+
+
+def split_train_eval(args, eval_split, first_label_column):
+    """Load the train split, and either the named eval split or a carve-out of train."""
+    train_data = load_dataset(args.input_dataset, args.dataset_config, split=args.train_split)
+
+    if eval_split:
+        eval_data = load_dataset(args.input_dataset, args.dataset_config, split=eval_split)
+        return train_data, eval_data
+
+    logger.info("No eval split found; carving %.0f%% off the train split.", args.eval_fraction * 100)
+    # Stratify when the first label column is typed, so a rare class cannot vanish from a small carve.
+    feature = train_data.features.get(first_label_column)
+    stratify = first_label_column if isinstance(feature, ClassLabel) else None
+    try:
+        parts = train_data.train_test_split(
+            test_size=args.eval_fraction, seed=args.seed, stratify_by_column=stratify
+        )
+    except ValueError as error:
+        # Stratification needs at least two members of every class, so it fails on exactly the
+        # singleton classes it is meant to protect. An unstratified split is worse but usable.
+        logger.warning("Could not stratify the carve-out (%s). Using an unstratified split.", error)
+        parts = train_data.train_test_split(test_size=args.eval_fraction, seed=args.seed)
+    return parts["train"], parts["test"]
+
+
+def load_json_file(path: str) -> Dataset:
+    """Load one JSON Lines file (a local path, or a path in a mounted bucket) as a Dataset."""
+    if not os.path.exists(path):
+        sys.exit(f"File not found: {path}")
+    return load_dataset("json", data_files=path, split="train")
+
+
+def load_splits(args):
+    """Return the train split, the eval splits as {name: Dataset}, and whether eval was carved out.
+
+    With --train-file, every split comes from a local file and each --eval-file is its own
+    eval split. Otherwise one eval split comes from the Hub dataset, as before.
+    """
+    if args.train_file:
+        logger.info("Loading the train file %s", args.train_file)
+        train_data = load_json_file(args.train_file)
+        eval_sets = {}
+        for name, path in args.eval_files.items():
+            logger.info("Loading eval split '%s' from %s", name, path)
+            eval_sets[name] = load_json_file(path)
+        return train_data, eval_sets, False
+
+    logger.info("Loading %s", args.input_dataset)
+    eval_split = pick_eval_split(args.input_dataset, args.dataset_config, args.train_split, args.eval_split)
+    train_data, eval_data = split_train_eval(args, eval_split, args.label_column[0])
+    carved_out = eval_split is None
+    return train_data, {eval_split or "eval": eval_data}, carved_out
+
+
+def add_row_numbers(dataset: Dataset) -> Dataset:
+    """Record each row's position, so it survives dropped rows and is exported with predictions."""
+    if ROW_COLUMN in dataset.column_names:
+        sys.exit(f"The data already has a column named '{ROW_COLUMN}'. Rename it.")
+    return dataset.add_column(ROW_COLUMN, list(range(len(dataset))))
+
+
+def load_labels_file(path: str) -> list:
+    """Read the fixed label set: a JSON list, or one label per line."""
+    if not os.path.exists(path):
+        sys.exit(f"Labels file not found: {path}")
+    with open(path) as handle:
+        content = handle.read()
+    if content.lstrip().startswith("["):
+        labels = json.loads(content)
+    else:
+        labels = [line.strip() for line in content.splitlines() if line.strip()]
+    if not labels:
+        sys.exit(f"Labels file {path} has no labels.")
+    return [str(label) for label in labels]
+
+
+def check_labels_in_set(tasks: list, gold_by_split: dict) -> None:
+    """With --labels-file, every gold label in every split must be one of the fixed labels."""
+    for task in tasks:
+        allowed = set(task["labels"])
+        for split_name, gold_by_task in gold_by_split.items():
+            unknown = Counter()
+            for value in gold_by_task[task["name"]]:
+                row_labels = value if task["multi_label"] else [value]
+                for label in row_labels:
+                    if label not in allowed:
+                        unknown[label] += 1
+            if unknown:
+                sys.exit(
+                    f"Task '{task['name']}', split '{split_name}': labels that are not in "
+                    f"--labels-file: {dict(unknown.most_common(20))}"
+                )
+
+
+def prepare_texts(dataset: Dataset, text_column: str, max_text_chars: int, split_name: str) -> list:
+    """Return the text for each row, truncated to max_text_chars."""
+    texts = []
+    truncated = 0
+    for value in dataset[text_column]:
+        text = str(value)
+        if len(text) > max_text_chars:
+            text = text[:max_text_chars]
+            truncated += 1
+        texts.append(text)
+    if truncated:
+        logger.warning(
+            "Truncated %d of %d %s texts to %d characters. Raise --max-text-chars if the label "
+            "depends on text past that point.",
+            truncated, len(texts), split_name, max_text_chars,
+        )
+    return texts
+
+
+def build_tasks(train_data: Dataset, label_columns: list, task_names: list, fixed_labels=None) -> list:
+    """Describe one classification task per label column.
+
+    GLiNER2 reads the task name as part of its prompt, next to the label names, so --task-name
+    lets you call the task "genre" rather than "label". Do not expect much from it: on BL book
+    titles the zero-shot accuracy was 0.79 with "label" and 0.78 with "genre".
+
+    The label list comes from the TRAIN split. A label that appears only in the eval split
+    cannot be predicted, and evaluate() counts it as an error rather than hiding it.
+    With --labels-file (fixed_labels), the label list is that file, in its order, instead.
+    """
+    tasks = []
+    for column, task_name in zip(label_columns, task_names):
+        multi = is_multi_label_column(train_data, column)
+        class_label = label_feature(train_data, column)
+        if fixed_labels is not None:
+            labels = [clean_label(name) for name in fixed_labels]
+        elif class_label is not None:
+            labels = [clean_label(name) for name in class_label.names]
+        else:
+            seen = set()
+            for value in decode_column(train_data, column):
+                if multi:
+                    seen.update(value)
+                else:
+                    seen.add(value)
+            labels = sorted(seen)
+
+        if fixed_labels is not None:
+            raw_names = list(fixed_labels)
+        elif class_label is not None:
+            raw_names = list(class_label.names)
+        else:
+            raw_names = []
+            for value in train_data[column]:
+                raw_names.extend((value or []) if multi else [value])
+            raw_names = sorted({str(name) for name in raw_names})
+        renamed = {name: clean_label(name) for name in raw_names if clean_label(name) != name}
+        if renamed:
+            logger.warning(
+                "Column '%s': GLiNER2 does not allow brackets in label names, so the model will "
+                "predict the cleaned names: %s", column, renamed,
+            )
+
+        # Check raw -> cleaned before trusting `labels`: for a plain string column the labels were
+        # cleaned on the way into a set, so two different raw labels could already have merged.
+        raw_by_cleaned = {}
+        for name in raw_names:
+            raw_by_cleaned.setdefault(clean_label(name), []).append(name)
+        merged = {cleaned: raws for cleaned, raws in raw_by_cleaned.items() if len(raws) > 1}
+        if merged:
+            sys.exit(
+                f"Column '{column}': different labels become identical after cleaning "
+                f"(brackets are removed): {merged}. Rename them in the dataset."
+            )
+        if len(set(labels)) != len(labels):
+            sys.exit(f"Column '{column}': two labels are identical after cleaning: {labels}")
+        if len(labels) < 2:
+            sys.exit(f"Column '{column}' has fewer than two labels: {labels}")
+        if all(label.lstrip("-").isdigit() for label in labels):
+            logger.warning(
+                "Column '%s' has numeric labels %s. GLiNER2 reads label NAMES, so the zero-shot "
+                "score will be meaningless and fine-tuning starts from nothing. A ClassLabel or "
+                "string column with real names will do better.",
+                column, labels[:6],
+            )
+        tasks.append({"name": clean_label(task_name), "column": column, "labels": labels, "multi_label": multi})
+        logger.info(
+            "Task '%s' (column '%s'): %d labels, %s.",
+            task_name, column, len(labels), "multi-label" if multi else "single-label",
+        )
+    return tasks
+
+
+def build_training_examples(texts: list, gold_by_task: dict, tasks: list) -> list:
+    examples = []
+    for row, text in enumerate(texts):
+        classifications = []
+        for task in tasks:
+            classifications.append(
+                Classification(
+                    task=task["name"],
+                    labels=task["labels"],
+                    true_label=gold_by_task[task["name"]][row],
+                    # Only auto-inferred when a row has 2+ true labels, so state it.
+                    multi_label=task["multi_label"],
+                )
+            )
+        examples.append(InputExample(text=text, classifications=classifications))
+    return examples
+
+
+def build_schema(tasks: list) -> ClassificationSchema:
+    schema = ClassificationSchema()
+    for task in tasks:
+        if task["multi_label"]:
+            schema.multi(task["name"], task["labels"])
+        else:
+            schema.single(task["name"], task["labels"])
+    return schema
+
+
+class TrainingOutOfMemory(Exception):
+    """Raised when the GPU keeps running out of memory during training."""
+
+
+class StopOnRepeatedOOM(logging.Handler):
+    """Abort training when the gliner2 trainer keeps hitting CUDA out-of-memory.
+
+    The gliner2 trainer catches an OOM, skips that batch, logs a warning and carries on. On a
+    GPU that is too small for the batch, EVERY step is skipped: the job runs to the end, looks
+    healthy, and produces a model that never trained. (Seen on t4-small with 56 labels at batch
+    size 16: 1,006 of 1,020 steps skipped.) The trainer has no option to raise instead, so this
+    handler watches its log. An exception raised in emit() propagates out of the trainer's own
+    logger.warning() call, which stops trainer.train().
+    """
+
+    def __init__(self, limit: int):
+        super().__init__(level=logging.WARNING)
+        self.limit = limit
+        self.oom_steps = 0
+
+    def emit(self, record: logging.LogRecord) -> None:
+        if "OOM at step" not in record.getMessage():
+            return
+        self.oom_steps += 1
+        if self.oom_steps >= self.limit:
+            raise TrainingOutOfMemory()
+
+
+def resolve_precision(requested: str) -> str:
+    """Pick the training precision: bf16 where the GPU does it in hardware, else fp32.
+
+    gliner2 itself defaults the 2.5 models to bf16. torch.cuda.is_bf16_supported() also says yes
+    on a T4, where bf16 is emulated and slow, so this checks the compute capability instead
+    (8.0+ = Ampere and newer: A10G, L4, A100, ...). fp16 is not offered: it overflowed on T4.
+    """
+    if requested != "auto":
+        return requested
+    if torch.cuda.is_available() and torch.cuda.get_device_capability()[0] >= 8:
+        return "bf16"
+    return "fp32"
+
+
+def resolve_sampling_config(mode: str) -> SamplingConfig:
+    """Pick the gliner2 training-time label augmentation.
+
+    "upstream" is gliner2 2.0.0's default SamplingConfig. For each classification task in each
+    training row, it replaces the real label names with "label 1", "label 2", ... half of the
+    time (synthetic_label_prob=0.5), and drops a random share of up to half of the labels
+    (remove_classification_label_prob=0.5; the true label is then put back only half of the
+    time). That teaches a general zero-shot model to cope with unseen label sets.
+
+    "off" is for a FIXED label set that is always scored in full: the model then always trains
+    on the real names and the complete label set, the same prompt it gets at inference.
+    Label-order shuffling stays on, and so does task-order shuffling: neither changes which
+    labels the model sees, and both stop it tying a label to a position in the prompt.
+    The other options only touch entities, relations and JSON structures, or label
+    descriptions and examples, which this script does not use.
+    """
+    if mode == "upstream":
+        return SamplingConfig()
+    return SamplingConfig(synthetic_label_prob=0.0, remove_classification_label_prob=0.0)
+
+
+def package_versions() -> dict:
+    versions = {}
+    for package in ("gliner2", "torch", "transformers", "datasets", "huggingface-hub"):
+        try:
+            versions[package] = importlib.metadata.version(package)
+        except importlib.metadata.PackageNotFoundError:
+            versions[package] = None
+    return versions
+
+
+def build_manifest(args, sampling_config: SamplingConfig, precision: str) -> dict:
+    """Everything needed to tell two runs apart. The HF token is left out."""
+    settings = {key: value for key, value in vars(args).items() if key != "hf_token"}
+    return {
+        "script": SCRIPT_URL,
+        "args": settings,
+        "label_augmentation": args.label_augmentation,
+        "sampling_config": dataclasses.asdict(sampling_config),
+        "precision": precision,
+        "device": torch.cuda.get_device_name(0) if torch.cuda.is_available() else "cpu",
+        "job_id": os.environ.get("JOB_ID"),
+        "versions": package_versions(),
+    }
+
+
+def write_manifest(manifest: dict, directories: list) -> None:
+    for directory in directories:
+        os.makedirs(directory, exist_ok=True)
+        path = os.path.join(directory, MANIFEST_FILENAME)
+        with open(path, "w") as handle:
+            json.dump(manifest, handle, indent=2)
+        logger.info("Wrote %s", path)
+
+
+def train_with_batch_fallback(args, examples: list, precision: str, sampling_config: SamplingConfig) -> int:
+    """Train, and if the GPU runs out of memory, restart the script at a quarter of the batch size.
+
+    Gradient accumulation grows by the same factor, so the effective batch size (and the
+    number of optimizer steps) stays the same: the fallback costs time, not comparability.
+
+    The restart is a whole new process (os.execv). Retrying inside this process was tried and
+    does not work: after a failed run the gliner2 trainer's model and optimizer state stay on
+    the GPU (about 4.6 GB per attempt), so each retry starts with less memory than the last.
+    A new process gets a clean GPU. It parses the new --batch-size / --grad-accum itself, so
+    the model card's reproduce command describes the run that produced the model. The restart
+    also repeats the zero-shot scoring; that gives the same number and takes under a minute.
+
+    Returns the number of training steps that were skipped for lack of memory.
+    """
+    model = AutoExtractor.from_pretrained(args.base_model)
+    # The trainer uses model.processor, and the processor reads sampling_config for every
+    # training row, so setting it here is what changes the training prompts.
+    model.processor.sampling_config = sampling_config
+    logger.info(
+        "Label augmentation '%s': %s",
+        args.label_augmentation, json.dumps(dataclasses.asdict(model.processor.sampling_config)),
+    )
+    config = TrainingConfig(
+        output_dir=args.output_dir,
+        num_epochs=args.epochs,
+        batch_size=args.batch_size,
+        gradient_accumulation_steps=args.grad_accum,
+        encoder_lr=args.encoder_lr,
+        task_lr=args.task_lr,
+        seed=args.seed,
+        # We score the held-out split ourselves, before and after, with the same code.
+        eval_strategy="no",
+        fp16=False,
+        bf16=(precision == "bf16"),
+        logging_steps=20,
+    )
+    oom_guard = StopOnRepeatedOOM(limit=MAX_OOM_STEPS)
+    logging.getLogger("gliner2.training.trainer").addHandler(oom_guard)
+    try:
+        result = ExtractorTrainer(model, config).train(train_data=examples)
+        # The trainer skips a batch that runs out of memory. On a short run every batch can be
+        # skipped without reaching MAX_OOM_STEPS, which would push an untrained model.
+        updates = result.get("total_steps") if isinstance(result, dict) else None
+        if updates != 0:
+            return oom_guard.oom_steps
+        if oom_guard.oom_steps == 0:
+            sys.exit("Stopped: training finished without a single optimizer update, so nothing was pushed.")
+        logger.warning("No optimizer update succeeded: every batch ran out of memory.")
+    except (TrainingOutOfMemory, torch.cuda.OutOfMemoryError):
+        # gliner2 catches out-of-memory in the forward and backward pass, but not in the
+        # optimizer step (for example while allocating optimizer state), so catch that here too.
+        pass
+
+    if args.batch_size == 1:
+        sys.exit(
+            "Stopped: the GPU ran out of memory even at batch size 1, so nothing was pushed. "
+            "Memory grows with number of labels x text length. Lower --max-text-chars, or use a "
+            "GPU with more memory (`--flavor a10g-small` has 24 GB, `--flavor a100-large` 80 GB)."
+        )
+    smaller = max(1, args.batch_size // 4)
+    grad_accum = args.grad_accum * (args.batch_size // smaller)
+    on_t4 = "T4" in torch.cuda.get_device_name(0)
+    logger.warning(
+        "The GPU ran out of memory at batch size %d. Restarting at batch size %d with %d gradient "
+        "accumulation steps (same effective batch).%s",
+        args.batch_size, smaller, grad_accum,
+        " `--flavor a10g-small` (24 GB) would be faster." if on_t4 else "",
+    )
+    sys.stdout.flush()
+    sys.stderr.flush()
+    # argparse keeps the LAST value of a repeated flag, so appending these overrides the originals.
+    os.execv(
+        sys.executable,
+        [sys.executable, *sys.argv, "--batch-size", str(smaller), "--grad-accum", str(grad_accum)],
+    )
+
+
+def score_task(task: dict, gold: list, results: list) -> dict:
+    """Accuracy-style metrics for one task, from decoded results."""
+    name = task["name"]
+    if task["multi_label"]:
+        predicted = [sorted(result.selected(name)) for result in results]
+        # Labels seen only in eval still count: the binarizer covers the union.
+        all_labels = sorted(set(task["labels"]) | {label for row in gold for label in row})
+        binarizer = MultiLabelBinarizer(classes=all_labels)
+        gold_matrix = binarizer.fit_transform(gold)
+        predicted_matrix = binarizer.transform(predicted)
+        return {
+            "f1_micro": round(f1_score(gold_matrix, predicted_matrix, average="micro", zero_division=0), 4),
+            "f1_macro": round(f1_score(gold_matrix, predicted_matrix, average="macro", zero_division=0), 4),
+            "exact_match": round(accuracy_score(gold_matrix, predicted_matrix), 4),
+        }
+    predicted = [result.value(name) for result in results]
+    # The majority-class rate is the floor any classifier must clear to be worth having.
+    majority = Counter(gold).most_common(1)[0][1] / len(gold)
+    return {
+        "accuracy": round(accuracy_score(gold, predicted), 4),
+        "f1_macro": round(f1_score(gold, predicted, average="macro", zero_division=0), 4),
+        "majority_baseline": round(majority, 4),
+    }
+
+
+def write_predictions(path: str, rows: list, scores: list, results: list, tasks: list) -> None:
+    """One JSON line per eval row, in order, with the probability and raw logit of EVERY label.
+
+    Logits are the model's per-label scores before any activation (ClassificationScores.tasks).
+    Probabilities are gliner2's own: softmax over the labels for a single-label task, a
+    sigmoid per label for a multi-label task.
+    """
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w") as handle:
+        for row, score, result in zip(rows, scores, results):
+            record = {"row": row, "probabilities": {}, "logits": {}}
+            for task in tasks:
+                name = task["name"]
+                probabilities = result.probabilities(name)
+                logits = score.tasks[name]
+                record["probabilities"][name] = {label: float(probabilities[label]) for label in task["labels"]}
+                record["logits"][name] = {label: float(logits[label]) for label in task["labels"]}
+            handle.write(json.dumps(record) + "\n")
+    logger.info("Wrote %d predictions to %s", len(rows), path)
+
+
+def evaluate(model_path: str, eval_sets: dict, tasks: list, batch_size: int, export_dir=None, export_name="") -> dict:
+    """Load a GLiNER2 checkpoint once, predict every task on every eval split, and score each task.
+
+    eval_sets maps a split name to {"texts", "gold", "rows"}. With export_dir, each split's
+    predictions are also written to export_dir/<export_name>-<split>/predictions.jsonl.
+    Returns {split name: metrics}.
+    """
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    # from_pretrained(device=...) does not move the weights in gliner2 2.0.0; .to() does.
+    classifier = Classifier.from_pretrained(model_path).to(device=device).eval()
+    parameters = sum(parameter.numel() for parameter in classifier.model.parameters())
+    schema = build_schema(tasks)
+    config = ClassificationConfig(batch_size=batch_size)
+
+    metrics_by_split = {}
+    for split_name, eval_set in eval_sets.items():
+        started = time.time()
+        # batch_classify() is batch_score() + decode(); calling both here keeps the raw logits.
+        scores = classifier.batch_score(eval_set["texts"], schema, config=config)
+        results = [classifier.decode(score, schema, config=config) for score in scores]
+        elapsed = time.time() - started
+
+        metrics = {}
+        for task in tasks:
+            metrics[task["name"]] = score_task(task, eval_set["gold"][task["name"]], results)
+        metrics_by_split[split_name] = {
+            "tasks": metrics,
+            "eval_examples": len(eval_set["texts"]),
+            "predict_seconds": round(elapsed, 1),
+            "parameters": parameters,
+        }
+
+        if export_dir:
+            path = os.path.join(export_dir, f"{export_name}-{split_name}", "predictions.jsonl")
+            write_predictions(path, eval_set["rows"], scores, results, tasks)
+
+    # Release the GPU before training starts.
+    del classifier
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+    return metrics_by_split
+
+
+# The smallest Jobs flavor for each GPU, keyed by a fragment of the GPU's name. "L40" comes
+# before "L4" because the first match wins.
+GPU_NAME_TO_FLAVOR = {"T4": "t4-small", "A10G": "a10g-small", "L40": "l40sx1", "L4": "l4x1", "A100": "a100-large"}
+
+
+def jobs_flavor() -> str:
+    """Return the Jobs hardware flavor, or "" when it is not known.
+
+    The docs say ACCELERATOR holds the flavor ("a10g-small"). On the t4-small and a10g-small
+    jobs that tested this script it held a bare "gpu", which is not a valid --flavor. So use
+    ACCELERATOR when it looks like a flavor, and otherwise name the smallest flavor that has
+    this GPU. A larger flavor of the same GPU reproduces the same result.
+    """
+    hardware = os.environ.get("ACCELERATOR") or ""
+    looks_like_flavor = "-" in hardware or any(character.isdigit() for character in hardware)
+    if looks_like_flavor:
+        return hardware
+    if not torch.cuda.is_available():
+        return ""
+    gpu_name = torch.cuda.get_device_name(0)
+    for fragment, flavor in GPU_NAME_TO_FLAVOR.items():
+        if fragment in gpu_name:
+            return flavor
+    return ""
+
+
+def build_reproduce_command(args) -> str:
+    """Rebuild the exact invocation, so the card's command produces the card's model."""
+    flavor = jobs_flavor() or "t4-small"
+    # The timeout is the [tool.hf-jobs] default, spelled out because older CLIs ignore the header.
+    parts = [f"hf jobs uv run --flavor {flavor} --timeout 1h --secrets HF_TOKEN \\"]
+    if args.train_file:
+        # Local files: the job needs them mounted at the same paths.
+        parts.insert(0, "# Mount the data files at the paths below, e.g. -v hf://buckets/<owner>/<bucket>:/bucket")
+    positionals = [shlex.quote(value) for value in (args.input_dataset, args.output_repo) if value]
+    if positionals:
+        parts.append(f"  {SCRIPT_URL} \\")
+        parts.append("  " + " ".join(positionals))
+    else:
+        parts.append(f"  {SCRIPT_URL}")
+    flags = []
+    if args.train_file:
+        flags.append(f"--train-file {shlex.quote(args.train_file)}")
+        for name, path in args.eval_files.items():
+            flags.append(f"--eval-file {shlex.quote(f'{name}={path}')}")
+    if args.labels_file:
+        flags.append(f"--labels-file {shlex.quote(args.labels_file)}")
+    if args.dataset_config:
+        flags.append(f"--dataset-config {shlex.quote(args.dataset_config)}")
+    if args.text_column != "text":
+        flags.append(f"--text-column {shlex.quote(args.text_column)}")
+    if args.label_column != ["label"]:
+        for column in args.label_column:
+            flags.append(f"--label-column {shlex.quote(column)}")
+    if args.task_name != args.label_column:
+        for task_name in args.task_name:
+            flags.append(f"--task-name {shlex.quote(task_name)}")
+    if args.base_model != DEFAULT_BASE_MODEL:
+        flags.append(f"--base-model {shlex.quote(args.base_model)}")
+    if args.train_split != "train":
+        flags.append(f"--train-split {shlex.quote(args.train_split)}")
+    if args.eval_split:
+        flags.append(f"--eval-split {shlex.quote(args.eval_split)}")
+    # These change which rows are trained on or scored, so a command without them reproduces
+    # a different model and a different number.
+    if args.eval_fraction != 0.1:
+        flags.append(f"--eval-fraction {args.eval_fraction}")
+    if args.max_train_samples:
+        flags.append(f"--max-train-samples {args.max_train_samples}")
+    if args.max_eval_samples != 2000:
+        flags.append(f"--max-eval-samples {args.max_eval_samples}")
+    if args.max_text_chars != 2000:
+        flags.append(f"--max-text-chars {args.max_text_chars}")
+    if args.epochs != 5:
+        flags.append(f"--epochs {args.epochs}")
+    if args.batch_size != 16:
+        flags.append(f"--batch-size {args.batch_size}")
+    if args.grad_accum != 1:
+        flags.append(f"--grad-accum {args.grad_accum}")
+    if args.encoder_lr != 1e-5:
+        flags.append(f"--encoder-lr {args.encoder_lr}")
+    if args.task_lr != 5e-4:
+        flags.append(f"--task-lr {args.task_lr}")
+    if args.seed != 42:
+        flags.append(f"--seed {args.seed}")
+    if args.precision != "auto":
+        flags.append(f"--precision {args.precision}")
+    if args.skip_zero_shot:
+        flags.append("--skip-zero-shot")
+    if args.label_augmentation != "upstream":
+        flags.append(f"--label-augmentation {args.label_augmentation}")
+    if args.no_push:
+        flags.append(f"--no-push --output-dir {shlex.quote(args.output_dir)}")
+    if args.export_predictions:
+        flags.append(f"--export-predictions {shlex.quote(args.export_predictions)}")
+    if args.public:
+        flags.append("--public")
+
+    if flags:
+        parts[-1] += " \\"
+        parts.append("  " + " ".join(flags))
+    return "\n".join(parts)
+
+
+def results_table(tasks: list, zero_shot, fine_tuned) -> str:
+    """One row per task and metric, with the zero-shot score next to the fine-tuned one."""
+    lines = ["| Task | Metric | Zero-shot | Fine-tuned |", "|---|---|---|---|"]
+    for task in tasks:
+        name = task["name"]
+        for metric, value in fine_tuned["tasks"][name].items():
+            if metric == "majority_baseline":
+                continue
+            before = zero_shot["tasks"][name][metric] if zero_shot else "not run"
+            lines.append(f"| `{name}` | {metric} | {before} | **{value}** |")
+    return "\n".join(lines)
+
+
+def build_card(args, tasks, zero_shot, fine_tuned, train_size, train_seconds, carved_out, oom_steps) -> str:
+    """Model card following the uv-scripts conventions (org credit, Jobs claim gated on JOB_ID)."""
+    on_jobs = os.environ.get("JOB_ID") is not None
+    hardware = jobs_flavor()
+    if on_jobs:
+        provenance = "Produced on [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs)"
+        if hardware:
+            provenance += f" (`{hardware}`)"
+    else:
+        provenance = "Produced"
+    provenance += " with [`uv-scripts/classification`](https://huggingface.co/datasets/uv-scripts/classification)."
+
+    tags = ["gliner2", "text-classification", "uv-script"]
+    if on_jobs:
+        tags.append("hf-jobs")
+    tag_lines = "\n".join(f"- {tag}" for tag in tags)
+
+    caveats = []
+    if carved_out:
+        caveats.append(
+            f"**No held-out split existed, so {args.eval_fraction:.0%} was carved out of train.** "
+            "These numbers are not comparable with published results on this dataset."
+        )
+    for split_name, split_metrics in fine_tuned.items():
+        for task in tasks:
+            if not task["multi_label"]:
+                floor = split_metrics["tasks"][task["name"]]["majority_baseline"]
+                caveats.append(
+                    f"`{task['name']}` on `{split_name}`: always answering the most common label scores "
+                    f"`{floor}` accuracy. Read the accuracy against that floor."
+                )
+    if oom_steps:
+        caveats.append(
+            f"**{oom_steps} training step(s) were skipped** because the GPU ran out of memory. "
+            "The model saw less data than the example count above suggests."
+        )
+    caveats.append("Single seed. Small differences between runs are not evidence of anything.")
+    caveat_block = "\n".join(f"- {caveat}" for caveat in caveats)
+
+    label_lines = []
+    for task in tasks:
+        kind = "multi-label" if task["multi_label"] else "single-label"
+        names = ", ".join(f"`{label}`" for label in task["labels"])
+        label_lines.append(f"- **`{task['name']}`** ({kind}): {names}")
+    label_block = "\n".join(label_lines)
+
+    schema_lines = ["schema = ClassificationSchema()"]
+    for task in tasks:
+        method = "multi" if task["multi_label"] else "single"
+        schema_lines.append(f"schema.{method}({task['name']!r}, {task['labels']!r})")
+    schema_code = "\n".join(schema_lines)
+    first_task = tasks[0]
+    read_result = "selected" if first_task["multi_label"] else "value"
+
+    result_sections = []
+    for split_name, split_metrics in fine_tuned.items():
+        split_zero_shot = zero_shot[split_name] if zero_shot else None
+        result_sections.append(
+            f"`{split_name}`: {split_metrics['eval_examples']} held-out examples.\n\n"
+            + results_table(tasks, split_zero_shot, split_metrics)
+        )
+    result_block = "\n\n".join(result_sections)
+
+    first_split = next(iter(fine_tuned.values()))
+    size = f"{first_split['parameters'] / 1e6:.0f}M parameters"
+    if args.input_dataset:
+        source = f"[`{args.input_dataset}`](https://huggingface.co/datasets/{args.input_dataset})"
+        dataset_metadata = f"datasets:\n- {args.input_dataset}\n"
+    else:
+        source = f"the local file `{os.path.basename(args.train_file)}`"
+        dataset_metadata = ""
+    if args.output_repo:
+        title = args.output_repo.split("/")[-1]
+        model_ref = args.output_repo
+    else:
+        title = os.path.basename(os.path.abspath(args.output_dir))
+        model_ref = os.path.join(args.output_dir, "final")
+
+    return f"""---
+tags:
+{tag_lines}
+library_name: gliner2
+pipeline_tag: text-classification
+base_model: {args.base_model}
+{dataset_metadata}---
+
+# {title}
+
+[GLiNER2](https://github.com/fastino-ai/GLiNER2) text classifier ({size}), fine-tuned from
+[`{args.base_model}`](https://huggingface.co/{args.base_model}) on {train_size} examples from
+{source}.
+
+{provenance}
+
+## Results
+
+"Zero-shot" is the base model given only the label names, before any training, on the same
+examples.
+
+{result_block}
+
+Training took {round(train_seconds)} seconds.
+
+## Read this before trusting the numbers
+
+{caveat_block}
+
+## Tasks and labels
+
+{label_block}
+
+## Use it
+
+```python
+# pip install "gliner2[local]==2.0.0" protobuf sentencepiece
+from gliner2.classification import ClassificationSchema, Classifier
+
+classifier = Classifier.from_pretrained("{model_ref}").eval()
+
+{schema_code}
+
+result = classifier.batch_classify(["some text to classify"], schema)[0]
+print(result.{read_result}({first_task["name"]!r}), result.confidence({first_task["name"]!r}))
+```
+
+To label a whole Hub dataset with this model:
+
+```bash
+hf jobs uv run --flavor t4-small --timeout 1h --secrets HF_TOKEN \\
+  https://huggingface.co/datasets/uv-scripts/classification/raw/main/classify-gliner2.py \\
+  <input-dataset> <output-dataset> --model {shlex.quote(model_ref)} --text-column {shlex.quote(args.text_column)}
+```
+
+## Reproduction
+
+Produced by [`train-gliner2.py`]({SCRIPT_URL}) from
+[`uv-scripts/classification`](https://huggingface.co/datasets/uv-scripts/classification):
+
+```bash
+{build_reproduce_command(args)}
+```
+"""
+
+
+def ensure_output_repo(api: HfApi, repo_id: str, private: bool) -> None:
+    """Create the model repo, and refuse to train if a private run would push to a public repo.
+
+    create_repo(exist_ok=True) leaves an existing repo's visibility alone, so a repo that
+    already exists as public would silently receive a "private" model.
+    """
+    api.create_repo(repo_id, repo_type="model", private=private, exist_ok=True)
+    if private and not api.repo_info(repo_id, repo_type="model").private:
+        sys.exit(
+            f"{repo_id} already exists and is public. Pass --public to push there anyway, or choose "
+            "a new repo name."
+        )
+
+
+def main(args) -> None:
+    token = args.hf_token or os.environ.get("HF_TOKEN")
+    if token:
+        login(token=token)
+    elif not args.no_push:
+        sys.exit("No HF token. Pass --hf-token or run with --secrets HF_TOKEN (or pass --no-push).")
+
+    if not torch.cuda.is_available():
+        if not args.allow_cpu:
+            sys.exit(
+                "No GPU found. GLiNER2 fine-tuning needs one: run with `--flavor t4-small` on HF "
+                "Jobs. Pass --allow-cpu to run anyway (only sensible with a tiny --max-train-samples)."
+            )
+        logger.warning("No GPU found; training on CPU because --allow-cpu was passed.")
+    else:
+        logger.info(
+            "GPU: %s (ACCELERATOR=%s)", torch.cuda.get_device_name(0), os.environ.get("ACCELERATOR")
+        )
+
+    # Prove we can write the output repo BEFORE paying for training.
+    api = HfApi(token=token)
+    if args.no_push:
+        logger.info("--no-push: the model will stay in %s.", os.path.join(args.output_dir, "final"))
+    else:
+        ensure_output_repo(api, args.output_repo, private=not args.public)
+
+    precision = resolve_precision(args.precision)
+    sampling_config = resolve_sampling_config(args.label_augmentation)
+    manifest = build_manifest(args, sampling_config, precision)
+    manifest_dirs = [args.output_dir]
+    if args.export_predictions:
+        manifest_dirs.append(args.export_predictions)
+    # Written now, so a run that dies still records what it was; rewritten with results at the end.
+    write_manifest(manifest, manifest_dirs)
+
+    train_data, raw_eval_sets, carved_out = load_splits(args)
+
+    for split_name, data in [("train", train_data)] + list(raw_eval_sets.items()):
+        for column in [args.text_column] + args.label_column:
+            if column not in data.column_names:
+                sys.exit(f"Column '{column}' not found in '{split_name}'. Columns are: {data.column_names}.")
+
+    train_data = drop_unlabelled_rows(train_data, args.label_column, args.text_column, "train")
+    if args.max_train_samples and len(train_data) > args.max_train_samples:
+        train_data = train_data.shuffle(seed=args.seed).select(range(args.max_train_samples))
+    logger.info("Train examples: %d.", len(train_data))
+
+    fixed_labels = load_labels_file(args.labels_file) if args.labels_file else None
+    tasks = build_tasks(train_data, args.label_column, args.task_name, fixed_labels)
+    train_texts = prepare_texts(train_data, args.text_column, args.max_text_chars, "train")
+    train_gold = {task["name"]: decode_column(train_data, task["column"]) for task in tasks}
+    logger.info("Example input: %s", train_texts[0][:300])
+
+    # Local eval files, and any eval split whose predictions are exported, are scored in full
+    # and in order. Only a Hub eval split that is not exported keeps the old shuffled cap.
+    full_eval = bool(args.train_file or args.export_predictions)
+    eval_sets = {}
+    for split_name, data in raw_eval_sets.items():
+        data = add_row_numbers(data)
+        data = drop_unlabelled_rows(data, args.label_column, args.text_column, split_name)
+        if not full_eval and len(data) > args.max_eval_samples:
+            data = data.shuffle(seed=args.seed).select(range(args.max_eval_samples))
+        eval_sets[split_name] = {
+            "texts": prepare_texts(data, args.text_column, args.max_text_chars, split_name),
+            "gold": {task["name"]: decode_column(data, task["column"]) for task in tasks},
+            "rows": list(data[ROW_COLUMN]),
+        }
+        logger.info("Eval split '%s': %d examples.", split_name, len(data))
+
+    if fixed_labels is not None:
+        gold_by_split = {"train": train_gold}
+        for split_name, eval_set in eval_sets.items():
+            gold_by_split[split_name] = eval_set["gold"]
+        check_labels_in_set(tasks, gold_by_split)
+
+    zero_shot = None
+    if not args.skip_zero_shot:
+        logger.info("Scoring the base model zero-shot, before any training.")
+        zero_shot = evaluate(
+            args.base_model, eval_sets, tasks, args.eval_batch_size, args.export_predictions, "base"
+        )
+        for split_name, split_metrics in zero_shot.items():
+            logger.info("Zero-shot on '%s': %s", split_name, json.dumps(split_metrics["tasks"]))
+
+    examples = build_training_examples(train_texts, train_gold, tasks)
+    logger.info("Training precision: %s", precision)
+    logger.info("Training for %d epochs on %d examples.", args.epochs, len(examples))
+    started = time.time()
+    oom_steps = train_with_batch_fallback(args, examples, precision, sampling_config)
+    train_seconds = time.time() - started
+    logger.info("Training took %.0f seconds.", train_seconds)
+    if oom_steps:
+        logger.warning(
+            "%d training step(s) were skipped after running out of GPU memory. The model trained "
+            "on the rest. Lower --batch-size to avoid this.", oom_steps,
+        )
+
+    # Score the checkpoint that will actually be uploaded.
+    final_dir = os.path.join(args.output_dir, "final")
+    fine_tuned = evaluate(
+        final_dir, eval_sets, tasks, args.eval_batch_size, args.export_predictions, "finetuned"
+    )
+    for split_name, split_metrics in fine_tuned.items():
+        logger.info("Fine-tuned on '%s': %s", split_name, json.dumps(split_metrics["tasks"]))
+
+    schema_record = {
+        "text_column": args.text_column,
+        "tasks": [
+            {"name": task["name"], "labels": task["labels"], "multi_label": task["multi_label"]}
+            for task in tasks
+        ],
+    }
+    with open(os.path.join(final_dir, SCHEMA_FILENAME), "w") as handle:
+        json.dump(schema_record, handle, indent=2)
+    card = build_card(
+        args, tasks, zero_shot, fine_tuned, len(examples), train_seconds, carved_out, oom_steps
+    )
+    with open(os.path.join(final_dir, "README.md"), "w") as handle:
+        handle.write(card)
+
+    summary = {"zero_shot": zero_shot, "fine_tuned": fine_tuned, "train_seconds": round(train_seconds)}
+    manifest["tasks"] = schema_record["tasks"]
+    manifest["train_examples"] = len(examples)
+    manifest["oom_steps"] = oom_steps
+    manifest["results"] = summary
+    write_manifest(manifest, manifest_dirs + [final_dir])
+
+    if args.no_push:
+        logger.info("--no-push: nothing uploaded. The model is in %s", final_dir)
+    else:
+        api.upload_folder(repo_id=args.output_repo, folder_path=final_dir, repo_type="model")
+        logger.info("Pushed to https://huggingface.co/%s", args.output_repo)
+    print("SUMMARY_JSON " + json.dumps(summary))
+
+
+def parse_eval_files(values: list) -> dict:
+    """Turn repeated --eval-file NAME=PATH values into {name: path}, in the order given."""
+    eval_files = {}
+    for value in values or []:
+        name, separator, path = value.partition("=")
+        name = name.strip()
+        if not separator or not name or not path:
+            sys.exit(f"--eval-file wants NAME=PATH, got {value!r}.")
+        if "/" in name or name in eval_files:
+            sys.exit(f"--eval-file name {name!r} must be unique and contain no '/'.")
+        eval_files[name] = path
+    return eval_files
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument(
+        "input_dataset", nargs="?",
+        help="Input dataset ID. Leave out with --train-file; a single positional is then the output repo.",
+    )
+    parser.add_argument("output_repo", nargs="?", help="Output model repo ID (username/model-name). Not needed with --no-push.")
+    parser.add_argument("--train-file", help="Train on a local JSON Lines file (e.g. under a mounted /bucket) instead of a Hub dataset")
+    parser.add_argument(
+        "--eval-file", action="append",
+        help="NAME=PATH of a local JSON Lines eval split. Repeat for several splits. Scored in full, in file order.",
+    )
+    parser.add_argument(
+        "--labels-file",
+        help="Fixed label set (a JSON list, or one label per line), used in this order for training, "
+        "zero-shot and eval. Every label in the data must be in it. Needs exactly one --label-column.",
+    )
+    parser.add_argument("--base-model", default=DEFAULT_BASE_MODEL, help=f"GLiNER2 checkpoint to start from (default: {DEFAULT_BASE_MODEL})")
+    parser.add_argument("--dataset-config", help="Dataset config name")
+    parser.add_argument("--text-column", default="text", help="Text column (default: text)")
+    parser.add_argument(
+        "--label-column", action="append",
+        help="Label column (default: label). Repeat for several tasks in one model. A column of "
+        "lists is treated as multi-label.",
+    )
+    parser.add_argument(
+        "--task-name", action="append",
+        help="Name of the task, one per --label-column in the same order (default: the column "
+        "name). The model reads it as part of its prompt, and it names the output columns.",
+    )
+    parser.add_argument("--train-split", default="train", help="Train split (default: train)")
+    parser.add_argument("--eval-split", help="Eval split (default: validation or test if present, else a carve-out of train)")
+    parser.add_argument("--eval-fraction", type=float, default=0.1, help="Eval fraction if no eval split (default: 0.1)")
+    parser.add_argument("--max-train-samples", type=int, help="Cap training examples (smoke runs)")
+    parser.add_argument(
+        "--max-eval-samples", type=int, default=2000,
+        help="Cap Hub eval examples (default: 2000). Not applied to --eval-file splits or with --export-predictions.",
+    )
+    parser.add_argument("--max-text-chars", type=int, default=2000, help="Truncate texts to this many characters (default: 2000)")
+    parser.add_argument("--epochs", type=int, default=5, help="Epochs (default: 5)")
+    parser.add_argument("--batch-size", type=int, default=16, help="Training batch size (default: 16)")
+    parser.add_argument("--eval-batch-size", type=int, default=32, help="Prediction batch size (default: 32)")
+    parser.add_argument("--grad-accum", type=int, default=1, help="Gradient accumulation steps (default: 1)")
+    parser.add_argument("--encoder-lr", type=float, default=1e-5, help="Encoder learning rate (default: 1e-5)")
+    parser.add_argument("--task-lr", type=float, default=5e-4, help="Task-head learning rate (default: 5e-4)")
+    parser.add_argument("--seed", type=int, default=42, help="Seed (default: 42)")
+    parser.add_argument(
+        "--precision", choices=["auto", "fp32", "bf16"], default="auto",
+        help="Training precision (default: auto = bf16 on Ampere or newer GPUs such as A10G and L4, fp32 on T4 and CPU)",
+    )
+    parser.add_argument(
+        "--label-augmentation", choices=["upstream", "off"], default="upstream",
+        help="upstream (default) = gliner2's synthetic label names and label dropping during training; "
+        "off = always train on the real, complete label set (for a fixed schema)",
+    )
+
+    parser.add_argument("--skip-zero-shot", action="store_true", help="Skip the zero-shot score of the base model")
+    parser.add_argument("--allow-cpu", action="store_true", help="Train without a GPU (slow)")
+    parser.add_argument("--output-dir", default="./output", help="Local checkpoint directory; the model is saved in <dir>/final (default: ./output)")
+    parser.add_argument(
+        "--export-predictions",
+        help="Directory for per-row predictions: <dir>/{base,finetuned}-<split>/predictions.jsonl",
+    )
+    parser.add_argument("--no-push", action="store_true", help="Do not create or upload a Hub repo; keep the model in --output-dir")
+    parser.add_argument("--public", action="store_true", help="Make the output model repo public (default: private)")
+    parser.add_argument("--private", action="store_true", help="Accepted for older commands; private is now the default")
+    parser.add_argument("--hf-token", help="HF token (or set HF_TOKEN)")
+    args = parser.parse_args()
+    if not args.label_column:
+        args.label_column = ["label"]
+    if not args.task_name:
+        args.task_name = list(args.label_column)
+    if len(args.task_name) != len(args.label_column):
+        parser.error("Pass one --task-name per --label-column, in the same order.")
+    if len(set(args.task_name)) != len(args.task_name):
+        parser.error("Each --task-name must be different.")
+    if args.public and args.private:
+        parser.error("Pass --public or --private, not both.")
+
+    if args.train_file:
+        # With local files there is no input dataset, so one positional is the output repo.
+        if args.input_dataset and not args.output_repo:
+            args.output_repo = args.input_dataset
+            args.input_dataset = None
+        if args.input_dataset:
+            parser.error("Pass either an input dataset or --train-file, not both.")
+        if not args.eval_file:
+            parser.error("--train-file needs at least one --eval-file NAME=PATH.")
+        if args.eval_split or args.dataset_config:
+            parser.error("--eval-split and --dataset-config apply to Hub datasets, not --train-file.")
+    else:
+        if not args.input_dataset:
+            parser.error("Pass an input dataset ID, or --train-file with --eval-file.")
+        if args.eval_file:
+            parser.error("--eval-file needs --train-file.")
+    args.eval_files = parse_eval_files(args.eval_file)
+    if not args.no_push and not args.output_repo:
+        parser.error("Pass an output repo, or --no-push.")
+    if args.labels_file and len(args.label_column) != 1:
+        parser.error("--labels-file needs exactly one --label-column.")
+    return args
+
+
+if __name__ == "__main__":
+    main(parse_args())