ONNX Runtime export of Qwen/Qwen3-ForcedAligner-0.6B, the forced-aligner that produces word-level timestamps for Qwen3-ASR output. int4 quantized for CPU / DirectML / CUDA inference without a PyTorch runtime. Produced as part of a from-scratch ONNX + C# inference PoC.

Source & License

This is a derivative work of Qwen/Qwen3-ForcedAligner-0.6B, which is licensed under Apache-2.0. This repository is released under the same license; a copy is included in LICENSE.

Changes made to the original model:

Exported the encoder and decoder to ONNX graphs (ONNX Runtime / opset).
Quantized weights to int4 (external data files).
Precomputed mel-spectrogram DSP constants (hann_400.f32, mel_filters.f32).

No model architecture or training was changed; this is a format/precision conversion. The aligner shares the Qwen3-ASR-0.6B architecture (encoder 24 layers + decoder 28 layers, hidden 1024) but runs as a single forward pass (no autoregressive decode loop): each <timestamp> slot's argmax × 80 ms gives the word boundary time.

Files

File	Purpose
`encoder.int4.onnx(+.data)`	Audio encoder (mel → audio features), int4
`decoder_init.int4.onnx(+.data)`	Decoder forward pass producing `<timestamp>` logits, int4
`vocab.json`, `merges.txt`	Byte-level BPE tokenizer (vocab + merge ranks)
`hann_400.f32`, `mel_filters.f32`	Precomputed Hann window & mel filterbank for the front-end

Usage

Produces word-level start/end times for a transcript (e.g. from qwen3-asr-0.6b-onnx). It is a single forward pass — no autoregressive loop. pip install onnxruntime numpy soundfile tokenizers:

python

import numpy as np, onnxruntime as ort, soundfile as sf
from huggingface_hub import snapshot_download
from tokenizers import Tokenizer, models, pre_tokenizers

MODEL_DIR = snapshot_download("jinhwan000/qwen3-aligner-0.6b-onnx")
WAV = "audio.wav"                          # 16 kHz mono
ASR_TEXT = "the transcription to align"    # from your ASR model

AUDIO_START, AUDIO_END, AUDIO_PAD, TSID, SEG = 151669, 151670, 151676, 151705, 0.08  # 80 ms / bucket

def log_mel(audio):  # whisper-compatible log-mel using the shipped DSP constants
    NFFT, HOP, NMELS, NBINS = 400, 160, 128, 201
    hann = np.fromfile(f"{MODEL_DIR}/hann_400.f32", np.float32)
    melf = np.fromfile(f"{MODEL_DIR}/mel_filters.f32", np.float32).reshape(NMELS, NBINS)
    x = np.pad(audio, NFFT // 2, mode="reflect")
    nfr = 1 + (len(x) - NFFT) // HOP
    frames = np.stack([x[i*HOP:i*HOP+NFFT] * hann for i in range(nfr)])
    spec = np.fft.rfft(frames, n=NFFT, axis=1)
    mel = np.log10(np.maximum((spec.real**2 + spec.imag**2) @ melf.T, 1e-10))
    mel = np.maximum(mel, mel.max() - 8.0)
    return ((mel + 4.0) / 4.0)[:-1].T.astype(np.float32)[None]   # [1,128,T] (drop last frame)

# byte-level BPE from vocab.json + merges.txt (this repo has no tokenizer.json)
tk = Tokenizer(models.BPE.from_file(f"{MODEL_DIR}/vocab.json", f"{MODEL_DIR}/merges.txt"))
tk.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=False, use_regex=True)

audio, sr = sf.read(WAV, dtype="float32")
if audio.ndim > 1: audio = audio.mean(1)
assert sr == 16000, "expects 16 kHz mono"
words = ASR_TEXT.split()

enc = ort.InferenceSession(f"{MODEL_DIR}/encoder.int4.onnx",      providers=["CPUExecutionProvider"])
dec = ort.InferenceSession(f"{MODEL_DIR}/decoder_init.int4.onnx", providers=["CPUExecutionProvider"])

af = enc.run(["audio_features"], {"mel": log_mel(audio)})[0]      # [1, N, 1024]
N = af.shape[1]

# input = audio pads + per-word (BPE tokens + two <timestamp> slots: start, end)
ids = [AUDIO_START] + [AUDIO_PAD]*N + [AUDIO_END]
for w in words:
    ids += tk.encode(w).ids + [TSID, TSID]
S = len(ids)

logits = dec.run(["logits"], {
    "input_ids":      np.array([ids], np.int64),
    "position_ids":   np.arange(S, dtype=np.int64)[None],
    "audio_features": af,
    "audio_offset":   np.array([1], np.int64)})[0]   # first audio-pad slot index

arg = logits[0].argmax(-1)                            # logits last dim = 5000 timestamp buckets
buckets = [int(arg[i]) for i in range(S) if ids[i] == TSID]   # 2 per word
for k, w in enumerate(words):
    print(f"{buckets[2*k]*SEG:6.2f} - {buckets[2*k+1]*SEG:6.2f}  {w}")

Each <timestamp> slot's argmax × 80 ms gives the boundary time. Validation against the reference aligner: timestamp buckets matched 62/62 (fp32) / 61/62 (int4, max 1 bucket = 80 ms); BPE tokenization matched 239/239 input ids.

Disclaimer

Experimental PoC artifacts; no production guarantees. For the canonical model, use Qwen/Qwen3-ForcedAligner-0.6B.