zipformer-asr-turkish-v1

zipformer-asr-turkish-v1

Turns Turkish speech into text as it is spoken, with a small 20M-parameter streaming recognizer that runs in real time on one CPU core, for developers building voice features on edge devices.

Made by oayk on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: This is a Turkish speech recognizer of about 20M parameters, built to stream and to run on small devices. It turns audio into lowercase text as people speak. A single CPU core is enough for live use with the ONNX int8 files, at a 640 ms delay. Shorter 320 ms chunks and whole-recording decoding come from those same weights.

Who it suits: Developers who need Turkish speech to text on small machines will find it fits, as will researchers who compare Turkish recognizers. The output is plain spoken-form text with no punctuation.

Industry | Who uses it | How they use it | Example
Edge devices | Embedded developers | Run Turkish recognition on a single CPU core | Live captions on a small device
Customer service | Voice engineers | Transcribe Turkish speech as it arrives | A rough live transcript of a call
Media | Subtitle teams | Draft Turkish text from audio before editing | A first pass for subtitles
Research | Speech researchers | Compare error rates with other Turkish models | Checking scores on the FLEURS and MediaSpeech sets

If you need punctuated text or another language, you can skip it, since it outputs lowercase Turkish without punctuation.

Where to use it:

• sherpa-onnx, which the card recommends for devices
• A single desktop CPU thread, using the ONNX int8 files
• PyTorch and icefall, for the research decoding setups in the card
• Windows, macOS or Linux with Python, to download the files

Use case | Who | What they get back
Live transcription | Device developers | Turkish text as the audio streams in
Offline transcription | Analysts | Text from a whole recording, using full context
Score comparison | Researchers | Word error rates on two public Turkish test sets

How to set it up: You need Python and the packages the example imports. The audio must be 16 kHz mono.

• Python on Windows, macOS or Linux
• numpy, soundfile and sherpa_onnx, which the example imports
• 16 kHz mono audio, such as a WAV file

1. Install the Hugging Face hub package.
2. Download the model files.
3. Install the packages the example imports.
4. Point the example at the folder for the latency you want.

pip install -U huggingface_hub
hf download oayk/zipformer-asr-turkish-v1

How to use it: Run the streaming example with sherpa-onnx. It feeds 100 ms of audio at a time, the way a microphone would, and decodes as the audio arrives. Use the 320 ms folder for lower delay.

import numpy as np, soundfile as sf, sherpa_onnx

d = "streaming-640ms"   # or "streaming-320ms"
rec = sherpa_onnx.OnlineRecognizer.from_transducer(
    tokens=f"{d}/tokens.txt", encoder=f"{d}/encoder.int8.onnx",
    decoder=f"{d}/decoder.int8.onnx", joiner=f"{d}/joiner.int8.onnx",
    num_threads=1, sample_rate=16000, feature_dim=80, decoding_method="greedy_search",
    enable_endpoint_detection=True)

x, sr = sf.read("example.wav", dtype="float32")
s = rec.create_stream()
for i in range(0, len(x), 1600):          # feed 100 ms at a time, like a microphone
    s.accept_waveform(sr, x[i:i + 1600])
    while rec.is_ready(s):
        rec.decode_stream(s)

Tool | What it does
streaming-640ms | ONNX int8 files for 640 ms chunks, the card's default
streaming-320ms | ONNX int8 files for 320 ms chunks with lower delay
offline-full-context | ONNX int8 files that read the whole recording at once
sherpa_onnx OnlineRecognizer | Python class that takes audio in pieces and decodes it

Example: You feed a Turkish WAV file to the recognizer in 100 ms pieces. It decodes while the audio arrives and returns the words as lowercase Turkish, with numbers written out and no punctuation.

For newcomers and experts: Speech recognition turns spoken audio into written words. A good first step is to run the streaming example on a short 16 kHz mono recording and read the text it produces.

Under the hood sits a Zipformer2 encoder that only looks backward in time. A pruned RNN-T transducer writes the text, and an extra CTC head sits alongside it. An optional LSTM language model adds 10.2M parameters. With beam search, that language model and ILME, the card reports 5.28 percent on FLEURS with one normalizer and 6.50 with the other. Greedy ONNX int8 at 640 ms scores 8.05 and 6.80. The test sets are in-house and unreleased.

You feed 16 kHz mono audio in small pieces
The encoder reads each chunk as it arrives
The transducer head decodes tokens from it
Lowercase Turkish text comes out

Title: FLEURS Turkish word error rate, balbal normalizer, lower is better
Google Chirp 3 cloud: 1.72 percent
ElevenLabs Scribe cloud: 2.41 percent
Whisper large-v3: 3.77 percent
Whisper large-v3-turbo: 4.42 percent
This model, beam 8 with LM: 5.28 percent
This model, greedy ONNX int8: 6.80 percent

Good to know:

• License: apache-2.0, as listed on Hugging Face
• Cost to run: none named. The cloud systems in the comparison are only reference scores
• Data it reaches: the audio you feed it, and the source names no web or account access
• Turkish is the only listed language
• Not for: punctuated or capitalised output, since text comes out lowercase without punctuation
• Scores use the authors' own runs and two different text normalizers

On Hugging Face, 13 November 2026

• Task: automatic speech recognition
• Library: icefall
• Downloads in the last 30 days: 0
• Likes: 6
• License: apache-2.0
• Languages: tr
• Tags: icefall, onnx, automatic-speech-recognition, speech, turkish, streaming, zipformer, transducer, rnn-t, sherpa-onnx, edge

Links

• Model: https://huggingface.co/oayk/zipformer-asr-turkish-v1
• Files: https://huggingface.co/oayk/zipformer-asr-turkish-v1/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download oayk/zipformer-asr-turkish-v1

Then follow the usage in its model card. Nothing in this kit runs by itself.