SpellSpeak Audience rc2.1

MANIFEST.json

@@ -1,14 +1,14 @@
 {
  "name": "SpellSpeak Audience",
- "release": "rc2",
- "package": "spellspeak-audience-rc2.1",
- "created": "2026-10-09T20:00:38Z",
+ "release": "rc2.1",
+ "package": "spellspeak-audience-rc2.2",
+ "created": "2026-10-09T22:24:09Z",
  "model_run": "addr-r3-ettin-32m-tt-s0",
  "inputs": "addressee-tt-0.6",
  "files": {
   "README.md": {
-   "bytes": 14398,
-   "sha256": "9cae3da033c7aaeb020924210c7a4ca0f9ec10615a840469ec42276c09a303bc"
+   "bytes": 16566,
+   "sha256": "c41e39a18c7a9d84d532065749abbde6d3b618eb35865a0b958d82881d513873"
   },
   "config.json": {
    "bytes": 341,
@@ -18,14 +18,22 @@
    "bytes": 127960962,
    "sha256": "8db0b9abf290b82b12ae9e71066e607e91a60d310562d84fc67a8668a5020f0d"
   },
+  "encoder_fp16.onnx": {
+   "bytes": 64103200,
+   "sha256": "9d71e550b8e497ed1c96dd6992f5133dc2f244fa708367cc5d024478a11ef7e2"
+  },
   "example.py": {
-   "bytes": 3506,
-   "sha256": "16985363b68b6bb650320069f70f8f483608cefca366888c877b9c8e2566e913"
+   "bytes": 4097,
+   "sha256": "676227bc4fb3c33c8fc0a99f2645dafacc56ac4586ee706233f0f1baac429338"
   },
   "head.onnx": {
    "bytes": 3692356,
    "sha256": "67c08fae8fd4712ebf08e1955c5b40800467cd3b6efb9d425539d2afcca2eb8c"
   },
+  "head_fp16.onnx": {
+   "bytes": 1858520,
+   "sha256": "78361e61605406bb0d8c13de148847684e55724fe183f24a713df2c4cee18655"
+  },
   "requirements.txt": {
    "bytes": 270,
    "sha256": "7ca7dcd5aa19a996d459ef0ab9f8e43f61d814931525369e57664044e66d72db"
@@ -59,8 +67,8 @@
    "sha256": "ffbc520ee544ebc2fea6a25fb99b2d6edd3232a339a6d49b85a96a16de5db5d8"
   },
   "runtime/harness/addressee/classifier.py": {
-   "bytes": 7720,
-   "sha256": "c2167ae8f35dfec6edef1a779313492a21e4d4bf35140f13b1bfde0b5c993146"
+   "bytes": 9314,
+   "sha256": "3d3b7e8c36988721dcf2f257d09584d666065c0bd0f0fe1fe22f88954a258864"
   },
   "runtime/harness/addressee/evidence.py": {
    "bytes": 10185,

README.md

@@ -19,7 +19,7 @@ tags:
   - dialogue
 ---
 
-# SpellSpeak Audience · RC2
+# SpellSpeak Audience · RC2.1
 
 When several AI characters listen to the same person, as in a game, an interactive story or any other multi-character voice experience, the application has to know who each line is for before any character answers or reacts. A name or a description often settles it, but much of what people say names nobody: "Hello.", "Who are you?", "You lied to me.". Once the characters talk among themselves, the application also needs to know who each character's line is for, to know who speaks next. The language model voicing each character could guess, but only by reading every character's context for every line. That adds latency, the characters can disagree, and a wrong guess is heard at once.
 
@@ -27,7 +27,18 @@ SpellSpeak Audience treats the question as classification by a small model. One
 
 [Try it in your browser](https://huggingface.co/spaces/spellspeak/audience-demo) · [Examples and source](https://github.com/spellspeak/models/tree/main/audience)
 
-## What is new in RC2
+## What is new in RC2.1
+
+- **A 16-bit copy at half the size, with the same answers.** `encoder_fp16.onnx` and `head_fp16.onnx` hold the same weights stored in 16 bits: 66.0 MB against 131.7 MB. They are cast back to 32 bits when they load.
+  - On the test lines, 99.92% of their answers read exactly as full precision's, with the spatial facts and without them. The other two lines only change which of several tied people is on top.
+  - No scorecard item is worse. A difference counts when it is 0.1 points or more on a set of at least 30 lines.
+  - A wrong person scored 0.8 or more stays at 0.69% with facts and 0.45% without.
+- **Memory and speed match full precision's**, because the weights become 32-bit when they load: 364 MB resident against 370 MB. The p95 per line is within a millisecond of full precision's, on one thread of an Apple M1 Max.
+- **Full precision is unchanged and stays the default.** It is the same files as RC2, byte for byte.
+
+Full precision is the reference. Every other number on this card is full precision's, and it is the file to keep for any further training.
+
+## What RC2 added
 
 - **Questions to the room.** "Who knows where the mill key is?", "Anyone seen my horse?", "Does anybody here sell rope?" are for everyone who can hear them, whoever the speaker is looking at. RC1 sent most of them to the one person looked at. With the speaker facing one person, RC2 gets all 63 test lines right, with the facts and without them; RC1 gets 27% with the facts and 84% without.
 - **Lines said by characters.** The speaker may be a character. The player is then one of the people the line can be said to, with a card of what the characters see of them. A character's line goes to the one it was answering, unless its words pick someone else out: "Wren, you were there, weren't you?" is for Wren, and "Ask Wren, she'd know." still answers the player.
@@ -35,24 +46,35 @@ SpellSpeak Audience treats the question as classification by a small model. One
 
 | | |
 |---|---|
-| **Released** | 2026-10-09 · rc2 (package `spellspeak-audience-rc2.1`, model run `addr-r3-ettin-32m-tt-s0`, inputs `addressee-tt-0.6`) |
+| **Released** | 2026-10-09 · rc2.1 (package `spellspeak-audience-rc2.2`, model run `addr-r3-ettin-32m-tt-s0`, inputs `addressee-tt-0.6`) |
 | **What it does** | Works out who a line is for, the player's or a character's: one person, several named on purpose, the whole group, or unclear |
-| **Size** | About 33M parameters · 135 MB ONNX (fp32) in two graphs: a 128 MB encoder and a 3.7 MB head |
-| **Speed** | p95 per line on 4 CPU threads (Apple M1 Max): 5.5 ms for 1 person, 5.7 for 2, 6.0 for 4, 6.6 for 8. On 1 thread: 11 to 12 ms. The first line of a scene also encodes everyone's card: 14 ms for 1 person to 61 ms for 8; cards are then cached |
-| **Runtime** | ONNX Runtime and tokenizers, on CPU. A Python reference runtime ships with it, including the function that turns positions into the spatial facts and an instant rules baseline. It also runs RC1's model files unchanged |
-| **Files** | `encoder.onnx`, `head.onnx`, `tokenizer.json` and `config.json`, with the reference runtime (`runtime/`), `example.py` and `requirements.txt`. `MANIFEST.json` lists every file with its size and sha256 |
+| **Size** | About 33M parameters. Full precision (fp32): 131.7 MB in two graphs, a 128.0 MB encoder and a 3.7 MB head. 16-bit: 66.0 MB, a 64.1 MB encoder and a 1.9 MB head. Both use the same 3.6 MB tokenizer |
+| **Speed** | p95 per line on 4 CPU threads (Apple M1 Max): 5.5 ms for 1 person, 5.7 for 2, 6.0 for 4, 6.6 for 8. On 1 thread: 11 to 12 ms. The first line of a scene also encodes everyone's card: 14 ms for 1 person to 61 ms for 8; cards are then cached. The 16-bit files time the same: within a millisecond of full precision's on one thread, timed in the same session |
+| **Runtime** | ONNX Runtime and tokenizers, on CPU. A Python reference runtime ships with it, including the function that turns positions into the spatial facts and an instant rules baseline. It reads full precision unless asked for the 16-bit files (`precision="fp16"`), and it also runs RC1's model files unchanged |
+| **Files** | `encoder.onnx` and `head.onnx` (full precision, the default), `encoder_fp16.onnx` and `head_fp16.onnx` (16-bit), `tokenizer.json` and `config.json`, with the reference runtime (`runtime/`), `example.py` and `requirements.txt`. `MANIFEST.json` lists every file with its size and sha256 |
 | **Licence** | Apache-2.0 |
 
 ## Quick start
 
+Everything, full precision and the 16-bit files:
+
 ```bash
 pip install -U huggingface_hub
-hf download spellspeak/audience --revision rc2 --local-dir spellspeak-audience
+hf download spellspeak/audience --revision rc2.1 --local-dir spellspeak-audience
 cd spellspeak-audience
 pip install -r requirements.txt
 python example.py
 ```
 
+Or the small download, the 16-bit files without the full-precision graphs:
+
+```bash
+hf download spellspeak/audience --revision rc2.1 --local-dir spellspeak-audience-fp16 --exclude encoder.onnx --exclude head.onnx
+cd spellspeak-audience-fp16
+pip install -r requirements.txt
+python example.py --fp16
+```
+
 The example puts a barkeep, an elf mercenary and an old sailor in a room, with the player facing the elf. It asks who four player lines are for, with and without the spatial facts. Then the barkeep speaks, after the player asked him where the mill key is:
 
 ```
@@ -68,6 +90,8 @@ Tomas: 'No idea, sorry.'               text only   player (1.00)
 Tomas: 'Wren, were you there?'         text only   wren (1.00)
 ```
 
+`python example.py --fp16` prints the same lines.
+
 In your own code, with the downloaded folder as the working directory:
 
 ```python
@@ -78,7 +102,8 @@ from contracts.schemas.addressee import AddresseeRequest
 from contracts.schemas.person_card import PersonCard
 from harness.addressee.classifier import load_classifier
 
-model = load_classifier(".")  # the folder with encoder.onnx, head.onnx, tokenizer.json and config.json
+model = load_classifier(".")  # full precision: encoder.onnx, head.onnx, tokenizer.json and config.json
+# model = load_classifier(".", precision="fp16")  # the 16-bit files instead: encoder_fp16.onnx and head_fp16.onnx
 people = [
     PersonCard(id="tomas", label="Tomas", aliases=["the barkeep"], features=[{"key": "headwear", "value": "red hat"}]),
     PersonCard(id="wren", label="Wren", features=[{"key": "role", "value": "mercenary"}]),
@@ -151,4 +176,4 @@ Measured on lines as given only:
 - **Spatial facts depend on the application's band edges.** Tune them (`BandConfig` in `bands.py`).
 - **It has not met real users yet.** It was tested in game settings only, on generated and hand-written lines, not on logs from real people or from other multi-character voice experiences.
 
-The numbers come from the training repository's reports for this release (`2026-10-09-addr-r3.md` and `2026-10-09-addr-r3-setup.md`, at commit `fce88bf`). The model was trained and exported at git tag `spellspeak-audience-rc2` (commit `97f3320`). That repository is private.
+The numbers come from the training repository's reports for this release: `2026-10-09-addr-r3.md` and `2026-10-09-addr-r3-setup.md` at commit `fce88bf`, and for the 16-bit files `2026-10-09-addr-precision.md` at commit `28e72a8`. The full-precision files are RC2's, trained and exported at git tag `spellspeak-audience-rc2` (commit `97f3320`), and this package was built at git tag `spellspeak-audience-rc2.2`. That repository is private.

encoder_fp16.onnx

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

example.py

@@ -1,11 +1,13 @@
 """Ask SpellSpeak Audience who a line is for.
 
     pip install -r requirements.txt
-    python example.py
+    python example.py           # full precision: encoder.onnx and head.onnx
+    python example.py --fp16    # the 16-bit files, where the release has them: half the download, the same answers
 
-The model files (encoder.onnx, head.onnx, tokenizer.json, config.json) are read from this folder. Without them, as in
-a git checkout, they are downloaded once from Hugging Face (spellspeak/audience, release rc2).
+The model files (the two graphs, tokenizer.json and config.json) are read from this folder. Without them, as in a git
+checkout, the ones the chosen precision needs are downloaded once from Hugging Face (spellspeak/audience, release rc2.1).
 """
+import argparse
 import pathlib
 import sys
 
@@ -17,13 +19,17 @@ from contracts.schemas.person_card import PersonCard  # noqa: E402
 from harness.addressee.bands import Pose, bands  # noqa: E402
 from harness.addressee.classifier import load_classifier  # noqa: E402
 
-MODEL_FILES = ["encoder.onnx", "head.onnx", "tokenizer.json", "config.json"]
+parser = argparse.ArgumentParser(description="Ask SpellSpeak Audience who a line is for.")
+parser.add_argument("--fp16", action="store_true", help="use the 16-bit files: half the download, the same answers")
+PRECISION = "fp16" if parser.parse_args().fp16 else "fp32"
+GRAPHS = ["encoder.onnx", "head.onnx"] if PRECISION == "fp32" else ["encoder_fp16.onnx", "head_fp16.onnx"]
+MODEL_FILES = [*GRAPHS, "tokenizer.json", "config.json"]
 model_dir = HERE
 if not all((HERE / f).exists() for f in MODEL_FILES):
     from huggingface_hub import snapshot_download
 
-    model_dir = snapshot_download("spellspeak/audience", revision="rc2", allow_patterns=MODEL_FILES)
-model = load_classifier(model_dir, threads=4)
+    model_dir = snapshot_download("spellspeak/audience", revision="rc2.1", allow_patterns=MODEL_FILES)
+model = load_classifier(model_dir, threads=4, precision=PRECISION)
 
 # What the player can see of each person. Keys are open: a game uses its own.
 people = [

head_fp16.onnx

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

runtime/harness/addressee/classifier.py

@@ -16,6 +16,25 @@ from contracts.schemas.addressee import AddresseeAnswer, AddresseeRequest
 from harness.addressee.render import RENDER_VERSION, render, span_mask
 
 
+PRECISIONS = ("fp32", "fp16")
+
+
+def graph_files(model_dir: str | pathlib.Path, precision: str = "fp32") -> tuple[pathlib.Path, pathlib.Path]:
+    """The cached-cards model's two graphs for a precision: `encoder.onnx` and `head.onnx` (full precision, the default
+    and the reference), or `encoder_fp16.onnx` and `head_fp16.onnx` (16-bit weights, cast to fp32 when they load: half
+    the file, the same answers). A clear error when the chosen files are not in the folder."""
+    if precision not in PRECISIONS:
+        raise ValueError(f"precision must be one of {', '.join(PRECISIONS)}, not {precision!r}")
+    d = pathlib.Path(model_dir)
+    suffix = "" if precision == "fp32" else "_fp16"
+    enc, head = d / f"encoder{suffix}.onnx", d / f"head{suffix}.onnx"
+    missing = [p.name for p in (enc, head) if not p.exists()]
+    if missing:
+        raise FileNotFoundError(f"precision {precision!r} needs {' and '.join(missing)} in {d}; "
+                                f"download them, or use precision='fp32' with encoder.onnx and head.onnx")
+    return enc, head
+
+
 def _sigmoid(x: float) -> float:
     return 1.0 / (1.0 + math.exp(-x)) if x >= 0 else math.exp(x) / (1.0 + math.exp(x))
 
@@ -69,7 +88,7 @@ class CachedCardsClassifier:
     version it was trained on (its config's `render_version`): rc1 reads addressee-tt-0.5, rc2
     addressee-tt-0.6, which also takes lines spoken by characters."""
 
-    def __init__(self, model_dir: str | pathlib.Path, threads: int = 4):
+    def __init__(self, model_dir: str | pathlib.Path, threads: int = 4, precision: str = "fp32"):
         import numpy as np
         import onnxruntime as ort
         from tokenizers import Tokenizer
@@ -78,6 +97,8 @@ class CachedCardsClassifier:
 
         self.np = np
         d = pathlib.Path(model_dir)
+        enc_file, head_file = graph_files(d, precision)
+        self.precision = precision
         self.config = json.loads((d / "config.json").read_text())
         self.version = self.config.get("render_version")
         if self.version not in TT_VERSIONS:
@@ -91,8 +112,8 @@ class CachedCardsClassifier:
         so = ort.SessionOptions()
         so.intra_op_num_threads = threads
         so.inter_op_num_threads = 1
-        self.enc = ort.InferenceSession(str(d / "encoder.onnx"), so, providers=["CPUExecutionProvider"])
-        self.head = ort.InferenceSession(str(d / "head.onnx"), so, providers=["CPUExecutionProvider"])
+        self.enc = ort.InferenceSession(str(enc_file), so, providers=["CPUExecutionProvider"])
+        self.head = ort.InferenceSession(str(head_file), so, providers=["CPUExecutionProvider"])
         self.temps = self.config["temperatures"]
         self.cache: dict[str, tuple] = {}
 
@@ -143,7 +164,13 @@ class CachedCardsClassifier:
         return a, (time.perf_counter() - t0) * 1000
 
 
-def load_classifier(model_dir: str | pathlib.Path, threads: int = 4):
-    """The right runtime for an exported model folder: cached cards when it has a card encoder, else single pass."""
+def load_classifier(model_dir: str | pathlib.Path, threads: int = 4, precision: str = "fp32"):
+    """The right runtime for an exported model folder: cached cards when it has a card encoder, else single pass.
+    `precision`: "fp32" (the default) reads encoder.onnx and head.onnx; "fp16" reads encoder_fp16.onnx and
+    head_fp16.onnx, in a folder that may hold only those (rc2.1 on)."""
     d = pathlib.Path(model_dir)
-    return CachedCardsClassifier(d, threads) if (d / "head.onnx").exists() else AddresseeClassifier(d, threads=threads)
+    if (d / "head.onnx").exists() or (d / "head_fp16.onnx").exists():
+        return CachedCardsClassifier(d, threads, precision)
+    if precision != "fp32":
+        raise ValueError(f"precision {precision!r} needs a cached-cards model (encoder and head); {d} holds a single-pass model.onnx")
+    return AddresseeClassifier(d, threads=threads)