Moonshine Streaming Tiny — Arabic
Arabic streaming speech recognition, 27.0M parameters. Same architecture as moonshine-ai/moonshine-streaming-tiny, trained for Arabic with a 12,288-entry Arabic tokenizer.
Moonshine Streaming pairs a 50 Hz time-domain audio frontend with a sliding-window Transformer encoder, so it transcribes incrementally rather than waiting for an utterance to finish. It is intended for on-device use on edge-class hardware.
Checkpoint identity
This repository is a conversion of one specific training checkpoint, recorded here because the weights behind a language move as later stages win:
| Checkpoint | ar12k_tiny_stageC_best.safetensors |
| Stage | C (read-speech mix) |
| Architecture | slinkier_prime_adapted |
| Tokenizer | tokenizer_ar12k.json, vocab 12,288 |
| Snapshot taken | 2026-08-24 |
| Parameters | 27.0M |
If you need reproducibility, pin the revision of this repository rather than
tracking main.
Usage
pip install --upgrade transformers datasets[audio]
from transformers import MoonshineStreamingForConditionalGeneration, AutoProcessor
import torch
model = MoonshineStreamingForConditionalGeneration.from_pretrained(
"moonshine-ai/moonshine-streaming-tiny-ar"
).eval()
processor = AutoProcessor.from_pretrained("moonshine-ai/moonshine-streaming-tiny-ar")
inputs = processor(audio, return_tensors="pt", sampling_rate=16000)
# Cap the output length. Like other seq2seq ASR models this one can fall into a
# repetition loop, and short or noisy clips are where it happens.
seq_lens = inputs.attention_mask.sum(dim=-1)
max_new_tokens = int((seq_lens * 6.5 / 16000).max().item()) + 2
generated = model.generate(**inputs, max_new_tokens=max_new_tokens)
print(processor.batch_decode(generated, skip_special_tokens=True)[0])
Pass the attention_mask. The encoder applies its per-layer sliding windows
only when it is given one; called without a mask it attends over the whole
utterance instead, which is a different model from the one that was trained. The
processor returns the mask, so the snippet above is the safe form. The processor
also pads audio to a whole number of 80-sample frames, which the frontend
requires.
Architecture
| Encoder | 6 layers, width 320, 8 heads, sliding windows (16, 4) on the first two and last two layers and (16, 0) between |
| Decoder | 6 layers, width 320, 8 heads, RoPE over 32 of each head's 40 dimensions |
| Frontend | 50 Hz features, CMVN, asinh compression, two causal stride-2 convolutions |
| Adapter | learned absolute positional embeddings before the decoder |
The lookahead layers give roughly 80 ms of lookahead; the intermediate layers have none.
Training data
Trained on a large-scale automatically labeled Arabic corpus:
- Podcast crawl, roughly 30,800 hours, pseudo-labeled.
- YouTube crawl, roughly 49,800 hours, pseudo-labeled.
- Crawled corpus, roughly 10,000 hours, pseudo-labeled and unaudited.
The crawled transcripts are pseudo-labels: they were produced by running a Whisper-family teacher model over crawled audio, not by human transcription. The model therefore inherits the teacher's error modes, including its handling of proper nouns, numerals and code-switching. No human-verified transcript was used for the bulk of training.
Evaluation
Arabic is scored on word error rate (WER), after the usual case and punctuation normalization. Mandarin and Japanese in this model family are instead scored on no-space CER, because they are written without spaces; every other language, this one included, uses WER.
suite_ar is Common Voice Arabic and FLEURS Arabic. The FLEURS panel is
Egyptian Arabic; Common Voice is broader but dominated by very short clips.
Modern Standard Arabic and the regional dialects are not measured separately,
and no dialect other than Egyptian is represented in the read-speech panel.
Do not quote a full-panel Arabic number from this card. The figures here are a seeded 400-clip sample. A wider Arabic measurement in our own notes reads 15.205, but it was taken on a 2,500-row draw of the 10,480-row Common Voice panel, so it is not a full-coverage result either. The numbers below are sound as relative measurements between these three builds, which is what they are for.
Seeded 400-utterance sample, batch 1
Batch 1 is the honest number for deployment. Batched evaluation zero-pads short clips up to the longest in the batch, and that trailing silence flatters the model.
| Panel | WER |
|---|---|
cv_ar | 17.91 |
fleurs_ar | 12.56 |
| macro | 15.231 |
This repository against the training checkpoint
These weights were converted from the neo training checkpoint, and the
conversion was checked by measurement rather than inspection: same seeded
sample, same batch size, same normalizer. A conversion that loads and emits
plausible text can still have a permuted weight mapping, which only a score
catches.
cv_ar | fleurs_ar | macro | |
|---|---|---|---|
| Training checkpoint | 17.91 | 12.56 | 15.231 |
| This repository | 17.86 | 12.56 | 15.207 |
399/400 and 400/400 transcripts are byte-identical.
The quantized build we ship
The .ort package served to the Moonshine deployment library is quantized to
int8 from these same weights, and scores 15.533 against 15.231 for the float
checkpoint on the same sample under the same stopping rule -- a cost of +0.302
WER. That build is a different artifact from this repository, which is float32.
Limitations
- Machine-labeled training data. See above; the model reproduces its teacher's mistakes as well as its strengths.
- Repetition loops on short clips. Like other seq2seq ASR models this one can fall into a repetition loop, and short or noisy clips are where it happens. Cap the output length, as the usage snippet does.
- Evaluated on 2 panels only. No evaluation of telephony, children's speech, heavy dialect, or noisy far-field conditions.
- Short-clip sensitivity. The Common Voice panel is 93% short clips, and short clips are where this architecture's stopping decision is weakest; int8 quantization costs four times as much on that panel as on FLEURS.
Out-of-scope use
Not intended for non-consensual surveillance, speaker identification, or high-stakes decisions.
License
MIT.