aufklarer/P99-Turn-1-Mini-CoreML

Core ML export of turn-1-mini by p99lab

Unofficial Float32 format conversion of turn-1-mini by p99lab. The original checkpoint weights are unchanged. This export is not endorsed by p99lab.

The model estimates end-of-turn probability from audio. It does not transcribe speech. The graph includes the required 4 kHz filtering, log-mel frontend and streaming network. Keep its seven state tensors between calls, and reset them between conversations.

Property	Value
Parameters	5,262,337
Format	Compiled Core ML .mlmodelc
Precision / quantization	Float32 / none
Compiled graph size	21,896,869 bytes
Audio	16 kHz mono Float32 PCM
Request size	2,560 samples / 160 ms
Output	Eight probabilities, one for each 20 ms frame
Language	English; other languages unmeasured
Platform	macOS 15+ / iOS 18+

All eight outputs become available after a complete 160 ms request. The 20 ms frame spacing is not a 20 ms response-latency claim. The application chooses its threshold, minimum silence and fallback policy.

Files

File	Bytes	Description
p99_turn_step.mlmodelc	21,896,869	Compiled graph directory
config.json	757	Input/output geometry and pinned source provenance
LICENSE	11,357	Licence text
NOTICE	1,860	Attribution and conversion notice
coreml-validation.json	374	Compiled graph parity and timing results
torch-parity.json	140	Export wrapper parity results
benchmark.json	5,486	Matched TurnBench pilot and original-checkpoint controls
SHA256SUMS	—	SHA-256 for each release file
README.md	—	This model card

Numerical validation and compute time

The compiled graph was compared with the pinned upstream Float32 streaming ONNX on 96 steps (15.36 seconds), using silence, noise, clean tones and very quiet tones. Maximum probability error was 0.00000707, below the 0.0002 tolerance.

Apple M5 Pro, 48 GiB, CPU only; one local validation run, with loading excluded from step times:

Measurement	Result
Model loading	72.04 ms
First 160 ms step	18.08 ms
Remaining steps, median	0.674 ms
Remaining steps, 95th percentile	0.932 ms

These are shared-machine compute samples, not end-of-turn delay measurements. SDK model checks additionally cover arbitrary chunk sizes, reset and fixed reference values. The matched TurnBench development pilot below evaluates this export and its fixed policy. eot-bench has not been rerun. Phone latency and memory have not been measured.

TurnBench development pilot

Two fixed English conversations, 20 and 21: 148 turn endings and 94 labelled mid-turn pauses. No threshold was selected on this pilot. The original TurnBench scorer and labels were retained.

Backend	Turn endings caught	False alarms	Audio-time delay, median	Request compute, median
Core ML + Silero policy	90.5% (134/148)	16.0% (15/94)	1506.0 ms	3.01 ms
Upstream Float32 ONNX + same policy	90.5% (134/148)	16.0% (15/94)	1506.0 ms	1.97 ms

The model uses complete 160 ms input steps. A fixed Silero policy confirms at least 0.3 s of silence, accepts end-of-turn probability at 0.5, and falls back after 2 s. The Core ML and original Float32 ONNX receive identical audio and policy. The larger two-channel system behind the published p99 TurnBench submission is a separate configuration.

Audio-time delay follows audio availability in offline replay; it excludes the separately measured request computation. These values do not measure complete deployed-agent latency or phone performance. Full counts, policies, checksums and reference comparisons are in benchmark.json and the leaderboard method.

Usage

Tested with Python 3.12. Install the inference dependencies and download CLI:

pip install coremltools==9.0 numpy==2.2.6 huggingface-hub==2.2.0

Download from the CLI:

hf download aufklarer/P99-Turn-1-Mini-CoreML --local-dir p99-coreml

Run one step on macOS with Python:

import json
from pathlib import Path
import coremltools as ct
import numpy as np

bundle = Path("p99-coreml")
config = json.loads((bundle / "config.json").read_text())
model = ct.models.CompiledMLModel(
    str(bundle / config["compiled_model"]), compute_units=ct.ComputeUnit.CPU_ONLY
)
state = {"state_" + name: np.zeros(shape, np.float32)
         for name, shape in config["state_shapes"].items()}
audio = np.zeros((1, config["step_samples"]), np.float32)
result = model.predict({"audio": audio, **state})
probabilities = np.asarray(result["probs"]).reshape(-1)
state = {"state_" + name: np.asarray(result["new_state_" + name])
         for name in config["state_shapes"]}

Feed successive audio steps and carry state forward. Real audio must be normalized Float32 PCM at 16 kHz. The graph performs its own frontend filtering.

Source and attribution

Upstream model and code: p99lab/turn-1-mini, revision 076c86d1744a231d3a4cce31f3bbbd1211b4c281. Apache 2.0; preserve LICENSE and the original NOTICE. config.json records the source weight checksum. This is a format export, not a new model or a claimed improvement.

Links

• speech-swift — Apple SDK
• Installation and guides
• Soniqo · Blog