Model card: minimal usage section, original card marked, minimal tags

README.md

@@ -4,78 +4,23 @@ base_model: microsoft/deberta-v3-large
 pipeline_tag: text-classification
 library_name: transformers.js
 tags:
-- typed-decisions
-- calibrated
-- decision-model
-- open-jev
-- deberta-v3
-- text-classification
 - deberta-v2
+- open-jev
 - onnx
 - transformers.js
-- transformersjs
 ---
 
 > This is a Transformers.js-ready ONNX conversion of the original Hugging Face model [com-kotobalabs/open-jev-deberta-v3-large](https://huggingface.co/com-kotobalabs/open-jev-deberta-v3-large).
 > The original model card content follows below.
 
-## ONNX conversion notes
-
-One graph runs the DeBERTa-v3-large encoder **and** the span-matching head, so
-a state with any number of typed questions is answered in a single forward
-pass, exactly like the source `OpenJev.decide()`.
-
-### Graph interface
-
-| name             | shape                     | dtype | meaning |
-| ---------------- | ------------------------- | ----- | ------- |
-| `input_ids`      | `[batch, seq]`            | int64 | `[CLS] [STATE] state [Q] instr [OPT] opt … [SEP]`, right padded with `[PAD]` (0) |
-| `attention_mask` | `[batch, seq]`            | int64 | 1 for real tokens |
-| `seg`            | `[batch, seq]`            | int64 | span slot of each token: option text tokens get their pair index, question text tokens get `pairs + question index`, everything else `-1` |
-| `pair_q`         | `[batch, pairs]`          | int64 | slot of the question of every (question, option) pair |
-| `pair_opt`       | `[batch, pairs]`          | int64 | slot of the option of every pair |
-| `logits`         | `[batch, pairs]`          | float32 (float16 in `fp16`/`q4f16`) | raw score per pair |
-
-Divide the logits of one question's pairs by the temperature (1.05) and
-softmax them; `choice` = argmax, `score` = expected level index, yes/no
-questions use the fixed option list `["no", "yes"]` and report p(yes). Batching
-several states: right-pad `input_ids`/`seg` (pad `seg` with `-1`) and pad the
-pair tensors with an unused slot such as `-2`.
-
-Pooling is done with equality masks and matrix products, so batch size,
-sequence length, and pair count are all dynamic and the graph has no
-data-dependent shapes. Context is 512 tokens (state cut to 256), as in the
-source. The three marker tokens (`[STATE]` 128001, `[Q]` 128002, `[OPT]`
-128003) are in `tokenizer.json`.
-
-### Variants
-
-| file | weights | size |
-| --- | --- | --- |
-| `onnx/model.onnx` | fp32 | 1.75 GB |
-| `onnx/model_fp16.onnx` | fp16, position-bucket math kept fp32 | 0.87 GB |
-| `onnx/model_q4.onnx` | 4-bit `MatMulNBits` (block 32, `accuracy_level=4`) + 4-bit embedding, fp32 activations | 0.48 GB |
-| `onnx/model_q4f16.onnx` | same 4-bit weights, fp16 activations | 0.34 GB |
-
-Accuracy against the original PyTorch model on 15 typed questions (banking77,
-SST-5, BoolQ rows and the example above): `fp32` and `fp16` reproduce every
-answer (max logit difference 1e-5 and 0.008); `q4` and `q4f16` agree on 14 of
-15 answers with probability shifts up to 0.2. No `q8` (`model_quantized.onnx`)
-is published: dynamic uint8 quantization, per-tensor or per-channel, changed
-the answer on 8 of the 15 questions, so it was rejected. Pass `dtype: "fp16"`
-(default), `"q4f16"`, `"q4"`, or `"fp32"`.
-
-Speed on an Apple M3 Max with WebGPU: the example below (3 questions, 17
-options, 103 tokens) takes about 50-65 ms per pass at `fp16` or `q4f16` once
-the model is warm; `fp32` on CPU in Node takes about 130 ms.
-
-### Transformers.js
-
-Load with `AutoModel` (the config is `deberta-v2`, so Transformers.js picks
-`DebertaV2Model`; its encoder forward feeds every graph input by name) and
-`AutoTokenizer` (`DebertaV2Tokenizer` reads the marker tokens from
-`tokenizer.json`). Everything below runs in the browser (`device: "webgpu"` or
-WASM) and in Node.
+## Usage with Transformers.js
+
+Variants under `onnx/`: `fp16` (default, 0.88 GB), `fp32` (1.75 GB), `q4`
+(0.48 GB), `q4f16` (0.35 GB). One state plus any number of typed questions go
+into a single sequence; one forward pass returns a logit per (question, option)
+pair. The graph takes the token ids, an attention mask, a span slot per token
+(`seg`: option tokens get their pair index, question tokens get
+`pairs + question index`, everything else `-1`) and the slot ids of each pair.
 
 ```js
 import { AutoModel, AutoTokenizer, Tensor } from "@huggingface/transformers";
@@ -87,25 +32,29 @@ const model = await AutoModel.from_pretrained(repo, { dtype: "fp16", device: "we
 const enc = (t) => Array.from(tokenizer(t, { add_special_tokens: false }).input_ids.data, Number);
 const [CLS, SEP, STATE, Q, OPT] = ["[CLS]", "[SEP]", "[STATE]", "[Q]", "[OPT]"].map((m) => enc(m)[0]);
 
-// one state, a list of questions ({type, instructions, options}); noul = ["no","yes"]
+const state = "I was charged twice for the same order. I want my money back now.";
+const questions = [
+  { type: "choice", instructions: "Which product area is the message about?", options: ["fees & charges", "refund & dispute", "card", "other"] },
+  { type: "noul", instructions: "The customer is asking for a refund.", options: ["no", "yes"] },
+];
+
 const tokens = [CLS, STATE, ...enc(state).slice(0, 256)];
-const seg = new Array(tokens.length).fill(-1);
+const seg = tokens.map(() => -1);
 const pairQ = [], pairOpt = [], groups = [];
 const totalPairs = questions.reduce((n, q) => n + q.options.length, 0);
 questions.forEach((q, qi) => {
-  const qSlot = totalPairs + qi;
   const text = enc(q.instructions);
-  tokens.push(Q, ...text); seg.push(-1, ...text.map(() => qSlot));
+  tokens.push(Q, ...text); seg.push(-1, ...text.map(() => totalPairs + qi));
   groups.push(q.options.map((option) => {
     const optText = enc(option);
     tokens.push(OPT, ...optText); seg.push(-1, ...optText.map(() => pairOpt.length));
-    pairQ.push(qSlot); pairOpt.push(pairOpt.length);
+    pairQ.push(totalPairs + qi); pairOpt.push(pairOpt.length);
     return pairOpt.length - 1;
   }));
 });
 tokens.push(SEP); seg.push(-1);
 
-const i64 = (values, dims) => new Tensor("int64", BigInt64Array.from(values, BigInt), dims);
+const i64 = (v, dims) => new Tensor("int64", BigInt64Array.from(v, BigInt), dims);
 const { logits } = await model({
   input_ids: i64(tokens, [1, tokens.length]),
   attention_mask: i64(tokens.map(() => 1), [1, tokens.length]),
@@ -116,24 +65,15 @@ const { logits } = await model({
 const scores = Array.from(logits.to("float32").data);
 const softmax = (xs) => { const m = Math.max(...xs); const e = xs.map((x) => Math.exp((x - m) / 1.05)); const s = e.reduce((a, b) => a + b); return e.map((x) => x / s); };
 const answers = groups.map((g) => softmax(g.map((p) => scores[p])));
-// choice: argmax; score: expected level index; noul: probability of "yes" (index 1)
+// choice: argmax; score: expected level index; noul (options ["no","yes"]): answers[i][1] is p(yes)
 ```
 
-To batch several states, right-pad `input_ids` with `0`, `attention_mask` with
-`0`, `seg` with `-1`, and the pair tensors with an unused slot such as `-2`;
-padded pairs produce meaningless logits that you simply ignore. In Node the
-same code runs with `device: "cpu"` or `"webgpu"`.
-
-### Limitations of the conversion
+The sequence is limited to 512 tokens (state cut to 256). Temperature 1.05 is
+the source model's calibration.
 
-- Standard ONNX operators only (opset 17); runs on any ONNX Runtime including
-  onnxruntime-web WASM and WebGPU.
-- The graph answers questions that fit the 512-token window with the state;
-  the host must split larger question sets across calls (the source raises
-  instead).
-- Everything else (English only, OOD gap, calibration) is inherited from the
-  source model and described below.
+---
 
+## Original model card
 
 # open-jev-deberta-v3-large