compiled artefacts from win_x64 (sm_120)

.gitattributes

@@ -36,3 +36,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 tokenizer.json filter=lfs diff=lfs merge=lfs -text
 code-daemon-denoise-v1-s_b64_s40_win_x64_tvm_vulkan.dll filter=lfs diff=lfs merge=lfs -text
 code-daemon-denoise-v1-s_win_x64_trt_sm_120.engine filter=lfs diff=lfs merge=lfs -text
+code-daemon-denoise-v1-s_linux_x64_trt11.0_sm_120.engine filter=lfs diff=lfs merge=lfs -text
+code-daemon-denoise-v1-s_win_x64_trt11.0_sm_120.engine filter=lfs diff=lfs merge=lfs -text
+code-daemon-denoise-v1_linux_x64_tvm0.25_vulkan.so filter=lfs diff=lfs merge=lfs -text
+code-daemon-denoise-v1_win_x64_tvm0.25_vulkan.dll filter=lfs diff=lfs merge=lfs -text

README.md

@@ -4,97 +4,192 @@ language:
 - en
 - ru
 tags:
-- feature-extraction
 - text-classification
+- feature-extraction
+- vocabulary-filtering
 - denoising
 - multilingual
+- quantized
+- int8
 - openvino
 - tensorrt
-pipeline_tag: feature-extraction
+pipeline_tag: text-classification
 base_model:
 - intfloat/multilingual-e5-small
 ---
 
 # code-daemon-denoise-v1
 
-A tiny, fast **bilingual (EN + RU) word denoiser** — it decides whether a single word form is a
-**meaningful technical term** (keep) or **noise / ballast** (drop). It ships with the
-[UltraCode](https://github.com/faxenoff/ultracode) MCP server, where it runs  in the knowledge-graph pipeline: classifying the UNKNOWN word forms harvested from a codebase's docs/identifiers so the search vocabulary stays clean.
+A **bilingual (EN + RU) word filter**: given one word form, it answers whether that word is a
+**meaningful technical term** worth keeping in a search vocabulary, or **ballast** to drop.
+
+It is deliberately small and one-purpose. A frozen `multilingual-e5-small` encoder produces a
+384-dim vector, and a **single trained affine** turns that vector into `P(keep)`. No fine-tuning of
+the encoder, no classification head with its own weights to load — the entire learned decision is
+384 numbers and a bias, shipped as a 6 KB JSON file.
+
+That buys throughput: **~800 words/sec on a CPU core**, **~17 800/sec on a laptop GPU**.
+
+```python
+emb = session.run(None, {"input_ids": ids, "attention_mask": mask})[0]   # [B, 384] pooled + L2
+p_keep = 1 / (1 + np.exp(-(emb @ w + b)))                               # the whole classifier
+```
+
+---
+
+## 1. What it is for
 
-- **Frozen encoder** — [`intfloat/multilingual-e5-small`](https://huggingface.co/intfloat/multilingual-e5-small)
-  (XLM-RoBERTa, 384-dim), **no weight changes**. Mean-pooling + L2-norm are baked into the graph.
-- **Trained linear head** — a logistic-regression probe (scikit-learn) over the 384-dim embedding,
-  **folded with its input scaler into a single affine** `P(keep) = sigmoid(w·e + b)`. Ships as
-  `denoise_head.json` (`{dim, w[384], b, strip_threshold}`) — no Python at runtime; the daemon does the dot product in-process.
-- **Vocab-pruned** — the 250k-token SentencePiece vocab is cut by character class to **Latin + Cyrillic + punctuation (142k tokens)**, lossless for EN + RU, dropping the INT8 weights from ~121 MB to **~76 MB**. The pruned-vocab id map is folded into a remap-Gather at the model input.
+Vocabulary hygiene. Harvest every word form out of a codebase — identifiers, doc prose, comments,
+commit messages — and most of what you get is not worth indexing: inflected function words, chopped
+identifier fragments, transliteration noise, boilerplate. Keeping them inflates a search vocabulary
+and dilutes term statistics; dropping them by frequency alone throws away rare-but-real technical
+terms, which are exactly the ones worth searching for.
 
-## How it was made
+This model makes that call per word, in both English and Russian, at a rate that keeps up with a
+full-repository scan.
 
-1. **Encoder**: export the frozen mE5-small to ONNX with mean-pool + L2-norm fused, prune the embedding table to the kept character classes, and PTQ-quantize to INT8 (NNCF) for OpenVINO.
-2. **Head**: embed a bilingual word-label set (EN: WordNet/BNC mid-frequency lemmas; RU:
-   Taiga/OpenCorpora/Nerus mid-Zipf) plus per-language manual gold, fit
-   `LogisticRegression(class_weight="balanced")`, then **fold** `StandardScaler` + LR into one `(w, b)`. A `strip_threshold` (default **0.95**) trades strip precision vs recall.
+**Suited to**
+- Filtering a harvested vocabulary before indexing.
+- Any per-token keep/drop decision over short, single-word inputs.
+- Mixed EN/RU corpora — including Cyrillic identifiers and comments.
 
-Words are embedded with a fixed `"vocab: "` prefix (the daemon pads every candidate word the same
-way) so very short inputs are not dropped by batch de-duplication — the head is trained on the
-**prefixed** embeddings, so reproduce the prefix for standalone use.
+**Not suited to**
+- Sentences or phrases. Inputs are single word forms; the sequence budget is 40 tokens.
+- Languages outside Latin/Cyrillic scripts — the vocabulary was pruned to those on purpose.
+- Domain term-vs-stopword calls outside software; the label set is technical-corpus flavoured.
 
-## Built for speed
+---
+
+## 2. Architecture
+
+| | |
+|---|---|
+| Encoder | [`intfloat/multilingual-e5-small`](https://huggingface.co/intfloat/multilingual-e5-small) — XLM-RoBERTa, **frozen, unchanged** |
+| Embedding dim | 384, mean-pooled and L2-normalised **inside the graph** |
+| Vocabulary | **142k** pieces, pruned from 250k by character class (Latin + Cyrillic + punctuation) |
+| Classifier | one affine: `P(keep) = sigmoid(w·e + b)`, `w ∈ ℝ³⁸⁴` |
+| Sequence | 40 tokens, batch 64 |
+| Inputs | `input_ids`, `attention_mask` |
+| Output | `[batch, 384]` — pooled, normalised, ready for the dot product |
+
+### Two decisions that make it small
+
+**The encoder is frozen.** The head is a logistic regression fitted on top of fixed embeddings, then
+folded — its `StandardScaler` and the LR coefficients are multiplied out into a single `(w, b)` pair.
+There is no scikit-learn at inference, and no second model to keep in sync: the decision boundary is
+a dot product you can apply in any language.
+
+**The vocabulary is pruned by script.** Cutting the 250k multilingual SentencePiece table to the
+Latin + Cyrillic + punctuation pieces removes ~43% of the rows, and the embedding table is most of
+this model's weight. The pruned-vocab id remap is baked into the graph as a Gather at the input, so
+callers still feed ordinary SentencePiece ids and never see the mapping. INT8 weights drop from
+~121 MB to **~76 MB** — lossless for the two languages it targets, because nothing outside those
+scripts was reachable anyway.
+
+### The `"vocab: "` prefix
+
+Words are embedded with a fixed `"vocab: "` prefix. The head was trained on prefixed embeddings, so
+**reproduce the prefix** for standalone use or the decision boundary will not line up.
+
+---
 
-- **Short, single-word inputs** — one length bucket only: **batch 64 × seq 40** (`-s_…_b64_s40`).
-- **INT8** weights (OpenVINO CPU); the embedding **mean-pool + L2-norm are fused** into the graph so
-  the output is already `[batch, 384]`.
-- **CPU-first by design** — on the daemon it runs on OpenVINO CPU and is moved to a discrete GPU
-  (TensorRT / TVM) only when the card is large (≥12 GB total VRAM) with free room.
+## 3. How it was made
 
-## Intended use
+1. **Encoder** — export the frozen mE5-small to ONNX with mean-pooling and L2-norm fused into the
+   graph, prune the embedding table to the kept character classes, and PTQ-quantize to INT8 (NNCF).
+2. **Head** — embed a bilingual labelled word set (English: WordNet / BNC mid-frequency lemmas;
+   Russian: Taiga / OpenCorpora / Nerus mid-Zipf) plus per-language hand-checked gold, fit
+   `LogisticRegression(class_weight="balanced")`, then fold the scaler and the LR into one affine.
 
-Per-word "is this a technical term?" classification for cleaning a search vocabulary. Encode a word
-(with the `"vocab: "` prefix) with the bundled SentencePiece + mE5-small, then apply the linear head:
+`strip_threshold` (default **0.95**) sets where you cut. It is high on purpose: dropping a real
+technical term is the expensive error, keeping a bit of ballast is not.
+
+---
+
+## 4. Speed
+
+Measured on one laptop: Intel Core Ultra 9 275HX / NVIDIA RTX 5060 Laptop, batch 64 × seq 40.
+
+| lane | per batch | throughput | per word |
+|---|--:|--:|--:|
+| **TensorRT FP16, RTX 5060 Laptop** | **3.60 ms** | **17 790 words/s** | 0.056 ms |
+| **OpenVINO INT8, CPU** | **80.4 ms** | **796 words/s** | 1.26 ms |
+| ONNX Runtime FP32, CPU | 188 ms | 341 words/s | 2.93 ms |
+
+The INT8 CPU lane is the intended default — 800 words/sec is enough to filter a repository's whole
+harvested vocabulary in seconds without touching a GPU, and it is 2.3× the unquantized ONNX path.
+The GPU lane exists for hosts that have spare VRAM anyway.
+
+---
+
+## 5. Standalone use
 
 ```python
-import onnxruntime as ort, sentencepiece as spm, numpy as np, json
+import json, numpy as np, onnxruntime as ort, sentencepiece as spm
 
 sp   = spm.SentencePieceProcessor(model_file="sentencepiece.bpe.model")
 sess = ort.InferenceSession("model.onnx", providers=["CPUExecutionProvider"])
-head = json.load(open("denoise_head.json"))          # {dim, w[dim], b, strip_threshold}
+head = json.load(open("denoise_head.json"))            # {dim, w[384], b, strip_threshold}
 w, b, thr = np.array(head["w"], np.float32), head["b"], head["strip_threshold"]
 
 def p_keep(words, max_len=40):
     toks = [[2, *sp.encode("vocab: " + x)[: max_len - 2], 3] for x in words]   # bos … eos
     L    = max(len(t) for t in toks)
-    ids  = np.array([t + [0] * (L - len(t)) for t in toks], dtype=np.int64)    # pad=0
+    ids  = np.array([t + [0] * (L - len(t)) for t in toks], dtype=np.int64)    # pad = 0
     mask = (ids != 0).astype(np.int64)
-    emb  = sess.run(None, {"input_ids": ids, "attention_mask": mask})[0]       # mean-pooled+L2 [B,384]
-    return 1.0 / (1.0 + np.exp(-(emb @ w + b)))                                # P(keep)
+    emb  = sess.run(None, {"input_ids": ids, "attention_mask": mask})[0]       # [B, 384]
+    return 1.0 / (1.0 + np.exp(-(emb @ w + b)))
 
 scores = p_keep(["mutex", "tensorrt", "пожалуйста", "asdfgh"])
-# keep where score >= thr ; the rest is ballast
+keep   = scores >= thr
 ```
 
-## What's in this repo
+The ONNX bakes in the fairseq `+1` id offset and the pruned-vocab remap, so feed raw SentencePiece
+ids — do not remap them yourself.
 
-Pre-compiled, ready-to-run engines named per **runtime × GPU arch × OS** (single `s` bucket):
+---
 
-- **OpenVINO** `*_ov_cpu_int8_b64_s40.{xml,bin}` — Intel/AMD/any CPU, INT8 (the default lane).
-- **TensorRT** `*_{win_x64,linux_x64}_trt_sm_{86,89,120}.engine` — NVIDIA, BF16 (optional GPU lane;
-  the INT8 lane is OV CPU — this remap-baked SentencePiece ONNX isn't compatible with generic INT8 PTQ).
-- **TVM** `*_b64_s40_{win_x64,…}_tvm_vulkan.{dll,so}` — Vulkan fallback (optional GPU lane).
-- **Head** — `denoise_head.json` (the trained affine; required).
-- **Tokenizer** — `sentencepiece.bpe.model` (+ `tokenizer_config.json`). The daemon feeds raw
-  SentencePiece ids; the fairseq +1 offset and pruned-vocab remap are baked into the ONNX.
-- **ONNX source** — `model.onnx` (FP32, pruned, mean-pool + L2-norm + remap fused) — the build
-  source for the TRT/TVM engines and for standalone `onnxruntime` use.
+## 6. Evaluation
 
-## Evaluation
+On a frozen held-out bilingual word set, at `strip_threshold = 0.95`:
 
-On a frozen held-out word set (EN + RU): **SAFE F1 ≈ 0.79**, BALLAST F1 ≈ 0.84, strip precision ≈
-0.88 at `strip_threshold = 0.95`. The INT8 vocab-pruned build matches the full-vocab FP build (F1 0.79
-vs 0.79) at 38 % of the size.
+| metric | value |
+|---|--:|
+| SAFE (keep) F1 | **0.79** |
+| BALLAST (drop) F1 | **0.84** |
+| Strip precision | **0.88** |
 
-## License & attribution
+The INT8 vocab-pruned build scores the same as the full-vocabulary FP build (F1 0.79 vs 0.79) at
+38% of the size — the pruning removes rows the two target languages never reach, so there is nothing
+to lose by it.
+
+Strip precision is the number to watch if you tune the threshold: it says how often a word the model
+drops really was ballast.
+
+---
+
+## 7. What is in this repo
+
+- **OpenVINO INT8** — `code-daemon-denoise-v1-s_ov2026.2_{cpu,igpu_lnl}_int8_b64_s40.{xml,bin}` — the
+  default lane (CPU) and an Intel iGPU build.
+- **OpenVINO INT4, NPU** — `code-daemon-denoise-v1-s_ov2026.2_npu_int4_b16_s40.{xml,bin}` — weight-only
+  INT4 at batch 16 for Intel NPUs.
+- **TensorRT FP16** — `code-daemon-denoise-v1-s_{win_x64,linux_x64}_trt11.0_sm_120.engine`.
+- **TVM Vulkan** — `code-daemon-denoise-v1_{win_x64,linux_x64}_tvm0.25_vulkan.{dll,so}` — GPU fallback
+  for non-NVIDIA hardware.
+- **Head** — `denoise_head.json`. **Required**: the ONNX alone emits embeddings, not a decision.
+- **Tokenizer** — `sentencepiece.bpe.model`, `tokenizer_config.json`.
+- **ONNX** — `model.onnx`, FP32, pruned, with mean-pool + L2-norm + id-remap fused. The build source
+  for every engine above and the path for standalone `onnxruntime` use.
+
+---
+
+## 8. License & attribution
 
 The encoder weights are **[`intfloat/multilingual-e5-small`](https://huggingface.co/intfloat/multilingual-e5-small)**
-(Apache-2.0), redistributed here in compiled form **unchanged**; this repo is therefore released under
-**Apache-2.0**. The linear head and the build/quantization tooling are original to UltraCode. Backbone:
-XLM-RoBERTa. Not legal advice.
+(Apache-2.0), redistributed here in compiled form **unchanged**; this repository is therefore
+released under **Apache-2.0**. The trained head and the build/quantization tooling are original.
+Backbone: XLM-RoBERTa. Not legal advice.
+
+Used by the [UltraCode](https://github.com/faxenoff/ultracode) code assistant, though nothing about
+the model is specific to it.

code-daemon-denoise-v1-s_linux_x64_trt11.0_sm_120.engine

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:85b1b7cc8dbbafabd233b69f8aa5e5324efd7ffd91b934967784fa8a060a5159
+size 157032332

code-daemon-denoise-v1-s_ov2026.2_cpu_int8_b64_s40.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4de341144ca02c3c1a83e46e76044f2465f0a552d0a69bac2c4bc469604edc22
+size 79105245

code-daemon-denoise-v1-s_ov2026.2_igpu_lnl_int8_b64_s40.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4de341144ca02c3c1a83e46e76044f2465f0a552d0a69bac2c4bc469604edc22
+size 79105245

code-daemon-denoise-v1-s_ov2026.2_npu_int4_b16_s40.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ae5a768b271ed4c7b6b01489ea821c66730aae14d14af297d3b414f9cd234f9
+size 68668863

code-daemon-denoise-v1-s_win_x64_trt11.0_sm_120.engine

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab8c8235b0af77d50ef0358166a4177be33949e424b29cc5b91d0ac1aba4b9d1
+size 157001948

code-daemon-denoise-v1_linux_x64_tvm0.25_vulkan.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cceaae57b2d913510d1fa16f83887c61634e0c784432ed606b6dfdd3e724e3ae
+size 331723344

code-daemon-denoise-v1_win_x64_tvm0.25_vulkan.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c377dce734bd31868ec6162747006f33c79c2e171c0903362842739fb62179a3
+size 331560448

manifest.json

@@ -0,0 +1,19 @@
+{
+  "model_id": "code-daemon-denoise-v1",
+  "dimension": 384,
+  "max_tokens": 40,
+  "quantization": "int8",
+  "targets": [
+    "openvino",
+    "tensorrt",
+    "tvm"
+  ],
+  "runtime_tags": {
+    "trt": "trt11.0",
+    "ov": "ov2026.2",
+    "tvm": "tvm0.25",
+    "mlx_dir": "model_gpu_mlx0.22"
+  },
+  "compiled_at": "2026-08-03T14:52:07Z",
+  "compiled_by": "models/_compile"
+}