Improve model card (SEO title, FAQ, citation, widgets) and add predict.py CLI, CITATION.cff, requirements.txt

CITATION.cff

@@ -0,0 +1,24 @@
+cff-version: 1.2.0
+title: "MasterFormat Classifier (mf-0.1)"
+message: "If you use this model, please cite it as below."
+type: software
+authors:
+  - name: "Constructelligence"
+    website: "https://constructelligence.co"
+license: MIT
+url: "https://huggingface.co/constructelligence/masterformat-classifier"
+repository-code: "https://huggingface.co/constructelligence/masterformat-classifier"
+abstract: >-
+  A BERT-based text classifier that maps construction line items, specification
+  paragraphs and section titles to one of 171 MasterFormat level-2 groups across
+  32 divisions. Fine-tuned from BAAI/bge-small-en-v1.5 on public-domain UFGS
+  specification text. Published as an early (step-700) checkpoint.
+keywords:
+  - MasterFormat
+  - construction
+  - text-classification
+  - specifications
+  - estimating
+  - takeoff
+  - UFGS
+  - BERT

README.md

@@ -1,17 +1,29 @@
 ---
+language:
+- en
 license: mit
-base_model: BAAI/bge-small-en-v1.5
 library_name: transformers
 pipeline_tag: text-classification
-language: en
+base_model: BAAI/bge-small-en-v1.5
 tags:
-- construction
 - masterformat
+- masterformat-classifier
+- csi-masterformat
+- construction
+- construction-technology
 - text-classification
-- spec-writing
-- takeoff
+- sequence-classification
 - bert
 - onnx
+- safetensors
+- specs
+- spec-writing
+- specifications
+- takeoff
+- estimating
+- cost-code
+- ufgs
+- public-domain
 metrics:
 - accuracy
 model-index:
@@ -19,7 +31,7 @@ model-index:
   results:
   - task:
       type: text-classification
-      name: MasterFormat level-2 classification
+      name: MasterFormat level-2 group classification
     dataset:
       type: ufgs-val
       name: UFGS held-out text units (13,518)
@@ -28,43 +40,37 @@ model-index:
     - type: accuracy
       value: 0.184
       name: Top-1 accuracy (step-700 checkpoint)
+widget:
+- text: 4000 psi concrete slab on grade
+  example_title: Cast-in-place concrete
+- text: TPO roofing, 60 mil, fully adhered
+  example_title: Membrane roofing
+- text: Cat 6 data cabling and jacks
+  example_title: Structured cabling
+- text: Wet pipe sprinkler system, light hazard
+  example_title: Fire suppression
 ---
 
-# MasterFormat level-2 classifier (mf-0.1)
+# MasterFormat classifier (mf-0.1) — construction spec & line-item classification
 
-> **Early checkpoint, published as-is.** This is step 700 of a planned 4,150-step fine-tune; training was
-> paused on an 8 GB CPU-only Mac. Top-1 accuracy on the full UFGS validation split is **18.4%** — well below the
-> TF-IDF baseline (53.1%) on the same split. Treat this release as a reproducible starting point and a
-> working deployment format, not as a finished classifier. A resume script and the full recipe are in the
-> source project.
+A BERT text classifier that maps **construction line items, specification paragraphs, submittals and
+section titles** to one of **171 MasterFormat level-2 groups** (e.g. `03 30 00 Cast-in-Place Concrete`,
+`23 30 00 HVAC Air Distribution`) across **32 divisions**. It is the machine-learning counterpart to a
+cost-code lookup table: hand it "TPO roofing, 60 mil, fully adhered" and it returns the MasterFormat group,
+ranked. English text, one label per input.
 
-Classifies a construction line item, specification paragraph, submittal or section title into one of **171
-MasterFormat level-2 groups** (e.g. `03 30 00 Cast-in-Place Concrete`, `23 30 00 HVAC Air Distribution`)
-across 32 divisions. English text, one label per input.
+Built for estimating, takeoff, spec-writing and RAG pipelines that need to tag free text with CSI
+MasterFormat codes without a human choosing from a 171-row list.
 
-MasterFormat is a registered trademark of CSI / CSC. This project is not affiliated with or endorsed by them.
+> **Early checkpoint, published as-is.** This is **step 700 of a planned 4,150-step fine-tune**
+> (`mf-0.1`); training was paused on an 8 GB CPU-only Mac. Top-1 accuracy on the UFGS validation split is
+> **18.4 %** (v1 split; **20.0 %** on the rebuilt v2 split) — well below this project's TF-IDF baseline
+> (**53.1 %** / **57.5 %**) on the same splits. Treat this release
+> as a reproducible starting point and a working deployment format, **not as a finished classifier**. A v2
+> dataset and trainer are in the repository; see *Model* and *Limitations*.
 
-## Model
-
-- Base: [`BAAI/bge-small-en-v1.5`](https://huggingface.co/BAAI/bge-small-en-v1.5) (BERT, 33M parameters, 384-d), MIT.
-- Fine-tuned with a 171-way sequence-classification head; `id2label` / `label2id` are in [`config.json`](config.json).
-- Training: 2 epochs planned over 66,396 rows (per-class balance capped at 450 / floored at 300, estimate-style
-  augmentation), batch 32, max length 96, AdamW, 6% linear warmup; body LR 6e-5, head LR 2e-3; embeddings and
-  the first 4 encoder layers frozen.
-- Checkpoint stopped at step 700; `train_state.json` records `{"step": 700, "val_acc": 0.18725}`.
-
-## Results
-
-All numbers are measured on held-out data from the same project. `val` = UFGS text units,
-`line_items` = 194 hand-labelled estimate line items, `manuals` = 6,890 chunks from 153 sections of two real
-commercial project manuals (out-of-taxonomy gold labels count only toward the division score).
-
-| Scorer | val top-1 | val top-3 | val division | line-item top-1 | manual-chunk top-1 | manual-section top-1 |
-|---|---:|---:|---:|---:|---:|---:|
-| **mf-0.1 (step 700)** | 0.184 | 0.345 | 0.321 | 0.283 | 0.175 | 0.287 |
-| TF-IDF + linear SGD (full run) | 0.531 | 0.690 | 0.634 | 0.665 | 0.290 | 0.607 |
-| bge-small embeddings + logistic regression | 0.349 | 0.517 | 0.458 | 0.576 | 0.256 | 0.593 |
-| Ensemble (0.25 embedding + 0.75 TF-IDF) | 0.532 | 0.700 | 0.637 | 0.702 | 0.318 | 0.640 |
+MasterFormat is a registered trademark of CSI / CSC. This project is independent and not affiliated with or
+endorsed by them.
 
 ## Quick start
 
@@ -74,59 +80,161 @@ from transformers import pipeline
 clf = pipeline("text-classification", model="constructelligence/masterformat-classifier", top_k=3)
 for p in clf("4000 psi concrete slab on grade"):
     print(p["label"], round(p["score"], 3))
+# 04 20 00 Unit Masonry 0.082
+# 03 60 00 Grouting 0.076
+# 09 30 00 Tiling 0.063   <- not competitive yet; this is the step-700 checkpoint
+```
+
+Batched, with the level-1 division roll-up and JSON output:
+
+```bash
+pip install -r requirements.txt        # transformers + torch
+python predict.py --top-k 5 --divisions "8\" CMU wall, grout filled at 32\" o.c."
+echo "Cat 6 data cabling and jacks" | python predict.py -
+python predict.py --file items.txt --json > out.json
 ```
 
-Or with the included example:
+ONNX (no torch, ~34 MB int8):
 
 ```bash
-pip install transformers torch
-python predict.py "TPO roofing, 60 mil, fully adhered"
+pip install onnxruntime transformers
+python predict.py --onnx onnx/model_quantized.onnx "Panelboards 208/120V 42 circuit"
 ```
 
 The encoder is English-only; inputs should be English.
 
-### ONNX
+### ONNX exports
 
 `onnx/model.onnx` (fp32, 134 MB) and `onnx/model_quantized.onnx` (dynamic int8, 34 MB) are exported with
-dynamic batch and sequence axes, in the layout `transformers.js` / Optimum expect, inputs `input_ids`,
-`attention_mask`, `token_type_ids`, output `logits`. The fp32 export matches PyTorch on a 4-text smoke set
-(max |delta logit| 5e-6, argmax agreement 4/4). Dynamic int8 quantization shifts low-confidence logits
-(max |delta| ~1.4 on the same smoke set, argmax agreement 3/4), so verify the quantized model on your own
-inputs before using it; see the project's `scripts/export_onnx.py` for the exact command.
+dynamic batch and sequence axes, in the layout `transformers.js` / Optimum expect — inputs `input_ids`,
+`attention_mask`, `token_type_ids`, output `logits`. The fp32 export matches PyTorch on a 5-text smoke set
+(max |Δ logit| 5e-6, argmax agreement 5/5). Dynamic int8 quantization shifts low-confidence logits
+(max |Δ| ≈ 1.5 on the same smoke set, argmax agreement 3/5), so verify the quantized model on your own
+inputs before relying on it. Reproduce with `python scripts/export_onnx.py runs/mf-0.1`.
 
-## Files
+## Model
 
-- `model.safetensors`, `config.json`, `tokenizer.json`, `tokenizer_config.json`, `vocab.txt`,
-  `special_tokens_map.json` — standard `transformers` checkpoint.
-- `train_state.json` — step and validation accuracy of the saved checkpoint (text logs and optimizer state
-  are not published).
-- `predict.py` — minimal pipeline example.
-- `onnx/` — ONNX fp32 and int8 exports.
+- **Base:** [`BAAI/bge-small-en-v1.5`](https://huggingface.co/BAAI/bge-small-en-v1.5) (BERT, 33M parameters, 384-d, MIT).
+- **Head:** 171-way sequence-classification layer; `id2label` / `label2id` are in [`config.json`](config.json).
+- **Recipe:** 2 planned epochs over the training set (per-class balance capped at 450 / floored at 300,
+  estimate-style augmentation), batch 32, max length 96, AdamW, 6 % linear warmup; body LR 6e-5, head LR 2e-3;
+  embeddings and the first 4 encoder layers frozen.
+- **Checkpoint:** stopped at step 700; `train_state.json` records `{"step": 700, "val_acc": 0.18725}`.
+- **A stronger v2 recipe already exists** in the source project (`label smoothing 0.05`, sentence-window
+  dataset, max length 64, lower learning rates) but no `mf-0.2` run has been completed yet.
+
+## Results
+
+All numbers are measured in this project on held-out data. `val` = UFGS text units, held out by a hash of
+the normalised source text; `line_items` = 194 hand-labelled estimate line items; `manuals` = 6,890 chunks
+from 153 sections of two real commercial project manuals. Out-of-taxonomy gold labels (e.g. `22 40 00`)
+count only toward the division score, so a row's top-1 is computed over in-taxonomy items only.
+
+| Scorer | val top-1 | val top-3 | val division | line-item top-1 | manual-chunk top-1 | manual-section top-1 |
+|---|---:|---:|---:|---:|---:|---:|
+| **mf-0.1 (step 700)** | **0.184** | 0.345 | 0.321 | 0.283 | 0.175 | 0.287 |
+| TF-IDF + linear SGD (full run) | 0.531 | 0.690 | 0.634 | 0.665 | 0.290 | 0.607 |
+| bge-small embeddings + logistic regression | 0.349 | 0.517 | 0.458 | 0.576 | 0.256 | 0.593 |
+| Ensemble (0.25 embedding + 0.75 TF-IDF) | **0.532** | **0.700** | **0.637** | **0.702** | **0.318** | **0.640** |
+
+The published checkpoint is the weakest scorer in this table. The best result on the real-world target
+(hand-labelled estimate line items) is the **ensemble at 70.2 % top-1**, which is why the project's next
+milestone is to finish the transformer run rather than ship `mf-0.1` as the answer.
+
+`val` is the only column that depends on the dataset version: `line_items`, `manuals` and `manual_sections`
+are fixed held-out sets, so those columns are directly comparable for every scorer. On the rebuilt **v2**
+validation split (11,598 units) the same `mf-0.1` checkpoint scores **0.200 top-1 / 0.372 top-3 / 0.356
+division**, against **0.575 / 0.732 / 0.675** for TF-IDF on that split. The `val` columns above are on the
+original v1 split (13,518 units).
+
+## Intended use
+
+- **Use it for:** tagging construction text with a candidate MasterFormat group (top-3 shown), prototyping
+  an auto-classification step for estimating or spec workflows, and as a reproducible baseline to fine-tune
+  further.
+- **Do not use it for:** unattended production takeoff, bid pricing, code compliance, or anything where a
+  wrong cost code has financial or contractual consequences. At 18.4 % top-1 it is not accurate enough.
+- **Not a substitute for review.** Always keep a human in the loop for classification decisions.
 
 ## Training data and taxonomy
 
-- **UFGS** (Unified Facilities Guide Specifications) `.SEC` files, US federal works in the **public domain**.
-  Paragraphs and titles are parsed into labelled text units; boilerplate shared by 3+ sections is dropped,
-  cross-references are stripped so section numbers cannot leak labels, and long paragraphs are windowed into
-  20–60-word units.
-- **Split:** held out by a hash of the normalised source text (10%), so a paragraph and its augmentations stay
-  on the same side. 66,396 train / 13,518 val rows.
+- **Source:** UFGS (Unified Facilities Guide Specifications) `.SEC` files — US federal works in the
+  **public domain**. Paragraphs and titles are parsed into labelled text units; boilerplate shared by
+  multiple sections is dropped, cross-references are stripped so section numbers cannot leak labels, and
+  long paragraphs are windowed into 20–60-word units.
+- **Split:** held out by a hash of the normalised source text (10 %), so a paragraph and its augmentations
+  stay on the same side. The `mf-0.1` run used 66,396 train / 13,518 val rows; the rebuilt v2 dataset has
+  65,496 / 11,598.
 - **Taxonomy:** 171 level-2 groups over 32 MasterFormat divisions; group numbers follow the MasterFormat
-  numbering convention and the short names are the project's own (see `config.json`).
+  numbering convention and the short names are this project's own (see `config.json`).
 
 ## Limitations
 
-- **Early checkpoint.** The 18.4% top-1 is a snapshot of an interrupted run; it is not competitive with the
-  TF-IDF baseline yet. Do not use it for production takeoff without further training and re-evaluation.
+- **Early checkpoint.** The 18.4 % top-1 is a snapshot of an interrupted run; it is not competitive with
+  the TF-IDF baseline yet. Do not use it for production takeoff without further training and re-evaluation.
 - **Domain skew.** UFGS over-represents heavy-civil, water/wastewater and process work relative to commercial
   building estimates; the training set is class-balanced, so raw predictions do not reflect building-project
   priors.
-- **Out-of-taxonomy inputs** (sections whose level-2 group is not in the 171) can only be scored at division
-  level.
-- Short, terse line items are the hardest inputs; division (2-digit) accuracy is higher than group accuracy.
+- **Out-of-taxonomy inputs** (sections whose level-2 group is not among the 171) can only be scored at
+  division level.
+- **Short, terse line items are the hardest inputs**; division (2-digit) accuracy is consistently higher than
+  group (6-digit) accuracy.
+- **No section-number leakage, but no section-number help either.** The model classifies text content only;
+  if your input already contains a MasterFormat number, don't ask the model — read the number.
+
+## Bias, risks and safety
+
+- **Estimating bias.** Class-balanced training over a public-domain federal corpus does not represent any
+  particular firm's cost structure or regional practice. Do not treat output as a standard or an authority.
+- **Trademark.** MasterFormat is a registered trademark of CSI / CSC; this model is not endorsed by them and
+  its group names are the project's own short descriptions, not CSI's official titles.
+- **Privacy.** The model runs locally; no input text leaves your machine unless you call a hosted endpoint.
+
+## FAQ
+
+**What is MasterFormat?** The CSI/CSC MasterFormat is the North American standard for organising construction
+specifications and cost data into numbered divisions and sections. This model predicts the **level-2 group**
+(a 6-digit code such as `03 30 00 Cast-in-Place Concrete`), not the full section number.
+
+**Can it classify a whole specification section?** Partly. Averaging the model's log-probabilities over a
+section's chunks is the intended way to score a section; at step 700 that gets 28.7 % top-1 on two real
+project manuals (53 % at division level). The TF-IDF baseline reaches 60.7 %.
+
+**Can it read a MasterFormat number out of the text?** No. It classifies the description. If the number is
+already present, parse it directly.
+
+**Does it work offline / in the browser?** Yes — the ONNX exports are intended for `onnxruntime` and
+`transformers.js`.
+
+**Is a better model available?** Not yet as a published checkpoint. The project's TF-IDF + embedding
+**ensemble scores 70.2 % top-1 on hand-labelled line items** and is the current production-candidate; the
+next transformer run (`mf-0.2`) is expected to close most of the gap. Constructelligence's proprietary models
+are at [constructelligence.co](https://constructelligence.co).
+
+## Files
+
+- `model.safetensors`, `config.json`, `tokenizer.json`, `tokenizer_config.json`, `vocab.txt`,
+  `special_tokens_map.json` — standard `transformers` checkpoint.
+- `train_state.json` — step and validation accuracy of the saved checkpoint (text logs and optimizer state
+  are not published).
+- `predict.py` — CLI example: batching, `--top-k`, `--divisions`, `--json`, stdin/file input, `--onnx`.
+- `onnx/` — ONNX fp32 and int8 exports.
+- `CITATION.cff`, `requirements.txt`.
+
+## Citation
+
+```bibtex
+@misc{constructelligence_masterformat_classifier,
+  title        = {MasterFormat Classifier (mf-0.1): construction spec and line-item classification},
+  author       = {Constructelligence},
+  year         = {2026},
+  howpublished = {\url{https://huggingface.co/constructelligence/masterformat-classifier}},
+  note         = {Fine-tuned from BAAI/bge-small-en-v1.5; 171-way MasterFormat level-2 classifier}
+}
+```
 
 ## Licence and attribution
 
 Released under the **MIT licence**, matching the base model. UFGS source text is public domain. MasterFormat
-is a registered trademark of CSI / CSC; this project is not affiliated with or endorsed by them. Constructelligence's
-production models are available at [constructelligence.co](https://constructelligence.co).
+is a registered trademark of CSI / CSC; this project is not affiliated with or endorsed by them.
+Constructelligence's production models are available at [constructelligence.co](https://constructelligence.co).

predict.py

@@ -1,24 +1,157 @@
-"""Classify construction text into MasterFormat level-2 groups.
+"""Classify construction text into MasterFormat level-2 groups (171 classes, 32 divisions).
 
+Examples
+--------
     pip install transformers torch
     python predict.py "4000 psi concrete slab on grade" "TPO roofing, 60 mil, fully adhered"
+    python predict.py --top-k 5 --divisions "8\" CMU wall, grout filled at 32\" o.c."
+    echo "Cat 6 data cabling and jacks" | python predict.py -
+    python predict.py --file items.txt --json > out.json
 
-Without arguments it classifies one example line item.
+ONNX (no torch, ~4 MB quantized weights):
+    pip install onnxruntime transformers
+    python predict.py --onnx onnx/model_quantized.onnx "Panelboards 208/120V 42 circuit"
+
+Without arguments it classifies one built-in example.
 """
+import argparse
+import json
 import sys
 
-from transformers import pipeline
-
 MODEL = "constructelligence/masterformat-classifier"
 
+# Division code -> name. Kept local so --divisions needs no extra package.
+DIVISIONS = {
+    "01": "General Requirements", "02": "Existing Conditions", "03": "Concrete",
+    "04": "Masonry", "05": "Metals", "06": "Wood, Plastics, and Composites",
+    "07": "Thermal and Moisture Protection", "08": "Openings", "09": "Finishes",
+    "10": "Specialties", "11": "Equipment", "12": "Furnishings",
+    "13": "Special Construction", "14": "Conveying Equipment", "21": "Fire Suppression",
+    "22": "Plumbing", "23": "HVAC", "25": "Integrated Automation", "26": "Electrical",
+    "27": "Communications", "28": "Electronic Safety and Security", "31": "Earthwork",
+    "32": "Exterior Improvements", "33": "Utilities", "34": "Transportation",
+    "35": "Waterway and Marine Construction", "40": "Process Interconnections",
+    "41": "Material Processing and Handling Equipment",
+    "43": "Process Gas and Liquid Handling, Purification, and Storage Equipment",
+    "44": "Pollution and Waste Control Equipment", "46": "Water and Wastewater Equipment",
+    "48": "Electrical Power Generation",
+}
+
+EXAMPLE = "4000 psi concrete slab on grade"
+
+
+def split_label(label):
+    """'03 30 00 Cast-in-Place Concrete' -> ('03 30 00', 'Cast-in-Place Concrete')."""
+    code, name = label[:8].strip(), label[8:].strip()
+    return code, (name or label)
+
+
+def division_rollup(preds):
+    """Sum level-2 probabilities by the first two digits (division)."""
+    totals = {}
+    for p in preds:
+        div = p["code"][:2]
+        totals[div] = totals.get(div, 0.0) + p["score"]
+    return [
+        {"code": d, "name": DIVISIONS.get(d, d), "score": s}
+        for d, s in sorted(totals.items(), key=lambda kv: -kv[1])
+    ]
+
+
+def hf_scorer(model, top_k):
+    from transformers import pipeline
+
+    clf = pipeline("text-classification", model=model, top_k=top_k)
+    return lambda texts: [[d for d in out] for out in clf(texts)]
+
 
-def main():
-    texts = sys.argv[1:] or ["4000 psi concrete slab on grade"]
-    clf = pipeline("text-classification", model=MODEL, top_k=3)
-    for text, preds in zip(texts, clf(texts)):
-        print(f"\n{text}")
+def onnx_scorer(path, top_k):
+    """Run onnx/model*.onnx directly. Mirrors scripts/export_onnx.py: inputs
+    input_ids / attention_mask / token_type_ids, output logits [batch, num_labels]."""
+    import numpy as np
+    import onnxruntime as ort
+    from pathlib import Path
+    from transformers import AutoTokenizer
+
+    # The labels and tokenizer live beside onnx/ in the repo; fall back to the Hub.
+    root = Path(path).resolve().parent.parent
+    src = str(root) if (root / "tokenizer.json").exists() or (root / "vocab.txt").exists() else MODEL
+    tok = AutoTokenizer.from_pretrained(src)
+    id2label = None
+    try:
+        c = json.loads((root / "config.json").read_text())
+        id2label = {int(k): v for k, v in c.get("id2label", {}).items()}
+    except Exception:
+        id2label = None
+    sess = ort.InferenceSession(path, providers=["CPUExecutionProvider"])
+    names = {i.name for i in sess.get_inputs()}
+
+    def score(texts):
+        enc = tok(texts, truncation=True, max_length=128, padding=True, return_tensors="np")
+        feed = {n: enc[n].astype(np.int64) for n in ("input_ids", "attention_mask", "token_type_ids") if n in names}
+        logits = sess.run(None, feed)[0]
+        idx = np.argsort(-logits, 1)[:, :top_k]
+        shifted = logits - logits.max(1, keepdims=True)
+        probs = np.exp(shifted) / np.exp(shifted).sum(1, keepdims=True)
+        out = []
+        for row, cols in zip(probs, idx):
+            out.append([{"label": id2label.get(int(c), str(int(c))), "score": float(row[c])} for c in cols])
+        return out
+
+    return score
+
+
+def predict(texts, score, top_k, want_div):
+    results = []
+    for text, preds in zip(texts, score(texts)):
+        pl = []
         for p in preds:
-            print(f"  {p['label']:64s} {p['score']:.3f}")
+            code, name = split_label(p["label"])
+            pl.append({"code": code, "label": p["label"], "name": name, "score": round(float(p["score"]), 4)})
+        item = {"text": text, "predictions": pl}
+        if want_div:
+            item["divisions"] = [dict(d, score=round(d["score"], 4)) for d in division_rollup(pl)]
+        results.append(item)
+    return results
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="MasterFormat level-2 classifier (mf-0.1).")
+    ap.add_argument("text", nargs="*", help="text to classify; use '-' to read lines from stdin")
+    ap.add_argument("--model", default=MODEL, help="HF repo id or local checkpoint dir")
+    ap.add_argument("--onnx", metavar="PATH", help="classify with an ONNX model instead of PyTorch")
+    ap.add_argument("--top-k", type=int, default=3, help="number of level-2 predictions to show")
+    ap.add_argument("--divisions", action="store_true", help="also show the level-1 (division) roll-up")
+    ap.add_argument("--file", help="read newline-separated inputs from a file")
+    ap.add_argument("--json", action="store_true", help="emit JSON instead of a table")
+    a = ap.parse_args(argv)
+
+    texts = list(a.text)
+    if a.file:
+        texts += [l.rstrip("\n") for l in open(a.file, encoding="utf-8") if l.strip()]
+    if "-" in texts:
+        texts = [t for t in texts if t != "-"] + [l.rstrip("\n") for l in sys.stdin if l.strip()]
+    if not texts:
+        texts = [EXAMPLE]
+    texts = [t for t in texts if t.strip()]
+    if not texts:
+        ap.error("no input text")
+
+    score = onnx_scorer(a.onnx, a.top_k) if a.onnx else hf_scorer(a.model, a.top_k)
+    results = predict(texts, score, a.top_k, a.divisions)
+
+    if a.json:
+        json.dump(results, sys.stdout, indent=2, ensure_ascii=False)
+        print()
+        return
+    for r in results:
+        print(f"\n{r['text']}")
+        for p in r["predictions"]:
+            print(f"  {p['code']} {p['name']:<48.48} {p['score']:.3f}")
+        if a.divisions:
+            print("  -- divisions --")
+            for d in r.get("divisions", []):
+                print(f"  {d['code']}      {d['name']:<48.48} {d['score']:.3f}")
 
 
 if __name__ == "__main__":

requirements.txt

@@ -0,0 +1,7 @@
+# Core inference (PyTorch)
+transformers>=4.40
+torch>=2.0
+
+# ONNX path: pip install -r requirements.txt onnxruntime
+# onnxruntime>=1.17
+# numpy>=1.24