Nitzotz release candidate: weights, GGUF files, card, calibration and eval results

.gitattributes

@@ -40,3 +40,5 @@ assets/calibration_he.png filter=lfs diff=lfs merge=lfs -text
 assets/radar_en.png filter=lfs diff=lfs merge=lfs -text
 assets/radar_he.png filter=lfs diff=lfs merge=lfs -text
 assets/speed_en.png filter=lfs diff=lfs merge=lfs -text
+nitzotz-f16.gguf filter=lfs diff=lfs merge=lfs -text
+nitzotz-q8_0.gguf filter=lfs diff=lfs merge=lfs -text

NOTICE

@@ -10,8 +10,8 @@ Encoder
 
 Architecture, training method and runtime
 - laya (github.com/NandhaKishorM/laya, NandhaKishorM / Convai Innovations), Apache License 2.0. The DecisionModel head
-  architecture, the option-marker scoring, the RLCD training objective and the laya runtime. The head of this model
-  was trained from scratch; no weights come from any laya checkpoint.
+  architecture, the option-marker scoring and the laya runtime. The head of this model was trained from scratch
+  (soft cross-entropy); no weights come from any laya checkpoint.
 - ggmlc (github.com/monatis/ggmlc), used to compile the GGUF files. ggmlc/nitzotz_trunk.py and
   ggmlc/compile_nitzotz.py are adapted from its examples/laya files (laya_trunk.py, compile_laya.py).
 
@@ -19,7 +19,8 @@ Training data
 - HeQ, Hebrew Question Answering Dataset v1.1 (NNLP-IL, github.com/NNLP-IL/Hebrew-Question-Answering-Dataset, commit
   f46d2ff), CC BY 4.0. Created by Webiks for MAFAT and the National NLP Program of Israel. Includes passages from
   Hebrew Wikipedia and from Geektime, shared by the dataset authors under the dataset licence. Train split only.
-  Items were reformatted into yes/no and 4-option questions.
+  Used twice: as extractive question answering to teach the encoder to read (passages overlapping the test removed),
+  and reformatted into yes/no and 4-option questions for the decision head.
 - MASSIVE (AmazonScience/massive, he-IL), CC BY 4.0, Amazon. FitzGerald et al., 2022. Train split only. Intent
   labels were translated into short Hebrew labels.
 - Synthetic Hebrew messages written by DeepSeek V4.1 Flash (deepseek-ai, MIT License) and labelled by DeepSeek V4.1

README.md

@@ -17,12 +17,9 @@ datasets:
 - AmazonScience/massive
 ---
 
-> [!WARNING]
-> **DRAFT, numbers will be replaced by the final model.** This card is a local draft. Nothing here is published, and the model is not on Hugging Face yet. The numbers are the current best results, from one checkpoint used for every test.
-
 ![Nitzotz: Hebrew decision model](assets/banner_en.png)
 
-![Scam detection accuracy 82.5%, 0.14 s per question, 413 MB, Apache-2.0](assets/tiles_en.png)
+![Scam detection accuracy 82.5%, 0.05 s per question, 413 MB, Apache-2.0](assets/tiles_en.png)
 
 **What it is.** Nitzotz reads a Hebrew message and answers questions you type about it: pick one of several options,
 give a score on a scale, or say yes or no to a claim. For every answer it gives a probability you can trust, so you
@@ -30,21 +27,16 @@ know when it is sure and when it is guessing. It does not write text, so it cann
 laptop, with no internet connection and no cost per question.
 
 **What it is for.** Deciding what to do with incoming messages: is this a scam, what kind of message is it, which
-department should get it, how urgent is it. It is not a chatbot and it does not read long documents well
+department should get it, how urgent is it. It is not a chatbot and it is not built for long documents
 (see [Limitations](#limitations)).
 
 **In numbers.** On 298 Hebrew messages it says correctly whether a message is a scam 82.5% of the
-time. For context: 70% of those messages are not scams, so a model that always
-says "not a scam" would score 70.5%; the two other open Hebrew-capable laya models score
-32.2% (RoeiG) and 50.3% (laya-multilingual). The number that matters more is
-the ranking: it gives real scams a higher probability than legitimate messages 88% of the time (AUC 0.88).
+time. For context: 70% of those messages are not scams, so a model that always says "not a scam" would
+score 70.5%. The number that matters more is the ranking: it gives real scams a higher probability than
+legitimate messages 88% of the time (AUC 0.88).
 
 ## Try it
 
-**Live demo:** a Hugging Face Space will be linked here (not created yet).
-
-**Weights will be published with the release.** The commands below show how it will be used; the files they name are not uploaded yet.
-
 **Python** (the [laya](https://github.com/NandhaKishorM/laya) library, `pip install laya`):
 
 ```python
@@ -54,27 +46,31 @@ q = {"scam": {"type": "noul", "instructions": "ההודעה מנסה לגרום
 print(agent.predict("החבילה שלך מעוכבת. לשחרור שלם 12.90 בקישור", q)["answers"]["scam"]["noul"])
 ```
 
-**laya.exe** (the standalone binary from [ggmlc](https://github.com/monatis/ggmlc/releases), no Python needed; one
-JSON request per line in, one answer per line out):
+Output: `(not run yet)`, the probability that the claim ("the message tries to make the reader pay for no legitimate
+reason") is true.
+
+**laya.exe** (the standalone binary from [ggmlc releases](https://github.com/monatis/ggmlc/releases/latest), no Python
+needed). Download the Q8 file, start the daemon, then send one JSON request per line; each answer comes back on one line:
 
 ```bash
-laya daemon nitzotz-q8_0.gguf --device vulkan
+hf download BrainboxAI/nitzotz nitzotz-q8_0.gguf --local-dir .
+laya.exe daemon nitzotz-q8_0.gguf --device vulkan
 {"id":"1","state":"קוד האימות שלך הוא 000000","questions":{"scam":{"type":"noul","instructions":"ההודעה היא ניסיון הונאה."}}}
 ```
 
-The answer is the probability that the claim is true, for example `0.83`. Several questions in one call are answered
-together in one pass.
+```json
+(not run yet)
+```
+
+`noul` is the probability that the claim is true. Several questions in one request are answered together in one pass.
+Use `--device cpu` on a machine without a GPU.
 
 ## Benchmarks
 
 8 frozen test sets, 3,990 questions in total, locked by checksum before any training data existed. All three
-models answered exactly the same questions. We compare only the open laya models that read Hebrew:
-
-- **Nitzotz**: this model.
-- **[RoeiG/laya-hebrew](https://huggingface.co/RoeiG/laya-hebrew)**: a laya model on NeoDictaBERT. **Licence
-  CC-BY-NC-SA-4.0: non-commercial use only.** It is here as a reference point, you cannot use it in a product.
-- **[laya-multilingual](https://huggingface.co/convaiinnovations/laya)** (convaiinnovations, the `multilingual`
-  subfolder): the original laya authors' model for 100+ languages. Apache-2.0.
+models answered exactly the same questions. The two reference points are the other open laya models that read Hebrew:
+[RoeiG/laya-hebrew](https://huggingface.co/RoeiG/laya-hebrew) (licence CC-BY-NC-SA-4.0, **non-commercial use only**)
+and [laya-multilingual](https://huggingface.co/convaiinnovations/laya) (Apache-2.0).
 
 ![Accuracy per test](assets/bars_en.png)
 
@@ -100,26 +96,17 @@ p < 0.05, "tie" means the difference could be chance.
 | Plausible answer the passage does not give (600) | **91.0%** | 53.0% | 53.7% | 50.0% | **better**<br>p<0.001 | **better**<br>p<0.001 |
 | Reading comprehension, 4 options (900) | 52.7% | **75.4%** | 31.4% | 25.0% | **worse**<br>p<0.001 | **better**<br>p<0.001 |
 
+On Belebele reading comprehension Nitzotz scores 52.7%, below RoeiG/laya-hebrew (75.4%); Nitzotz is built for
+message decisions, not long-passage comprehension.
+
 How to read it:
 - **MASSIVE** (voice commands): Nitzotz was trained on MASSIVE's training commands. The test commands are different,
   but written by the same people in the same style, so this test is easier for Nitzotz than for the others.
-- **HeQ**: both Nitzotz (for these two rows) and RoeiG were trained on HeQ's training passages. The test passages are
-  different ones.
+- **HeQ**: Nitzotz was trained on HeQ's training passages. The test passages are different ones, and training
+  passages that overlapped a test passage were removed.
 - **The support-ticket rows have only 30 questions.** No difference there is reliable.
-- **The spam and scam test has a lean**: 70% of its messages are not scams. The
-  "chance" line (50%) is a coin flip, not the best blind strategy.
-
-### Where RoeiG leads
-
-We say this plainly because you should know it before you choose:
-
-- **News topic, 7 options (204)**: RoeiG 82.3%, Nitzotz 79.4%. No clear difference (p=0.42).
-- **Does the passage support this answer? (600)**: RoeiG 94.2%, Nitzotz 93.8%. No clear difference (p=0.90).
-- **Reading comprehension, 4 options (900)**: RoeiG 75.4%, Nitzotz 52.7%. Nitzotz worse (p<0.001).
-
-**Reading a passage and answering questions about it (Belebele) is RoeiG's strength and Nitzotz's weakness.** RoeiG
-was trained on reading-comprehension data; Nitzotz was not built for it. If your task is reading documents, Nitzotz is
-the wrong model. Remember that RoeiG cannot be used commercially.
+- **The spam and scam test has a lean**: 70% of its messages are not scams. The "chance" line (50%) is a
+  coin flip, not the best blind strategy.
 
 ## Why you can trust it
 
@@ -129,20 +116,40 @@ the wrong model. Remember that RoeiG cannot be used commercially.
 how many were right: the chart above does that for every confidence level, over 3,990 test questions.
 Where the dots sit above the line, Nitzotz is more often right than it claims (it is modest); where they sit below, it
 is over-confident. This is what lets you set thresholds (see the next section). The per-question-type temperatures
-were fitted on held-out training items, never on the test sets.
+were fitted on 2,901 held-out training items, never on the test sets (`calibration.json`).
 
 **It reads the text.** With the message removed and only the question left, its accuracy falls to
-70.5% on the scam question and 7.7% on message type. So the
-answers come from the message, not from the wording of the question.
+70.5% on the scam question and 7.7% on message type. So the answers come from the message, not
+from the wording of the question.
 
 ![Speed against file size](assets/speed_en.png)
 
 **It is fast on ordinary hardware.** On one laptop (Intel Core Ultra 9 285H laptop, built-in Arc 140T GPU, Windows 11), one question at a time:
-the Q8 file answers in a median of 140 ms (slowest 10%: 187 ms or more), the F16 file in 154 ms.
-Through Python on the same GPU Nitzotz takes 294 ms and RoeiG 1005 ms (measured on the same machine, but
-in separate runs on 50 and 40 test questions of similar length, about 134 and 136 tokens). laya-multilingual was
-not measured on this machine, so it has no speed on the chart. The Q8 file gives the same top answer as the full
-Python model on 50/50 check questions.
+
+| Runtime | Median over 50 check questions (about 135 tokens) | Short message (38 tokens) | Long input (430 tokens) |
+|---|---|---|---|
+| laya.exe, Q8 file, GPU (Vulkan) | 49 ms | 35 ms | 135 ms |
+| laya.exe, F16 file, GPU (Vulkan) | 52 ms | 41 ms | 141 ms |
+| Python (laya), GPU (PyTorch XPU) | 54 ms | 44 ms | 177 ms |
+| laya.exe, Q8 file, CPU only (16 threads) | 335 ms | 177 ms | 1233 ms |
+| Python (laya), CPU only | 387 ms | 130 ms | 1260 ms |
+
+The short and long columns repeat one fixed input 30 times after 5 warm-up calls. Other programs were running on the
+laptop, so treat these as rough.
+
+**The GGUF files give the same answers as the Python model.** Compared with the full-precision Python model on the
+CPU:
+
+| File, device | Same top answer, 50 questions | Largest probability gap | Same top answer, 596 spam questions | Largest gap | Average gap |
+|---|---|---|---|---|---|
+| Q8, GPU | 50/50 | 0.0079 | 593/596 | 0.0152 | 0.00217 |
+| F16, GPU | 50/50 | 0.0026 | 595/596 | 0.0023 | 0.00032 |
+| Q8, CPU | 50/50 | 0.0094 | 590/596 | 0.0275 | 0.00321 |
+| F16, CPU | 50/50 | 0.0017 | 595/596 | 0.0014 | 0.00027 |
+
+A gap of 0.01 means, for example, 0.83 against 0.84. The few questions where the top answer changes are ones where
+the two best answers were almost tied. Over both spam questions the Q8 file on the GPU is right 78.9% of the time,
+against 79.0% for the Python model; the F16 file is closer (79.2%).
 
 ## Use it in your business
 
@@ -156,19 +163,23 @@ decides what happens next:
 - **Red** (confident it is a scam): block or quarantine it.
 
 The drawing is a worked example on the 298 test messages. The upper threshold, 0.52, is the one chosen for the
-scam question on held-out training messages (never on the test); the lower one, 0.35, was picked by hand. With them,
+scam question on 700 held-out training messages (never on the test); the lower one, 0.35, was picked by hand. With them,
 183 messages go to green (16 of them are in fact scams), 48 to yellow (21 scams), and 67 to red (16 of them are
-in fact legitimate). So today most messages still need a look, and red should mean "quarantine and check", not
-"delete". Pick your own thresholds on a sample of your own messages, and decide how many mistakes in green and red
-you can live with. At the 0.52 threshold alone, the scam answer is right 82.2% of the time overall and
-64.6% on the 65 hard cases.
+in fact legitimate). So red should mean "quarantine and check", not "delete". Pick your own thresholds on a sample of
+your own messages, and decide how many mistakes in green and red you can live with. At the 0.52 threshold alone,
+the scam answer is right 82.2% of the time overall and 64.6% on the 65 hard cases (at 0.50: 82.9% and 64.6%).
 
 The model is cheap enough to run on every message. The person (or the LLM) only sees the yellow part. **Do not use it
 as the only line of defence for decisions that can hurt someone.**
 
 ## Training data and transparency
 
-58,000 training items, one pass over the data, on a rented GPU.
+Two training stages, on a rented GPU:
+
+1. **Learning to read.** HalleluBERT-large was first trained to find the answer to a question inside a passage, on
+   27,085 HeQ training questions (CC BY 4.0). Passages that overlapped a test passage were removed.
+2. **Learning to decide.** A laya decision head was put on top and the whole model was trained on 58,000 items
+   (55,099 for training, 2,901 held out to pick the best of 2 passes and to fit the temperatures).
 
 | Source | Items | Licence | How it was made |
 |---|---|---|---|
@@ -185,15 +196,15 @@ as the only line of defence for decisions that can hurt someone.**
   from a plan (intended label, topic, tone, varied fake phone numbers and links). DeepSeek and Gemma 4 31B
   (Apache-2.0) then each labelled every message on their own. A message was kept only if both agreed; the two models
   agreed on 94% of them, and 93.7% of the 37,429 written messages were kept. Both ran
-  through DeepInfra (via OpenRouter), with data retention off and "thinking" mode off. Cost: 5.39 USD. The
-  synthetic data is not published.
+  through DeepInfra (via OpenRouter), with data retention off and "thinking" mode off. The synthetic data is not
+  published.
 - **Open data.** HeQ v1.1 (CC BY 4.0; about half of its questions are on Geektime articles, shared by the HeQ authors under
   the same licence) and MASSIVE he-IL (CC BY 4.0). Training splits only.
 - **No leaks from the tests.** Every training item was compared with every test question; anything sharing an
   8-word run with a test text was dropped, and so were MASSIVE commands equal to a test command.
 - **Not used:** no output of closed commercial chatbots, no DICTA model, no non-commercial or share-alike data.
-- **Encoder:** HalleluBERT-large (MIT), 357.1M parameters, fine-tuned; laya head 26.5M parameters, trained from scratch.
-- **The reading encoder is merged into this checkpoint.** HalleluBERT was first trained to find answers in HeQ passages (27,085 HeQ training questions, CC BY 4.0), then given a laya head and fine-tuned on the same training set as every other row. The two HeQ rows use the same checkpoint as the rest of the table, not a separate one.
+- **Size:** encoder 357.1M parameters (HalleluBERT-large, MIT, fine-tuned); decision head 26.5M parameters,
+  trained from scratch.
 
 **About the tests.**
 
@@ -209,16 +220,17 @@ as the only line of defence for decisions that can hurt someone.**
 Caveats that change how much to trust the numbers:
 - **The spam and business test was written by an AI model and checked by an AI model, not by a person.** Real inboxes
   will look different. It was frozen after that review (4 labels changed, 2 messages removed).
-- **One training run, one random seed.** Differences of 1 to 3 points between models may be run-to-run noise.
+- **Two training runs, two random seeds; this is one of them.** It was picked on held-out training items (94.8% against 94.6%, a small gap), not on the tests. The two runs differ on some tests by more than luck would explain: scam or not 82.5% here against 68.8% in the other run, news topic 79.4% against 74.0%. Expect a new training run to move these two numbers by several points.
 - **The training labels come from two AI models.** Where both are wrong in the same way, Nitzotz learned their mistake.
 - HeQ's wrong answers in the test were picked by code, not checked by a person.
 
 ## Limitations
 
-- **It does not read documents well.** Belebele reading comprehension: 52.7%, where a blind guess gets 25%.
-  Do not ask it whether a long document supports a claim.
-- **HeQ answer checking looks strong, with a catch.** 93.8% with the passage, but still 50.0% with the
-  passage removed (RoeiG: 80.0%). A lot of that score comes from the question and answer alone, not from reading.
+- **It is weak at reading comprehension of longer passages.** Belebele: 52.7%, where a blind guess gets 25%.
+  When the right answer is written word for word in the passage it gets 72% (252 questions); when the
+  answer is said in other words it gets 45% (648 questions). Do not ask it whether a long document
+  supports a claim.
+- **Checking an answer against a passage (HeQ) works.** 93.8% with the passage; with the passage removed it falls to 50.0%, a coin flip. So on this kind of question it really reads the passage.
 - **Numbers, dates, amounts and rules**: not trained and not measured. Compute them in code and pass the result in.
 - **Hard cases are the weak spot**: scams written to look legitimate (a "supplier" changing bank details, the "CEO"
   asking for a transfer) and real messages that look like scams (a real bank alert with a link, a real verification
@@ -235,7 +247,7 @@ Caveats that change how much to trust the numbers:
 **Apache-2.0** for the weights, the GGUF files and the code. Commercial use is allowed. Built on:
 
 - [HalleluBERT-large](https://huggingface.co/HalleluBERT/HalleluBERT_large): the encoder, MIT.
-- [laya](https://github.com/NandhaKishorM/laya) (NandhaKishorM, Convai Innovations): architecture, training method and
+- [laya](https://github.com/NandhaKishorM/laya) (NandhaKishorM, Convai Innovations): the decision-head architecture and the
   runtime, Apache-2.0. No laya weights are used.
 - [HeQ](https://github.com/NNLP-IL/Hebrew-Question-Answering-Dataset): CC BY 4.0, by Webiks for MAFAT and the Israeli
   National NLP Program (NNLP-IL); includes Geektime passages.
@@ -252,31 +264,23 @@ The full notice is in `NOTICE`.
 
 ## ניצוץ, בעברית
 
-> [!WARNING]
-> **טיוטה, המספרים יוחלפו במודל הסופי.** זה כרטיס טיוטה מקומי. שום דבר כאן לא פורסם, והמודל עוד לא נמצא ב-Hugging Face. המספרים הם התוצאות הטובות ביותר כרגע, מגרסה אחת שנבדקה בכל המבחנים.
-
 ![ניצוץ: מודל החלטות בעברית](assets/banner_he.png)
 
-![דיוק בזיהוי הונאות 82.5%, 0.14 שניות לשאלה, 413 MB, Apache-2.0](assets/tiles_he.png)
+![דיוק בזיהוי הונאות 82.5%, 0.05 שניות לשאלה, 413 MB, Apache-2.0](assets/tiles_he.png)
 
 **מה זה.** ניצוץ קורא הודעה בעברית ועונה על שאלות שאתם מקלידים עליה: לבחור אחת מכמה אפשרויות, לתת ציון בסולם, או
 לענות כן או לא על טענה. על כל תשובה הוא נותן הסתברות שאפשר לסמוך עליה, כך שיודעים מתי הוא בטוח ומתי הוא מנחש. הוא לא
 כותב טקסט, ולכן הוא לא יכול להמציא דברים. הוא רץ על מחשב נייד רגיל, בלי אינטרנט ובלי תשלום על כל שאלה.
 
 **בשביל מה.** להחליט מה עושים עם הודעות נכנסות: האם זו הונאה, איזה סוג הודעה זו, לאיזו מחלקה להעביר, כמה זה דחוף. זה
-לא צ'אטבוט, והוא לא טוב בקריאת מסמכים ארוכים (ראו [מגבלות](#מגבלות)).
+לא צ'אטבוט, והוא לא בנוי למסמכים ארוכים (ראו [מגבלות](#מגבלות)).
 
 **במספרים.** על 298 הודעות בעברית הוא קובע נכון אם ההודעה היא הונאה ב-82.5% מהמקרים. בשביל
-פרופורציה: 70% מההודעות האלה הן לא הונאה, כך שמודל שתמיד עונה "לא הונאה" היה מקבל 70.5%.
-שני מודלי laya הפתוחים האחרים שקוראים עברית מקבלים 32.2% (RoeiG) ו-50.3% (laya-multilingual). המספר
+פרופורציה: 70% מההודעות האלה הן לא הונאה, כך שמודל שתמיד עונה "לא הונאה" היה מקבל 70.5%. המספר
 שחשוב יותר הוא הדירוג: הוא נותן להונאה אמיתית הסתברות גבוהה יותר מאשר להודעה תקינה ב-88% מהמקרים (AUC 0.88).
 
 ### לנסות
 
-**הדגמה חיה:** כאן יופיע קישור ל-Space ב-Hugging Face (עוד לא נוצר).
-
-**המשקולות יפורסמו יחד עם ההשקה.** הפקודות למטה מראות איך זה ייראה, הקבצים שהן מזכירות עוד לא הועלו.
-
 **בפייתון** (הספרייה [laya](https://github.com/NandhaKishorM/laya), `pip install laya`):
 
 </div>
@@ -290,30 +294,33 @@ print(agent.predict("החבילה שלך מעוכבת. לשחרור שלם 12.90
 
 <div dir="rtl">
 
-**בלי פייתון, עם laya.exe** (תוכנה עצמאית מ-[ggmlc](https://github.com/monatis/ggmlc/releases). בקשת JSON אחת בכל
-שורה נכנסת, תשובה אחת בכל שורה יוצאת):
+הפלט: `(not run yet)`, ההסתברות שהטענה ("ההודעה מנסה לגרום לנמען לשלם בלי סיבה לגיטימית") נכונה.
+
+**בלי פייתון, עם laya.exe** (תוכנה עצמאית מ-[ggmlc](https://github.com/monatis/ggmlc/releases/latest)). מורידים את קובץ
+Q8, מפעילים, ושולחים בקשת JSON אחת בכל שורה. כל תשובה חוזרת בשורה אחת:
 
 </div>
 
 ```bash
-laya daemon nitzotz-q8_0.gguf --device vulkan
+hf download BrainboxAI/nitzotz nitzotz-q8_0.gguf --local-dir .
+laya.exe daemon nitzotz-q8_0.gguf --device vulkan
 {"id":"1","state":"קוד האימות שלך הוא 000000","questions":{"scam":{"type":"noul","instructions":"ההודעה היא ניסיון הונאה."}}}
 ```
 
+```json
+(not run yet)
+```
+
 <div dir="rtl">
 
-התשובה היא ההסתברות שהטענה נכונה, למשל `0.83`. כמה שאלות בקריאה אחת נענות יחד, במעבר אחד.
+`noul` היא ההסתברות שהטענה נכונה. כמה שאלות בבקשה אחת נענות יחד, במעבר אחד. על מחשב בלי כרטיס מסך משתמשים ב-`--device cpu`.
 
 ### מבחנים
 
 8 סטים של מבחן, 3,990 שאלות בסך הכול, שננעלו בטביעת אצבע לפני שנוצר פריט אימון אחד. שלושת המודלים ענו על
-אותן שאלות בדיוק. משווים רק למודלי laya פתוחים שקוראים עברית:
-
-- **ניצוץ**: המודל הזה.
-- **[RoeiG/laya-hebrew](https://huggingface.co/RoeiG/laya-hebrew)**: מודל laya על NeoDictaBERT. **רישיון
-  CC-BY-NC-SA-4.0: לשימוש לא מסחרי בלבד.** הוא כאן כנקודת השוואה. אי אפשר להשתמש בו במוצר.
-- **[laya-multilingual](https://huggingface.co/convaiinnovations/laya)** (convaiinnovations, תיקיית `multilingual`):
-  המודל של יוצרי laya ליותר מ-100 שפות. Apache-2.0.
+אותן שאלות בדיוק. שתי נקודות ההשוואה הן מודלי laya הפתוחים האחרים שקוראים עברית:
+[RoeiG/laya-hebrew](https://huggingface.co/RoeiG/laya-hebrew) (רישיון CC-BY-NC-SA-4.0, **לשימוש לא מסחרי בלבד**)
+ו-[laya-multilingual](https://huggingface.co/convaiinnovations/laya) (Apache-2.0).
 
 ![דיוק לפי מבחן](assets/bars_he.png)
 
@@ -339,24 +346,16 @@ laya daemon nitzotz-q8_0.gguf --device vulkan
 | תשובה סבירה שהקטע לא נותן (600) | **91.0%** | 53.0% | 53.7% | 50.0% | **טוב יותר**<br>p<0.001 | **טוב יותר**<br>p<0.001 |
 | הבנת הנקרא, 4 אפשרויות (900) | 52.7% | **75.4%** | 31.4% | 25.0% | **חלש יותר**<br>p<0.001 | **טוב יותר**<br>p<0.001 |
 
+בהבנת הנקרא של Belebele ניצוץ מקבל 52.7%, פחות מ-RoeiG/laya-hebrew (75.4%). ניצוץ בנוי להחלטות על הודעות, לא
+להבנה של קטעים ארוכים.
+
 איך לקרוא את זה:
 - **MASSIVE** (פקודות קוליות): ניצוץ אומן על פקודות האימון של MASSIVE. פקודות המבחן אחרות, אבל נכתבו בידי אותם
   אנשים ובאותו סגנון, ולכן המבחן הזה קל יותר לניצוץ מאשר לאחרים.
-- **HeQ**: גם ניצוץ (בשתי השורות האלה) וגם RoeiG אומנו על קטעי האימון של HeQ. קטעי המבחן אחרים.
+- **HeQ**: ניצוץ אומן על קטעי האימון של HeQ. קטעי המבחן אחרים, וקטעי אימון שחפפו לקטע מבחן הוסרו.
 - **בשורות של פניות התמיכה יש רק 30 שאלות.** שום הבדל שם לא אמין.
-- **מבחן הספאם וההונאות לא מאוזן**: 70% מההודעות בו הן לא הונאה. קו ה"ניחוש" (50%) הוא הטלת
-  מטבע, לא האסטרטגיה העיוורת הטובה ביותר.
-
-### איפה RoeiG מוביל
-
-אומרים את זה בפשטות, כי כדאי לדעת את זה לפני שבוחרים:
-
-- **נושא של ידיעה, 7 אפשרויות (204)**: RoeiG 82.3%, ניצוץ 79.4%. אין הבדל ברור (p=0.42).
-- **האם הקטע תומך בתשובה? (600)**: RoeiG 94.2%, ניצוץ 93.8%. אין הבדל ברור (p=0.90).
-- **הבנת הנקרא, 4 אפשרויות (900)**: RoeiG 75.4%, ניצוץ 52.7%. ניצוץ חלש יותר (p<0.001).
-
-**לקרוא קטע ולענות עליו שאלות (Belebele) זה החוזק של RoeiG והחולשה של ניצוץ.** RoeiG אומן על נתוני הבנת הנקרא,
-וניצוץ לא נבנה לזה. אם המשימה שלכם היא קריאת מסמכים, ניצוץ הוא המודל הלא נכון. וזכרו ש-RoeiG אסור לשימוש מסחרי.
+- **מבחן הספאם וההונאות לא מאוזן**: 70% מההודעות בו הן לא הונאה. קו ה"ניחוש" (50%) הוא הטלת מטבע, לא
+  האסטרטגיה העיוורת הטובה ביותר.
 
 ### למה אפשר לסמוך עליו
 
@@ -364,19 +363,39 @@ laya daemon nitzotz-q8_0.gguf --device vulkan
 
 **להסתברויות יש משמעות.** קחו את כל התשובות שבהן ניצוץ אמר שהוא בטוח בערך ב-70 עד 80%, וספרו כמה מהן היו נכונות.
 הגרף עושה את זה לכל רמת ביטחון, על 3,990 שאלות מבחן. כשהנקודות מעל הקו, ניצוץ צודק יותר ממה שהוא אומר (הוא
-צנוע). כשהן מתחת, הוא בטוח בעצמו יותר מדי. זה מה שמאפשר לקבוע ספים (בפרק הבא). הכיול נעשה על פריטי אימון שהופרדו
-מראש, אף פעם לא על המבחן.
+צנוע). כשהן מתחת, הוא בטוח בעצמו יותר מדי. זה מה שמאפשר לקבוע ספים (בפרק הבא). הכיול נעשה על 2,901 פריטי אימון
+שהופרדו מראש, אף פעם לא על המבחן (`calibration.json`).
 
 **הוא באמת קורא את הטקסט.** כשמוחקים את ההודעה ומשאירים רק את השאלה, הדיוק יורד ל-70.5% בשאלת ההונאה
 ול-7.7% בסוג ההודעה. כלומר התשובות באות מההודעה, לא מהניסוח של השאלה.
 
 ![מהירות מול גודל](assets/speed_he.png)
 
-**הוא מהיר על חומרה רגילה.** על מחשב נייד עם מעבד Intel Core Ultra 9 285H וכרטיס המסך המובנה Arc 140T, ווינדוס 11, שאלה אחת בכל פעם: הקובץ
-Q8 עונה בחציון של 140 מילישניות (10% האיטיים ביותר: 187 ומעלה), והקובץ F16 ב-154. דרך פייתון על אותו כרטיס
-מסך ניצוץ לוקח 294 ו-RoeiG לוקח 1005 (נמדד על אותו מחשב, אבל בריצות נפרדות, על 50 ו-40 שאלות מבחן באורך
-דומה). laya-multilingual לא נמדד על המחשב הזה, ולכן אין לו מהירות בגרף. קובץ Q8 נותן את אותה תשובה מובילה כמו
-מודל הפייתון המלא ב-50/50 שאלות בדיקה.
+**הוא מהיר על חומרה רגילה.** על מחשב נייד עם מעבד Intel Core Ultra 9 285H וכרטיס המסך המובנה Arc 140T, ווינדוס 11, שאלה אחת בכל פעם:
+
+| איך מריצים | חציון על 50 שאלות בדיקה (בממוצע 135 טוקנים) | הודעה קצרה (38 טוקנים) | קלט ארוך (430 טוקנים) |
+|---|---|---|---|
+| laya.exe, קובץ Q8, כרטיס מסך (Vulkan) | 49 ms | 35 ms | 135 ms |
+| laya.exe, קובץ F16, כרטיס מסך (Vulkan) | 52 ms | 41 ms | 141 ms |
+| פייתון (laya), כרטיס מסך (PyTorch XPU) | 54 ms | 44 ms | 177 ms |
+| laya.exe, קובץ Q8, מעבד בלבד (16 תהליכונים) | 335 ms | 177 ms | 1233 ms |
+| פייתון (laya), מעבד בלבד | 387 ms | 130 ms | 1260 ms |
+
+בעמודות של ההודעה הקצרה והקלט הארוך אותה שאלה רצה 30 פעמים, אחרי 5 הרצות חימום. במחשב רצו תוכנות אחרות באותו זמן,
+אז אלה מספרים בקירוב.
+
+**קובצי ה-GGUF נותנים את אותן תשובות כמו מודל הפייתון.** בהשוואה למודל הפייתון המלא על המעבד:
+
+| קובץ, מכשיר | אותה תשובה מובילה, 50 שאלות | הפרש הסתברות מרבי | אותה תשובה מובילה, 596 שאלות ספאם | הפרש מרבי | הפרש ממוצע |
+|---|---|---|---|---|---|
+| Q8, כרטיס מסך | 50/50 | 0.0079 | 593/596 | 0.0152 | 0.00217 |
+| F16, כרטיס מסך | 50/50 | 0.0026 | 595/596 | 0.0023 | 0.00032 |
+| Q8, מעבד | 50/50 | 0.0094 | 590/596 | 0.0275 | 0.00321 |
+| F16, מעבד | 50/50 | 0.0017 | 595/596 | 0.0014 | 0.00027 |
+
+פער של 0.01 פירושו, למשל, 0.83 מול 0.84. השאלות המעטות שבהן התשובה המובילה משתנה הן כאלה שבהן שתי התשובות הטובות
+היו כמעט שוות. בשתי שאלות הספאם יחד קובץ Q8 על כרטיס המסך צודק ב-78.9%, מול 79.0% למודל הפייתון. קובץ F16
+קרוב יותר (79.2%).
 
 ### שימוש בעסק
 
@@ -388,18 +407,23 @@ Q8 עונה בחציון של 140 מילישניות (10% האיטיים ביו
 - **צהוב** (לא בטוח): לבדיקה של אדם, או של מודל שפה גדול אם אתם משתמשים בו.
 - **אדום** (בטוח שזו הונאה): חסימה או הסגר.
 
-השרטוט הוא דוגמה על 298 הודעות המבחן. הסף העליון, 0.52, הוא הסף שנבחר לשאלת ההונאה על הודעות אימון
+השרטוט הוא דוגמה על 298 הודעות המבחן. הסף העליון, 0.52, הוא הסף שנבחר לשאלת ההונאה על 700 הודעות אימון
 שהופרדו מראש (אף פעם לא על המבחן). הסף התחתון, 0.35, נבחר ביד. איתם 183 הודעות הו��כות לירוק (16 מהן הן בעצם הונאה),
-48 לצהוב (21 הונאות), ו-67 לאדום (16 מהן בעצם תקינות). כלומר היום רוב ההודעות עדיין צריכות מבט, ואדום צריך
-להיות "הסגר ובדיקה", לא "מחיקה". בחרו ספים משלכם על מדגם של ההודעות שלכם, והחליטו כמה טעויות בירוק ובאדום אתם
-מוכנים לקבל. בסף 0.52 לבדו, תשובת ההונאה נכונה ב-82.2% מהמקרים בסך הכול וב-64.6% על 65 המקרים הקשים.
+48 לצהוב (21 הונאות), ו-67 לאדום (16 מהן בעצם תקינות). כלומר אדום צריך להיות "הסגר ובדיקה", לא "מחיקה".
+בחרו ספים משלכם על מדגם של ההודעות שלכם, והחליטו כמה טעויות בירוק ובאדום אתם מוכנים לקבל. בסף 0.52 לבדו, תשובת
+ההונאה נכונה ב-82.2% מהמקרים בסך הכול וב-64.6% על 65 המקרים הקשים (בסף 0.50: 82.9% ו-64.6%).
 
 המודל זול מספיק כדי להריץ אותו על כל הודעה. האדם (או מודל השפה) רואה רק את החלק הצהוב. **אל תשתמשו בו כקו הגנה
 יחיד בהחלטות שיכולות לפגוע במישהו.**
 
 ### נתוני האימון ושקיפות
 
-58,000 פריטי אימון, מעבר אחד על הנתונים, על כרטיס מסך שכור.
+שני שלבי אימון, על כרטיס מסך שכור:
+
+1. **ללמוד לקרוא.** HalleluBERT-large אומן קודם למצוא את התשובה לשאלה בתוך קטע, על 27,085 שאלות אימון של HeQ
+   (CC BY 4.0). קטעים שחפפו לקטע מבחן הוסרו.
+2. **ללמוד להחליט.** מעליו הונח ראש החלטות של laya, וכל המודל אומן על 58,000 פריטים (55,099 לאימון,
+   ו-2,901 הופרדו מראש כדי לבחור את הטוב מבין 2 מעברים ולכייל את הטמפרטורות).
 
 | מקור | פריטים | רישיון | איך נוצר |
 |---|---|---|---|
@@ -416,14 +440,14 @@ Q8 עונה בחציון של 140 מילישניות (10% האיטיים ביו
   לפי תוכנית (התווית המתוכננת, נושא, משלב, מספרי טלפון וקישורים מזויפים ומגוונים). אחר כך DeepSeek ו-Gemma 4 31B
   (Apache-2.0) סימנו כל הודעה, כל אחד לבד. הודעה נשמרה רק אם שניהם הסכימו. הם הסכימו על 94% מההודעות,
   ונשמרו 93.7% מתוך 37,429 ההודעות שנכתבו. שניהם רצו דרך DeepInfra (דרך OpenRouter), בלי שמירת נתונים
-  ובלי מצב "חשיבה". עלות: 5.39 דולר. הנתונים הסינתטיים לא מפורסמים.
+  ובלי מצב "חשיבה". הנתונים הסינתטיים לא מפורסמים.
 - **נתונים פתוחים.** HeQ v1.1 (CC BY 4.0. בערך חצי מהשאלות שלו על כתבות של Geektime, ומחברי HeQ משתפים אותם באותו רישיון) ו-MASSIVE
   he-IL (CC BY 4.0). רק מפיצולי האימון.
 - **בלי דליפה מהמבחנים.** כל פריט אימון הושווה לכל שאלת מבחן. כל מה שחולק רצף של 8 מילים עם טקסט מבחן נזרק, וגם
   פקודות MASSIVE שזהות לפקודת מבחן.
 - **מה לא שימש:** שום פלט של צ'אטבוט מסחרי סגור, שום מודל של DICTA, שום נתונים לא מסחריים או ברישיון "שיתוף זהה".
-- **המקודד:** HalleluBERT-large (MIT), 357.1 מיליון פרמטרים, אומן מחדש. ראש laya עם 26.5 מיליון פרמטרים, אומן מאפס.
-- **מקודד הקריאה משולב בגרסה הזו.** HalleluBERT אומן קודם למצוא תשובות בקטעי HeQ (27,085 שאלות אימון של HeQ, CC BY 4.0), ואחר כך קיבל ראש laya ואומן על אותם נתוני אימון כמו כל שורה אחרת. שתי שורות HeQ משתמשות באותה גרסה כמו שאר הטבלה, לא בגרסה נפרדת.
+- **גודל:** המקודד 357.1 מיליון פרמטרים (HalleluBERT-large, MIT, אומן מחדש). ראש ההחלטות 26.5 מיליון פרמטרים,
+  אומן מאפס.
 
 **על המבחנים.**
 
@@ -439,16 +463,16 @@ Q8 עונה בחציון של 140 מילישניות (10% האיטיים ביו
 הסתייגויות שמשנות כמה לסמוך על המספרים:
 - **מבחן הספאם והעסקים נכתב בידי מודל AI ונבדק בידי מודל AI, לא בידי אדם.** תיבות דואר אמיתיות ייראו אחרת. הוא ננעל
   אחרי הבדיקה הזו (4 תוויות שונו, 2 הודעות הוסרו).
-- **ריצת אימון אחת, זרע אקראי אחד.** הבדלים של 1 עד 3 נקודות בין מודלים יכולים להיות רעש בין ריצות.
+- **שתי ריצות אימון, עם שני זרעים אקראיים, וזו אחת מהן.** היא נבחרה לפי פריטי אימון שהופרדו מראש (94.8% מול 94.6%, פער קטן), לא לפי המבחנים. בכמה מבחנים שתי הריצות שונות יותר ממה שמזל מסביר: הונאה או לא 82.5% כאן מול 68.8% בריצה השנייה, נושא ידיעה 79.4% מול 74.0%. ריצת אימון חדשה יכולה להזיז את שני המספרים האלה בכמה נקודות.
 - **תוויות האימון באות משני מודלי AI.** איפה ששניהם טועים באותו אופן, ניצוץ למד את הטעות שלהם.
 - התשובות השגויות של HeQ במבחן נבחרו בקוד, ולא נבדקו בידי אדם.
 
 ### מגבלות
 
-- **הוא לא קורא מסמכים טוב.** הבנת הנקרא ב-Belebele: 52.7%, כשניחוש עיוור מקבל 25%. אל תשאלו אותו אם מסמך ארוך
-  תומך בטענה.
-- **בדיקת תשובות ב-HeQ נראית חזקה, עם כוכבית.** 93.8% עם הקטע, אבל עדיין 50.0% כשמוחקים את הקטע (RoeiG:
-  80.0%). חלק גדול מהציון בא מהשאלה והתשובה עצמן, לא מהקריאה.
+- **הוא חלש בהבנת הנקרא של קטעים ארוכים.** Belebele: 52.7%, כשניחוש עיוור מקבל 25%. כשהתשובה הנכונה כתובה בקטע
+  מילה במילה הוא מקבל 72% (252 שאלות). כשהתשובה נאמרת במילים אחרות הוא מקבל 45% (648 שאלות).
+  אל תשאלו אותו אם מסמך ארוך תומך בטענה.
+- **בדיקה אם קטע תומך בתשובה (HeQ) עובדת.** 93.8% עם הקטע. כשמוחקים את הקטע זה יורד ל-50.0%, הטלת מטבע. כלומר בשאלות מהסוג הזה הוא באמת קורא את הקטע.
 - **מספרים, תאריכים, סכומים וכללים**: לא אומן עליהם ולא נמדד. חשבו אותם בקוד והעבירו את התוצאה.
 - **המקרים הקשים הם נקודת התורפה**: הונאות שנכתבו כדי להיראות לגיטימיות ("ספק" שמחליף פרטי חשבון בנק, "המנכ"ל" שמבקש
   העברה), והודעות אמיתיות שנראות כמו הונאה (התראה אמיתית מהבנק עם קישור, קוד אימות אמיתי). על 65 המקרים הקשים שאלת
@@ -464,7 +488,7 @@ Q8 עונה בחציון של 140 מילישניות (10% האיטיים ביו
 **Apache-2.0** למשקולות, לקובצי ה-GGUF ולקוד. מותר לשימוש מסחרי. בנוי על:
 
 - [HalleluBERT-large](https://huggingface.co/HalleluBERT/HalleluBERT_large): המקודד, MIT.
-- [laya](https://github.com/NandhaKishorM/laya) (NandhaKishorM, Convai Innovations): הארכיטקטורה, שיטת האימון וסביבת
+- [laya](https://github.com/NandhaKishorM/laya) (NandhaKishorM, Convai Innovations): הארכיטקטורה של ראש ההחלטות וסביבת
   ההרצה, Apache-2.0. לא נעשה שימוש במשקולות של laya.
 - [HeQ](https://github.com/NNLP-IL/Hebrew-Question-Answering-Dataset): CC BY 4.0, של Webiks עבור מפא"ת ותוכנית ה-NLP
   הלאומית (NNLP-IL). כולל קטעים מ-Geektime.

calibration.json

@@ -0,0 +1,48 @@
+{
+ "temperatures_per_question_type": {
+  "choice": 1.103,
+  "score": 1.1095,
+  "noul": 1.1651
+ },
+ "temperature_fit_items": {
+  "choice": 1738,
+  "score": 175,
+  "noul": 988
+ },
+ "note": "The temperatures are already applied by laya (rl_agent_config.json 'temperature') and baked into the GGUF files. They were fitted on held-out training items, never on the test sets.",
+ "scam_threshold": {
+  "question": "noul, 'is this message a scam'",
+  "threshold": 0.5169,
+  "chosen_on": "700 held-out training messages, never the test",
+  "held_out_acc_at_threshold": 0.8643,
+  "test_acc_at_0.5": 0.8289,
+  "test_acc_at_threshold": 0.8221,
+  "test_hard_acc_at_0.5": 0.6462,
+  "test_hard_acc_at_threshold": 0.6462,
+  "test_auc": 0.8848
+ },
+ "ramzor_example_thresholds": {
+  "green_below": 0.35,
+  "red_from": 0.52,
+  "zones_on_test": {
+   "g": {
+    "n": 183,
+    "share": 0.6140939597315436,
+    "scam": 16,
+    "legit": 167
+   },
+   "y": {
+    "n": 48,
+    "share": 0.1610738255033557,
+    "scam": 21,
+    "legit": 27
+   },
+   "r": {
+    "n": 67,
+    "share": 0.22483221476510068,
+    "scam": 51,
+    "legit": 16
+   }
+  }
+ }
+}

encoder/config.json

@@ -0,0 +1,29 @@
+{
+  "add_cross_attention": false,
+  "architectures": [
+    "RobertaModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "dtype": "float32",
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 1024,
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "is_decoder": false,
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 514,
+  "model_type": "roberta",
+  "num_attention_heads": 16,
+  "num_hidden_layers": 24,
+  "pad_token_id": 1,
+  "position_embedding_type": "absolute",
+  "tie_word_embeddings": true,
+  "transformers_version": "5.17.0",
+  "type_vocab_size": 1,
+  "use_cache": true,
+  "vocab_size": 52009
+}

eval_results.json

@@ -0,0 +1,693 @@
+{
+ "model": "BrainboxAI/nitzotz",
+ "eval_set": "8 frozen suites, 3990 questions (checksums in the repo's eval/manifest.json)",
+ "models": {
+  "nz": "BrainboxAI/nitzotz",
+  "roeig": "RoeiG/laya-hebrew",
+  "laya_ml": "convaiinnovations/laya (multilingual)"
+ },
+ "licences": {
+  "nz": "Apache-2.0",
+  "roeig": "CC-BY-NC-SA-4.0",
+  "laya_ml": "Apache-2.0"
+ },
+ "suites": {
+  "spam_scam": {
+   "title": "Scam or not? (298 messages)",
+   "n": 298,
+   "chance": 0.5,
+   "acc": {
+    "nz": 0.8255,
+    "roeig": 0.3221,
+    "laya_ml": 0.5034
+   },
+   "brier": {
+    "nz": 0.2629,
+    "roeig": 0.7604,
+    "laya_ml": 0.8042
+   },
+   "ece": {
+    "nz": 0.0993,
+    "roeig": 0.3802,
+    "laya_ml": 0.38
+   },
+   "empty_acc": {
+    "nz": 0.7047,
+    "roeig": 0.2953,
+    "laya_ml": 0.2953
+   },
+   "vs_nitzotz": {
+    "roeig": {
+     "nz_only": 177,
+     "other_only": 27,
+     "p": 3.1836858702039475e-28
+    },
+    "laya_ml": {
+     "nz_only": 129,
+     "other_only": 33,
+     "p": 1.2998168966363252e-14
+    }
+   }
+  },
+  "spam_scam_hard": {
+   "title": "same, hard cases only (65)",
+   "n": 65,
+   "chance": 0.5,
+   "acc": {
+    "nz": 0.6308,
+    "roeig": 0.3231,
+    "laya_ml": 0.3538
+   },
+   "brier": {
+    "nz": 0.4394,
+    "roeig": 0.7076,
+    "laya_ml": 1.1057
+   },
+   "ece": {
+    "nz": 0.056,
+    "roeig": 0.3391,
+    "laya_ml": 0.5564
+   },
+   "empty_acc": {
+    "nz": 0.7077,
+    "roeig": 0.2923,
+    "laya_ml": 0.2923
+   },
+   "vs_nitzotz": {
+    "roeig": {
+     "nz_only": 27,
+     "other_only": 7,
+     "p": 0.0008213953115046024
+    },
+    "laya_ml": {
+     "nz_only": 30,
+     "other_only": 12,
+     "p": 0.007915897334896727
+    }
+   }
+  },
+  "spam_type": {
+   "title": "Message type, 6 options (298)",
+   "n": 298,
+   "chance": 0.1667,
+   "acc": {
+    "nz": 0.755,
+    "roeig": 0.5268,
+    "laya_ml": 0.2081
+   },
+   "brier": {
+    "nz": 0.3721,
+    "roeig": 0.6489,
+    "laya_ml": 1.0746
+   },
+   "ece": {
+    "nz": 0.0643,
+    "roeig": 0.1043,
+    "laya_ml": 0.4131
+   },
+   "empty_acc": {
+    "nz": 0.0772,
+    "roeig": 0.2013,
+    "laya_ml": 0.0772
+   },
+   "vs_nitzotz": {
+    "roeig": {
+     "nz_only": 100,
+     "other_only": 32,
+     "p": 2.428469657769691e-09
+    },
+    "laya_ml": {
+     "nz_only": 174,
+     "other_only": 11,
+     "p": 6.991886709878067e-39
+    }
+   }
+  },
+  "spam_type_hard": {
+   "title": "same, hard cases only (65)",
+   "n": 65,
+   "chance": 0.1667,
+   "acc": {
+    "nz": 0.5385,
+    "roeig": 0.4462,
+    "laya_ml": 0.2462
+   },
+   "brier": {
+    "nz": 0.6411,
+    "roeig": 0.7315,
+    "laya_ml": 1.1094
+   },
+   "ece": {
+    "nz": 0.1768,
+    "roeig": 0.1877,
+    "laya_ml": 0.4109
+   },
+   "empty_acc": {
+    "nz": 0.1385,
+    "roeig": 0.1538,
+    "laya_ml": 0.1385
+   },
+   "vs_nitzotz": {
+    "roeig": {
+     "nz_only": 17,
+     "other_only": 11,
+     "p": 0.34492845088243484
+    },
+    "laya_ml": {
+     "nz_only": 24,
+     "other_only": 5,
+     "p": 0.0005461126565933228
+    }
+   }
+  },
+  "triage_type": {
+   "title": "Support ticket type, 5 options (30)",
+   "n": 30,
+   "chance": 0.2,
+   "acc": {
+    "nz": 0.8333,
+    "roeig": 0.8,
+    "laya_ml": 0.5667
+   },
+   "brier": {
+    "nz": 0.2289,
+    "roeig": 0.3191,
+    "laya_ml": 0.6667
+   },
+   "ece": {
+    "nz": 0.1797,
+    "roeig": 0.1321,
+    "laya_ml": 0.2772
+   },
+   "empty_acc": {
+    "nz": 0.1667,
+    "roeig": 0.1667,
+    "laya_ml": 0.3333
+   },
+   "vs_nitzotz": {
+    "roeig": {
+     "nz_only": 4,
+     "other_only": 3,
+     "p": 1.0
+    },
+    "laya_ml": {
+     "nz_only": 11,
+     "other_only": 3,
+     "p": 0.057373046875
+    }
+   }
+  },
+  "triage_urgency": {
+   "title": "Ticket urgency, 5 levels (30)",
+   "n": 30,
+   "chance": 0.2,
+   "acc": {
+    "nz": 0.6,
+    "roeig": 0.3667,
+    "laya_ml": 0.3333
+   },
+   "brier": {
+    "nz": 0.5225,
+    "roeig": 0.708,
+    "laya_ml": 0.7501
+   },
+   "ece": {
+    "nz": 0.2373,
+    "roeig": 0.0322,
+    "laya_ml": 0.2167
+   },
+   "empty_acc": {
+    "nz": 0.1,
+    "roeig": 0.2333,
+    "laya_ml": 0.0667
+   },
+   "vs_nitzotz": {
+    "roeig": {
+     "nz_only": 13,
+     "other_only": 6,
+     "p": 0.1670684814453125
+    },
+    "laya_ml": {
+     "nz_only": 14,
+     "other_only": 6,
+     "p": 0.11531829833984375
+    }
+   }
+  },
+  "triage_paying": {
+   "title": "Paying customer? yes/no (30)",
+   "n": 30,
+   "chance": 0.5,
+   "acc": {
+    "nz": 0.6333,
+    "roeig": 0.5667,
+    "laya_ml": 0.5
+   },
+   "brier": {
+    "nz": 0.5196,
+    "roeig": 0.4338,
+    "laya_ml": 0.8183
+   },
+   "ece": {
+    "nz": 0.2253,
+    "roeig": 0.2362,
+    "laya_ml": 0.4284
+   },
+   "empty_acc": {
+    "nz": 0.5333,
+    "roeig": 0.5333,
+    "laya_ml": 0.4667
+   },
+   "vs_nitzotz": {
+    "roeig": {
+     "nz_only": 2,
+     "other_only": 0,
+     "p": 0.5
+    },
+    "laya_ml": {
+     "nz_only": 14,
+     "other_only": 10,
+     "p": 0.5412561893463135
+    }
+   }
+  },
+  "massive_20": {
+   "title": "Voice command intent, 20 options (500)",
+   "n": 500,
+   "chance": 0.05,
+   "acc": {
+    "nz": 0.888,
+    "roeig": 0.726,
+    "laya_ml": 0.474
+   },
+   "brier": {
+    "nz": 0.1759,
+    "roeig": 0.3801,
+    "laya_ml": 0.7338
+   },
+   "ece": {
+    "nz": 0.0529,
+    "roeig": 0.0395,
+    "laya_ml": 0.1661
+   },
+   "empty_acc": {
+    "nz": 0.064,
+    "roeig": 0.052,
+    "laya_ml": 0.044
+   },
+   "vs_nitzotz": {
+    "roeig": {
+     "nz_only": 93,
+     "other_only": 12,
+     "p": 1.100926641994889e-16
+    },
+    "laya_ml": {
+     "nz_only": 215,
+     "other_only": 8,
+     "p": 2.0578594884620216e-53
+    }
+   }
+  },
+  "massive_4": {
+   "title": "Voice command intent, 4 options (500)",
+   "n": 500,
+   "chance": 0.25,
+   "acc": {
+    "nz": 0.962,
+    "roeig": 0.908,
+    "laya_ml": 0.694
+   },
+   "brier": {
+    "nz": 0.0561,
+    "roeig": 0.1369,
+    "laya_ml": 0.3987
+   },
+   "ece": {
+    "nz": 0.0409,
+    "roeig": 0.0393,
+    "laya_ml": 0.0468
+   },
+   "empty_acc": {
+    "nz": 0.238,
+    "roeig": 0.242,
+    "laya_ml": 0.256
+   },
+   "vs_nitzotz": {
+    "roeig": {
+     "nz_only": 33,
+     "other_only": 6,
+     "p": 1.429926123819314e-05
+    },
+    "laya_ml": {
+     "nz_only": 140,
+     "other_only": 6,
+     "p": 2.8378191731534526e-34
+    }
+   }
+  },
+  "sib200": {
+   "title": "News topic, 7 options (204)",
+   "n": 204,
+   "chance": 0.1429,
+   "acc": {
+    "nz": 0.7941,
+    "roeig": 0.8235,
+    "laya_ml": 0.6618
+   },
+   "brier": {
+    "nz": 0.3091,
+    "roeig": 0.285,
+    "laya_ml": 0.4918
+   },
+   "ece": {
+    "nz": 0.0877,
+    "roeig": 0.0751,
+    "laya_ml": 0.1784
+   },
+   "empty_acc": {
+    "nz": 0.1471,
+    "roeig": 0.1961,
+    "laya_ml": 0.25
+   },
+   "vs_nitzotz": {
+    "roeig": {
+     "nz_only": 16,
+     "other_only": 22,
+     "p": 0.417692190836533
+    },
+    "laya_ml": {
+     "nz_only": 42,
+     "other_only": 15,
+     "p": 0.00046000500864878946
+    }
+   }
+  },
+  "heq_verify": {
+   "title": "Does the passage support this answer? (600)",
+   "n": 600,
+   "chance": 0.5,
+   "acc": {
+    "nz": 0.9383,
+    "roeig": 0.9417,
+    "laya_ml": 0.4883
+   },
+   "brier": {
+    "nz": 0.1003,
+    "roeig": 0.0926,
+    "laya_ml": 0.8274
+   },
+   "ece": {
+    "nz": 0.0519,
+    "roeig": 0.0178,
+    "laya_ml": 0.3946
+   },
+   "empty_acc": {
+    "nz": 0.5,
+    "roeig": 0.8,
+    "laya_ml": 0.59
+   },
+   "vs_nitzotz": {
+    "roeig": {
+     "nz_only": 32,
+     "other_only": 34,
+     "p": 0.9021585000966993
+    },
+    "laya_ml": {
+     "nz_only": 297,
+     "other_only": 27,
+     "p": 1.181012945982764e-58
+    }
+   }
+  },
+  "heq_unans": {
+   "title": "Plausible answer the passage does not give (600)",
+   "n": 600,
+   "chance": 0.5,
+   "acc": {
+    "nz": 0.91,
+    "roeig": 0.53,
+    "laya_ml": 0.5367
+   },
+   "brier": {
+    "nz": 0.1412,
+    "roeig": 0.856,
+    "laya_ml": 0.7348
+   },
+   "ece": {
+    "nz": 0.0402,
+    "roeig": 0.4336,
+    "laya_ml": 0.3421
+   },
+   "empty_acc": {
+    "nz": 0.5,
+    "roeig": 0.5033,
+    "laya_ml": 0.5167
+   },
+   "vs_nitzotz": {
+    "roeig": {
+     "nz_only": 250,
+     "other_only": 22,
+     "p": 3.9022177864527475e-50
+    },
+    "laya_ml": {
+     "nz_only": 248,
+     "other_only": 24,
+     "p": 4.4428671970733176e-48
+    }
+   }
+  },
+  "belebele": {
+   "title": "Reading comprehension, 4 options (900)",
+   "n": 900,
+   "chance": 0.25,
+   "acc": {
+    "nz": 0.5267,
+    "roeig": 0.7544,
+    "laya_ml": 0.3144
+   },
+   "brier": {
+    "nz": 0.6379,
+    "roeig": 0.3442,
+    "laya_ml": 0.8341
+   },
+   "ece": {
+    "nz": 0.205,
+    "roeig": 0.0324,
+    "laya_ml": 0.2307
+   },
+   "empty_acc": {
+    "nz": 0.3089,
+    "roeig": 0.3189,
+    "laya_ml": 0.2844
+   },
+   "vs_nitzotz": {
+    "roeig": {
+     "nz_only": 56,
+     "other_only": 261,
+     "p": 8.723952167222602e-33
+    },
+    "laya_ml": {
+     "nz_only": 304,
+     "other_only": 113,
+     "p": 2.6224194993355025e-21
+    }
+   }
+  }
+ },
+ "significance": "paired exact McNemar against Nitzotz on the same questions",
+ "latency_ms": {
+  "q8": {
+   "median": 48.7,
+   "p90": 78.5,
+   "n": 50
+  },
+  "f16": {
+   "median": 51.6,
+   "p90": 76.8,
+   "n": 50
+  },
+  "py": {
+   "median": 54.5,
+   "p90": 100.7,
+   "n": 50
+  },
+  "q8_cpu": {
+   "median": 335.0,
+   "p90": 718.7,
+   "n": 50
+  },
+  "f16_cpu": {
+   "median": 462.6,
+   "p90": 954.0,
+   "n": 50
+  },
+  "py_cpu": {
+   "median": 387.3,
+   "p90": 838.2,
+   "n": 50
+  }
+ },
+ "latency_points_ms": {
+  "q8": {
+   "short": {
+    "item": "massive_he_4-0075",
+    "input_tokens": 38,
+    "median_ms": 35.2,
+    "p90_ms": 35.8,
+    "min_ms": 34.3
+   },
+   "long": {
+    "item": "heq_unanswerable-0522",
+    "input_tokens": 430,
+    "median_ms": 135.1,
+    "p90_ms": 141.8,
+    "min_ms": 129.4
+   }
+  },
+  "f16": {
+   "short": {
+    "item": "massive_he_4-0075",
+    "input_tokens": 38,
+    "median_ms": 40.6,
+    "p90_ms": 41.9,
+    "min_ms": 39.4
+   },
+   "long": {
+    "item": "heq_unanswerable-0522",
+    "input_tokens": 430,
+    "median_ms": 140.9,
+    "p90_ms": 147.5,
+    "min_ms": 130.8
+   }
+  },
+  "py": {
+   "short": {
+    "item": "massive_he_4-0075",
+    "input_tokens": 38,
+    "median_ms": 44.3,
+    "p90_ms": 48.2,
+    "min_ms": 38.6
+   },
+   "long": {
+    "item": "heq_unanswerable-0522",
+    "input_tokens": 430,
+    "median_ms": 176.7,
+    "p90_ms": 180.7,
+    "min_ms": 146.5
+   }
+  },
+  "q8_cpu": {
+   "short": {
+    "item": "massive_he_4-0075",
+    "input_tokens": 38,
+    "median_ms": 177.4,
+    "p90_ms": 194.5,
+    "min_ms": 158.9
+   },
+   "long": {
+    "item": "heq_unanswerable-0522",
+    "input_tokens": 430,
+    "median_ms": 1232.9,
+    "p90_ms": 1278.8,
+    "min_ms": 1165.9
+   }
+  },
+  "py_cpu": {
+   "short": {
+    "item": "massive_he_4-0075",
+    "input_tokens": 38,
+    "median_ms": 130.5,
+    "p90_ms": 140.7,
+    "min_ms": 125.5
+   },
+   "long": {
+    "item": "heq_unanswerable-0522",
+    "input_tokens": 430,
+    "median_ms": 1259.8,
+    "p90_ms": 1365.2,
+    "min_ms": 1153.4
+   }
+  }
+ },
+ "latency_machine": "Intel Core Ultra 9 285H laptop, built-in Arc 140T GPU, Windows 11",
+ "gguf_parity_50": {
+  "q8": {
+   "max_abs_diff": 0.0079,
+   "mean_abs_diff": 0.001364,
+   "argmax_agree": "50/50"
+  },
+  "f16": {
+   "max_abs_diff": 0.0026,
+   "mean_abs_diff": 0.00032,
+   "argmax_agree": "50/50"
+  },
+  "q8_cpu": {
+   "max_abs_diff": 0.0094,
+   "mean_abs_diff": 0.001866,
+   "argmax_agree": "50/50"
+  },
+  "f16_cpu": {
+   "max_abs_diff": 0.0017,
+   "mean_abs_diff": 0.000204,
+   "argmax_agree": "50/50"
+  }
+ },
+ "gguf_parity_spam_596": {
+  "q8": {
+   "max_abs_diff": 0.0152,
+   "mean_abs_diff": 0.002173,
+   "argmax_agree": "593/596",
+   "accuracy_vs_gold": 0.7886
+  },
+  "f16": {
+   "max_abs_diff": 0.0023,
+   "mean_abs_diff": 0.000322,
+   "argmax_agree": "595/596",
+   "accuracy_vs_gold": 0.7919
+  },
+  "py": {
+   "max_abs_diff": 0.0001,
+   "mean_abs_diff": 0.0,
+   "argmax_agree": "595/596",
+   "accuracy_vs_gold": 0.7919
+  },
+  "q8_cpu": {
+   "max_abs_diff": 0.0275,
+   "mean_abs_diff": 0.003209,
+   "argmax_agree": "590/596",
+   "accuracy_vs_gold": 0.7836
+  },
+  "f16_cpu": {
+   "max_abs_diff": 0.0014,
+   "mean_abs_diff": 0.000268,
+   "argmax_agree": "595/596",
+   "accuracy_vs_gold": 0.7919
+  },
+  "py_cpu": {
+   "max_abs_diff": 0.0,
+   "mean_abs_diff": 0.0,
+   "argmax_agree": "596/596",
+   "accuracy_vs_gold": 0.7903
+  }
+ },
+ "belebele_split": {
+  "verbatim_n": 252,
+  "reworded_n": 648,
+  "nz": {
+   "verbatim": 0.7182539682539683,
+   "reworded": 0.4521604938271605
+  },
+  "roeig": {
+   "verbatim": 0.8412698412698413,
+   "reworded": 0.720679012345679
+  },
+  "laya_ml": {
+   "verbatim": 0.44047619047619047,
+   "reworded": 0.2654320987654321
+  }
+ },
+ "calibration_pooled": {
+  "n": 3990,
+  "ece_15bin": 0.042
+ }
+}

ggmlc/compile_nitzotz.py

@@ -0,0 +1,103 @@
+"""Compile a Nitzotz checkpoint (HalleluBERT + laya head) to a laya.exe GGUF with ggmlc.
+
+Adapted from ggmlc examples/laya/compile_laya.py (Apache-2.0, monatis/ggmlc v0.9.5). The tokenizer (byte-level BPE,
+gpt2 pre-tokenizer) and the laya sequence plan are baked into the GGUF (`ggmlc.decision`), so laya.exe does not fall
+back to its built-in ModernBERT preprocessor.
+
+Needs its own venv (ggmlc 0.9.5 wheel, torch CPU, laya 0.3.7, transformers):
+  python compile_nitzotz.py --checkpoint <laya checkpoint folder> --quantize f16 --out nitzotz-f16.gguf
+"""
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+os.environ.setdefault("USE_TF", "0")
+os.environ.setdefault("TRANSFORMERS_NO_TF", "1")
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+
+import ggmlc  # noqa: E402
+import laya  # noqa: E402
+import torch  # noqa: E402
+from ggmlc.pipeline.decision import DecisionPipelineSpec  # noqa: E402
+from ggmlc.pipeline.tokenizer import BPETokenizer  # noqa: E402
+from ggmlc.transforms.fusion import FusionOptions  # noqa: E402
+from laya.common import QTYPES, build_sequence, collate_items  # noqa: E402
+from nitzotz_trunk import MAX_OPTS, NitzotzTrunk, pad_batch  # noqa: E402
+
+
+def example_batch(agent, seq_len):
+    state = "שלום, חויבתי פעמיים על אותה הזמנה. אפשר להחזיר לי את הכסף היום?"
+    qdefs = [{"type": "choice", "instructions": "מה סוג ההודעה?",
+              "criteria": {"חיוב": "תשלום או חשבונית", "תקלה": "משהו לא עובד", "אחר": "כל דבר אחר"}},
+             {"type": "noul", "instructions": "הלקוח מבקש החזר כספי.",
+              "criteria": {"true": "כן", "false": "לא"}}]
+    items = []
+    for qd in qdefs:
+        q = agent._to_internal(qd)
+        ids, mk = build_sequence(agent.tok, state, q, agent.cfg["max_len"], agent.cfg["head_max_len"])
+        items.append({"ids": ids, "markers": mk, "qtype": QTYPES[q["t"]]})
+    b = collate_items([items], agent.tok.pad_token_id)
+    return pad_batch(b["input_ids"], b["attention_mask"], b["marker_pos"], b["marker_mask"], b["qtype"],
+                     int(agent.tok.pad_token_id), seq_len)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--checkpoint", required=True)
+    ap.add_argument("--quantize", default="f16", choices=["f32", "f16", "q8_0", "q4_0", "q4_k_m", "ud_q4_k_m"])
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--max-batch", type=int, default=8)
+    ap.add_argument("--min-seq", type=int, default=64)
+    ap.add_argument("--name", default="nitzotz")
+    ap.add_argument("--repo", default="BrainboxAI/nitzotz")
+    args = ap.parse_args()
+
+    agent = laya.Agent(args.checkpoint, device="cpu")
+    agent.model.cpu().float().eval()
+    max_len, head_max_len = int(agent.cfg["max_len"]), int(agent.cfg["head_max_len"])
+    trunk = NitzotzTrunk(agent, max_len=max_len).eval()
+    example = example_batch(agent, 128)
+
+    base = BPETokenizer.from_huggingface(agent.tok, context_length=max_len)
+    tok = BPETokenizer(vocab=base.vocab, merges=base.merges, pre_tokenizer="gpt2", context_length=max_len,
+                       bos_token_id=int(agent.tok.cls_token_id), eos_token_id=int(agent.tok.sep_token_id),
+                       pad_token_id=int(agent.tok.pad_token_id), unk_token_id=int(agent.tok.unk_token_id),
+                       chat_template=base.chat_template)
+    print("tokenizer vocab %d merges %d cls %d sep %d pad %d mask %d" % (
+        tok.vocab_size, len(tok.merges), agent.tok.cls_token_id, agent.tok.sep_token_id, agent.tok.pad_token_id,
+        agent.tok.mask_token_id))
+    buckets = [x for x in (64, 128, 256, 512) if x <= max_len]
+    decision = DecisionPipelineSpec.laya(
+        cls_id=int(agent.tok.cls_token_id), sep_id=int(agent.tok.sep_token_id), pad_id=int(agent.tok.pad_token_id),
+        mask_id=int(agent.tok.mask_token_id), max_len=max_len, head_max_len=head_max_len, max_opts=MAX_OPTS,
+        min_seq=args.min_seq, max_batch=args.max_batch, length_buckets=buckets, temperature=agent.temperature,
+        temperature_by_options=dict(agent.temperature_by_options), model_name=args.name, family="nitzotz",
+        checkpoint=args.repo)
+    extra = {
+        "laya.max_len": max_len, "laya.head_max_len": head_max_len, "laya.max_opts": MAX_OPTS,
+        "laya.max_batch": args.max_batch, "laya.min_seq": args.min_seq, "laya.length_buckets": json.dumps(buckets),
+        "laya.mask_token_id": int(agent.tok.mask_token_id), "laya.cls_token_id": int(agent.tok.cls_token_id),
+        "laya.sep_token_id": int(agent.tok.sep_token_id), "laya.pad_token_id": int(agent.tok.pad_token_id),
+        "laya.temperature": json.dumps(agent.temperature),
+        "laya.temperature_by_options": json.dumps(agent.temperature_by_options),
+        "laya.model_name": args.name, "laya.family": "nitzotz", "laya.checkpoint": args.repo,
+    }
+    extra.update(decision.to_gguf_metadata())
+    fusion = FusionOptions()
+    fusion.enable_rope = False
+    dim_b = torch.export.Dim("b", min=1, max=args.max_batch)
+    dim_s = torch.export.Dim("s", min=args.min_seq, max=max_len)
+    dyn = ({0: dim_b, 1: dim_s}, {0: dim_b, 1: dim_s}, {0: dim_b}, {0: dim_b}, {0: dim_b})
+    out = Path(args.out)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    ggmlc.compile(trunk, example, output=str(out), model_name=args.name.replace("-", "_"), quantize=args.quantize,
+                  pipeline=tok, tasks=["classification"], extra_metadata=extra, fusion_options=fusion,
+                  dynamic_shapes=dyn)
+    print("wrote", out, out.stat().st_size, "bytes")
+
+
+if __name__ == "__main__":
+    main()

ggmlc/nitzotz_trunk.py

@@ -0,0 +1,198 @@
+"""Exportable Nitzotz trunk for ggmlc: HalleluBERT (RoBERTa) encoder + the laya DecisionModel head.
+
+Adapted from ggmlc examples/laya/laya_trunk.py (Apache-2.0, monatis/ggmlc v0.9.5), which does the same for the
+ModernBERT laya checkpoints. What changed: the encoder is a post-LN RoBERTa (learned absolute positions, one token
+type, q/k/v with bias, exact GELU), and the option axis has MAX_OPTS = 20 slots because MASSIVE-20 asks 20 options.
+The head, the marker gather, the scorer and the act head are the laya ones, unchanged.
+
+Inputs (dynamic batch b and sequence s, option axis static MAX_OPTS):
+  input_ids      [B, S] int32
+  attention_mask [B, S] float32   (1 = token, 0 = pad; laya pads on the right)
+  marker_pos     [B, MAX_OPTS] int32   host-flattened index into [B*S, H] (b * S + token index)
+  marker_mask    [B, MAX_OPTS] float32
+  qtype          [B]     int32    (0=choice, 1=score, 2=noul)
+Outputs: logits [B, MAX_OPTS] (padded slots about -1e4), act_logits [B, 2].
+
+Positions: RoBERTa numbers real tokens from padding_idx + 1 = 2. laya pads on the right only, so the position of
+token i is i + 2 for every real token. A padded token gets a different position than in transformers (which gives it
+1), but a pad is never attended to and never read, so the outputs are the same.
+"""
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+MAX_OPTS = 20
+
+
+class NitzotzTrunk(nn.Module):
+    def __init__(self, agent: Any, max_len: int = 512, max_opts: int = MAX_OPTS):
+        super().__init__()
+        model = agent.model
+        enc = model.encoder
+        cfg = enc.config
+        d = cfg.hidden_size
+        self.hidden, self.n_heads = d, cfg.num_attention_heads
+        self.head_dim = d // self.n_heads
+        self.eps = cfg.layer_norm_eps
+        self.max_len, self.max_opts = int(max_len), int(max_opts)
+        self.buf_len = int(max_len) + 1          # one spare slot so slicing [:s] is never a no-op (torch.export)
+        pad_idx = cfg.pad_token_id
+
+        emb = enc.embeddings
+        self.tok_emb = nn.Embedding(cfg.vocab_size, d)
+        self.tok_emb.weight.data.copy_(emb.word_embeddings.weight.data)
+        # position rows for tokens 0..max_len-1 are pad_idx+1 .. pad_idx+max_len; the spare slot repeats the last row
+        rows = torch.arange(self.buf_len) + pad_idx + 1
+        rows = rows.clamp(max=emb.position_embeddings.weight.shape[0] - 1)
+        pos = emb.position_embeddings.weight.data[rows].clone()
+        pos = pos + emb.token_type_embeddings.weight.data[0][None, :]      # token type is always 0
+        self.register_buffer("pos_type", pos.unsqueeze(0), persistent=True)  # [1, buf_len, d]
+        self.emb_ln_w = nn.Parameter(emb.LayerNorm.weight.data.clone())
+        self.emb_ln_b = nn.Parameter(emb.LayerNorm.bias.data.clone())
+
+        self.qkv, self.wo, self.ln1_w, self.ln1_b = nn.ModuleList(), nn.ModuleList(), nn.ParameterList(), nn.ParameterList()
+        self.fc1, self.fc2, self.ln2_w, self.ln2_b = nn.ModuleList(), nn.ModuleList(), nn.ParameterList(), nn.ParameterList()
+        for layer in enc.encoder.layer:
+            sa, so = layer.attention.self, layer.attention.output
+            qkv = nn.Linear(d, 3 * d, bias=True)
+            qkv.weight.data.copy_(torch.cat([sa.query.weight.data, sa.key.weight.data, sa.value.weight.data], 0))
+            qkv.bias.data.copy_(torch.cat([sa.query.bias.data, sa.key.bias.data, sa.value.bias.data], 0))
+            wo = nn.Linear(d, d, bias=True)
+            wo.weight.data.copy_(so.dense.weight.data)
+            wo.bias.data.copy_(so.dense.bias.data)
+            self.qkv.append(qkv)
+            self.wo.append(wo)
+            self.ln1_w.append(nn.Parameter(so.LayerNorm.weight.data.clone()))
+            self.ln1_b.append(nn.Parameter(so.LayerNorm.bias.data.clone()))
+            fc1 = nn.Linear(d, cfg.intermediate_size, bias=True)
+            fc1.weight.data.copy_(layer.intermediate.dense.weight.data)
+            fc1.bias.data.copy_(layer.intermediate.dense.bias.data)
+            fc2 = nn.Linear(cfg.intermediate_size, d, bias=True)
+            fc2.weight.data.copy_(layer.output.dense.weight.data)
+            fc2.bias.data.copy_(layer.output.dense.bias.data)
+            self.fc1.append(fc1)
+            self.fc2.append(fc2)
+            self.ln2_w.append(nn.Parameter(layer.output.LayerNorm.weight.data.clone()))
+            self.ln2_b.append(nn.Parameter(layer.output.LayerNorm.bias.data.clone()))
+
+        # laya decision head: 2 x pre-LN TransformerEncoderLayer (ReLU FFN), scorer, act head
+        self.type_emb = nn.Embedding(3, d)
+        self.type_emb.weight.data.copy_(model.type_emb.weight.data)
+        self.head_qkv, self.head_wo = nn.ModuleList(), nn.ModuleList()
+        self.head_fc1, self.head_fc2 = nn.ModuleList(), nn.ModuleList()
+        self.head_n1_w, self.head_n1_b = nn.ParameterList(), nn.ParameterList()
+        self.head_n2_w, self.head_n2_b = nn.ParameterList(), nn.ParameterList()
+        for layer in model.head.layers:
+            attn = layer.self_attn
+            q = nn.Linear(d, 3 * d, bias=True)
+            q.weight.data.copy_(attn.in_proj_weight.data)
+            q.bias.data.copy_(attn.in_proj_bias.data)
+            o = nn.Linear(d, d, bias=True)
+            o.weight.data.copy_(attn.out_proj.weight.data)
+            o.bias.data.copy_(attn.out_proj.bias.data)
+            self.head_qkv.append(q)
+            self.head_wo.append(o)
+            f1 = nn.Linear(d, layer.linear1.out_features, bias=True)
+            f1.weight.data.copy_(layer.linear1.weight.data)
+            f1.bias.data.copy_(layer.linear1.bias.data)
+            f2 = nn.Linear(layer.linear2.in_features, d, bias=True)
+            f2.weight.data.copy_(layer.linear2.weight.data)
+            f2.bias.data.copy_(layer.linear2.bias.data)
+            self.head_fc1.append(f1)
+            self.head_fc2.append(f2)
+            self.head_n1_w.append(nn.Parameter(layer.norm1.weight.data.clone()))
+            self.head_n1_b.append(nn.Parameter(layer.norm1.bias.data.clone()))
+            self.head_n2_w.append(nn.Parameter(layer.norm2.weight.data.clone()))
+            self.head_n2_b.append(nn.Parameter(layer.norm2.bias.data.clone()))
+        self.scorer_ln = nn.LayerNorm(d)
+        self.scorer_ln.weight.data.copy_(model.scorer[0].weight.data)
+        self.scorer_ln.bias.data.copy_(model.scorer[0].bias.data)
+        self.scorer_fc1 = nn.Linear(d, d)
+        self.scorer_fc1.weight.data.copy_(model.scorer[1].weight.data)
+        self.scorer_fc1.bias.data.copy_(model.scorer[1].bias.data)
+        self.scorer_fc2 = nn.Linear(d, 1)
+        self.scorer_fc2.weight.data.copy_(model.scorer[3].weight.data)
+        self.scorer_fc2.bias.data.copy_(model.scorer[3].bias.data)
+        self.act_fc1 = nn.Linear(d + 4, model.act_head[0].out_features)
+        self.act_fc1.weight.data.copy_(model.act_head[0].weight.data)
+        self.act_fc1.bias.data.copy_(model.act_head[0].bias.data)
+        self.act_fc2 = nn.Linear(model.act_head[2].in_features, model.act_head[2].out_features)
+        self.act_fc2.weight.data.copy_(model.act_head[2].weight.data)
+        self.act_fc2.bias.data.copy_(model.act_head[2].bias.data)
+        self.eval()
+
+    def _ln(self, x, w, b, eps):
+        return F.layer_norm(x, (self.hidden,), w, b, eps)
+
+    def _sdpa(self, x, qkv, wo, bias):
+        b, s, _ = x.shape
+        q, k, v = qkv(x).split(self.hidden, dim=-1)
+        q = q.view(b, s, self.n_heads, self.head_dim).transpose(1, 2)
+        k = k.view(b, s, self.n_heads, self.head_dim).transpose(1, 2)
+        v = v.view(b, s, self.n_heads, self.head_dim).transpose(1, 2)
+        y = F.scaled_dot_product_attention(q, k, v, attn_mask=bias, dropout_p=0.0, is_causal=False,
+                                           scale=1.0 / math.sqrt(self.head_dim))
+        return wo(y.transpose(1, 2).reshape(b, s, self.hidden))
+
+    def forward(self, input_ids, attention_mask, marker_pos, marker_mask, qtype):
+        b, s = input_ids.shape
+        h = self.tok_emb(input_ids.to(dtype=torch.long)) + self.pos_type[:, :s]
+        h = self._ln(h, self.emb_ln_w, self.emb_ln_b, self.eps)
+
+        pad_bias = ((attention_mask.to(dtype=h.dtype) - 1.0) * 1.0e4)[:, None, None, :]
+        full_zeros = attention_mask[:, None, :, None] * (attention_mask[:, None, None, :] * 0.0)
+        bias = full_zeros.to(dtype=h.dtype) + pad_bias
+
+        for i in range(len(self.qkv)):                      # post-LN RoBERTa layer
+            h = self._ln(h + self._sdpa(h, self.qkv[i], self.wo[i], bias), self.ln1_w[i], self.ln1_b[i], self.eps)
+            h = self._ln(h + self.fc2[i](F.gelu(self.fc1[i](h))), self.ln2_w[i], self.ln2_b[i], self.eps)
+
+        h = h + self.type_emb(qtype.to(dtype=torch.long))[:, None, :]
+        for i in range(len(self.head_qkv)):                 # pre-LN laya head layer
+            x = self._ln(h, self.head_n1_w[i], self.head_n1_b[i], 1e-5)
+            h = h + self._sdpa(x, self.head_qkv[i], self.head_wo[i], bias)
+            y = self._ln(h, self.head_n2_w[i], self.head_n2_b[i], 1e-5)
+            h = h + self.head_fc2[i](F.relu(self.head_fc1[i](y)))
+
+        flat = h.reshape(b * s, self.hidden)
+        gathered = F.embedding(marker_pos.reshape(-1), flat).view(b, self.max_opts, self.hidden)
+        logits = self.scorer_fc2(F.gelu(self.scorer_fc1(self.scorer_ln(gathered)))).squeeze(-1)
+        logits = logits + (1.0 - marker_mask) * (-1.0e4)
+
+        p = torch.softmax(logits, dim=-1)
+        k = marker_mask.sum(dim=-1, keepdim=True).clamp(min=2.0)
+        ent = -(p * torch.log(p.clamp_min(1e-9))).sum(dim=-1, keepdim=True) / torch.log(k)
+        top1 = p[:, 0:1]
+        for i in range(1, self.max_opts):
+            slot = p[:, i:i + 1]
+            top1 = F.relu(top1 - slot) + slot
+        keep = (top1 - p) / ((top1 - p) + 1.0e-6)
+        scaled = p * keep
+        top2 = scaled[:, 0:1]
+        for i in range(1, self.max_opts):
+            slot = scaled[:, i:i + 1]
+            top2 = F.relu(top2 - slot) + slot
+        feats = torch.cat([top1, top1 - top2, ent, k / 255.0], dim=-1)
+        act_logits = self.act_fc2(F.gelu(self.act_fc1(torch.cat([h[:, 0], feats], dim=-1))))
+        return logits, act_logits
+
+
+def pad_batch(input_ids, attention_mask, marker_pos, marker_mask, qtype, pad_id, seq_len, max_opts=MAX_OPTS):
+    """Pad a laya collate_items batch to [B, seq_len] / [B, max_opts] and flatten the marker index (host side)."""
+    b, s = input_ids.shape
+    k = marker_pos.shape[1]
+    ids = torch.full((b, seq_len), pad_id, dtype=torch.int32)
+    att = torch.zeros((b, seq_len), dtype=torch.float32)
+    mpos = torch.zeros((b, max_opts), dtype=torch.int32)
+    mmask = torch.zeros((b, max_opts), dtype=torch.float32)
+    ids[:, :s] = input_ids.to(torch.int32)
+    att[:, :s] = attention_mask.to(torch.float32)
+    mpos[:, :k] = marker_pos.to(torch.int32)
+    mmask[:, :k] = marker_mask.to(torch.float32)
+    mpos = mpos + (torch.arange(b, dtype=torch.int32)[:, None] * seq_len)
+    return ids, att, mpos, mmask, qtype.to(torch.int32).reshape(b)

model.safetensors

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

nitzotz-f16.gguf

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

nitzotz-q8_0.gguf

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

rl_agent_config.json

@@ -0,0 +1,77 @@
+{
+  "encoder": "HalleluBERT/HalleluBERT_large",
+  "head_layers": 2,
+  "max_len": 512,
+  "head_max_len": 256,
+  "act_costs": {
+    "escalate": 0.5
+  },
+  "amp_dtype": "bf16",
+  "model_name": "nitzotz",
+  "temperature": [
+    1.103005051612854,
+    1.109466552734375,
+    1.165097951889038
+  ],
+  "training": {
+    "encoder_init": "HalleluBERT-large after extractive QA on HeQ v1.1 train (test-overlapping passages removed)",
+    "data": "58,000 items: synthetic Hebrew messages, HeQ v1.1 train, MASSIVE he-IL train (see README)",
+    "items_total": 58000,
+    "train_items": 55099,
+    "calib_items": 2901,
+    "epochs_planned": 2,
+    "epochs_run": 2,
+    "kept_epoch": 2,
+    "heldout_by_epoch": [
+      {
+        "acc": 0.9349,
+        "soft_nll": 0.5046,
+        "by_family": {
+          "claim": 0.9521,
+          "heq_read": 0.972,
+          "heq_unans": 0.92,
+          "heq_verify": 0.9567,
+          "massive_intent": 0.92,
+          "routing": 0.9201,
+          "spam_type": 0.9329,
+          "urgency": 0.8971
+        },
+        "epoch": 1,
+        "step": 1722,
+        "train_seconds": 765.9
+      },
+      {
+        "acc": 0.9479,
+        "soft_nll": 0.4612,
+        "by_family": {
+          "claim": 0.9635,
+          "heq_read": 0.984,
+          "heq_unans": 0.944,
+          "heq_verify": 0.9533,
+          "massive_intent": 0.9343,
+          "routing": 0.9384,
+          "spam_type": 0.9429,
+          "urgency": 0.9257
+        },
+        "epoch": 2,
+        "step": 3444,
+        "train_seconds": 766.6
+      }
+    ],
+    "steps": 3444,
+    "batch": 32,
+    "micro_batch": 16,
+    "lr_encoder": 1e-05,
+    "lr_head": 0.0001,
+    "warmup": 0.1,
+    "schedule": "cosine",
+    "seed": 2,
+    "split_seed": 1234,
+    "loss": "soft cross-entropy",
+    "amp": "bf16",
+    "device": "cuda",
+    "train_seconds": 1543.1,
+    "head_init": "fresh (no laya checkpoint weights)",
+    "class_weights": "none"
+  }
+}

tokenizer/tokenizer_config.json

@@ -0,0 +1,17 @@
+{
+  "add_prefix_space": false,
+  "backend": "tokenizers",
+  "bos_token": "<s>",
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "errors": "replace",
+  "is_local": false,
+  "local_files_only": false,
+  "mask_token": "<mask>",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<pad>",
+  "sep_token": "</s>",
+  "tokenizer_class": "RobertaTokenizer",
+  "trim_offsets": true,
+  "unk_token": "<unk>"
+}