Classification Scripts

Text classification on HF Jobs: label a dataset with a model that needs no training, or train your own classifier from labelled examples.

If you have seen Jev 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 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.

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.

Script	What it does
classify-gliner2.py	Label a dataset with GLiNER2: zero-shot from label names, or with a train-gliner2.py model
train-gliner2.py	Fine-tune 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 train a classifier from 8-64 labels per class with SetFit — runs on CPU or GPU
train-classifier.py	Fine-tune an encoder into a classifier (default: LFM2.5-Encoder-350M) and push it to the Hub
classify-dataset.py	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)

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 (models from 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.) 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

# 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. Sizes and speeds: 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 (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	single-label	4	2,000 × 2	125s	$0.01	accuracy	0.268	0.718	0.852
google-research-datasets/go_emotions	multi-label	28	2,000 × 2	216s	$0.02	micro F1	—	0.265	0.464
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 (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), --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.

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 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: 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 · Notes on how it was trained

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.

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

# 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	2	16	MiniLM-L6	cpu-basic	78s	0.924	0.924
fancyzhx/ag_news	4	32	MiniLM-L6	cpu-basic	118s	0.804	0.807
legacy-datasets/banking77	77	616	MiniLM-L6	t4-small	18s	0.803	0.789
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 (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.
• 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.
• 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.
• 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 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.

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

# 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 contains 21k Hub dataset cards (frontmatter stripped) labelled with their task_categories metadata — a real multi-label task over long documents:

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'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; 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:

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

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.