The Dataset Viewer has been disabled on this dataset.

Classification Scripts

Text and image 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
train-kev.py Fine-tune the open Kev-4B decision model on your own questions, with Kev's own training code
train-timm.py Image classification: fine-tune a timm model on a Hub image dataset, single-label or multi-label (experimental)
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

For images, use train-timm.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. For English zero-shot, try fastino/GLiNER2.5-Decide. 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.

Fine-tune a Kev decision model (train-kev.py)

Kev is an open decision model by Jared Palmer. It answers yes/no, multiple-choice and rating questions about a text, with a probability for each answer. Kev-4B is a rank-16 LoRA adapter and a small pointer head on Qwen3.5-4B-Base. This script fine-tunes the released Kev-4B on your own labelled questions.

The script is a thin launcher. It pins one Kev commit and the Kev-4B v1.0 weights, installs Kev, and runs Kev's own kev.train, kev.benchmark and kev.calibrate. All training and evaluation code is Kev's. Kev's own recipes run on Modal (the kev-finetune skill) or on a GPU you have (Fine-Tune on Your Own Data); use this script when your data and credit are already on the Hub.

First put train.jsonl and development.jsonl in a bucket folder (the snippet at the end of this section shows one way). Each line is one record in Kev's format; a record can carry more than one question:

{"state": "<the text>",
 "questions": {"newsgroup": {"type": "choice",
                             "instructions": "Which newsgroup was this post published in?",
                             "criteria": {"alt.atheism": null, "comp.graphics": null},
                             "label": "comp.graphics"}}}

Then run:

hf jobs uv run --flavor a100-large --timeout 1h --secrets HF_TOKEN \
  -v hf://buckets/<you>/kev-data:/mnt/kev \
  https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-kev.py \
  /mnt/kev/newsgroups /mnt/kev/runs/newsgroups-v1

The script checks every record and the output folder before it installs anything. The output folder must be new or empty. It gets checkpoint/, finetuned-development/ and baseline-development/ (Kev benchmark reports for the fine-tuned and the released model), finetuned-development/calibration.json (when kev.calibrate succeeds) and a run.json summary. Each result is copied to the bucket as soon as it is written. On Jobs, the script refuses an output folder that is not on a mounted bucket.

Measured

Task Train / test records Flavor Time Cost Released Kev-4B Fine-tuned
SetFit/20_newsgroups (20 classes) 846 / 426 (1,000 / 500 prepared) a100-large 31 min about $1.29 62.4% 72.3%

One seed, 2026-10-30. The paired difference is +9.9 points (95% CI +6.1 to +13.6). Training took about 25 of the 31 minutes (846 records, 2 epochs).

The fine-tuned model is overconfident: mean confidence 0.82 against accuracy 0.72 (ECE 0.100). The fine-tuned checkpoint runs at temperature 1.0. calibration.json reports what one temperature fitted on your development records would do; nothing in the checkpoint changes. On 20 Newsgroups, the out-of-fold fit (workload_oof) brings ECE to 0.028 and mean confidence to 0.73, with accuracy unchanged (ECE change -0.072, 95% CI -0.092 to -0.023). To use the fitted value (workload_temperature, 1.52 here), set KEV_TEMPERATURE=1.52 when you serve or benchmark the checkpoint with Kev's commands, or pass LoadOptions(temperature=1.52) when you load it in Python.

Good to know

  • Long records are dropped. kev.train's default context is 384 state tokens (Kev's --max_state raises it; this script does not expose it). kev.train drops longer records and prints how many; kev.benchmark drops them too and lists them in rejected.json. On 20 Newsgroups, after cutting posts at 2,000 characters, this dropped 154 of 1,000 training and 74 of 500 test posts.
  • Raise --timeout before you add data or epochs. Training time grows with records × epochs. If the Job hits the timeout, the results already copied stay in the bucket.
  • Everything is pinned: the Kev commit, the Kev-4B weights (by commit, because a tag can move) and the Qwen3.5 base revision. If the kev-1.0 tag moves, the script stops with a message.
  • No extra kernels. Kev's Modal images add flash-linear-attention (and, in modal_app.py, causal-conv1d). In our a100-large runs they gave no speed-up, so this script leaves them out.
  • Smoke test first: --max-steps 5 runs the whole path in about 6 minutes.
  • No 20 Newsgroups checkpoint is published. SetFit/20_newsgroups declares no licence.
Turn a labelled dataset into Kev records (the 20 Newsgroups example)
import json
from pathlib import Path

from datasets import load_dataset

data = load_dataset("SetFit/20_newsgroups")
labels = sorted(set(data["train"]["label_text"]))
out = Path("newsgroups")
out.mkdir(exist_ok=True)
for split, count, name in [("train", 1000, "train.jsonl"), ("test", 500, "development.jsonl")]:
    rows = data[split].filter(lambda row: len(row["text"].strip()) >= 50).shuffle(seed=42).select(range(count))
    with (out / name).open("w") as f:
        for row in rows:
            question = {"type": "choice", "instructions": "Which newsgroup was this post published in?",
                        "criteria": {label: None for label in labels}, "label": row["label_text"]}
            f.write(json.dumps({"state": row["text"].strip()[:2000], "questions": {"newsgroup": question}}) + "\n")

Then copy the folder to your bucket: hf buckets sync ./newsgroups hf://buckets/<you>/kev-data/newsgroups.

Image classification with timm (train-timm.py)

For images: fine-tune a timm classifier on a Hub image dataset and push it to the Hub. The script runs timm's own train.py and adds the Hub and Jobs parts around it. A ClassLabel column gives a single-label model and a List(ClassLabel) column a multi-label one; the script reads the columns, label names and validation split from the dataset. Experimental: it works on HF Jobs, but the options may change.

The [tool.hf-jobs] header sets a10g-small, a 2-hour timeout and HF_TOKEN:

# Single-label, a short first run
hf jobs uv run \
  https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-timm.py \
  AI-Lab-Makerere/beans username/beans-convnext --epochs 3

# Multi-label
hf jobs uv run \
  https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-timm.py \
  timm/bee-dataset username/bee-convnext --epochs 10

The result loads with timm.create_model("hf-hub:username/beans-convnext", pretrained=True), and model.pretrained_cfg["label_names"] gives the class names.

Measured

Default backbone unless named, evaluated by train.py on each dataset's validation split (beans: 133 images, bee-dataset: 4 labels). Time is the whole Job after the dependencies install: data, training, push and reload check.

Dataset Task Backbone Epochs Flavor Time Result
AI-Lab-Makerere/beans single-label, 3 classes ConvNeXt-T 3 a10g-small 0.7 min top-1 97.7%
AI-Lab-Makerere/beans single-label ConvNeXt-S 3 a10g-small 1.0 min top-1 100%
AI-Lab-Makerere/beans single-label ViT-B/16 3 a10g-small 0.9 min top-1 99.2%
AI-Lab-Makerere/beans single-label ConvNeXt-T 3 a10g-largex2 (2 GPUs) 0.8 min top-1 96.2%
timm/bee-dataset multi-label, 4 labels ConvNeXt-T 3 a10g-small 1.0 min mAP 99.7, macro F1 99.2

These are easy datasets. They show that the recipe runs end to end, not how well it does on your images. Try two or three backbones (--model) on your own data before you trust one.

Good to know

  • Any timm model. --model takes a Hub ID such as timm/resnet50.a1_in1k or a bare timm name. The base model's licence carries over to the trained model; the default is Apache-2.0.
  • Several GPUs in one Job. On a flavor such as l4x4, the script runs train.py on all its GPUs. --batch-size is per GPU, and --lr is the rate for one GPU's batch: timm scales it for the global batch. It does not train across several Jobs.
  • timm options pass through. Everything after a second -- goes to train.py, and the pushed model keeps architecture and preprocessing flags. Put the first -- right after hf jobs uv run and its flags, so hf passes the second one on: hf jobs uv run -- <script-url> timm/bee-dataset username/bee-asl -- --loss asl --mixup 0.2.
  • No validation split? The script carves a seeded 10% split from train and says so on the card.
  • Metrics come from timm. The card shows train.py's validation metrics for the best epoch.

All options, what the script decides for you, and timm details: TIMM-NOTES.md.

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:v0.32.0 --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:v0.32.0 --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 (no GPU or vLLM needed).

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: on Jobs, vLLM, PyTorch and Transformers come from the vllm/vllm-openai image, so the script header does not list them. For a local GPU run (Linux + CUDA), add vLLM yourself: uv run --with vllm classify-dataset.py .... The script needs vLLM 0.12 or newer (StructuredOutputsParams).
Downloads last month
342

Space using uv-scripts/classification 1