Model reference · open weights

ufakzeka-kulak

Audio ufakai Speech→text 1 build Open weights 510 dl/mo

ufakzeka-kulak is an open-weight audio or speech model from ufakai. ufakzeka-kulak (BF16) weighs 126 MB; the smallest configuration that runs it is RTX 3060 12 GB.

For self-hosting, compare this build's requirements below with the GPU you plan to rent.

  • ufakzeka-kulak is a small Turkish speech-to-text model developed by ufak AI and released under the Apache-2.0 licence.
  • It features 31,564,935 parameters and is designed to run offline on a CPU for transcribing single utterances of Turkish audio.
  • The model supports multiple runtimes including NeMo, transformers, and sherpa-onnx, and it outputs text with basic punctuation while writing numbers as words.

Summary of the ufakai/ufakzeka-kulak model card, 2026-11-05

What it is

Released byufakai
Released2026-10-22
VRAM126 MB for the weights

What it runs on

Memory and cards for ufakzeka-kulak (BF16)

126 MBweights, file size
1.6 GBruntime overhead
CardOne streamMemory
RTX 3060 12 GBfits11.6 GB
RTX 4060 Ti 16 GBfits15.4 GB
RTX 3090 24 GBfits23.4 GB
RTX 4090 24 GBfits23.4 GB
RTX 5090 32 GBfits31.0 GB
L40S 48 GBfits44.0 GB
A100 80 GBfits78.2 GB
H100 80 GBfits78.1 GB
RTX PRO 6000 Blackwell 96 GBfits93.8 GB
DGX Spark (GB10) 128 GB unifiedfits107 GB
H200 141 GBfits138 GB
B200 180 GBfits176 GB

From the model card

What ufakai says about ufakzeka-kulak

Read the model card

ufakzeka-kulak ("kulak" is Turkish for ear) is a small Turkish speech-to-text model by ufak AI, trained from scratch and released under Apache-2.0. It runs offline on a CPU, and the same weights ship for NeMo, transformers, sherpa-onnx, parakeet.cpp (GGUF) and parakeet-mlx (MLX).

Read this before you try it

The model is meant for transcribing Turkish speech offline on a laptop, a server or in a browser page, where a licence that allows commercial use and a known list of training sources matter. Identifying, tracking or profiling the people who speak is out of scope, and so is acting on a transcript about a person without someone checking it.

Limits:

  • Turkish only. Other languages, and Turkish mixed with them, were not measured.
  • One utterance at a time. The released model is not a streaming model. Cut long recordings into utterances with voice activity detection and keep a few hundred milliseconds of audio around each one, as the demo does; a segment cut tight to the speech can come out without capitals or punctuation.
  • The model does not say who is speaking. Word timestamps were not evaluated.
  • Numbers come out as words. An application that needs digits must convert them.
  • Commas are often missed, with a comma recall of 0.359 on FLEURS Turkish test and 0.612 on Common Voice 27.0 Turkish test, against 0.839 and 0.939 for full stops.
  • Conversational speech is much harder. On Real-TurnTurk, a conversational test set with 6 speakers, normalised WER is 0.3807, against 0.0921 on FLEURS Turkish test; with so few speakers its interval is wide.
  • Most of the training text of the YODAS recordings (4,326.6 of 4,696.2 hours) was written by one speech recogniser and checked by another, wherever no uploader subtitle agreed with that transcript (see Training data). Errors on which the two agreed remain in the training text.
  • Accuracy by speaker gender, age or regional accent was not measured.
  • Each runtime has its own limits, listed under Known limitations.

Model summary

PropertyValue
Developed byufak AI
Modelufakzeka-kulak
LicenceApache-2.0
LanguageTurkish
Size31,564,935 parameters; the NeMo file is 126,955,520 bytes
ArchitectureFastConformer encoder (16 layers, width 256, 4 attention heads, time reduction 8) feeding two outputs, a token-and-duration transducer (TDT) decoder with durations 0, 1, 2, 3, 4 and a CTC head
VocabularySentencePiece BPE, 1,024 pieces, trained only on the training transcripts after decontamination
Inputmono audio at 16,000 Hz, 80 log-mel features, one utterance at a time
Outputwritten Turkish, described below
Trainingfrom scratch, on the sources listed under Training data; the training of this model ran on A100 80 GB GPUs for 52.3 GPU session hours, counting setup, validation passes and checkpoint saves as well as training steps

Output. The model writes Turkish with capital letters, full stops, commas, question marks, apostrophes and hyphens inside words. Other punctuation in the training text was mapped to these (an exclamation mark to a full stop, a semicolon or a colon to a comma). Numbers are written as words, so the model writes "iki bin yirmi ikide", not 2022'de. Circumflex letters are written without the circumflex.

Files and how to run them

Path in the repoRuntimePrecisionChecked against NeMo on the development sets
ufakzeka-kulak.nemoNeMo 3.0.0float32the reference
transformers-tdt/, transformers-ctc/transformers 5.20.1float32the same token ids as NeMo on every utterance (TDT yes, CTC yes)
sherpa-onnx-tdt/, sherpa-onnx-ctc/sherpa-onnx 1.13.8float32 and int8every shipped file, at input gain 8; CTC with the caller pad
gguf/parakeet.cpp v0.6.1f32 and q8_0both files, TDT and CTC
mlx/parakeet-mlx 0.5.3 with mlx 0.32.4, and our feature functionfloat32 weights, run at bfloat16TDT, with our feature function
LICENSE, ATTRIBUTION.mdthe Apache-2.0 licence of the weights, and the credits of every data source

"Checked" means that the file was decoded on Common Voice dev and FLEURS Turkish dev and its normalised WER stayed within 0.0050 of NeMo's on both sets, with no failed utterance; a reduced copy (int8, q8_0, or the MLX weights run at bfloat16) was also held to its full-precision copy by the same margin. The sherpa-onnx, parakeet.cpp and parakeet-mlx checks ran under Linux x86-64; parakeet.cpp and parakeet-mlx ran on the CPU. One SHA256SUMS file at the top level lists every file of the release, LICENSE and ATTRIBUTION.md included, except this card, SHA256SUMS itself and the Hub's .gitattributes. Add "SHA256SUMS" to the allow_patterns below, then sha256sum -c --ignore-missing SHA256SUMS (GNU coreutils) in the download folder checks the files you fetched.

Everything is in this one repo. The NeMo file sits at the top level, where NeMo's from_pretrained looks for it, and NeMo downloads only that file; each other runtime has its own folder, and the examples below download only the folder they use.

The examples below read speech.wav, one utterance of mono audio at 16,000 Hz. The install lines name the versions the files were checked with.

NeMo

The checkpoint holds both the TDT decoder and the CTC head; TDT is the default.

pip install "nemo_toolkit[asr]==3.0.0"
from nemo.collections.asr.models import ASRModel

model = ASRModel.from_pretrained("ufakai/ufakzeka-kulak")
print(model.transcribe(["speech.wav"])[0].text)

model.change_decoding_strategy(decoder_type="ctc")  # the CTC head
print(model.transcribe(["speech.wav"])[0].text)

transformers

pip install transformers==5.20.1 torch soundfile==0.14.0 huggingface_hub==1.33.0
import soundfile as sf
import torch
from huggingface_hub import snapshot_download
from transformers import ParakeetForTDT

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

Benchmarks

Reported results

As published on the model card: the maker's own numbers, not measured by AxForge.

TaskDatasetMetricScore
Speech recognitionFLEURS Turkish (test)WER (normalised)0.092
Speech recognitionFLEURS Turkish (test)CER (normalised)0.034
Speech recognitionCommon Voice Scripted Speech 27.0 Turkish (test)WER (normalised)0.092
Speech recognitionCommon Voice Scripted Speech 27.0 Turkish (test)CER (normalised)0.024
© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms