ONNX release v1

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

NOTICE

@@ -0,0 +1,15 @@
+g2p_en 2.1.0: English grapheme-to-phoneme conversion
+Original work by Kyubyong Park and Jongseok Kim, licensed under the Apache
+License, Version 2.0. https://github.com/Kyubyong/g2p
+Source file: g2p_en/checkpoint20.npz (SHA-256
+b8af35e4596d8dd5836dfd3fe9b2ba4f97b9c311efe8879544cbcfcbd566d8c6)
+
+This repository contains an ONNX conversion made by Drew Bednar for
+go-phonmatchnet, from the repackaging androiddrew/g2p-en-decoder-pytorch
+(revision v1, commit fc55559c25a12fce6e0cf9062729e7f2a9fc1ddc). It is not
+affiliated with or endorsed by the g2p_en authors.
+
+Modifications to the original work: the NumPy arrays were renamed and stored
+in safetensors format, then the network was split into a word-encoder graph
+and a single-step decoder graph and exported to ONNX. Values are unchanged.
+No training or fine-tuning was performed.

README.md

@@ -0,0 +1,92 @@
+---
+license: apache-2.0
+library_name: onnx
+language:
+  - en
+pipeline_tag: feature-extraction
+tags:
+  - grapheme-to-phoneme
+  - g2p
+  - keyword-spotting
+  - wake-word
+  - onnx
+base_model: androiddrew/g2p-en-decoder-pytorch
+---
+
+# g2p_en decoder: keyword text features, ONNX
+
+The [g2p_en](https://github.com/Kyubyong/g2p) grapheme-to-phoneme model
+(Kyubyong Park & Jongseok Kim, Apache-2.0, release 2.1.0) as two ONNX graphs,
+converted from
+[`androiddrew/g2p-en-decoder-pytorch`](https://huggingface.co/androiddrew/g2p-en-decoder-pytorch).
+The values are unchanged.
+
+It is **not** used to output phoneme strings. The keyword model
+[`androiddrew/naptrap-phonmatchnet-en-onnx`](https://huggingface.co/androiddrew/naptrap-phonmatchnet-en-onnx)
+was trained on the decoder's **hidden states**. It is embedded in
+[go-phonmatchnet](https://github.com/androiddrew/go-phonmatchnet).
+
+> Not affiliated with or endorsed by the g2p_en authors. See `LICENSE` and `NOTICE`.
+
+## Files
+
+| Graph | Inputs | Outputs |
+|---|---|---|
+| `encoder.onnx` | `graphemes` int64 `[L]`: a word's grapheme IDs, then `</s>` (2) | `hidden` `[1, 256]`; `separator` `[1, 256]`, the row placed between words |
+| `decoder.onnx` | `token` int64 `[1]`, `hidden` `[1, 256]` | `next_hidden` `[1, 256]`; `logits` `[1, 74]` |
+
+`config.json` lists the grapheme vocabulary, start/end phoneme IDs, the
+20-step limit and the SHA-256 of both graphs. `conversion/` holds the export
+script, its locked environment and README.
+
+## Keyword features
+
+1. Normalize the keyword: NFKD, drop combining marks, lowercase, and keep
+   words matching `[a-z]+(?:'[a-z]+)*`. Numbers must be spelled out.
+2. Encode each word: grapheme IDs from `config.json` (`<unk>` for `'`), then `</s>`.
+3. Decode greedily from token 2 (`<s>`) for up to 20 steps; each step's
+   `next_hidden` is one feature row, until the argmax token is 3 (`</s>`),
+   whose state is not kept.
+4. Put the `separator` row between words.
+
+```python
+import numpy as np
+import onnxruntime as ort
+
+encoder = ort.InferenceSession("encoder.onnx")
+decoder = ort.InferenceSession("decoder.onnx")
+graphemes = {g: i for i, g in enumerate(config["graphemes"])}
+
+def features(normalized):
+    rows = []
+    for i, word in enumerate(normalized.split()):
+        ids = np.array([graphemes.get(c, 1) for c in word] + [2], dtype=np.int64)
+        hidden, separator = encoder.run(None, {"graphemes": ids})
+        if i:
+            rows.append(separator)
+        token = 2
+        for _ in range(20):
+            hidden, logits = decoder.run(None, {"token": np.array([token]), "hidden": hidden})
+            token = int(logits.argmax())
+            if token == 3:
+                break
+            rows.append(hidden)
+    return np.concatenate(rows)   # float32 [positions, 256]
+```
+
+## Conversion and accuracy
+
+`conversion/export.py` loads the PyTorch release at commit
+`fc55559c25a12fce6e0cf9062729e7f2a9fc1ddc` with naptrap 0.1.0. The grapheme
+GRU has PyTorch's gate layout, so the encoder is an ONNX `GRU` operator; the
+decoder is one GRU-cell step plus the output projection. Over eight keywords,
+including apostrophes, accents, one letter, a 34-letter word and a nine-word
+sentence, every feature length matched naptrap and the maximum difference was
+5.5e-6. With the locked environment it reproduces both graphs byte for byte.
+
+## Limitations
+
+The model was trained on CMUdict pronunciations of American English words.
+Unusual names, brand names and non-English words get its best-guess
+pronunciation, which may not match how people say them. The dictionary-lookup,
+homograph and number-expansion steps of the g2p_en package are not used.

config.json

@@ -0,0 +1,58 @@
+{
+  "format": "naptrap-g2p-en-decoder-onnx-v1",
+  "source": {
+    "repo_id": "androiddrew/g2p-en-decoder-pytorch",
+    "commit": "fc55559c25a12fce6e0cf9062729e7f2a9fc1ddc",
+    "format": "naptrap-g2p-en-decoder-v1",
+    "sha256": "bba37553a3414f90c7ed0cd465925aa15def67f42cc59bf43b8c633e1eb7b445"
+  },
+  "opset": 17,
+  "hidden_size": 256,
+  "graphemes": [
+    "<pad>",
+    "<unk>",
+    "</s>",
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z"
+  ],
+  "phonemes": 74,
+  "start_token": 2,
+  "end_token": 3,
+  "max_decoder_steps": 20,
+  "inputs": {
+    "encoder": "graphemes [L] int64: a word's grapheme IDs followed by </s> (2)",
+    "decoder": "token [1] int64 (start with 2), hidden [1,256] float32"
+  },
+  "outputs": {
+    "encoder": "hidden [1,256]; separator [1,256], the row placed between words",
+    "decoder": "next_hidden [1,256], one feature row; logits [1,74], argmax is the next token"
+  },
+  "sha256": {
+    "encoder.onnx": "c492a8907a8b62d7f1e311c0df469490a4e4670865a6a5d8b4b7749a38666091",
+    "decoder.onnx": "86953a2604f3494bf44c4d81df67c444455b4a9f0cf6f08d62fab08393bd29e1"
+  }
+}

conversion/README.md

@@ -0,0 +1,65 @@
+# Export tooling
+
+`export.py` rebuilds every model go-phonmatchnet embeds (`models/`) from
+naptrap's PyTorch releases on Hugging Face, pinned by commit and SHA-256:
+
+| Source | Commit | Output |
+|---|---|---|
+| `androiddrew/naptrap-phonmatchnet-en` v1 | `e8f6c45bff04d7368cbe14979392b7d52dc88ba8` | `phonmatchnet/model.onnx`, `config.json` |
+| `androiddrew/google-speech-embedding-pytorch` v1 | `ad7a3dd93b02f83797a040857425d6343d98680a` | `google/model.onnx`, `config.json` |
+| `androiddrew/g2p-en-decoder-pytorch` v1 | `fc55559c25a12fce6e0cf9062729e7f2a9fc1ddc` | `g2p/encoder.onnx`, `decoder.onnx`, `config.json` |
+
+The PyTorch modules come from naptrap 0.1.0, so the graphs are traced from the
+same code that defines the reference outputs. The trained values are copied
+unchanged. Two things are re-expressed for ONNX:
+
+- **Spectrogram frontends.** `torch.stft` and `torch.fft.rfft` do not export
+  reliably, so each FFT is a strided `Conv` with a fixed cos/sin DFT basis
+  that has the original window folded in. Reflect and zero padding, power or
+  magnitude, the mel matrix and the log are ordinary graph operators. The
+  graphs take raw samples.
+- **The g2p greedy decode.** The encoder is an ONNX `GRU`; the decoder is one
+  step, which the caller runs until the end token. Data-dependent loops stay
+  out of the graph.
+
+After exporting, the script runs every graph with ONNX Runtime against
+naptrap's PyTorch modules (17 clips of speech and noise from 8,000 to
+32,000 samples long, eight keywords) and fails outside 1e-3 on embeddings and
+logits or 1e-5 on text features. The measured maxima are about 4e-5, 1e-5 and 5.5e-6.
+
+```bash
+cd tools/export
+uv run --frozen python export.py --output out --check
+```
+
+`--check` compares each output with the committed file and fails on any
+difference. With the locked environment in `uv.lock` (Python 3.12, torch
+2.6.0+cpu, onnx 1.17.0, onnxruntime 1.22.1, naptrap 0.1.0) on Linux/amd64,
+all seven outputs reproduce byte for byte. Copy `out/` over `models/` only
+when intentionally changing the embedded models.
+
+## Hugging Face repositories
+
+```bash
+uv run --frozen python hf.py --output hf-out
+```
+
+assembles `hf-out/naptrap-phonmatchnet-en-onnx`, `google-speech-embedding-onnx`
+and `g2p-en-decoder-onnx` from the committed `models/`, the cards and NOTICE
+files in `hf/`, the Apache-2.0 LICENSE and this directory as `conversion/`.
+
+## Test fixtures
+
+`fixtures.py` builds `testdata/`:
+
+```bash
+uv run --frozen python fixtures.py synth --server http://host:8880   # Kokoro clips
+uv run --frozen python fixtures.py reference                         # naptrap outputs
+```
+
+`synth` requests each phrase from an OpenAI-compatible Kokoro speech server
+(`kokoro-v1.0`; voices `af_heart`, `am_michael`, `bf_emma`), converts it to
+16 kHz 16-bit mono with ffmpeg and adds 0.2 s of silence on each side. TTS
+output is not guaranteed to be bit-stable, so the clips are committed.
+`reference` scores the committed clips with naptrap's PyTorch models and
+writes `testdata/reference.json`.

conversion/export.py

@@ -0,0 +1,398 @@
+"""Convert naptrap's PyTorch PhonMatchNet models to the ONNX graphs go-phonmatchnet embeds.
+
+Sources are naptrap's three Hugging Face repositories at their v1 commits,
+pinned by commit and SHA-256. The PyTorch modules come from naptrap 0.1.0, so
+every graph is traced from the same code that produced the reference outputs.
+
+Outputs, in the repository's models/ layout:
+
+  phonmatchnet/model.onnx   waveform [N], google [G,96], text [P,256] -> logit [1]
+  google/model.onnx         waveform [N] -> embeddings [floor(N/1280), 96]
+  g2p/encoder.onnx          graphemes [L] -> hidden [1,256], separator [1,256]
+  g2p/decoder.onnx          token [1], hidden [1,256] -> next_hidden [1,256], logits [1,74]
+  */config.json             metadata the Go engine reads
+
+The STFT frontends are inside the graphs. Each FFT is written as a strided
+convolution with a fixed DFT basis (the window folded in), which ONNX exports
+exactly; torch.stft and torch.fft do not export reliably. The g2p greedy
+decode stays a loop in Go around the single-step decoder graph.
+
+Usage: uv run --frozen python export.py --output out [--check]
+"""
+
+import argparse
+import hashlib
+import json
+import math
+import shutil
+import sys
+import urllib.request
+from pathlib import Path
+
+import numpy as np
+import onnx
+import onnxruntime
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+from naptrap.models.phonmatchnet import PhonMatchNet
+from naptrap.text import GRAPHEMES
+
+REPO = Path(__file__).resolve().parents[2]
+OPSET = 17
+HF = "https://huggingface.co/androiddrew/{repo}/resolve/{commit}/{file}"
+SOURCES = {
+    "naptrap-phonmatchnet-en": ("e8f6c45bff04d7368cbe14979392b7d52dc88ba8", {
+        "config.json": "33b0a0decd5b563ebc67cd248008f8fcfcca8a2e71c03b79da9677470b7a619a",
+        "model.safetensors": "6cdb3f86b6ab57a00d47d3436b16c7ffd9c4b0d049cfcb98d49a478877213226",
+        "examples/said-mister.wav": "770afe00e123da53a8ef37be2b637083b2b84cdaeba59ab2d060878d349b2403",
+    }),
+    "google-speech-embedding-pytorch": ("ad7a3dd93b02f83797a040857425d6343d98680a", {
+        "config.json": "cd241bf118d3e16c74e3850ed6c75340216af00c8810835c95b8b620c6f22b6f",
+        "model.safetensors": "80a10015f4eb8ff9ba1aa10b56b1d6e27ef9f9f3419ebbae56fb43e9afce37be",
+    }),
+    "g2p-en-decoder-pytorch": ("fc55559c25a12fce6e0cf9062729e7f2a9fc1ddc", {
+        "config.json": "d1f02ff5209f688537731abdb849c5b793538abecdb5b9c19c1a0c0f25a03b11",
+        "model.safetensors": "bba37553a3414f90c7ed0cd465925aa15def67f42cc59bf43b8c633e1eb7b445",
+    }),
+}
+OUTPUTS = [
+    "phonmatchnet/model.onnx",
+    "phonmatchnet/config.json",
+    "google/model.onnx",
+    "google/config.json",
+    "g2p/encoder.onnx",
+    "g2p/decoder.onnx",
+    "g2p/config.json",
+]
+# Clip lengths cover the accepted range, both frame-length rules and every
+# boundary where N % 160 or N % 1280 changes the frame count.
+LENGTHS = [8000, 8001, 8159, 8160, 12800, 12801, 16000, 23999, 31840, 32000]
+KEYWORDS = ["hey computer", "said mister", "okay naptrap", "don't stop", "Café au lait", "a",
+            "supercalifragilisticexpialidocious", "the quick brown fox jumps over the lazy dog"]
+
+
+def sha256(path):
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+
+def fetch(cache):
+    """Download each pinned source file once and verify it."""
+    roots = {}
+    for repo, (commit, files) in SOURCES.items():
+        root = cache / repo / commit
+        for name, digest in files.items():
+            path = root / name
+            if not path.exists() or sha256(path) != digest:
+                path.parent.mkdir(parents=True, exist_ok=True)
+                url = HF.format(repo=repo, commit=commit, file=name)
+                print("download", url, file=sys.stderr)
+                with urllib.request.urlopen(url) as response:
+                    path.write_bytes(response.read())
+            if sha256(path) != digest:
+                raise SystemExit(f"{repo}/{name}: SHA-256 mismatch")
+        roots[repo] = root
+    return roots
+
+
+def dft_basis(window, n_fft, offset=0):
+    """[2*(n_fft//2+1), 1, taps] cos/-sin DFT rows with the window applied.
+
+    The window sits at ``offset`` inside the n_fft-point frame; taps after it
+    multiply zeros, so they are dropped.
+    """
+    bins = n_fft // 2 + 1
+    padded = torch.zeros(n_fft, dtype=torch.float64)
+    padded[offset:offset + window.numel()] = window.double()
+    n = torch.arange(n_fft, dtype=torch.float64)
+    angle = 2 * math.pi * torch.arange(bins, dtype=torch.float64)[:, None] * n[None, :] / n_fft
+    basis = torch.cat([torch.cos(angle), -torch.sin(angle)]) * padded
+    length = offset + window.numel()
+    return basis[:, :length].float().unsqueeze(1).contiguous()
+
+
+class GoogleGraph(nn.Module):
+    """naptrap GoogleSpeechEmbedding with its rfft frontend as a DFT convolution."""
+
+    def __init__(self, google):
+        super().__init__()
+        self.google = google
+        self.register_buffer("basis", dft_basis(google.window, 512))
+
+    def forward(self, waveform):
+        padded = F.pad(waveform, (11120, 0)).reshape(1, 1, -1)
+        spectrum = F.conv1d(padded, self.basis, stride=160)[0]
+        real, imag = spectrum[:257], spectrum[257:]
+        magnitude = torch.sqrt(real * real + imag * imag).transpose(0, 1)
+        log_mel = torch.log(magnitude @ self.google.mel_matrix + .001)
+        return self.google.encode_log_mel(log_mel)
+
+
+class PhonMatchNetGraph(nn.Module):
+    """naptrap PhonMatchNetwork with its centered STFT frontend as a DFT convolution."""
+
+    def __init__(self, network):
+        super().__init__()
+        self.network = network
+        frontend = network.audio.frontend
+        # torch.stft centers a 400-sample window inside the 512-point frame.
+        self.register_buffer("basis", dft_basis(frontend.window, 512, offset=56))
+        self.register_buffer("mel_matrix", frontend.mel_matrix.clone())
+
+    def forward(self, waveform, google, text):
+        samples = waveform.shape[0]
+        padded = F.pad(waveform.reshape(1, 1, -1), (256, 256), mode="reflect")
+        spectrum = F.conv1d(padded, self.basis, stride=160)[0]
+        real, imag = spectrum[:257], spectrum[257:]
+        power = (real * real + imag * imag).transpose(0, 1)
+        keyword_mel = torch.log10(power @ self.mel_matrix + 1e-7)
+        keyword_mel = keyword_mel[:(samples + 159) // 160].unsqueeze(0)
+        return self.network(keyword_mel, google.unsqueeze(0), text.unsqueeze(0))
+
+
+class G2PEncoderGraph(nn.Module):
+    """Grapheme IDs of one word (ending in </s>) -> final encoder GRU state.
+
+    The g2p_en cell has PyTorch's GRU gate layout (r, z, n with the reset gate
+    applied after the hidden projection), so nn.GRU exports it as an ONNX GRU.
+    The decoder's <pad> phoneme embedding is returned as the word separator.
+    """
+
+    def __init__(self, text):
+        super().__init__()
+        size = text.size
+        self.embedding = nn.Parameter(text.enc_emb.detach().clone())
+        self.gru = nn.GRU(size, size, batch_first=True)
+        cell = text.encoder
+        self.gru.weight_ih_l0.data.copy_(cell.w_ih)
+        self.gru.weight_hh_l0.data.copy_(cell.w_hh)
+        self.gru.bias_ih_l0.data.copy_(cell.b_ih)
+        self.gru.bias_hh_l0.data.copy_(cell.b_hh)
+        self.register_buffer("pad", text.dec_emb[0:1].detach().clone())
+
+    def forward(self, graphemes):
+        _, hidden = self.gru(self.embedding[graphemes].unsqueeze(0))
+        return hidden[0], self.pad
+
+
+class G2PDecoderGraph(nn.Module):
+    """One greedy decoder step: previous phoneme ID and state -> new state, logits."""
+
+    def __init__(self, text):
+        super().__init__()
+        self.text = text
+
+    def forward(self, token, hidden):
+        hidden = self.text.decoder(self.text.dec_emb[token], hidden)
+        return hidden, hidden @ self.text.fc_w.T + self.text.fc_b
+
+
+def export(module, path, args, inputs, outputs, axes):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    module.eval()
+    with torch.no_grad():
+        torch.onnx.export(module, args, str(path), input_names=inputs, output_names=outputs,
+                          dynamic_axes=axes, opset_version=OPSET, do_constant_folding=True, dynamo=False)
+    model = onnx.load(str(path))
+    # A constant output (the g2p separator) is folded into an initializer and
+    # loses its requested name; restore it with an Identity node.
+    for output, name in zip(model.graph.output, outputs):
+        if output.name != name:
+            model.graph.node.append(onnx.helper.make_node("Identity", [output.name], [name]))
+            output.name = name
+    onnx.checker.check_model(model, full_check=True)
+    # Drop the exporter's version stamp so the bytes depend only on the graph.
+    model.producer_version = ""
+    onnx.save(model, str(path))
+
+
+def companion_config(source_config, repo, commit, fmt, files, extra):
+    config = {
+        "format": fmt,
+        "source": {
+            "repo_id": "androiddrew/" + repo,
+            "commit": commit,
+            "format": source_config["format"],
+            "sha256": source_config["sha256"]["model.safetensors"],
+        },
+        "opset": OPSET,
+    }
+    config.update(extra)
+    config["sha256"] = {name: sha256(path) for name, path in files}
+    return config
+
+
+def write_json(path, value):
+    path.write_text(json.dumps(value, indent=2) + "\n")
+
+
+def build(roots, output):
+    pm_root = roots["naptrap-phonmatchnet-en"]
+    google_root = roots["google-speech-embedding-pytorch"]
+    g2p_root = roots["g2p-en-decoder-pytorch"]
+    model = PhonMatchNet(pm_root, google_root, g2p_root)
+    google, text = model.google_encoder, model.text_encoder
+    configs = {key: json.loads((roots[repo] / "config.json").read_text()) for key, repo in [
+        ("phonmatchnet", "naptrap-phonmatchnet-en"), ("google", "google-speech-embedding-pytorch"),
+        ("g2p", "g2p-en-decoder-pytorch")]}
+
+    wave = torch.zeros(16000)
+    export(GoogleGraph(google), output / "google/model.onnx", (wave,), ["waveform"], ["embeddings"],
+           {"waveform": {0: "samples"}, "embeddings": {0: "frames"}})
+    export(PhonMatchNetGraph(model._model), output / "phonmatchnet/model.onnx",
+           (wave, torch.zeros(12, 96), torch.zeros(9, 256)), ["waveform", "google", "text"], ["logit"],
+           {"waveform": {0: "samples"}, "google": {0: "google_frames"}, "text": {0: "positions"}})
+    export(G2PEncoderGraph(text), output / "g2p/encoder.onnx", (torch.tensor([5, 6, 2]),),
+           ["graphemes"], ["hidden", "separator"], {"graphemes": {0: "length"}})
+    export(G2PDecoderGraph(text), output / "g2p/decoder.onnx", (torch.tensor([2]), torch.zeros(1, 256)),
+           ["token", "hidden"], ["next_hidden", "logits"], {})
+
+    source = configs["phonmatchnet"]
+    commit = SOURCES["naptrap-phonmatchnet-en"][0]
+    write_json(output / "phonmatchnet/config.json", companion_config(
+        source, "naptrap-phonmatchnet-en", commit, "naptrap-phonmatchnet-onnx-v1",
+        [("model.onnx", output / "phonmatchnet/model.onnx")], {
+            "architecture": source["architecture"],
+            "task": source["task"],
+            "language": source["language"],
+            "thresholds": source["thresholds"],
+            "threshold_note": source["threshold_note"],
+            "inputs": {
+                "waveform": "[N] mono 16 kHz float32 in [-1, 1], 8000 <= N <= 32000",
+                "google": "[floor(N / 1280), 96] output of google/model.onnx for the same waveform",
+                "text": "[P, 256] g2p decoder features, 1 <= P <= 128",
+            },
+            "outputs": {"logit": "[1] keyword logit; score = sigmoid(logit)"},
+            "frontend": source["frontend"],
+            # The companion graphs this model was trained with, pinned like the
+            # PyTorch release pins its encoders.
+            "requires": {
+                "google": {"repo_id": "androiddrew/google-speech-embedding-onnx", "revision": "v1",
+                           "sha256": {"model.onnx": sha256(output / "google/model.onnx")}},
+                "g2p": {"repo_id": "androiddrew/g2p-en-decoder-onnx", "revision": "v1",
+                        "sha256": {"encoder.onnx": sha256(output / "g2p/encoder.onnx"),
+                                   "decoder.onnx": sha256(output / "g2p/decoder.onnx")}},
+            },
+        }))
+    source = configs["google"]
+    write_json(output / "google/config.json", companion_config(
+        source, "google-speech-embedding-pytorch", SOURCES["google-speech-embedding-pytorch"][0],
+        "naptrap-google-speech-embedding-onnx-v1", [("model.onnx", output / "google/model.onnx")], {
+            "embedding_size": source["embedding_size"],
+            "inputs": {"waveform": "[N] mono 16 kHz float32, N >= 1280"},
+            "outputs": {"embeddings": "[floor(N / 1280), 96]"},
+            "preprocessing": source["preprocessing"],
+        }))
+    source = configs["g2p"]
+    write_json(output / "g2p/config.json", companion_config(
+        source, "g2p-en-decoder-pytorch", SOURCES["g2p-en-decoder-pytorch"][0],
+        "naptrap-g2p-en-decoder-onnx-v1", [("encoder.onnx", output / "g2p/encoder.onnx"),
+                                           ("decoder.onnx", output / "g2p/decoder.onnx")], {
+            "hidden_size": source["hidden_size"],
+            "graphemes": GRAPHEMES,
+            "phonemes": source["phonemes"],
+            "start_token": 2,
+            "end_token": 3,
+            "max_decoder_steps": source["max_decoder_steps"],
+            "inputs": {
+                "encoder": "graphemes [L] int64: a word's grapheme IDs followed by </s> (2)",
+                "decoder": "token [1] int64 (start with 2), hidden [1,256] float32",
+            },
+            "outputs": {
+                "encoder": "hidden [1,256]; separator [1,256], the row placed between words",
+                "decoder": "next_hidden [1,256], one feature row; logits [1,74], argmax is the next token",
+            },
+        }))
+    return model
+
+
+class OnnxText:
+    """The Go engine's keyword algorithm, run with ONNX Runtime."""
+
+    def __init__(self, output):
+        self.encoder = onnxruntime.InferenceSession(str(output / "g2p/encoder.onnx"))
+        self.decoder = onnxruntime.InferenceSession(str(output / "g2p/decoder.onnx"))
+        self.index = {g: i for i, g in enumerate(GRAPHEMES)}
+
+    def __call__(self, normalized):
+        rows = []
+        for i, word in enumerate(normalized.split()):
+            ids = np.array([self.index.get(c, 1) for c in word] + [2], dtype=np.int64)
+            hidden, separator = self.encoder.run(None, {"graphemes": ids})
+            if i:
+                rows.append(separator)
+            token = 2
+            for _ in range(20):
+                hidden, logits = self.decoder.run(None, {"token": np.array([token], dtype=np.int64),
+                                                         "hidden": hidden})
+                token = int(logits.argmax())
+                if token == 3:
+                    break
+                rows.append(hidden)
+        return np.concatenate(rows)
+
+
+def verify(model, output, wav):
+    """Compare every graph with naptrap's PyTorch modules; fail outside tolerance."""
+    google_session = onnxruntime.InferenceSession(str(output / "google/model.onnx"))
+    pm_session = onnxruntime.InferenceSession(str(output / "phonmatchnet/model.onnx"))
+    text = OnnxText(output)
+    generator = torch.Generator().manual_seed(7)
+    clips = [("said-mister", wav)]
+    for n in LENGTHS:
+        noise = torch.randn(n, generator=generator) * 0.1
+        clips.append((f"noise-{n}", noise.clamp(-1, 1)))
+        if n >= wav.numel():
+            clips.append((f"said-mister-pad-{n}", F.pad(wav, (0, n - wav.numel()))))
+    worst = {"google": 0.0, "text": 0.0, "logit": 0.0}
+    keywords = {}
+    for keyword in KEYWORDS:
+        expected = model.keyword(keyword)
+        actual = text(expected.text)
+        if actual.shape != tuple(expected.features.shape):
+            raise SystemExit(f"text positions differ for {keyword!r}: {actual.shape} vs {tuple(expected.features.shape)}")
+        worst["text"] = max(worst["text"], float(np.abs(actual - expected.features.numpy()).max()))
+        keywords[keyword] = (expected, actual)
+    for name, clip in clips:
+        clip = clip.float().contiguous()
+        g_ref = model.google_encoder(clip)
+        (g_onnx,) = google_session.run(None, {"waveform": clip.numpy()})
+        worst["google"] = max(worst["google"], float(np.abs(g_onnx - g_ref.numpy()).max()))
+        mel_ref = model._frontend(clip)[0]
+        for keyword, (expected, features) in keywords.items():
+            ref = model.predict({"keyword_mel": mel_ref, "google": g_ref, "text": expected.features})
+            (logit,) = pm_session.run(None, {"waveform": clip.numpy(), "google": g_onnx, "text": features})
+            worst["logit"] = max(worst["logit"], abs(float(logit[0]) - ref.details["keyword_logit"]))
+    limits = {"google": 1e-3, "text": 1e-5, "logit": 1e-3}
+    for key, value in worst.items():
+        print(f"max |onnx - torch| {key}: {value:.3g} (limit {limits[key]:g})")
+    failed = [key for key, value in worst.items() if value > limits[key]]
+    if failed:
+        raise SystemExit("ONNX graphs differ from naptrap: " + ", ".join(failed))
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--cache", type=Path, default=Path(__file__).resolve().parent / ".cache")
+    parser.add_argument("--check", action="store_true", help="compare outputs with the committed models/")
+    args = parser.parse_args()
+    torch.manual_seed(0)
+    roots = fetch(args.cache)
+    if args.output.exists():
+        shutil.rmtree(args.output)
+    model = build(roots, args.output)
+    from naptrap import load_wav
+    verify(model, args.output, load_wav(roots["naptrap-phonmatchnet-en"] / "examples/said-mister.wav"))
+    if args.check:
+        changed = [name for name in OUTPUTS
+                   if not (REPO / "models" / name).exists()
+                   or sha256(args.output / name) != sha256(REPO / "models" / name)]
+        if changed:
+            raise SystemExit("differs from models/: " + ", ".join(changed))
+        print(f"all {len(OUTPUTS)} outputs match models/")
+
+
+if __name__ == "__main__":
+    main()

conversion/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "go-phonmatchnet-export"
+version = "0.1.0"
+description = "Convert naptrap's PyTorch PhonMatchNet models to the ONNX graphs go-phonmatchnet embeds"
+requires-python = "==3.12.*"
+dependencies = [
+    "naptrap==0.1.0",
+    "numpy==2.2.6",
+    "onnx==1.17.0",
+    "onnxruntime==1.22.1",
+    "safetensors==0.5.3",
+    "torch==2.6.0+cpu",
+]
+
+[tool.uv]
+package = false
+environments = ["sys_platform == 'linux' and platform_machine == 'x86_64'"]
+
+[tool.uv.sources]
+torch = { index = "pytorch-cpu" }
+
+[[tool.uv.index]]
+name = "pytorch-cpu"
+url = "https://download.pytorch.org/whl/cpu"
+explicit = true

conversion/uv.lock

@@ -0,0 +1,247 @@
+version = 1
+revision = 3
+requires-python = "==3.12.*"
+resolution-markers = [
+    "platform_machine == 'x86_64' and sys_platform == 'linux'",
+]
+supported-markers = [
+    "platform_machine == 'x86_64' and sys_platform == 'linux'",
+]
+
+[[package]]
+name = "coloredlogs"
+version = "15.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "humanfriendly", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cc/c7/eed8f27100517e8c0e6b923d5f0845d0cb99763da6fdee00478f91db7325/coloredlogs-15.0.1.tar.gz", hash = "sha256:7c991aa71a4577af2f82600d8f8f3a89f936baeaf9b50a9c197da014e5bf16b0", size = 278520, upload-time = "2021-06-11T10:22:45.202Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a7/06/3d6badcf13db419e25b07041d9c7b4a2c331d3f4e7134445ec5df57714cd/coloredlogs-15.0.1-py2.py3-none-any.whl", hash = "sha256:612ee75c546f53e92e70049c9dbfcc18c935a2b9a53b66085ce9ef6a6e5c0934", size = 46018, upload-time = "2021-06-11T10:22:42.561Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "4.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/35/c8/1d457d9150ff948f2ce6ada7715e0eeebbe5d3b58a45271a1e222474bcd3/filelock-4.1.1.tar.gz", hash = "sha256:7ba0927482c5a814b0a7f391d029ccdb8010f576f0a74c0dcde1811e8bc4c1b6", size = 563430, upload-time = "2026-10-11T16:11:54.373Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/8b/f837f52905395ba4510fe61f753c24833fb0a9c76e21267bb9f828b664a9/filelock-4.1.1-py3-none-any.whl", hash = "sha256:3f4a557945a7b0f95efeb1f432267affe5d45ac8ddde2aed1b97ebb62382c089", size = 132460, upload-time = "2026-10-11T16:11:52.753Z" },
+]
+
+[[package]]
+name = "flatbuffers"
+version = "25.12.19"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" },
+]
+
+[[package]]
+name = "fsspec"
+version = "2026.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/77/cd/9be253869fc42e764de7f3dedd6969af7d44ff9c3375214a3442a6f3fc08/fsspec-2026.9.0.tar.gz", hash = "sha256:0f08147951c8cb31d844c3547d631053b127863b60be04cf06e121333ee0e2fe", size = 333545, upload-time = "2026-09-18T17:50:42.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6c/c0/a98505f18594f1bce828bb159cec0fcf9860562f1a2c85913409fc8f3d9e/fsspec-2026.9.0-py3-none-any.whl", hash = "sha256:8dd6e646e99ea382bd85f97a45e6b526a442d79423a7dc673f1e2756d05fcb5f", size = 221738, upload-time = "2026-09-18T17:50:41.341Z" },
+]
+
+[[package]]
+name = "go-phonmatchnet-export"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "naptrap", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "numpy", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "onnx", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "onnxruntime", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "safetensors", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "torch", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "naptrap", specifier = "==0.1.0" },
+    { name = "numpy", specifier = "==2.2.6" },
+    { name = "onnx", specifier = "==1.17.0" },
+    { name = "onnxruntime", specifier = "==1.22.1" },
+    { name = "safetensors", specifier = "==0.5.3" },
+    { name = "torch", specifier = "==2.6.0+cpu", index = "https://download.pytorch.org/whl/cpu" },
+]
+
+[[package]]
+name = "humanfriendly"
+version = "10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cc/3f/2c29224acb2e2df4d2046e4c73ee2662023c58ff5b113c4c1adac0886c43/humanfriendly-10.0.tar.gz", hash = "sha256:6b0b831ce8f15f7300721aa49829fc4e83921a9a301cc7f606be6686a2288ddc", size = 360702, upload-time = "2021-09-17T21:40:43.31Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f0/0f/310fb31e39e2d734ccaa2c0fb981ee41f7bd5056ce9bc29b2248bd569169/humanfriendly-10.0-py2.py3-none-any.whl", hash = "sha256:1697e1a8a8f550fd43c2865cd84542fc175a61dcb779b6fee18cf6b6ccba1477", size = 86794, upload-time = "2021-09-17T21:40:39.897Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/38/9b/e422a865e1d5d57d0e509b4e0bf1c1a70a7f6382c29a5aa428df994c8bc8/markupsafe-3.0.4.tar.gz", hash = "sha256:2e9ad7dd851bf45fab9f75cbff4cb493fee9979e8d8c7c9c3ee119022518edd6", size = 153777, upload-time = "2026-10-02T23:07:22.29Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4f/a7/aeedb5140afa41fc74c225e9184ab96723a6e873b6ee1c9fede7283456d8/markupsafe-3.0.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e124f974786f831d6043728e38296969d3579db8896fe004682f5758e613581", size = 22985, upload-time = "2026-10-02T23:04:57.521Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/fe/fb1e79be0fea60aa32602ebefc9c35a82bb42b4df157285ab7dfec12341a/markupsafe-3.0.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c9a7f43c0b202b334cc9184af09bb8f21d3a209e038efaf106936fb69e6b026e", size = 23048, upload-time = "2026-10-02T23:05:04.479Z" },
+]
+
+[[package]]
+name = "mpmath"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" },
+]
+
+[[package]]
+name = "naptrap"
+version = "0.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "safetensors", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "torch", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/73/02/f32e8515c47f30688f191f35e594b74d1a70e176de57addddff950f73f3b/naptrap-0.1.0.tar.gz", hash = "sha256:d458c0999441710ea3d67622f7ef3c782c75a07624d44ecaacedfb93685ccb6d", size = 28457, upload-time = "2026-10-12T13:40:05.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d3/70/7c0d678b0e60eaad6712685172a4b943a1d37ba50b2e6bcc39de870329aa/naptrap-0.1.0-py3-none-any.whl", hash = "sha256:8dc2a77ff212a40d7fe4b57bb79961870c16a3b123571a87c346ca96cfc63e52", size = 25185, upload-time = "2026-10-12T13:40:04.606Z" },
+]
+
+[[package]]
+name = "networkx"
+version = "3.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/dc/76/3af777226b63a5e64a6b36b1ec5855c14e2b94a37096d4760e595fc43511/networkx-3.7.tar.gz", hash = "sha256:fd77a511bd90f39f3d016351345b52cf5319b813bdca01de3f755d3cca62e96a", size = 1866482, upload-time = "2026-09-21T16:45:16.974Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/cd/fe58041e9011f307c490e3e17dd48cc516448f7c698a3f2d9d9d65d7e6a8/networkx-3.7-py3-none-any.whl", hash = "sha256:e3fd2c13a7814cee3746340d8d7f8598a67f16a58bf47fb7f8793fab6efca1b0", size = 2142205, upload-time = "2026-09-21T16:45:14.609Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.2.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" },
+]
+
+[[package]]
+name = "onnx"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "protobuf", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9a/54/0e385c26bf230d223810a9c7d06628d954008a5e5e4b73ee26ef02327282/onnx-1.17.0.tar.gz", hash = "sha256:48ca1a91ff73c1d5e3ea2eef20ae5d0e709bb8a2355ed798ffc2169753013fd3", size = 12165120, upload-time = "2024-10-01T21:48:40.63Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/7c/67f4952d1b56b3f74a154b97d0dd0630d525923b354db117d04823b8b49b/onnx-1.17.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f3fb5cc4e2898ac5312a7dc03a65133dd2abf9a5e520e69afb880a7251ec97a", size = 16046307, upload-time = "2024-10-01T21:46:21.186Z" },
+]
+
+[[package]]
+name = "onnxruntime"
+version = "1.22.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coloredlogs", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "flatbuffers", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "numpy", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "packaging", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "protobuf", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "sympy", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0a/50/519828a5292a6ccd8d5cd6d2f72c6b36ea528a2ef68eca69647732539ffa/onnxruntime-1.22.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2d39a530aff1ec8d02e365f35e503193991417788641b184f5b1e8c9a6d5ce8d", size = 16475713, upload-time = "2025-07-10T19:15:45.452Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
+]
+
+[[package]]
+name = "protobuf"
+version = "7.36.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d9/89/5b8517baa72f84a67b8a307ba953c91057af618bf40bf676f3c03551f8f0/protobuf-7.36.2.tar.gz", hash = "sha256:497d0463ff3316681da6c0b9e8d06cb465d61abce00b613ab42226175644d1bb", size = 512737, upload-time = "2026-09-17T20:07:59.326Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/f3/3996583dd2906297a637af12114deddf7658af6e683fedb83be061983fb5/protobuf-7.36.2-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:89f23aa53c24553a2416fd4fd1ec06f74fa42b14b546d8883128813f775bbfd2", size = 343223, upload-time = "2026-09-17T20:07:54.931Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/04/d52c7016b04b6c5108f26691f9d33ec82a9b65d041f1a9c771137693d618/protobuf-7.36.2-py3-none-any.whl", hash = "sha256:bdb3a345d48db958e6ce1f18e508beb0cc981d64f24088427549c866cd039f1e", size = 179806, upload-time = "2026-09-17T20:07:58.211Z" },
+]
+
+[[package]]
+name = "safetensors"
+version = "0.5.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/71/7e/2d5d6ee7b40c0682315367ec7475693d110f512922d582fef1bd4a63adc3/safetensors-0.5.3.tar.gz", hash = "sha256:b6b0d6ecacec39a4fdd99cc19f4576f5219ce858e6fd8dbe7609df0b8dc56965", size = 67210, upload-time = "2025-02-26T09:15:13.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a6/f8/dae3421624fcc87a89d42e1898a798bc7ff72c61f38973a65d60df8f124c/safetensors-0.5.3-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cead1fa41fc54b1e61089fa57452e8834f798cb1dc7a09ba3524f1eb08e0317a", size = 471642, upload-time = "2025-02-26T09:15:00.544Z" },
+    { url = "https://files.pythonhosted.org/packages/40/ad/2b113098e69c985a3d8fbda4b902778eae4a35b7d5188859b4a63d30c161/safetensors-0.5.3-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:37f1521be045e56fc2b54c606d4455573e717b2d887c579ee1dbba5f868ece04", size = 643147, upload-time = "2025-02-26T09:15:11.185Z" },
+]
+
+[[package]]
+name = "setuptools"
+version = "84.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6d/44/f5da03a8ef95d369145c5bb53050e7877c9f3d312e128605fd9504829143/setuptools-84.0.0.tar.gz", hash = "sha256:f4695c21257f0d9b537ec2692c941d02ee143b7cc1276941349a546573b2ef73", size = 1168449, upload-time = "2026-08-08T18:27:58.365Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/9c/c510029fc6ef33a6275cd2c5d3cecd6613dfd6aa401d57c54f1c18852ccf/setuptools-84.0.0-py3-none-any.whl", hash = "sha256:51a52592b3b99e102b609654876bd65f19f999935166d1352678931132b0c670", size = 818216, upload-time = "2026-08-08T18:27:56.719Z" },
+]
+
+[[package]]
+name = "sympy"
+version = "1.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mpmath", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ca/99/5a5b6f19ff9f083671ddf7b9632028436167cd3d33e11015754e41b249a4/sympy-1.13.1.tar.gz", hash = "sha256:9cebf7e04ff162015ce31c9c6c9144daa34a93bd082f54fd8f12deca4f47515f", size = 7533040, upload-time = "2024-07-19T09:26:51.238Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b2/fe/81695a1aa331a842b582453b605175f419fe8540355886031328089d840a/sympy-1.13.1-py3-none-any.whl", hash = "sha256:db36cdc64bf61b9b24578b6f7bab1ecdd2452cf008f34faa33776680c26d66f8", size = 6189177, upload-time = "2024-07-19T09:26:48.863Z" },
+]
+
+[[package]]
+name = "torch"
+version = "2.6.0+cpu"
+source = { registry = "https://download.pytorch.org/whl/cpu" }
+dependencies = [
+    { name = "filelock", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "fsspec", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "jinja2", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "networkx", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "setuptools", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "sympy", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "typing-extensions", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+]
+wheels = [
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.6.0%2Bcpu-cp312-cp312-linux_x86_64.whl", hash = "sha256:59e78aa0c690f70734e42670036d6b541930b8eabbaa18d94e090abf14cc4d91", upload-time = "2025-01-30T00:38:31Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
+]

decoder.onnx

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

encoder.onnx

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