Upload Model

.gitattributes

@@ -21,6 +21,11 @@
 *.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.svg filter=lfs diff=lfs merge=lfs -text
 *.rar filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
@@ -28,8 +33,17 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
 *.tgz filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text
 *.wasm filter=lfs diff=lfs merge=lfs -text
 *.xz filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+
+# LF-pinned: manifest integrity hashes must match git-served bytes
+*.py text eol=lf
+*.json text eol=lf
+*.md text eol=lf
+*.jinja text eol=lf
+LICENSE text eol=lf
+README text eol=lf

LICENSE

@@ -0,0 +1,34 @@
+MIT License
+
+Copyright (c) 2026 valkayuh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+-------------------------------------------------------------------------------
+Third-party material
+
+The encoders are fine-tuned from jhu-clsp/mmBERT-base (MIT) and
+FacebookAI/xlm-roberta-large (MIT).
+
+Training data included Wikipedia (CC-BY-SA-4.0), Tatoeba sentences
+(CC-BY-2.0 FR, (c) Tatoeba contributors, https://tatoeba.org), Europarl,
+HPLT 2.0 (CC0-1.0), VoxPopuli transcripts (CC0-1.0) and the Aya dataset
+(Apache-2.0), plus Whisper transcripts of synthetic speech produced with
+Kokoro-82M (Apache-2.0) and facebook/mms-tts (CC-BY-NC-4.0). None of that
+data is redistributed here. See README.md, "Licence and data provenance".

README.md

@@ -0,0 +1,770 @@
+---
+license: mit
+language:
+- ar
+- az
+- bg
+- bn
+- bs
+- ca
+- cs
+- da
+- de
+- el
+- en
+- eo
+- es
+- et
+- fa
+- fi
+- fr
+- he
+- hi
+- hr
+- hu
+- hy
+- id
+- it
+- ja
+- ka
+- kk
+- ko
+- ku
+- lt
+- lv
+- mk
+- mn
+- mr
+- ms
+- my
+- nb
+- nl
+- pl
+- pt
+- ro
+- ru
+- sk
+- sl
+- sq
+- sr
+- sv
+- sw
+- ta
+- th
+- tr
+- uk
+- ur
+- vi
+- zh
+- af
+- be
+- cy
+- eu
+- ga
+- gl
+- is
+- kn
+- ml
+- ne
+- nn
+- si
+- te
+- tl
+- uz
+- gu
+- pa
+- km
+- la
+- lb
+- mt
+- so
+- am
+- ky
+pipeline_tag: token-classification
+tags:
+- punctuation
+- punctuation-restoration
+- truecasing
+- capitalization
+- asr
+- speech-recognition-postprocessing
+- multilingual
+- ensemble
+- modernbert
+- xlm-roberta
+base_model:
+- jhu-clsp/mmBERT-base
+- valkayuh/dewpoint
+base_model_relation: quantized
+datasets:
+- wikimedia/wikipedia
+- Helsinki-NLP/europarl
+- HPLT/HPLT2.0_cleaned
+- facebook/voxpopuli
+- CohereLabs/aya_dataset
+metrics:
+- f1
+model-index:
+- name: Dewpoint
+  results:
+  - task:
+      type: token-classification
+      name: Punctuation restoration
+    dataset:
+      name: IWSLT 2017 TED, official tst2010-2015 (9 languages)
+      type: IWSLT/iwslt2017
+    metrics:
+    - type: f1
+      value: 0.7559
+      name: Macro-F1 (COMMA, PERIOD, QUESTION), mean over languages
+    - type: f1
+      value: 0.6557
+      name: Comma F1
+    - type: f1
+      value: 0.7923
+      name: Period F1
+    - type: f1
+      value: 0.8197
+      name: Question F1
+  - task:
+      type: token-classification
+      name: Punctuation restoration
+    dataset:
+      name: WIT3 TED, same 90 talks (57 language tracks)
+      type: wit3
+    metrics:
+    - type: f1
+      value: 0.7303
+      name: Macro-F1 (COMMA, PERIOD, QUESTION), mean over languages
+    - type: f1
+      value: 0.6482
+      name: Comma F1
+    - type: f1
+      value: 0.7794
+      name: Period F1
+    - type: f1
+      value: 0.7632
+      name: Question F1
+  - task:
+      type: token-classification
+      name: Punctuation restoration
+    dataset:
+      name: IWSLT TED through TTS and Whisper ASR (33 languages)
+      type: iwslt-ted-asr
+    metrics:
+    - type: f1
+      value: 0.6332
+      name: Macro-F1 (COMMA, PERIOD, QUESTION), mean over languages
+    - type: f1
+      value: 0.5656
+      name: Comma F1
+    - type: f1
+      value: 0.7102
+      name: Period F1
+    - type: f1
+      value: 0.6238
+      name: Question F1
+---
+
+# About
+
+This model was quantized to BF16 from valkayuh/dewpoint. Refer to the [original model card](https://huggingface.co/valkayuh/dewpoint) for more details on the model.
+
+# Original Model Card
+
+![Dewpoint: punctuation and capitals for the spoken word](assets/banner.jpg)
+
+# Dewpoint
+
+**Punctuation and truecasing for speech-recognition output, in 79 languages.** Speech
+recognisers hand back a stream of lowercase words with no punctuation, and Dewpoint
+restores it: it adds the commas, full stops and question marks, and the capitals.
+Open weights, MIT licence, free for everyone.
+
+```text
+so i said meet at three thirty tuesday what do you think the iphone was announced by steve jobs in san francisco
+→ So I said meet at three thirty Tuesday. What do you think? The iPhone was announced by Steve Jobs in San Francisco.
+
+ich weiß nicht ob wir das schaffen aber wir sollten es versuchen was meinst du
+→ Ich weiß nicht, ob wir das schaffen, aber wir sollten es versuchen. Was meinst du?
+
+πού είναι ο σταθμός ξέρεις να μου πεις
+→ Πού είναι ο σταθμός; Ξέρεις να μου πεις;
+```
+
+These are unedited outputs of this checkpoint. Dewpoint is a **tagger, not a
+generator**. For each word it decides which mark follows (none, `,` `.` `?` `!`) and how
+the word is cased (lower, Capitalised, UPPER). It never adds, drops, reorders or rewrites
+a word, so it cannot invent content.
+
+## Results
+
+On the IWSLT TED benchmark, Dewpoint scores higher than every other multilingual
+punctuation model we tested, under all three test conditions. On the two text test
+sets it is behind no other model in any language: **0 of 9** on the official
+set and **0 of 57** on the extended one. Under ASR noise it trails in
+**7 of 33**, 5 of them to raw Whisper.
+
+![Macro-F1 on three benchmarks](assets/benchmarks.jpg)
+
+| system | params | official, 9 lang | WIT3, 57 lang | ASR, 33 lang |
+|---|---|---|---|---|
+| **Dewpoint** | 869M | **0.7559** | **0.7303** | **0.6332** |
+| Dewpoint, mmBERT-base half alone | 307M | 0.7392 | 0.7098 | 0.6197 |
+| Dewpoint, XLM-R-large half alone | 561M | 0.7443 | 0.7241 | 0.6208 |
+| [oliverguhr/fullstop-punctuation-multilang-large](https://huggingface.co/oliverguhr/fullstop-punctuation-multilang-large) | 559M | 0.6438 | 0.5984 | 0.5301 |
+| [kredor/punctuate-all](https://huggingface.co/kredor/punctuate-all) | 278M | 0.6344 | 0.5950 | 0.5333 |
+| [oliverguhr/fullstop-punctuation-multilingual-sonar-base](https://huggingface.co/oliverguhr/fullstop-punctuation-multilingual-sonar-base) | 278M | 0.6381 | 0.5653 | 0.5205 |
+| [1-800-BAD-CODE/xlm-roberta_punctuation_fullstop_truecase](https://huggingface.co/1-800-BAD-CODE/xlm-roberta_punctuation_fullstop_truecase) | 278M | 0.6204 | 0.5710 | 0.5346 |
+| raw [openai/whisper-large-v3-turbo](https://huggingface.co/openai/whisper-large-v3-turbo) punctuation | 809M | — | — | 0.4436 |
+
+Macro-F1 over COMMA, PERIOD and QUESTION, averaged over languages. Every system runs
+through the same harness and gets the same dev-set threshold calibration.
+
+**Head to head on each model's own languages.** The averages above include languages the
+other models were never trained on, which pulls their means down. Scored only on the
+languages each model lists on its own model card, the margins are smaller:
+
+| other model | languages it supports | official | WIT3 | ASR |
+|---|---|---|---|---|
+| [oliverguhr/fullstop-punctuation-multilang-large](https://huggingface.co/oliverguhr/fullstop-punctuation-multilang-large) | 4 | 0.755 vs **0.791** (4) | 0.758 vs **0.793** (5) | 0.741 vs **0.772** (4) |
+| [oliverguhr/fullstop-punctuation-multilingual-sonar-base](https://huggingface.co/oliverguhr/fullstop-punctuation-multilingual-sonar-base) | 5 | 0.734 vs **0.786** (5) | 0.752 vs **0.797** (6) | 0.702 vs **0.753** (5) |
+| [kredor/punctuate-all](https://huggingface.co/kredor/punctuate-all) | 12 | 0.726 vs **0.786** (5) | 0.733 vs **0.797** (14) | 0.695 vs **0.755** (9) |
+| [1-800-BAD-CODE/xlm-roberta_punctuation_fullstop_truecase](https://huggingface.co/1-800-BAD-CODE/xlm-roberta_punctuation_fullstop_truecase) | 47 | 0.620 vs **0.756** (9) | 0.598 vs **0.744** (37) | 0.540 vs **0.636** (27) |
+
+Dewpoint is ahead in every one of these languages except Bengali on Whisper ASR output against xlm-r truecase.
+
+Each cell is that model's mean macro-F1 vs Dewpoint's on the same languages, with the
+number of languages in brackets. This is the fairer comparison.
+
+---
+
+## Quick start
+
+```bash
+pip install torch transformers safetensors huggingface_hub numpy   # GPU or CPU
+# or, with no torch at all:
+pip install onnxruntime tokenizers huggingface_hub numpy
+```
+
+```python
+import os, sys
+from huggingface_hub import hf_hub_download
+sys.path.insert(0, os.path.dirname(hf_hub_download("valkayuh/dewpoint", "dewpoint.py")))
+from dewpoint import Punctuator
+
+p = Punctuator.from_pretrained("valkayuh/dewpoint")   # torch if installed, else ONNX
+p.restore("what time is it in tokyo right now", lang="en")
+# 'What time is it in Tokyo right now?'
+```
+
+`from_pretrained` downloads only what the chosen backend needs. The torch backend
+fetches the safetensors (3.5 GB, or 1.2 GB with `members=["mmbert-base"]`), the ONNX
+backend fetches the ONNX graphs, and neither fetches the other.
+
+**Always pass the language.** It selects the calibrated decision thresholds, turns
+casing off for scripts that have none, and picks the right marks to write: `؟` for
+Arabic, `;` for the Greek question mark, `。` and `，` for Chinese, `।` for Hindi.
+
+**Single-model mode.** Pass `members=["mmbert-base"]` to download and run only the
+307M-parameter mmBERT-base half. It uses its own calibration, runs in about half the
+GPU time, and still beats every other model we tested on every benchmark:
+
+```python
+p = Punctuator.from_pretrained("valkayuh/dewpoint", members=["mmbert-base"])
+```
+
+**Streaming.** For live captions, each word is released only once it has right-hand
+context and a stable label, so marks don't flicker:
+
+```python
+s = p.stream(lang="en", lag=6)
+for chunk in asr_chunks:            # partial transcripts as they arrive
+    print(s.push(chunk), end="", flush=True)
+print(s.finish())
+```
+
+**Labels and probabilities.** `p.predict(words, lang)` returns per-word labels plus
+the averaged posteriors (`punct_probs`, `case_probs`), in case you want confidence
+scores or your own decision rule.
+
+**Command line.**
+
+```bash
+echo "i called the office this morning but nobody answered did you get my message" | python dewpoint.py --lang en
+# I called the office this morning, but nobody answered. Did you get my message?
+```
+
+## Formats and integration
+
+| you want | use |
+|---|---|
+| Python with a GPU | `Punctuator(..., backend="torch")`: bf16 on CUDA, fp32 on CPU |
+| Python without torch, e.g. a slim CPU server | `Punctuator(..., backend="onnx")`: needs only `onnxruntime`, `tokenizers`, `numpy` |
+| a local HTTP API | `python serve.py` gives `POST /restore {"text", "lang"}` (standard library only) |
+| a hosted API | deploy this repo as a [Hugging Face Inference Endpoint](https://huggingface.co/inference-endpoints); `handler.py` serves `{"inputs", "parameters": {"lang"}}` |
+| the shell | `python dewpoint.py --lang de "…"` or pipe text on stdin |
+| C#, Java, JavaScript, C++, mobile | the ONNX graphs in `onnx/`, with the pre- and post-processing below |
+
+**ONNX graphs.** There is one per member, in `onnx/mmbert-base/` and
+`onnx/xlm-roberta-large/` (the latter keeps its weights in `model.onnx.data` beside
+the graph). Both are fp32, opset 17, with dynamic batch and sequence axes:
+
+- inputs: `input_ids`, `attention_mask`, int64 `[batch, seq]`, from that member's
+  `tokenizer.json` with the words passed pre-tokenised
+- outputs: `punct_logits` `[batch, seq, 5]` and `case_logits` `[batch, seq, 3]`
+
+Around the graph, `dewpoint.py` does four things, and a port needs the same four:
+1. split the input into overlapping windows of at most 508 subwords, keeping each
+   window's centre (`plan_windows`)
+2. read each word's label from its first subword
+3. average the two members' softmax posteriors
+4. add the calibrated per-class bias from `ensemble_config.json` for the language, then
+   take the argmax
+
+**Verified.** Run over the whole official test set on CPU, the ONNX backend scores **0.7558** macro-F1 against the published 0.7559; the largest difference in any scored language is 0.0011, the gap between fp32 ONNX and the bf16 GPU run the published numbers come from. Its tokenisation matches transformers exactly on 323 documents in 57 languages.
+
+### Speed
+
+Measured on a 584-word TED passage, after warm-up, with the code in this repo:
+
+| hardware | Dewpoint (869M) | mmBERT half (307M) |
+|---|---|---|
+| RTX 5080, torch bf16 | 45 ms (13k words/s) | 23 ms (25k words/s) |
+| Ryzen 7 5800X3D, torch fp32 | 2.18 s | 632 ms (1k words/s) |
+| Ryzen 7 5800X3D, ONNX Runtime fp32 | 2.13 s | 606 ms (1k words/s) |
+
+Input of any length is handled with overlapping 512-token windows. Only the centre of
+each window commits its predictions, because words near a window edge lack context and
+score measurably worse.
+
+---
+
+## Model
+
+Dewpoint is an **ensemble of two dual-head token classifiers**. Both members read the
+same word list and produce one posterior per word, and those posteriors are averaged.
+
+| member | encoder | architecture | parameters | of which embeddings |
+|---|---|---|---|---|
+| `mmbert-base/` | [jhu-clsp/mmBERT-base](https://huggingface.co/jhu-clsp/mmBERT-base) | ModernBERT | 307.5M | 196.6M |
+| `xlm-roberta-large/` | [FacebookAI/xlm-roberta-large](https://huggingface.co/FacebookAI/xlm-roberta-large) | XLM-RoBERTa | 561.0M | 256.5M |
+
+**Each member** is an encoder, then a residual shared trunk (Linear, GELU, LayerNorm),
+then two linear heads:
+
+- **punctuation**, 5 classes: `O` `COMMA` `PERIOD` `QUESTION` `EXCLAM`
+- **case**, 3 classes: `LOWER` (*meeting*), `CAP` for a capitalised first letter
+  (*Tuesday*, *Tokyo*, a sentence's first word), and `UPPER` for a word written
+  entirely in capitals (*NASA*, *BBC*, *DNA*). Mixed-case words such as *iPhone* are
+  handled by a word list, described below.
+
+There is one decision per word, not per subword: the label sits on each word's first
+subword. Punctuation and case are learned together because they are correlated: a
+sentence end means a capital comes next.
+
+**Combining the members.** Both members label the same words, so their outputs line up
+without any tokenizer reconciliation. The average is taken in **probability space**, not
+log space. With a geometric mean, one confident but wrong member could veto a class;
+the arithmetic mean degrades gracefully instead.
+
+**Calibration.** Class weighting stops the model predicting "no punctuation"
+everywhere, but it buys recall at the cost of precision, so a plain argmax is not the
+F1-optimal rule. Instead, a per-class additive bias on the log-posterior is fitted on
+IWSLT dev2010, which is held out of every test table. Whether to add per-language
+biases on top, and how far to trust them, is chosen by cross-validation *inside*
+dev2010: its talks are split in half five times, and each strategy is fitted on one
+half and scored on the other. An unshrunk bias per language, fitted on eight talks,
+overfits: it was never the winning strategy, and for Dewpoint it scored worst. Dewpoint
+uses per-language biases pulled three quarters of the way back to the pooled one. The ensemble is
+calibrated as a system in its own right, and every other model in the tables went
+through the identical procedure, each choosing its own strategy.
+
+**Post-processing**, in `restore()` only (`predict()` returns the raw decision):
+- a capital after every sentence-final mark
+- a gazetteer of 4,896 mixed-case forms such as *iPhone*, *McDonald* and *GHz*
+- a closing mark if the text would otherwise end on none
+
+---
+
+## Evaluation
+
+- **Three test conditions:**
+  - the IWSLT 2017 official tst2010–2015 sets, with 9 scorable languages
+  - the WIT3 releases of the *same 90 talks* in 57 language tracks, so only the
+    language changes
+  - an ASR condition: TED text spoken by TTS, transcribed by Whisper
+    large-v3-turbo, and aligned back to the reference, in 33 languages
+- **Metric.** Macro-F1 over COMMA, PERIOD and QUESTION, averaged over languages.
+  EXCLAM is folded into PERIOD, because no other model emits it. Accuracy is never
+  reported: about 87% of words carry no mark, so a model that predicts nothing is
+  "87% accurate".
+- **Exclusions.** Japanese and Thai are excluded, and named here. Their TED references
+  carry almost no punctuation (0.38% and 0.12% of tokens).
+- **Reference audit.** Two errors in the reference's label maps were fixed for every
+  system alike. Armenian writes its full stop as an ASCII colon; fixing that doubled
+  *every* system's Armenian score. And the Burmese comma U+104A had been mapped to a
+  full stop.
+- **No TED data was used for training.** TED is the test set.
+
+### Every language on the extended set
+
+![Per-language macro-F1 on 57 WIT3 language tracks](assets/per_language_wit3.jpg)
+
+### Under ASR noise
+
+![Per-language gap to the best rival under ASR](assets/asr_condition_gap.jpg)
+
+5 of the 7 are to raw Whisper (English, Spanish, French, Italian, Portuguese). Whisper punctuates from the audio itself, so it can use pauses and intonation that a text-only tagger never sees. The rest: Bengali (−0.044 to fullstop-sonar), Albanian (−0.025 to xlm-r truecase). Languages marked * in the chart have under 3,000 scored words, so their gaps are noisy.
+
+### Per class, and truecasing
+
+![Per-class F1](assets/per_class.jpg)
+
+Mean per-class F1 against the strongest other model:
+
+| test set | system | COMMA | PERIOD | QUESTION |
+|---|---|---|---|---|
+| IWSLT 2017 official (9 languages) | Dewpoint | **0.6557** | **0.7923** | **0.8197** |
+| IWSLT 2017 official (9 languages) | fullstop-large | 0.5334 | 0.7206 | 0.6772 |
+| WIT3, same 90 talks (57 language tracks) | Dewpoint | **0.6482** | **0.7794** | **0.7632** |
+| WIT3, same 90 talks (57 language tracks) | fullstop-large | 0.5067 | 0.6988 | 0.5896 |
+| Whisper ASR output (33 languages) | Dewpoint | **0.5656** | **0.7102** | **0.6238** |
+| Whisper ASR output (33 languages) | fullstop-large | 0.4489 | 0.6556 | 0.4858 |
+
+Truecasing F1 against the only other model that restores case, on cased scripts:
+
+| test set | cased languages | Dewpoint CAP | UPPER | xlm-r truecase CAP | UPPER | languages behind |
+|---|---|---|---|---|---|---|
+| IWSLT 2017 official (9 languages) | 6 | **0.8772** | **0.8748** | 0.7708 | 0.7888 | 0 |
+| WIT3, same 90 talks (57 language tracks) | 43 | **0.8533** | **0.8599** | 0.7173 | 0.8005 | 0 |
+| Whisper ASR output (33 languages) | 25 | **0.8007** | **0.7584** | 0.7136 | 0.7083 | 0 |
+
+**Reading the truecasing table.** `CAP` scores words whose first letter should be a
+capital: names, places, and the first word of every sentence. `UPPER` scores words
+written entirely in capitals, which in practice means acronyms and initialisms such as
+*NASA*, *BBC* or *DNA*. These are much rarer, so they get their own score and are not
+swamped by ordinary capitals. A single capital letter such as *I* counts as `CAP`.
+
+The truecasing comparison covers cased scripts only. On caseless scripts (Arabic,
+Chinese, Korean, Hindi and others) the case head is masked by design, so Latin loanwords
+inside them are never capitalised. `xlm-roberta_punctuation_fullstop_truecase` does
+capitalise them, so it wins on those words by construction. The native EXCLAM class
+scores 0.11 F1 on the official set and 0.07 on WIT3. No other
+model emits it at all.
+
+### Size
+
+![Parameters against macro-F1](assets/size_vs_score.jpg)
+
+### Where the gain comes from
+
+Every other model in these tables is an XLM-RoBERTa model, so a win could come from the
+architecture or from the training recipe. To separate the two, we trained
+**XLM-R-large, the encoder `fullstop-punctuation-multilang-large` uses, on this corpus
+with this recipe**.
+
+![Method against architecture](assets/method_vs_architecture.jpg)
+
+The recipe is worth **+0.08 to +0.13** macro-F1. Swapping the encoder is worth −0.004
+to +0.016. The corpus, the orthography fixes and the decision rule matter roughly an
+order of magnitude more than the encoder. Neither encoder dominated the other, and
+averaging exploits exactly that: members that do not make the same errors.
+
+### Per-language tables
+
+<details>
+<summary>IWSLT 2017 official, 9 languages</summary>
+
+| language | Dewpoint | mmBERT half alone | best other model | which | gap |
+|---|---|---|---|---|---|
+| Arabic (`ar`) | 0.6538 | 0.6229 | 0.5586 | fullstop-large | +0.095 |
+| Chinese (`zh`) | 0.6551 | 0.6546 | 0.5502 | xlm-r truecase | +0.105 |
+| Dutch (`nl`) | 0.7686 | 0.7587 | 0.7304 | fullstop-sonar | +0.038 |
+| English (`en`) | 0.8033 | 0.7935 | 0.7430 | fullstop-large | +0.060 |
+| French (`fr`) | 0.7956 | 0.7841 | 0.7581 | fullstop-large | +0.038 |
+| German (`de`) | 0.8496 | 0.8402 | 0.8338 | fullstop-large | +0.016 |
+| Italian (`it`) | 0.7145 | 0.6886 | 0.6838 | fullstop-large | +0.031 |
+| Korean (`ko`) | 0.8010 | 0.7825 | 0.6553 | xlm-r truecase | +0.146 |
+| Romanian (`ro`) | 0.7618 | 0.7274 | 0.6860 | fullstop-large | +0.076 |
+
+</details>
+
+<details>
+<summary>WIT3 extended set, 57 language tracks</summary>
+
+| language | Dewpoint | mmBERT half alone | best other model | which | gap |
+|---|---|---|---|---|---|
+| Albanian (`sq`) | 0.7152 | 0.6828 | 0.6036 | fullstop-large | +0.112 |
+| Arabic (`ar`) | 0.6538 | 0.6225 | 0.5585 | fullstop-large | +0.095 |
+| Armenian (`hy`) | 0.7902 | 0.7709 | 0.4924 | kredor | +0.298 |
+| Azerbaijani (`az`) | 0.7286 | 0.7105 | 0.5832 | fullstop-sonar | +0.145 |
+| Bengali (`bn`) | 0.6940 | 0.6497 | 0.5584 | fullstop-large | +0.136 |
+| Bosnian (`bs`) | 0.7753 | 0.7540 | 0.6324 | fullstop-large | +0.143 |
+| Bulgarian (`bg`) | 0.8089 | 0.7906 | 0.7491 | kredor | +0.060 |
+| Burmese (`my`) | 0.4427 | 0.3569 | 0.3553 | xlm-r truecase | +0.087 |
+| Catalan (`ca`) | 0.7189 | 0.6880 | 0.6339 | fullstop-large | +0.085 |
+| Chinese (`zh`) | 0.6543 | 0.6349 | 0.4509 | xlm-r truecase | +0.203 |
+| Chinese (Simplified) (`zh-cn`) | 0.6486 | 0.6483 | 0.5439 | xlm-r truecase | +0.105 |
+| Chinese (Traditional) (`zh-tw`) | 0.5941 | 0.5960 | 0.5136 | xlm-r truecase | +0.081 |
+| Croatian (`hr`) | 0.7712 | 0.7540 | 0.6942 | fullstop-large | +0.077 |
+| Czech (`cs`) | 0.8120 | 0.7930 | 0.7461 | kredor | +0.066 |
+| Danish (`da`) | 0.7661 | 0.7498 | 0.6975 | fullstop-large | +0.069 |
+| Dutch (`nl`) | 0.8171 | 0.8060 | 0.7819 | fullstop-sonar | +0.035 |
+| English (`en`) | 0.8036 | 0.7937 | 0.7431 | fullstop-large | +0.061 |
+| Esperanto (`eo`) | 0.7663 | 0.7297 | 0.6385 | fullstop-sonar | +0.128 |
+| Estonian (`et`) | 0.8146 | 0.7884 | 0.7178 | fullstop-large | +0.097 |
+| Finnish (`fi`) | 0.8207 | 0.7996 | 0.7283 | kredor | +0.092 |
+| French (`fr`) | 0.7961 | 0.7842 | 0.7588 | fullstop-large | +0.037 |
+| French (Canada) (`fr-ca`) | 0.7778 | 0.7604 | 0.7445 | fullstop-sonar | +0.033 |
+| Georgian (`ka`) | 0.7142 | 0.6583 | 0.6179 | fullstop-large | +0.096 |
+| German (`de`) | 0.8472 | 0.8392 | 0.8302 | fullstop-large | +0.017 |
+| Greek (`el`) | 0.7331 | 0.7071 | 0.6951 | fullstop-large | +0.038 |
+| Hebrew (`he`) | 0.7398 | 0.7030 | 0.6506 | fullstop-large | +0.089 |
+| Hindi (`hi`) | 0.5855 | 0.5600 | 0.4925 | fullstop-large | +0.093 |
+| Hungarian (`hu`) | 0.7903 | 0.7637 | 0.6771 | fullstop-large | +0.113 |
+| Indonesian (`id`) | 0.7350 | 0.7174 | 0.6401 | fullstop-large | +0.095 |
+| Italian (`it`) | 0.7412 | 0.7211 | 0.7148 | fullstop-large | +0.026 |
+| Kazakh (`kk`) | 0.7657 | 0.7556 | 0.6508 | xlm-r truecase | +0.115 |
+| Korean (`ko`) | 0.8008 | 0.7825 | 0.6564 | xlm-r truecase | +0.144 |
+| Kurdish (`ku`) | 0.1114 | 0.2843 | 0.0298 | xlm-r truecase | +0.082 |
+| Latvian (`lv`) | 0.8174 | 0.7928 | 0.7117 | kredor | +0.106 |
+| Lithuanian (`lt`) | 0.7935 | 0.7725 | 0.6945 | kredor | +0.099 |
+| Macedonian (`mk`) | 0.7479 | 0.7190 | 0.6378 | fullstop-large | +0.110 |
+| Malay (`ms`) | 0.7748 | 0.7426 | 0.6387 | fullstop-large | +0.136 |
+| Marathi (`mr`) | 0.6624 | 0.6120 | 0.5224 | fullstop-large | +0.140 |
+| Mongolian (`mn`) | 0.7962 | 0.7447 | 0.6349 | xlm-r truecase | +0.161 |
+| Norwegian (`nb`) | 0.7704 | 0.7531 | 0.7399 | fullstop-large | +0.031 |
+| Persian (`fa`) | 0.6895 | 0.6700 | 0.5903 | fullstop-large | +0.099 |
+| Polish (`pl`) | 0.8181 | 0.7999 | 0.7696 | kredor | +0.049 |
+| Portuguese (`pt`) | 0.7725 | 0.7555 | 0.7095 | kredor | +0.063 |
+| Portuguese (Brazil) (`pt-br`) | 0.7550 | 0.7354 | 0.6701 | kredor | +0.085 |
+| Romanian (`ro`) | 0.7623 | 0.7320 | 0.6975 | fullstop-large | +0.065 |
+| Russian (`ru`) | 0.8354 | 0.8218 | 0.7312 | kredor | +0.104 |
+| Serbian (`sr`) | 0.7783 | 0.7588 | 0.6984 | fullstop-large | +0.080 |
+| Slovak (`sk`) | 0.8050 | 0.7787 | 0.7440 | kredor | +0.061 |
+| Slovenian (`sl`) | 0.8386 | 0.8211 | 0.8100 | kredor | +0.029 |
+| Spanish (`es`) | 0.7582 | 0.7463 | 0.7070 | fullstop-large | +0.051 |
+| Swahili (`sw`) | 0.6403 | 0.5944 | 0.5180 | fullstop-sonar | +0.122 |
+| Swedish (`sv`) | 0.7822 | 0.7611 | 0.7432 | fullstop-large | +0.039 |
+| Tamil (`ta`) | 0.5091 | 0.4862 | 0.4771 | xlm-r truecase | +0.032 |
+| Turkish (`tr`) | 0.7290 | 0.7082 | 0.5883 | xlm-r truecase | +0.141 |
+| Ukrainian (`uk`) | 0.8149 | 0.7951 | 0.7241 | kredor | +0.091 |
+| Urdu (`ur`) | 0.5309 | 0.5186 | 0.5042 | fullstop-large | +0.027 |
+| Vietnamese (`vi`) | 0.7105 | 0.6830 | 0.5800 | fullstop-sonar | +0.131 |
+
+</details>
+
+<details>
+<summary>ASR condition, 33 languages</summary>
+
+| language | Dewpoint | mmBERT half alone | best other model | which | gap |
+|---|---|---|---|---|---|
+| Albanian (`sq`) | 0.3580 | 0.4005 | 0.3830 | xlm-r truecase | −0.025 |
+| Arabic (`ar`) | 0.5309 | 0.5020 | 0.4840 | fullstop-large | +0.047 |
+| Bengali (`bn`) | 0.0730 | 0.1404 | 0.1170 | fullstop-sonar | −0.044 |
+| Bulgarian (`bg`) | 0.7247 | 0.6928 | 0.6776 | kredor | +0.047 |
+| Catalan (`ca`) | 0.7112 | 0.6698 | 0.6025 | fullstop-sonar | +0.109 |
+| Chinese (`zh`) | 0.7528 | 0.7620 | 0.7312 | xlm-r truecase | +0.022 |
+| Dutch (`nl`) | 0.6765 | 0.6661 | 0.6115 | kredor | +0.065 |
+| English (`en`) | 0.7837 | 0.7869 | 0.9382 | raw Whisper | −0.155 |
+| Finnish (`fi`) | 0.7233 | 0.7053 | 0.6593 | kredor | +0.064 |
+| French (`fr`) | 0.7702 | 0.7705 | 0.8240 | raw Whisper | −0.054 |
+| German (`de`) | 0.8329 | 0.8204 | 0.8140 | fullstop-large | +0.019 |
+| Greek (`el`) | 0.6437 | 0.5979 | 0.5943 | kredor | +0.049 |
+| Hebrew (`he`) | 0.6332 | 0.5870 | 0.5265 | fullstop-sonar | +0.107 |
+| Hindi (`hi`) | 0.6238 | 0.5805 | 0.5509 | fullstop-sonar | +0.073 |
+| Hungarian (`hu`) | 0.7210 | 0.7041 | 0.6368 | fullstop-large | +0.084 |
+| Indonesian (`id`) | 0.6723 | 0.6582 | 0.6249 | fullstop-large | +0.047 |
+| Italian (`it`) | 0.7025 | 0.6750 | 0.7745 | raw Whisper | −0.072 |
+| Kazakh (`kk`) | 0.4953 | 0.4933 | 0.3990 | raw Whisper | +0.096 |
+| Latvian (`lv`) | 0.7218 | 0.7039 | 0.6108 | kredor | +0.111 |
+| Malay (`ms`) | 0.6743 | 0.6516 | 0.5907 | fullstop-large | +0.084 |
+| Marathi (`mr`) | 0.2584 | 0.2685 | 0.2000 | xlm-r truecase | +0.058 |
+| Persian (`fa`) | 0.5209 | 0.4990 | 0.4512 | xlm-r truecase | +0.070 |
+| Polish (`pl`) | 0.7608 | 0.7462 | 0.7409 | kredor | +0.020 |
+| Portuguese (`pt`) | 0.7616 | 0.7535 | 0.8522 | raw Whisper | −0.091 |
+| Romanian (`ro`) | 0.6462 | 0.6148 | 0.5553 | xlm-r truecase | +0.091 |
+| Russian (`ru`) | 0.7627 | 0.7647 | 0.6927 | kredor | +0.070 |
+| Spanish (`es`) | 0.7866 | 0.7844 | 0.8386 | raw Whisper | −0.052 |
+| Swahili (`sw`) | 0.4165 | 0.3931 | 0.3596 | kredor | +0.057 |
+| Swedish (`sv`) | 0.6646 | 0.6514 | 0.6435 | fullstop-large | +0.021 |
+| Tamil (`ta`) | 0.4052 | 0.3825 | 0.2485 | fullstop-sonar | +0.157 |
+| Turkish (`tr`) | 0.6670 | 0.6613 | 0.5448 | xlm-r truecase | +0.122 |
+| Ukrainian (`uk`) | 0.7310 | 0.6955 | 0.6545 | xlm-r truecase | +0.076 |
+| Vietnamese (`vi`) | 0.6895 | 0.6684 | 0.5873 | xlm-r truecase | +0.102 |
+
+</details>
+
+All per-language, per-class scores for every system are in
+[`results/scores.json`](results/scores.json).
+
+---
+
+## Training
+
+### Text: 79 languages, no TED
+
+| source | licence | role |
+|---|---|---|
+| [Wikipedia](https://huggingface.co/datasets/wikimedia/wikipedia) | CC-BY-SA-4.0 | volume, and most of the proper nouns truecasing needs |
+| [Europarl](https://huggingface.co/datasets/Helsinki-NLP/europarl) | no known restrictions | spoken-style parliamentary prose |
+| [Tatoeba](https://tatoeba.org/en/downloads) | CC-BY-2.0 FR | questions: 10–25% of its sentences are questions |
+| [HPLT 2.0 cleaned](https://huggingface.co/datasets/HPLT/HPLT2.0_cleaned) | CC0-1.0 | fills six languages Wikipedia leaves thin |
+| [VoxPopuli transcripts](https://github.com/facebookresearch/voxpopuli) | CC0-1.0 | verbatim spoken transcripts, 16 languages |
+| [Aya dataset](https://huggingface.co/datasets/CohereLabs/aya_dataset) | Apache-2.0 | question-dense human prose for low-resource languages |
+
+The corpus is temperature-sampled so that the largest languages don't swamp the rest.
+Labels come free: strip the punctuation and case from clean prose, and what was
+stripped is exactly what the model must predict. **Synthetic ASR noise** is applied to
+about two thirds of training examples: filler words, dropped short words, character
+substitutions, merged and split words, numbers written the way they're spoken, and
+truncated utterances.
+
+### Speech: round-trip ASR data
+
+A slice of the training text was spoken aloud by TTS, transcribed by Whisper
+large-v3-turbo, and aligned back to the original. That gives inputs with genuine
+recognition errors but ground-truth labels. The corpus has 0.96M unique words across 23 languages, voiced by three permissively licensed engines. Oversampled to match the per-language dose of the original recipe, it makes up 6.8% of the final fine-tuning stage.
+
+| engine | licence | languages (utterances kept) |
+|---|---|---|
+| [Kokoro-82M](https://huggingface.co/hexgrad/Kokoro-82M) | Apache-2.0 | en (5,998), es (5,077), fr (3,996), hi (3,879), it (3,996), pt (3,996), zh (2,992) |
+| [Piper voices](https://huggingface.co/rhasspy/piper-voices) | CC0 or CC-BY-4.0, per voice | bg (2,180), de (2,198), el (2,124), fa (1,057), fi (1,196), hu (1,184), kk (244), lv (1,067), nl (2,168), pl (2,189), ro (1,194), ru (1,177), sq (662), sv (2,183), uk (1,150) |
+| [Chatterbox Multilingual](https://huggingface.co/ResembleAI/chatterbox) | MIT | ar (606) |
+
+Every Piper voice's licence was read from its model card by code, and any voice whose
+card said non-commercial, share-alike, "see URL" or nothing at all was refused.
+The voice that produced a language's ASR *test* audio is never used for its training
+audio. French is the exception, because Kokoro has only one French voice. No audio was
+kept or is distributed.
+
+### Procedure
+
+Each member was trained in stages. Every stage starts from the weights the previous
+stage ended with, and each later stage makes smaller, more targeted changes:
+
+1. **Learn the task.** The encoder starts from its public pretrained weights, knowing
+   language but nothing about punctuation, and learns to predict marks and capitals on
+   a large clean-text corpus.
+2. **Rebalance toward speech.** Training continues on a resample of the corpus that
+   gives more weight to spoken-style sources (parliamentary transcripts, Tatoeba, Aya)
+   and mixes short passages in with long ones, closer to what ASR produces.
+3. **Harden against recognition errors.** A short final stage on a 55M-word mix that
+   includes the round-trip ASR data above, at a low learning rate, so the model learns
+   to punctuate text containing Whisper's mistakes without forgetting the rest.
+
+| member | stage | starts from | data | steps | peak learning rate |
+|---|---|---|---|---|---|
+| mmBERT-base | learn the task | `jhu-clsp/mmBERT-base` | 1.02B-word corpus, long passages | 34,000 | 4e-5 |
+| mmBERT-base | rebalance | previous stage | 735M-word resample | 13,000 | 1.8e-5 |
+| mmBERT-base | rebalance, continued | previous stage | 735M-word resample | 3,500 | 8e-6 |
+| mmBERT-base | harden | previous stage | 55M-word mix with round-trip data | 4,000 | 9e-6 |
+| XLM-R-large | learn + rebalance | `FacebookAI/xlm-roberta-large` | 735M-word resample | 17,000 | 8e-6 |
+| XLM-R-large | harden | previous stage | 55M-word mix with round-trip data | 4,000 | 3e-6 |
+
+How to read the table:
+- **Steps.** A step is one update of the weights, computed from a batch of 64 text
+  windows of up to 512 subword tokens each, roughly 30,000 tokens. The first mmBERT
+  stage, for example, saw about a billion tokens.
+- **Peak learning rate.** This is the largest step size in that stage's schedule. It
+  falls from stage to stage because later stages refine rather than relearn.
+- **XLM-R-large has fewer stages** because it went straight to the rebalanced
+  corpus. It was first trained as a controlled comparison against mmBERT-base, and
+  later became the second member.
+
+Settings shared by all stages:
+- AdamW, with a learning rate that warms up and then decays along a cosine curve
+- a higher learning rate for the two heads than for the encoder
+- class-weighted cross-entropy on both heads, so the rare marks are not drowned out by
+  the many words that take none
+- label smoothing 0.02
+- for XLM-R-large only, a frozen embedding matrix
+
+Everything was trained on a single RTX 5080 with 16 GB.
+
+### What did not work
+
+| attempt | result |
+|---|---|
+| supervised contrastive loss (reported +1.9 to +3.2 F1 on this task) | +0.001 / +0.001 / −0.002; the rarest class got worse |
+| joint punctuation–case decoding | cut head contradictions from 9.0% to 0.27% but lowered F1 at every setting |
+| mDeBERTa-v3-base as a third encoder | lost on all three sets |
+| distilling the ensemble into one mmBERT-base | in-domain validation +0.015, every held-out set flat |
+| choosing case *given* the decided punctuation | lowered case F1 at every coupling strength |
+
+The distillation result is why Dewpoint is an ensemble. Its robustness comes from the
+two members disagreeing on each input. A single model trained to mimic their average
+has no disagreement left to exploit. Two of these experiments were pre-registered:
+their success criteria were written down before the run.
+
+---
+
+## Limitations
+
+- **Two forward passes.** The ensemble has 2.8× the parameters of its mmBERT half, for +0.013 to +0.020 macro-F1. If latency matters more than that margin, use `members=["mmbert-base"]`.
+- **Text only.** Raw Whisper still wins in English, Spanish, French, Italian, Portuguese under ASR conditions, most likely because it hears pauses and intonation. Adding a tagger after ASR only helps if your ASR doesn't already punctuate.
+- **English is not state of the art against English-only systems.** On English tst2011, Dewpoint scores 0.800 macro-F1 (COMMA 0.715, PERIOD 0.823, QUESTION 0.860) without having seen any TED text. The strongest published English-only systems report about 0.85 overall F1 on IWSLT2011; they were trained in-domain on TED and scored on a differently preprocessed version of the set.
+- **Weak languages.** Kurdish (0.11), Burmese (0.44), Tamil (0.51), Urdu (0.53) are still low in absolute terms, even where Dewpoint leads the other models. In Kurdish (0.11 against 0.28) the ensemble is below its own mmBERT half, so averaging in probability space does not help everywhere.
+- **Japanese and Thai are unmeasured.** Their TED references are nearly unpunctuated, so no trustworthy number exists. The model is trained on both.
+- **Very short inputs.** With only a few words there is little context, and the case head can guess a sentence boundary that the punctuation head didn't place (`hello how are you` → `Hello, How are You?`). On full passages it is rare: 0.4% of words on the official test set. Pass whole utterances, not fragments.
+- **Caseless-script loanwords** are never capitalised (see truecasing above).
+- **EXCLAM is weak**: 0.11 F1 on the official set and 0.07 on WIT3, and exclamation marks are rare there too.
+- **Only five marks.** Colons, semicolons, dashes, quotes and parentheses are not restored, and French typographic spacing before `?` and `!` is not added.
+- **Domain.** The benchmark is TED, which is prepared monologue. Conversational, overlapping, multi-speaker speech is harder, and isn't measured here.
+
+---
+
+## Licence and provenance
+
+**Weights and code: MIT.** Both base encoders are MIT-licensed. Every TTS voice used for
+training audio is MIT, Apache-2.0, CC0 or CC-BY-4.0.
+
+A few things are worth knowing before commercial use:
+
+- **Wikipedia is CC-BY-SA-4.0.** Whether share-alike terms reach model weights trained
+  on such text is legally unsettled. Many encoders trained on Wikipedia, BERT among
+  them, are released under permissive licences, and Dewpoint follows that practice.
+- **Tatoeba is CC-BY-2.0 FR.** Sentences © Tatoeba contributors, https://tatoeba.org.
+- **Some Piper voices are CC-BY-4.0**, which asks for attribution to the voice
+  datasets. They are listed in [`results/rt2_voices.json`](results/rt2_voices.json).
+- **Evaluation data.** IWSLT/WIT3 TED transcripts are CC-BY-NC-ND-4.0. They were used
+  for measurement only and are not included here.
+
+This is a description, not legal advice.
+
+---
+
+## Files
+
+| path | contents |
+|---|---|
+| `dewpoint.py` | self-contained inference: `Punctuator` (torch or ONNX backend), streaming, command line |
+| `onnx/` | both members as fp32 ONNX graphs |
+| `serve.py` | a standard-library HTTP server |
+| `handler.py` | the Hugging Face Inference Endpoints handler |
+| `requirements.txt`, `requirements-onnx.txt` | dependencies for each backend |
+| `ensemble_config.json` | member list, weights, the ensemble's calibrated biases |
+| `mmbert-base/` | weights (safetensors), encoder config, tokenizer, its own calibration |
+| `xlm-roberta-large/` | the same, for the XLM-R-large member |
+| `gazetteer.json` | mixed-case surface forms, per language |
+| `results/` | per-language scores for every system, and round-trip voice provenance |
+| `assets/` | the images on this page |
+
+The inference file reproduces the published official-set score exactly, per language,
+against the evaluation harness it was measured with.
+
+## Citation
+
+```bibtex
+@misc{dewpoint2026,
+  title  = {Dewpoint: multilingual punctuation restoration and truecasing for speech},
+  author = {valkayuh},
+  year   = {2026},
+  url    = {https://huggingface.co/valkayuh/dewpoint}
+}
+```
+
+Please also cite the encoders Dewpoint builds on:
+[mmBERT](https://huggingface.co/jhu-clsp/mmBERT-base) and
+[XLM-RoBERTa](https://arxiv.org/abs/1911.02116).

dewpoint.py

@@ -0,0 +1,596 @@
+"""Dewpoint: multilingual punctuation restoration and truecasing.
+
+Self-contained inference for the released checkpoints, in one file, with two
+interchangeable backends:
+
+    from dewpoint import Punctuator
+    p = Punctuator.from_pretrained("valkayuh/dewpoint")
+    p.restore("so i said meet at three thirty tuesday what do you think", lang="en")
+    # -> 'So I said meet at three thirty Tuesday. What do you think?'
+
+backend="torch"  needs torch + transformers + safetensors, and uses a GPU if present.
+backend="onnx"   needs only onnxruntime + tokenizers + numpy (no torch at all),
+                 and downloads the ONNX graphs instead of the safetensors.
+backend="auto"   (the default) uses torch when it is installed, otherwise ONNX.
+
+The model is an ensemble of two dual-head token taggers (mmBERT-base and
+XLM-RoBERTa-large).  Each member reads the same word list and returns one
+posterior per word; the posteriors are averaged in probability space, a
+per-class decision bias fitted on IWSLT dev2010 is applied, and the argmax is
+taken.  Pass ``members=["mmbert-base"]`` for the single 307M-parameter model,
+which uses its own calibration.
+
+It is a tagger, not a generator: it never adds, drops, reorders or rewrites a
+word.  It only decides, per word, which mark follows it (none / , / . / ? / !)
+and how it is cased (lower / Capitalised / UPPER).
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import unicodedata
+from typing import Iterable, Sequence
+
+import numpy as np
+
+try:                              # torch is optional: the ONNX backend needs none
+    import torch
+    import torch.nn as nn
+except ImportError:               # pragma: no cover
+    torch = None
+    nn = None
+
+__all__ = ["Punctuator", "StreamingPunctuator"]
+
+PUNCT_LABELS = ["O", "COMMA", "PERIOD", "QUESTION", "EXCLAM"]
+CASE_LABELS = ["LOWER", "CAP", "UPPER"]
+_SENT_END = {"PERIOD", "QUESTION", "EXCLAM"}
+
+# ------------------------------------------------------------ language rules
+# Scripts with no case distinction: the case head is masked to LOWER.
+CASELESS_LANGS = {
+    "zh", "zh-cn", "zh-tw", "ja", "ko", "ar", "he", "fa", "ur", "th", "hi", "bn",
+    "ta", "te", "ml", "kn", "mr", "gu", "pa", "ne", "si", "my", "km", "lo", "am",
+    "ti", "dv", "bo", "dz", "ps", "sd", "ug", "yi", "yue", "wuu", "as", "or",
+    "arq", "arz", "ary", "acm", "apc", "ckb", "ka", "he-il", "sa", "ks", "bho",
+}
+# Written without spaces between words: one grapheme cluster is one token.
+NO_SPACE_LANGS = {"zh", "zh-cn", "zh-tw", "ja", "th", "my", "km", "lo", "bo",
+                  "dz", "yue", "wuu"}
+
+_SURFACE = {
+    "ascii": {"O": "", "COMMA": ",", "PERIOD": ".", "QUESTION": "?", "EXCLAM": "!"},
+    "cjk": {"O": "", "COMMA": "，", "PERIOD": "。", "QUESTION": "？", "EXCLAM": "！"},
+    "ja": {"O": "", "COMMA": "、", "PERIOD": "。", "QUESTION": "？", "EXCLAM": "！"},
+    "arab": {"O": "", "COMMA": "،", "PERIOD": ".", "QUESTION": "؟", "EXCLAM": "!"},
+    "deva": {"O": "", "COMMA": ",", "PERIOD": "।", "QUESTION": "?", "EXCLAM": "!"},
+    # Greek writes its question mark with the ASCII semicolon.
+    "el": {"O": "", "COMMA": ",", "PERIOD": ".", "QUESTION": ";", "EXCLAM": "!"},
+    "hy": {"O": "", "COMMA": ",", "PERIOD": "։", "QUESTION": "՞", "EXCLAM": "՜"},
+}
+_SURFACE_BY_LANG = {}
+for _l in ("zh", "zh-cn", "zh-tw", "yue", "wuu"):
+    _SURFACE_BY_LANG[_l] = _SURFACE["cjk"]
+for _l in ("ar", "fa", "ur", "ps", "arq", "arz", "ary", "ckb", "sd", "ug"):
+    _SURFACE_BY_LANG[_l] = _SURFACE["arab"]
+for _l in ("hi", "bn", "mr", "ne", "pa", "as", "or", "sa", "bho"):
+    _SURFACE_BY_LANG[_l] = _SURFACE["deva"]
+_SURFACE_BY_LANG.update(el=_SURFACE["el"], hy=_SURFACE["hy"], ja=_SURFACE["ja"])
+
+# Characters stripped from the edges of an input token before tagging, so text
+# that already carries some punctuation is handled the same as bare ASR output.
+_MARKS = set(
+    ".。．۔।॥။։។…⋯።,，،٫၊、᠂᠈፣?？؟;՞⸮፧!！՜:：；؛·-–—―−፡"
+    "\"'‘’“”„‚«»()[]{}〈〉《》「」『』（）‹›‟″′¡¿⸘‛*_`•⁃・＂＇´‐‑"
+)
+_LATIN_RUN = re.compile(r"[A-Za-z0-9À-ɏ]+(?:[.'’-][A-Za-z0-9]+)*")
+
+
+def base_lang(lang: str) -> str:
+    return lang.split("-")[0].lower()
+
+
+def is_caseless(lang: str) -> bool:
+    return lang.lower() in CASELESS_LANGS or base_lang(lang) in CASELESS_LANGS
+
+
+def is_no_space(lang: str) -> bool:
+    return lang.lower() in NO_SPACE_LANGS or base_lang(lang) in NO_SPACE_LANGS
+
+
+def surface_for(lang: str) -> dict:
+    return _SURFACE_BY_LANG.get(base_lang(lang), _SURFACE["ascii"])
+
+
+def apply_case(word: str, case: str) -> str:
+    if case == "UPPER":
+        return word.upper()
+    if case == "CAP":
+        return word[:1].upper() + word[1:]
+    return word
+
+
+def split_words(text: str, lang: str) -> list[str]:
+    """Raw text -> the lowercased, mark-free word list the model was trained on."""
+    text = unicodedata.normalize("NFC", text)
+    if is_no_space(lang):
+        return _split_charwise(text)
+    out = []
+    for raw in text.split():
+        chars = [i for i, ch in enumerate(raw) if ch not in _MARKS]
+        if not chars:
+            continue
+        core = raw[chars[0]:chars[-1] + 1]
+        if any(ch.isalnum() for ch in core):
+            out.append(core.lower())
+    return out
+
+
+def _split_charwise(text: str) -> list[str]:
+    """CJK / Thai / Khmer: grapheme clusters, with Latin runs kept whole."""
+    words, i, n = [], 0, len(text)
+    while i < n:
+        ch = text[i]
+        if ch.isspace() or ch in _MARKS:
+            i += 1
+            continue
+        m = _LATIN_RUN.match(text, i)
+        if m and m.group():
+            words.append(m.group().lower())
+            i = m.end()
+            continue
+        if ch.isalnum() or unicodedata.category(ch) in ("Mn", "Mc", "Me"):
+            j = i + 1
+            while j < n and unicodedata.category(text[j]) in ("Mn", "Mc", "Me"):
+                j += 1
+            words.append(text[i:j].lower())
+            i = j
+            continue
+        i += 1
+    return words
+
+
+# ------------------------------------------------------------------- model
+if torch is not None:
+    class PunctCaseModel(nn.Module):
+        """Encoder -> residual shared trunk -> punctuation head and case head."""
+
+        def __init__(self, config, n_punct=5, n_case=3):
+            super().__init__()
+            from transformers import AutoModel
+            self.encoder = AutoModel.from_config(config)
+            h = config.hidden_size
+            self.drop = nn.Dropout(0.1)
+            self.trunk = nn.Sequential(nn.Linear(h, h), nn.GELU(),
+                                       nn.LayerNorm(h, eps=1e-5))
+            self.head_punct = nn.Linear(h, n_punct)
+            self.head_case = nn.Linear(h, n_case)
+
+        def forward(self, input_ids, attention_mask=None):
+            x = self.encoder(input_ids=input_ids,
+                             attention_mask=attention_mask).last_hidden_state
+            x = self.drop(x)
+            x = x + self.trunk(x)
+            return self.head_punct(x), self.head_case(x)
+
+    __all__.append("PunctCaseModel")
+
+
+def plan_windows(sub_counts, max_sub=508, overlap_sub=256):
+    """Overlapping windows under a subword budget; only each window's centre
+    commits.  Returns (win_start, win_end, commit_start, commit_end) in words."""
+    n = len(sub_counts)
+    if n == 0:
+        return []
+    overlap_sub = min(overlap_sub, max_sub // 2)
+    prefix = [0] * (n + 1)
+    for i, c in enumerate(sub_counts):
+        prefix[i + 1] = prefix[i] + max(1, c)
+
+    def end_for(start):
+        lo, hi = start + 1, n
+        budget = prefix[start] + max_sub
+        while lo < hi:
+            mid = (lo + hi + 1) // 2
+            if prefix[mid] <= budget:
+                lo = mid
+            else:
+                hi = mid - 1
+        return max(lo, start + 1)
+
+    wins, start = [], 0
+    while True:
+        end = end_for(start)
+        wins.append([start, end])
+        if end >= n:
+            break
+        target = prefix[end] - overlap_sub
+        nxt = end
+        while nxt > start + 1 and prefix[nxt] > target:
+            nxt -= 1
+        start = max(nxt, start + 1)
+    out = []
+    for i, (s, e) in enumerate(wins):
+        cs = s if i == 0 else (wins[i - 1][1] + s) // 2
+        ce = e if i == len(wins) - 1 else (e + wins[i + 1][0] + 1) // 2
+        cs = max(cs, s)
+        out.append((s, e, cs, min(max(ce, cs), e)))
+    return out
+
+
+class _MemberBase:
+    """Windowing, first-subword gathering and caseless masking, shared by both
+    backends so that they cannot drift apart.  Subclasses supply `_counts`
+    (subwords per word), `_encode` (a padded batch plus word ids) and
+    `_forward` (softmaxed posteriors as numpy)."""
+
+    def _load_meta(self, path):
+        with open(os.path.join(path, "vpunct_config.json"), encoding="utf-8") as f:
+            self.meta = json.load(f)
+        self.max_len = int(self.meta.get("max_len", 512))
+
+    def posteriors(self, words, lang):
+        n = len(words)
+        pp = np.zeros((n, len(PUNCT_LABELS)), dtype=np.float32)
+        pp[:, 0] = 1.0
+        cp = np.zeros((n, len(CASE_LABELS)), dtype=np.float32)
+        cp[:, 0] = 1.0
+        if n == 0:
+            return pp, cp
+        wins = plan_windows(self._counts(list(words)), max_sub=self.max_len - 4,
+                            overlap_sub=256)
+        for i in range(0, len(wins), self.batch_size):
+            chunk = wins[i:i + self.batch_size]
+            ids, mask, wids = self._encode([list(words[s:e]) for s, e, _, _ in chunk])
+            p, c = self._forward(ids, mask)
+            for b, (s, e, cs, ce) in enumerate(chunk):
+                loc_p = np.zeros((e - s, len(PUNCT_LABELS)), dtype=np.float32)
+                loc_p[:, 0] = 1.0
+                loc_c = np.zeros((e - s, len(CASE_LABELS)), dtype=np.float32)
+                loc_c[:, 0] = 1.0
+                seen = set()
+                for pos, w in enumerate(wids[b]):
+                    if w is None or w in seen or pos >= p.shape[1]:
+                        continue
+                    seen.add(w)          # label lives on a word's first subword
+                    loc_p[w] = p[b, pos]
+                    loc_c[w] = c[b, pos]
+                pp[cs:ce] = loc_p[cs - s:ce - s]
+                cp[cs:ce] = loc_c[cs - s:ce - s]
+        if is_caseless(lang):
+            cp[:] = 0.0
+            cp[:, 0] = 1.0
+        return pp, cp
+
+
+def _softmax(x):
+    x = x - x.max(-1, keepdims=True)
+    e = np.exp(x)
+    return e / e.sum(-1, keepdims=True)
+
+
+class _TorchMember(_MemberBase):
+    """One tagger run by torch, from its safetensors."""
+
+    def __init__(self, path, device, dtype, batch_size=64):
+        from safetensors.torch import load_file
+        from transformers import AutoConfig, AutoTokenizer
+        self._load_meta(path)
+        cfg = AutoConfig.from_pretrained(path)
+        model = PunctCaseModel(cfg, self.meta["n_punct"], self.meta["n_case"])
+        model.load_state_dict(load_file(os.path.join(path, "model.safetensors")))
+        self.model = model.to(device=device, dtype=dtype).eval()
+        try:
+            self.model.encoder.config._attn_implementation = "sdpa"
+        except Exception:
+            pass
+        self.tok = AutoTokenizer.from_pretrained(path)
+        self.device = device
+        self.batch_size = batch_size
+
+    def _counts(self, words):
+        return [len(e) for e in self.tok(words, add_special_tokens=False)["input_ids"]]
+
+    def _encode(self, batch):
+        enc = self.tok(batch, is_split_into_words=True, truncation=True,
+                       max_length=self.max_len, padding=True, return_tensors="pt")
+        return enc["input_ids"], enc["attention_mask"], \
+            [enc.word_ids(b) for b in range(len(batch))]
+
+    def _forward(self, ids, mask):
+        with torch.no_grad():
+            lp, lc = self.model(ids.to(self.device), mask.to(self.device))
+        return (lp.float().softmax(-1).cpu().numpy(),
+                lc.float().softmax(-1).cpu().numpy())
+
+
+class _OnnxMember(_MemberBase):
+    """One tagger run by onnxruntime, tokenised by the `tokenizers` library.
+    No torch and no transformers anywhere on this path."""
+
+    def __init__(self, path, onnx_dir, providers=None, batch_size=8, threads=None):
+        import onnxruntime as ort
+        from tokenizers import Tokenizer
+        self._load_meta(path)
+        self.tok = Tokenizer.from_file(os.path.join(path, "tokenizer.json"))
+        self.tok.no_padding()
+        # truncate the way transformers does: before the special tokens are
+        # added, so an over-long window still ends in its closing token
+        self.tok.enable_truncation(max_length=self.max_len)
+        with open(os.path.join(path, "tokenizer_config.json"), encoding="utf-8") as f:
+            tcfg = json.load(f)
+        self.pad_id = self.tok.token_to_id(tcfg.get("pad_token", "<pad>")) or 0
+        so = ort.SessionOptions()
+        if threads:
+            so.intra_op_num_threads = threads
+        if providers is None:
+            avail = ort.get_available_providers()
+            providers = [p for p in ("CUDAExecutionProvider", "CoreMLExecutionProvider",
+                                     "DmlExecutionProvider") if p in avail]
+            providers.append("CPUExecutionProvider")
+        self.sess = ort.InferenceSession(os.path.join(onnx_dir, "model.onnx"), so,
+                                         providers=providers)
+        self.batch_size = batch_size
+
+    def _counts(self, words):
+        return [len(e.ids) for e in
+                self.tok.encode_batch(words, add_special_tokens=False)]
+
+    def _encode(self, batch):
+        encs = self.tok.encode_batch(batch, is_pretokenized=True)
+        L = min(self.max_len, max(len(e.ids) for e in encs))
+        ids = np.full((len(encs), L), self.pad_id, dtype=np.int64)
+        mask = np.zeros((len(encs), L), dtype=np.int64)
+        wids = []
+        for b, e in enumerate(encs):
+            n = min(L, len(e.ids))
+            ids[b, :n] = e.ids[:n]
+            mask[b, :n] = 1
+            wids.append(list(e.word_ids[:n]))
+        return ids, mask, wids
+
+    def _forward(self, ids, mask):
+        lp, lc = self.sess.run(None, {"input_ids": ids, "attention_mask": mask})
+        return _softmax(lp.astype(np.float32)), _softmax(lc.astype(np.float32))
+
+
+# -------------------------------------------------------------- public api
+class Punctuator:
+    """Restore punctuation and case in unpunctuated, lowercased text."""
+
+    MEMBERS = ("mmbert-base", "xlm-roberta-large")
+
+    def __init__(self, path, members=None, backend="auto", device=None, dtype=None,
+                 use_gazetteer=True, batch_size=None, providers=None, threads=None):
+        members = list(members or self.MEMBERS)
+        self.backend = self._pick_backend(path, members, backend)
+        if self.backend == "torch":
+            if device is None:
+                device = "cuda" if torch.cuda.is_available() else "cpu"
+            if dtype is None:
+                dtype = torch.bfloat16 if str(device).startswith("cuda") else torch.float32
+            self.members = [_TorchMember(os.path.join(path, m), device, dtype,
+                                         batch_size or 64) for m in members]
+        else:
+            self.members = [_OnnxMember(os.path.join(path, m),
+                                        os.path.join(path, "onnx", m), providers,
+                                        batch_size or 8, threads) for m in members]
+        if len(members) == len(self.MEMBERS):
+            # The ensemble is calibrated as its own system: each member's bias
+            # describes its own posterior, not the average of two.
+            with open(os.path.join(path, "ensemble_config.json"), encoding="utf-8") as f:
+                ens = json.load(f)
+            self.weights = ens["weights"]
+            self.bias = ens["punct_bias"]
+            self.bias_per_lang = ens["punct_bias_per_lang"]
+        else:
+            self.weights = [1.0 / len(members)] * len(members)
+            meta = self.members[0].meta if len(members) == 1 else {}
+            self.bias = meta.get("punct_bias")
+            self.bias_per_lang = meta.get("punct_bias_per_lang") or {}
+        gz = os.path.join(path, "gazetteer.json")
+        self.gazetteer = {}
+        if use_gazetteer and os.path.exists(gz):
+            with open(gz, encoding="utf-8") as f:
+                self.gazetteer = json.load(f)
+
+    @staticmethod
+    def _pick_backend(path, members, backend):
+        if backend == "auto":
+            has_st = all(os.path.exists(os.path.join(path, m, "model.safetensors"))
+                         for m in members)
+            backend = "torch" if (torch is not None and has_st) else "onnx"
+        if backend == "torch" and torch is None:
+            raise ImportError("backend='torch' needs torch; install it, or use "
+                              "backend='onnx' (onnxruntime + tokenizers only)")
+        if backend not in ("torch", "onnx"):
+            raise ValueError("backend must be 'auto', 'torch' or 'onnx'")
+        return backend
+
+    @classmethod
+    def from_pretrained(cls, repo_or_path="valkayuh/dewpoint", **kw):
+        """A local directory, or a Hugging Face repo id to download.  Only the
+        files the chosen backend needs are fetched: the ONNX backend never
+        downloads the safetensors, and the torch backend never downloads ONNX."""
+        if os.path.isdir(repo_or_path):
+            return cls(repo_or_path, **kw)
+        from huggingface_hub import snapshot_download
+        members = kw.get("members") or cls.MEMBERS
+        backend = kw.get("backend", "auto")
+        if backend == "auto":
+            backend = "torch" if torch is not None else "onnx"
+            kw["backend"] = backend
+        allow = ["dewpoint.py", "ensemble_config.json", "gazetteer.json"]
+        for m in members:
+            allow += [f"{m}/vpunct_config.json", f"{m}/tokenizer.json",
+                      f"{m}/tokenizer_config.json"]
+            allow += ([f"{m}/config.json", f"{m}/model.safetensors"]
+                      if backend == "torch" else [f"onnx/{m}/*"])
+        return cls(snapshot_download(repo_or_path, allow_patterns=allow), **kw)
+
+    # ------------------------------------------------------------ core
+    def _bias_for(self, lang):
+        b = None
+        if self.bias_per_lang:
+            b = self.bias_per_lang.get(lang) or self.bias_per_lang.get(base_lang(lang))
+        return b if b is not None else self.bias
+
+    def predict(self, words: Sequence[str], lang: str = "en") -> dict:
+        """Per-word labels and averaged posteriors for an already-split word list.
+
+        ``words`` should be lowercased and free of punctuation, as ASR output is.
+        """
+        words = list(words)
+        acc_p = acc_c = None
+        for w, m in zip(self.weights, self.members):
+            p, c = m.posteriors(words, lang)
+            acc_p = w * p if acc_p is None else acc_p + w * p
+            acc_c = w * c if acc_c is None else acc_c + w * c
+        lp = np.log(np.clip(acc_p, 1e-9, None))
+        b = self._bias_for(lang)
+        if b is not None:
+            lp = lp + np.asarray(b, dtype=np.float32)[None, :]
+        punct = [PUNCT_LABELS[i] for i in lp.argmax(1)] if len(words) else []
+        case = [CASE_LABELS[i] for i in acc_c.argmax(1)] if len(words) else []
+        return {"words": words, "punct": punct, "case": case,
+                "punct_probs": acc_p, "case_probs": acc_c, "punct_scores": lp}
+
+    @staticmethod
+    def _close(punct, scores):
+        """A complete text ends on a sentence mark: if the last word got none,
+        take the likeliest of . ? ! for it.  Applied to finished text only --
+        predict() is left exactly as benchmarked."""
+        if punct and punct[-1] not in _SENT_END:
+            ends = [PUNCT_LABELS.index(x) for x in ("PERIOD", "QUESTION", "EXCLAM")]
+            punct[-1] = PUNCT_LABELS[max(ends, key=lambda i: scores[-1][i])]
+        return punct
+
+    def _postprocess(self, words, punct, case, lang, is_start=True, prev_punct=None):
+        """Gazetteer surface forms (iPhone, McDonald) and a capital after every
+        sentence-final mark."""
+        case = list(case)
+        caseless = is_caseless(lang)
+        gz = self.gazetteer.get(base_lang(lang), {})
+        out = []
+        for i, w in enumerate(words):
+            s = gz.get(w)
+            if s and not caseless:
+                out.append(s)
+                case[i] = "AS_IS"
+            else:
+                out.append(w)
+        if not caseless and words:
+            lead = prev_punct in _SENT_END if prev_punct is not None else False
+            if case[0] == "LOWER" and (is_start or lead):
+                case[0] = "CAP"
+            for i in range(1, len(words)):
+                if punct[i - 1] in _SENT_END and case[i] == "LOWER":
+                    case[i] = "CAP"
+        return out, list(punct), case
+
+    def _render(self, words, punct, case, lang):
+        surf = surface_for(lang)
+        sep = "" if is_no_space(lang) else " "
+        return sep.join((w if c == "AS_IS" else apply_case(w, c)) + surf.get(p, "")
+                        for w, p, c in zip(words, punct, case))
+
+    def restore(self, text: str, lang: str = "en", close: bool = True) -> str:
+        """Unpunctuated text in, punctuated and truecased text out.
+
+        ``close`` ends the text on a sentence mark; turn it off when ``text``
+        is a fragment that continues elsewhere.
+        """
+        words = split_words(text, lang)
+        if not words:
+            return text
+        r = self.predict(words, lang)
+        punct = self._close(r["punct"], r["punct_scores"]) if close else r["punct"]
+        w, p, c = self._postprocess(words, punct, r["case"], lang)
+        return self._render(w, p, c, lang)
+
+    def restore_batch(self, texts: Iterable[str], lang: str = "en") -> list[str]:
+        return [self.restore(t, lang) for t in texts]
+
+    def stream(self, lang="en", lag=6, context=180, stable_n=2):
+        return StreamingPunctuator(self, lang, lag, context, stable_n)
+
+
+class StreamingPunctuator:
+    """Commit-with-lag for live transcripts.
+
+    Later words change earlier decisions -- "what do you think" only becomes a
+    question at its last word -- so a word is released only once it has
+    ``lag`` words of right context and the same label for ``stable_n``
+    consecutive updates.  Call ``push(words)`` as ASR emits, ``finish()`` at
+    the end; each returns the newly committed text.
+    """
+
+    def __init__(self, punctuator, lang="en", lag=6, context=180, stable_n=2):
+        self.p, self.lang = punctuator, lang
+        self.lag, self.context, self.stable_n = lag, context, stable_n
+        self.words, self.emitted = [], 0
+        self._last, self._streak = {}, {}
+
+    def push(self, new_words) -> str:
+        if isinstance(new_words, str):
+            new_words = split_words(new_words, self.lang)
+        self.words.extend(w.lower() for w in new_words)
+        return self._commit(final=False)
+
+    def finish(self) -> str:
+        return self._commit(final=True)
+
+    def _commit(self, final):
+        if not self.words:
+            return ""
+        off = max(0, len(self.words) - self.context)
+        r = self.p.predict(self.words[off:], self.lang)
+        punct, case = r["punct"], r["case"]
+        if final:
+            punct = self.p._close(punct, r["punct_scores"])
+        limit = len(self.words) if final else len(self.words) - self.lag
+        done, i = [], self.emitted
+        while i < limit:
+            j = i - off
+            if j < 0:
+                i += 1
+                continue
+            if not final:
+                lab = (punct[j], case[j])
+                if self._last.get(i) == lab:
+                    self._streak[i] = self._streak.get(i, 1) + 1
+                else:
+                    self._last[i], self._streak[i] = lab, 1
+                if self._streak[i] < self.stable_n:
+                    break
+            done.append(i)
+            i += 1
+        if not done:
+            return ""
+        s, e = done[0], done[-1] + 1
+        prev = punct[s - off - 1] if s - off - 1 >= 0 else None
+        w, p, c = self.p._postprocess(self.words[s:e], punct[s - off:e - off],
+                                      case[s - off:e - off], self.lang,
+                                      is_start=(s == 0), prev_punct=prev)
+        self.emitted = e
+        out = self.p._render(w, p, c, self.lang)
+        return out if s == 0 or is_no_space(self.lang) else " " + out
+
+
+if __name__ == "__main__":
+    import argparse
+    import sys
+    ap = argparse.ArgumentParser(description="Restore punctuation and case.")
+    ap.add_argument("text", nargs="*", help="text to restore (default: stdin)")
+    ap.add_argument("--lang", default="en", help="ISO 639-1 code, e.g. en, de, zh")
+    ap.add_argument("--model", default=os.path.dirname(os.path.abspath(__file__)))
+    ap.add_argument("--single", action="store_true",
+                    help="use only the mmBERT-base member (307M, faster)")
+    ap.add_argument("--backend", default="auto", choices=["auto", "torch", "onnx"])
+    a = ap.parse_args()
+    p = Punctuator.from_pretrained(a.model, backend=a.backend,
+                                   members=["mmbert-base"] if a.single else None)
+    src = [" ".join(a.text)] if a.text else sys.stdin.read().splitlines()
+    for line in src:
+        print(p.restore(line, a.lang))

ensemble_config.json

@@ -0,0 +1,116 @@
+{
+ "members": [
+  "mmbert-base",
+  "xlm-roberta-large"
+ ],
+ "weights": [
+  0.5,
+  0.5
+ ],
+ "combine": "arithmetic mean of per-word softmax posteriors",
+ "punct_labels": [
+  "O",
+  "COMMA",
+  "PERIOD",
+  "QUESTION",
+  "EXCLAM"
+ ],
+ "case_labels": [
+  "LOWER",
+  "CAP",
+  "UPPER"
+ ],
+ "punct_bias": [
+  0.0,
+  -0.25,
+  0.375,
+  -1.0,
+  -3.0
+ ],
+ "punct_bias_per_lang": {
+  "ar": [
+   0.0,
+   -0.1875,
+   0.46875,
+   -0.9375,
+   -3.0
+  ],
+  "de": [
+   0.0,
+   -0.15625,
+   0.5625,
+   -0.75,
+   -2.625
+  ],
+  "en": [
+   0.0,
+   -0.25,
+   0.3125,
+   -0.9375,
+   -2.84375
+  ],
+  "fr": [
+   0.0,
+   -0.28125,
+   0.40625,
+   -0.96875,
+   -2.9375
+  ],
+  "it": [
+   0.0,
+   -0.3125,
+   0.75,
+   -0.75,
+   -3.0
+  ],
+  "ko": [
+   0.0,
+   -0.34375,
+   0.25,
+   -0.90625,
+   -3.0
+  ],
+  "nl": [
+   0.0,
+   -0.1875,
+   0.5,
+   -1.0,
+   -2.9375
+  ],
+  "ro": [
+   0.0,
+   -0.40625,
+   0.25,
+   -1.125,
+   -2.96875
+  ],
+  "zh": [
+   0.0,
+   -0.28125,
+   0.34375,
+   -1.21875,
+   -3.0
+  ]
+ },
+ "calibration": {
+  "fitted_on": "IWSLT dev2010 (held out of every test table)",
+  "dev_macro_f1_argmax": 0.7191,
+  "dev_macro_f1_calibrated": 0.7472
+ },
+ "window": {
+  "max_len": 512,
+  "overlap_subwords": 256
+ },
+ "params": {
+  "mmbert-base": {
+   "params": 307537928,
+   "embedding_params": 196608768,
+   "dtype": "torch.float32"
+  },
+  "xlm-roberta-large": {
+   "params": 560950280,
+   "embedding_params": 256531456,
+   "dtype": "torch.float32"
+  }
+ }
+}

handler.py

@@ -0,0 +1,51 @@
+"""Hugging Face Inference Endpoints handler.
+
+Deploy this repository as an Inference Endpoint and it serves Dewpoint with no
+further code.  Request body:
+
+    {"inputs": "so i said meet at three thirty tuesday what do you think",
+     "parameters": {"lang": "en"}}
+
+`inputs` may also be a list of strings.  Optional parameters:
+    lang      ISO 639-1 code (default "en")
+    single    true to run only the mmBERT-base member
+    labels    true to also return per-word punctuation and case labels
+
+Response: [{"text": "..."}] per input (plus "words", "punct", "case" if
+labels=true).
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from dewpoint import Punctuator, split_words  # noqa: E402
+
+
+class EndpointHandler:
+    def __init__(self, path=""):
+        path = path or os.path.dirname(os.path.abspath(__file__))
+        self.full = Punctuator(path)
+        self._single = None
+        self.path = path
+
+    def _model(self, single):
+        if not single:
+            return self.full
+        if self._single is None:
+            self._single = Punctuator(self.path, members=["mmbert-base"])
+        return self._single
+
+    def __call__(self, data):
+        inputs = data.get("inputs", data)
+        params = data.get("parameters") or {}
+        lang = params.get("lang", "en")
+        p = self._model(bool(params.get("single", False)))
+        texts = [inputs] if isinstance(inputs, str) else list(inputs)
+        out = []
+        for t in texts:
+            item = {"text": p.restore(t, lang)}
+            if params.get("labels"):
+                r = p.predict(split_words(t, lang), lang)
+                item.update(words=r["words"], punct=r["punct"], case=r["case"])
+            out.append(item)
+        return out

mmbert-base/config.json

@@ -0,0 +1,78 @@
+{
+  "architectures": [
+    "ModernBertForMaskedLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 2,
+  "classifier_activation": "gelu",
+  "classifier_bias": false,
+  "classifier_dropout": 0.0,
+  "classifier_pooling": "mean",
+  "cls_token_id": 1,
+  "decoder_bias": true,
+  "deterministic_flash_attn": false,
+  "dtype": "bfloat16",
+  "embedding_dropout": 0.0,
+  "eos_token_id": 1,
+  "global_attn_every_n_layers": 3,
+  "gradient_checkpointing": false,
+  "hidden_activation": "gelu",
+  "hidden_size": 768,
+  "initializer_cutoff_factor": 2.0,
+  "initializer_range": 0.02,
+  "intermediate_size": 1152,
+  "layer_norm_eps": 1e-05,
+  "layer_types": [
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention",
+    "sliding_attention",
+    "sliding_attention",
+    "full_attention"
+  ],
+  "local_attention": 128,
+  "mask_token_id": 4,
+  "max_position_embeddings": 8192,
+  "mlp_bias": false,
+  "mlp_dropout": 0.0,
+  "model_type": "modernbert",
+  "norm_bias": false,
+  "norm_eps": 1e-05,
+  "num_attention_heads": 12,
+  "num_hidden_layers": 22,
+  "pad_token_id": 0,
+  "position_embedding_type": "sans_pos",
+  "rope_parameters": {
+    "full_attention": {
+      "rope_theta": 160000,
+      "rope_type": "default"
+    },
+    "sliding_attention": {
+      "rope_theta": 160000,
+      "rope_type": "default"
+    }
+  },
+  "sep_token_id": 1,
+  "sparse_pred_ignore_index": -100,
+  "sparse_prediction": false,
+  "tie_word_embeddings": true,
+  "transformers_version": "5.17.0",
+  "vocab_size": 256000
+}

mmbert-base/model.safetensors

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

mmbert-base/tokenizer.json

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

mmbert-base/tokenizer_config.json

@@ -0,0 +1,25 @@
+{
+  "backend": "tokenizers",
+  "bos_token": "<bos>",
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "<bos>",
+  "eos_token": "<eos>",
+  "extra_special_tokens": [
+    "<start_of_turn>",
+    "<end_of_turn>"
+  ],
+  "is_local": false,
+  "local_files_only": false,
+  "mask_token": "<mask>",
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ],
+  "model_max_length": 8192,
+  "pad_token": "<pad>",
+  "padding_side": "right",
+  "sep_token": "<eos>",
+  "spaces_between_special_tokens": false,
+  "tokenizer_class": "TokenizersBackend",
+  "unk_token": "<unk>"
+}

mmbert-base/vpunct_config.json

@@ -0,0 +1,27 @@
+{
+ "base_id": "jhu-clsp/mmBERT-base",
+ "n_punct": 5,
+ "n_case": 3,
+ "max_len": 512,
+ "punct_labels": [
+  "O",
+  "COMMA",
+  "PERIOD",
+  "QUESTION",
+  "EXCLAM"
+ ],
+ "case_labels": [
+  "LOWER",
+  "CAP",
+  "UPPER"
+ ],
+ "punct_bias": [
+  0.0,
+  -0.625,
+  -0.125,
+  -1.375,
+  -2.875
+ ],
+ "punct_bias_per_lang": {},
+ "calibration_strategy": "pooled"
+}

requirements.txt

@@ -0,0 +1,7 @@
+# torch backend (GPU or CPU): pip install -r requirements.txt
+torch>=2.4
+transformers>=5.0
+safetensors>=0.4
+huggingface_hub>=0.24
+numpy>=1.26
+# Measured with torch 2.11.0, transformers 5.17.0, tokenizers 0.23.2, numpy 2.5.3

results/rt2_voices.json

@@ -0,0 +1,166 @@
+{
+ "kokoro": {
+  "repo": "hexgrad/Kokoro-82M",
+  "licence": "Apache-2.0"
+ },
+ "chatterbox": {
+  "repo": "ResembleAI/chatterbox",
+  "licence": "MIT"
+ },
+ "piper": {
+  "admitted": {
+   "bg/bg_BG/dimitar/medium/bg_BG-dimitar-medium": [
+    "* License:  CC0"
+   ],
+   "de/de_DE/kerstin/low/de_DE-kerstin-low": [
+    "* License: CC0"
+   ],
+   "de/de_DE/mls/medium/de_DE-mls-medium": [
+    "* License: CC-BY 4.0"
+   ],
+   "de/de_DE/thorsten/high/de_DE-thorsten-high": [
+    "* License: CC0"
+   ],
+   "de/de_DE/thorsten/low/de_DE-thorsten-low": [
+    "* License: CC0"
+   ],
+   "de/de_DE/thorsten/medium/de_DE-thorsten-medium": [
+    "* License: CC0"
+   ],
+   "de/de_DE/thorsten_emotional/medium/de_DE-thorsten_emotional-medium": [
+    "* License: CC0"
+   ],
+   "el/el_GR/rapunzelina/low/el_GR-rapunzelina-low": [
+    "* License: CC0"
+   ],
+   "el/el_GR/rapunzelina/medium/el_GR-rapunzelina-medium": [
+    "* License: CC0"
+   ],
+   "hu/hu_HU/anna/medium/hu_HU-anna-medium": [
+    "* License: CC0"
+   ],
+   "hu/hu_HU/berta/medium/hu_HU-berta-medium": [
+    "* License: CC0"
+   ],
+   "hu/hu_HU/imre/medium/hu_HU-imre-medium": [
+    "* License: CC0"
+   ],
+   "ro/ro_RO/mihai/medium/ro_RO-mihai-medium": [
+    "* License: CC0"
+   ],
+   "fa/fa_IR/amir/medium/fa_IR-amir-medium": [
+    "* License: CC0"
+   ],
+   "fa/fa_IR/ganji/medium/fa_IR-ganji-medium": [
+    "* License: CC0"
+   ],
+   "fa/fa_IR/ganji_adabi/medium/fa_IR-ganji_adabi-medium": [
+    "* License: CC0"
+   ],
+   "fa/fa_IR/reza_ibrahim/medium/fa_IR-reza_ibrahim-medium": [
+    "* License: CC0"
+   ],
+   "fi/fi_FI/harri/low/fi_FI-harri-low": [
+    "* License: CC0"
+   ],
+   "fi/fi_FI/harri/medium/fi_FI-harri-medium": [
+    "* License: CC0"
+   ],
+   "uk/uk_UA/mykyta/high/uk_UA-mykyta-high": [
+    "* License: Apache 2.0"
+   ],
+   "uk/uk_UA/oleksa/high/uk_UA-oleksa-high": [
+    "* License: Apache 2.0"
+   ],
+   "uk/uk_UA/tetiana/high/uk_UA-tetiana-high": [
+    "* License: Apache 2.0"
+   ],
+   "uk/uk_UA/ukrainian_tts/medium/uk_UA-ukrainian_tts-medium": [
+    "* License: CC0"
+   ],
+   "lv/lv_LV/aivars/medium/lv_LV-aivars-medium": [
+    "* License: CC0 1.0 Universal"
+   ],
+   "nl/nl_BE/nathalie/medium/nl_BE-nathalie-medium": [
+    "* License:  CC0"
+   ],
+   "nl/nl_BE/rdh/medium/nl_BE-rdh-medium": [
+    "* License:  CC0 1.0 Universal"
+   ],
+   "nl/nl_NL/alex/medium/nl_NL-alex-medium": [
+    "* License:  CC0"
+   ],
+   "nl/nl_NL/mls/medium/nl_NL-mls-medium": [
+    "* License: CC-BY 4.0"
+   ],
+   "nl/nl_NL/mls_5809/low/nl_NL-mls_5809-low": [
+    "* License:  CC BY 4.0"
+   ],
+   "nl/nl_NL/mls_7432/low/nl_NL-mls_7432-low": [
+    "* License: CC BY 4.0"
+   ],
+   "nl/nl_NL/pim/medium/nl_NL-pim-medium": [
+    "* License:  CC0"
+   ],
+   "nl/nl_NL/ronnie/medium/nl_NL-ronnie-medium": [
+    "* License:  CC0"
+   ],
+   "pl/pl_PL/bass/high/pl_PL-bass-high": [
+    "## License",
+    "[Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0)"
+   ],
+   "pl/pl_PL/darkman/medium/pl_PL-darkman-medium": [
+    "* License: CC0"
+   ],
+   "pl/pl_PL/gosia/medium/pl_PL-gosia-medium": [
+    "* License: CC0"
+   ],
+   "pl/pl_PL/mc_speech/medium/pl_PL-mc_speech-medium": [
+    "* License: CC0"
+   ],
+   "pl/pl_PL/mls_6892/low/pl_PL-mls_6892-low": [
+    "* License:  CC BY 4.0"
+   ],
+   "ru/ru_RU/denis/medium/ru_RU-denis-medium": [
+    "* License: CC0"
+   ],
+   "ru/ru_RU/dmitri/medium/ru_RU-dmitri-medium": [
+    "* License: CC0"
+   ],
+   "sq/sq_AL/edon/medium/sq_AL-edon-medium": [
+    "* License: CC0"
+   ],
+   "sv/sv_SE/alma/medium/sv_SE-alma-medium": [
+    "## License",
+    "The model weights are released under CC BY 4.0, following the license of the NST training data."
+   ],
+   "sv/sv_SE/nst/medium/sv_SE-nst-medium": [
+    "* License: CC0"
+   ]
+  },
+  "refused": {
+   "de/de_DE/karlsson/low/de_DE-karlsson-low": [
+    "* License: See URL"
+   ],
+   "de/de_DE/pavoque/low/de_DE-pavoque-low": [
+    "* License: http://creativecommons.org/licenses/by-nc-sa/4.0/"
+   ],
+   "de/de_DE/ramona/low/de_DE-ramona-low": [
+    "* License: See URL"
+   ],
+   "el/el_GR/joy/medium/el_GR-joy-medium": [
+    "* License: CC BY-NC 4.0"
+   ],
+   "fa/fa_IR/gyro/medium/fa_IR-gyro-medium": [
+    "* License: See URL"
+   ],
+   "ru/ru_RU/irina/medium/ru_RU-irina-medium": [
+    "* License: Unknown"
+   ],
+   "ru/ru_RU/ruslan/medium/ru_RU-ruslan-medium": [
+    "* License: https://creativecommons.org/licenses/by-nc-sa/4.0/"
+   ],
+   "sv/sv_SE/lisa/medium/sv_SE-lisa-medium": []
+  }
+ }
+}

serve.py

@@ -0,0 +1,84 @@
+"""A small local HTTP server for Dewpoint, using only the standard library.
+
+    python serve.py                       # ensemble, port 8000
+    python serve.py --single --port 9000  # the 307M member only
+    python serve.py --backend onnx        # no torch needed
+
+    curl -s localhost:8000/restore -H "content-type: application/json" \\
+         -d '{"text": "what time is it in tokyo right now", "lang": "en"}'
+    -> {"text": "What time is it in Tokyo right now?"}
+
+POST /restore   {"text": str | [str], "lang": "en", "labels": false}
+GET  /health    {"ok": true, "backend": ..., "members": [...]}
+
+It serves one request at a time, which is right for a single model on one
+machine; put it behind a process manager for anything larger.
+"""
+import argparse
+import json
+import os
+import sys
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from dewpoint import Punctuator, split_words  # noqa: E402
+
+
+def make_handler(p):
+    class H(BaseHTTPRequestHandler):
+        def _send(self, code, obj):
+            body = json.dumps(obj, ensure_ascii=False).encode("utf-8")
+            self.send_response(code)
+            self.send_header("content-type", "application/json; charset=utf-8")
+            self.send_header("content-length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def do_GET(self):
+            if self.path.rstrip("/") == "/health":
+                self._send(200, {"ok": True, "backend": p.backend,
+                                 "members": len(p.members)})
+            else:
+                self._send(404, {"error": "try POST /restore or GET /health"})
+
+        def do_POST(self):
+            if self.path.rstrip("/") != "/restore":
+                return self._send(404, {"error": "POST /restore"})
+            try:
+                n = int(self.headers.get("content-length", 0))
+                req = json.loads(self.rfile.read(n) or b"{}")
+                text, lang = req.get("text", ""), req.get("lang", "en")
+                texts = [text] if isinstance(text, str) else list(text)
+                out = []
+                for t in texts:
+                    item = {"text": p.restore(t, lang)}
+                    if req.get("labels"):
+                        r = p.predict(split_words(t, lang), lang)
+                        item.update(words=r["words"], punct=r["punct"], case=r["case"])
+                    out.append(item)
+                self._send(200, out[0] if isinstance(text, str) else out)
+            except Exception as e:  # report, don't crash the server
+                self._send(400, {"error": f"{type(e).__name__}: {e}"})
+
+        def log_message(self, fmt, *args):
+            pass
+
+    return H
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Serve Dewpoint over HTTP.")
+    ap.add_argument("--host", default="127.0.0.1")
+    ap.add_argument("--port", type=int, default=8000)
+    ap.add_argument("--model", default=os.path.dirname(os.path.abspath(__file__)))
+    ap.add_argument("--single", action="store_true")
+    ap.add_argument("--backend", default="auto", choices=["auto", "torch", "onnx"])
+    a = ap.parse_args()
+    p = Punctuator.from_pretrained(a.model, backend=a.backend,
+                                   members=["mmbert-base"] if a.single else None)
+    print(f"Dewpoint ({p.backend}, {len(p.members)} member(s)) on http://{a.host}:{a.port}")
+    HTTPServer((a.host, a.port), make_handler(p)).serve_forever()
+
+
+if __name__ == "__main__":
+    main()

xlm-roberta-large/config.json

@@ -0,0 +1,30 @@
+{
+  "add_cross_attention": false,
+  "architectures": [
+    "XLMRobertaForMaskedLM"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "dtype": "bfloat16",
+  "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": "xlm-roberta",
+  "num_attention_heads": 16,
+  "num_hidden_layers": 24,
+  "output_past": true,
+  "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": 250002
+}

xlm-roberta-large/model.safetensors

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

xlm-roberta-large/tokenizer.json

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

xlm-roberta-large/tokenizer_config.json

@@ -0,0 +1,15 @@
+{
+  "add_prefix_space": true,
+  "backend": "tokenizers",
+  "bos_token": "<s>",
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "is_local": false,
+  "local_files_only": false,
+  "mask_token": "<mask>",
+  "model_max_length": 512,
+  "pad_token": "<pad>",
+  "sep_token": "</s>",
+  "tokenizer_class": "XLMRobertaTokenizer",
+  "unk_token": "<unk>"
+}

xlm-roberta-large/vpunct_config.json

@@ -0,0 +1,91 @@
+{
+ "base_id": "FacebookAI/xlm-roberta-large",
+ "n_punct": 5,
+ "n_case": 3,
+ "max_len": 512,
+ "punct_labels": [
+  "O",
+  "COMMA",
+  "PERIOD",
+  "QUESTION",
+  "EXCLAM"
+ ],
+ "case_labels": [
+  "LOWER",
+  "CAP",
+  "UPPER"
+ ],
+ "punct_bias": [
+  0.0,
+  -0.25,
+  0.5,
+  -1.0,
+  -3.0
+ ],
+ "punct_bias_per_lang": {
+  "ar": [
+   0.0,
+   -0.09375,
+   0.5625,
+   -1.03125,
+   -3.0
+  ],
+  "de": [
+   0.0,
+   -0.46875,
+   0.5,
+   -1.03125,
+   -2.96875
+  ],
+  "en": [
+   0.0,
+   -0.1875,
+   0.46875,
+   -0.75,
+   -3.0
+  ],
+  "fr": [
+   0.0,
+   -0.28125,
+   0.53125,
+   -1.03125,
+   -2.6875
+  ],
+  "it": [
+   0.0,
+   -0.28125,
+   0.59375,
+   -0.90625,
+   -2.9375
+  ],
+  "ko": [
+   0.0,
+   -0.28125,
+   0.6875,
+   -0.875,
+   -3.0
+  ],
+  "nl": [
+   0.0,
+   -0.28125,
+   0.6875,
+   -0.875,
+   -2.875
+  ],
+  "ro": [
+   0.0,
+   -0.40625,
+   0.6875,
+   -0.875,
+   -2.9375
+  ],
+  "zh": [
+   0.0,
+   -0.28125,
+   0.5,
+   -0.90625,
+   -2.4375
+  ]
+ },
+ "calibration_strategy": "shrink0.25"
+}