README.md

---
viewer: false
tags: [uv-script, classification, fine-tuning, few-shot, zero-shot, decision-model, setfit, gliner2, vllm, structured-outputs, hf-jobs]
---

# Classification Scripts

Text classification on [HF Jobs](https://huggingface.co/docs/hub/jobs): label a dataset with a model that needs no training, or train your own classifier from labelled examples.

If you have seen [Jev](https://docs.typesafe.ai/introduction) and other "System One" models: the
models these scripts train are small, open versions of the same idea. They read a piece of data and
return a label with a probability, and you can train one on your own labels. For example, this
[demo](https://huggingface.co/spaces/davanstrien/hub-task-tagger) suggests task tags for any Hub
dataset; its model was fine-tuned with `train-gliner2.py` in 17 minutes.

To try it on your own account, this command fine-tunes a classifier for British Library book titles
(Fiction / Non-fiction). Training takes about 2 minutes on a `t4-small` and costs about $0.02.
Accuracy goes from 0.767 zero-shot to 0.907 fine-tuned. You get a private model repo, and its card
shows both scores next to the majority-class baseline. Copy and paste it as it is: the model goes
to your own account.

```bash
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 gliner2-blbooks-genre \
  --dataset-config title_genre_classifiction --text-column title
```

You need the `hf` CLI, signed in, and Jobs credit: see the [Jobs quickstart](https://huggingface.co/docs/hub/jobs-quickstart).

| Script | What it does |
|--------|--------------|
| [`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://huggingface.co/fastino), 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://huggingface.co/docs/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-classification-classify-datasetpy) | Zero-shot variant on SGLang (reasoning-aware `<think>` models) |

Pick by how many labels you have:

| Labels you have | Use | Hardware |
|---|---|---|
| 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 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-gliner2.py` or `classify-dataset.py`, review them,
then train a small dedicated model on what you kept. Each rung is one command, so you can move up
as you collect more labels.

## Zero-shot first, then fine-tune (GLiNER2)

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.

[GLiNER2](https://github.com/fastino-ai/GLiNER2) ([models from Fastino](https://huggingface.co/fastino)) 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:

- **`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 scores next to the
  majority-class baseline.
- **`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 name: `--model gliner2-blbooks-genre`. A name on its own means your account; use `org/name`
  for an organisation.

### 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 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 blbooks-genre-predictions \
  --dataset-config title_genre_classifiction --text-column title --model 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 ag-news-topics --split test \
  --labels World Sports Business "Science and technology" --task-name topic
```

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).

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. For English zero-shot, try
`fastino/GLiNER2.5-Decide`. Sizes and speeds: [Choosing a model size](GLINER2-NOTES.md#choosing-a-model-size).

### Results

Fine-tuning beat zero-shot on every dataset below. The public-dataset runs took 2 to 30 minutes of
training on one GPU and cost $0.01 to $0.20; the 52-tag example took 17 minutes and about $1.50.

| 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) |

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).

### 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: in a hand-checked sample, about 1 in 10 datasets was
missing a tag that fits.

[Try the demo](https://huggingface.co/spaces/davanstrien/hub-task-tagger): paste a dataset id and
see the suggested tags, the owner's tags and the exact text the model read. On a free 2-vCPU Space
one prediction takes about 0.7–1 s.
[Model](https://huggingface.co/davanstrien/hub-task-tagger-gliner2.5-base) · [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://huggingface.co/docs/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.

**Runs on CPU or GPU.** CPU is practical for small few-shot experiments. Use a GPU for faster
training, particularly with larger models, longer texts or more classes. The same model and
training settings work on either; the recipe uses the available accelerator automatically.

```bash
# 8 labels per class, on CPU
hf jobs uv run --flavor cpu-basic --timeout 20m --secrets HF_TOKEN \
  https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-setfit.py \
  fancyzhx/ag_news username/ag-news-setfit --num-samples 8

# Same model and training settings on a GPU for faster training
hf jobs uv run --flavor t4-small --timeout 20m --secrets HF_TOKEN \
  https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-setfit.py \
  fancyzhx/ag_news username/ag-news-setfit-gpu --num-samples 8
```

### Measured

8 labels per class, seed 42, evaluated on each dataset's own held-out split (capped at 500
examples, 1000 for banking77):

| Dataset | Classes | Labels used | Body | Flavor | Training | Accuracy | Macro F1 |
|---|---|---|---|---|---|---|---|
| [`SetFit/enron_spam`](https://huggingface.co/datasets/SetFit/enron_spam) | 2 | 16 | MiniLM-L6 | `cpu-basic` | 78s | 0.924 | 0.924 |
| [`fancyzhx/ag_news`](https://huggingface.co/datasets/fancyzhx/ag_news) | 4 | 32 | MiniLM-L6 | `cpu-basic` | 118s | 0.804 | 0.807 |
| [`legacy-datasets/banking77`](https://huggingface.co/datasets/legacy-datasets/banking77) | 77 | 616 | MiniLM-L6 | `t4-small` | 18s | 0.803 | 0.789 |
| [`dair-ai/emotion`](https://huggingface.co/datasets/dair-ai/emotion) | 6 | 48 | MiniLM-L6 | `cpu-basic` | 216s | 0.370 | 0.325 |

**Single seed each — these do not rank models or predict your dataset.** Few-shot results vary
substantially with which examples happen to get sampled; SetFit's own benchmarks report mean and
standard deviation across ten seeds for exactly this reason. Run your own task before trusting
any of these numbers.

### Good to know

- **Default body**: [`all-MiniLM-L6-v2`](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) (22M), chosen for CPU speed. Swap it with `--body-model`; set `--max-seq-length` within its context window and add any task prefix it needs yourself. See [Choosing another body or longer context](SETFIT-NOTES.md#choosing-another-body-or-longer-context).
- **Single-label only.** A multi-label column exits with a pointer to `train-classifier.py`.
- **Beat more than the majority baseline.** Every run reports it, but `emotion` beat it by under 2 points; compare with TF-IDF plus logistic regression or zero-shot on the same rows. See [Compare more than the majority baseline](SETFIT-NOTES.md#compare-more-than-the-majority-baseline).
- **Many classes: watch the pair count.** Pairs grow with the square of the training-set size; at 77 classes use `--sampling-strategy undersampling`. See [Many classes](SETFIT-NOTES.md#many-classes-watch-the-pair-count).
- **It refuses runs projected above `--max-minutes`** (default 60). On `biglam/hansard_speech` (2.7M speeches, 28 parties) it refused to train and produced no score, and [the worked failure](SETFIT-NOTES.md#real-world-data-a-worked-failure) shows why.
- **Load it with `SetFitModel.from_pretrained(repo)`**, not `AutoModelForSequenceClassification`: a SetFit model is a sentence-transformer body plus a scikit-learn head.

Evaluation split, metrics, dropped rows and `--private`: [SETFIT-NOTES.md](SETFIT-NOTES.md#behaviour-details).

## 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 LiquidAI reports 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`)

Label a dataset with an instruction LLM and no training data. You give a list of labels; the
model picks one per row, and guided decoding (structured outputs) makes sure every answer is one
of your labels. The default model is
[HuggingFaceTB/SmolLM3-3B](https://huggingface.co/HuggingFaceTB/SmolLM3-3B); any instruction
model works via `--model`. The result is your dataset with a new `classification` column.

Two scripts do this. `classify-dataset.py` runs on vLLM and is the one to start with.
`classify-dataset-sglang.py` runs the same task on SGLang, for reasoning models that write
`<think>` traces; its options differ (`--reasoning`, `--save-reasoning`, `--batch-size`,
`--grammar-backend`), so check its `--help`.

### Quick start

A GPU is required. Run on Jobs with the vLLM image:

```bash
hf jobs uv run --flavor l4x1 --image vllm/vllm-openai:latest --secrets HF_TOKEN \
  https://huggingface.co/datasets/uv-scripts/classification/raw/main/classify-dataset.py \
  --input-dataset stanfordnlp/imdb \
  --column text \
  --labels "positive,negative" \
  --output-dataset username/imdb-classified \
  --max-samples 100 --shuffle
```

`--max-samples` with `--shuffle` takes a random sample, which matters for datasets sorted by
date or label. Drop both to label the whole split.

### With reasoning and label descriptions

```bash
hf jobs uv run --flavor l4x1 --image vllm/vllm-openai:latest --secrets HF_TOKEN \
  https://huggingface.co/datasets/uv-scripts/classification/raw/main/classify-dataset.py \
  --input-dataset user/support-tickets \
  --column content \
  --labels "bug,feature_request,question,other" \
  --label-descriptions "bug:code or product not working as expected,feature_request:asking for new functionality,question:seeking help or clarification,other:general comments or feedback" \
  --enable-reasoning \
  --output-dataset username/tickets-classified
```

With `--enable-reasoning` the model thinks step by step before it answers, and the output also
has `reasoning` and `parsing_success` columns. Reasoning mode turns off structured outputs: the
model must end with `{"label": "..."}`, and rows where that cannot be parsed are marked in
`parsing_success`. It is slower, but you can read why each label was chosen.

### Options

| Option | What it does |
|---|---|
| `--model` | Model to use (default `HuggingFaceTB/SmolLM3-3B`) |
| `--label-descriptions` | `label:description,...` pairs that tell the model what each label means |
| `--enable-reasoning` | Think before answering; adds `reasoning` and `parsing_success` columns |
| `--split` | Split to process (default `train`) |
| `--max-samples` | Label only the first N rows (or N random rows with `--shuffle`) |
| `--shuffle`, `--shuffle-seed` | Shuffle before `--max-samples` (seed default 42) |

Run `uv run classify-dataset.py --help` for all options.

### Good to know

- **Speed**: about 50-100 texts/second for SmolLM3-3B on an A10, and 20-50 for 7B models.
  `l4x1` is a good start; use `a10g-large` or larger for 7B+ models or out-of-memory errors.
- **Text handling**: texts shorter than 3 characters and empty values are skipped; texts are
  truncated to 4,000 characters.
- **Label names matter.** Use clear, distinct names, add `--label-descriptions` when names are
  ambiguous, and try a larger model for nuanced tasks.
- **vLLM version**: `ImportError: cannot import name GuidedDecodingParams` means the vLLM
  version does not match; the script requires `vllm>=0.6.6`.