You need to agree to share your Hugging Face information to access this model

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

Log in or Sign Up to review the conditions and access this model content.

Pocket TTS Turkish (8 layers)

An open Turkish text-to-speech model that runs faster than real time on an ordinary CPU, with no GPU and no internet connection needed after the first download. It is a fine-tune of Kyutai's Pocket TTS, released by OrionCAF for the Turkish open-source community. The full training pipeline is on GitHub: Orion-CAF/pocket-tts-turkish.

A 24-layer Turkish teacher was trained first, then distilled into this 8-layer student, which needs one forward pass per audio frame instead of two.

Status: preliminary. The scores below come from a validation set. The held-out test set has not been run yet.

Quick start

Downloads are gated: open this page while logged in, click Agree and access repository once (approval is instant), then log in from the terminal with a read token from your settings.

pip install pocket-tts soundfile
hf auth login

pocket-tts generate \
  --config hf://OrionCAF/pocket-tts-turkish-8l/config.yaml \
  --voice voice_sample.wav \
  --text "Merhaba, bugΓΌn hava Γ§ok gΓΌzel."

The output is written to tts_output.wav (24 kHz mono).

from pocket_tts import TTSModel
import soundfile as sf

model = TTSModel.load_model(config="hf://OrionCAF/pocket-tts-turkish-8l/config.yaml")
voice = model.get_state_for_audio_prompt("voice_sample.wav")
audio = model.generate_audio(voice, "İstanbul ile Iğdır arasında uzun bir yol var.")
sf.write("out.wav", audio.numpy(), model.sample_rate)

Voice sample tips

The model was trained with voice samples of up to about 2 seconds, and it works best when the sample looks like that:

  • Use about 1.5–2 seconds of clean speech from one speaker. Longer samples make the output worse, not better.
  • Use a WAV or FLAC file. Clean, close-microphone speech without echo or music works best. Resampling to 16 kHz can help, since the training audio was 16 kHz.
  • Write numbers as words ("bin dokuz yΓΌz", not "1900"). Training text contained no digits.

Speed

Measured on an Apple M5 laptop CPU: about 8Γ— faster than real time (80 seconds of speech generated in 10.5 seconds, default settings).

Model

Architecture Pocket TTS: Transformer over continuous audio latents, Mimi codec, 24 kHz output
Backbone 8 Transformer layers, d_model 1024, ~105M trainable parameters
Tokenizer SentencePiece unigram, 4,000 pieces, trained on Turkish training transcripts
Guidance Classifier-free guidance (coefficient 2) distilled into the weights; sample with CFG 1
Weights EMA of training step 4,750

How it was trained

  1. Data. Common Voice 17 Turkish, filtered to 3–10 s clips without digits, silence or duplicates, then word-aligned with a Turkish wav2vec2 CTC model. Clips whose ASR transcript disagreed with the text were removed. Result: 14.2 h train, 2.8 h validation, 3.0 h test.
  2. Teacher. The released English 24-layer Pocket TTS fine-tuned on Turkish for 5,000 steps on one RTX 3090 (new text embedding, frozen Mimi codec, effective batch 64). Step 4,000 was selected by validation WER.
  3. Student (this model). Initialized from teacher layers 0–3 and 20–23, then trained for 5,000 steps (about 2.5 hours on one RTX 3090, 4.6 GiB peak GPU memory) to match the teacher's guidance-combined hidden states. The flow and end-of-speech heads stay frozen from the teacher.

The scripts and configs for every step are in Orion-CAF/pocket-tts-turkish.

Evaluation (preliminary, validation set)

100 fixed validation clips. Each clip's first part is the voice prompt and the model speaks the rest. The generated audio is transcribed with openai/whisper-small and compared with the reference text after Turkish-aware normalization.

Model WER CER
Teacher, 24 layers, CFG 2 0.315 0.120
This model, 8 layers, CFG 1 0.386 0.143
6-layer student, CFG 1 0.450 0.188
Real recordings (ASR error floor) 0.199 0.068

Three of the 100 clips are excluded for every model because Whisper looped on at least one model's output (for example repeating a phrase dozens of times on a 2-second clip). Including them, this model scores WER 0.802 and CER 0.538, which reflects those Whisper failures rather than the audio. A stronger ASR model will be used for the final test-set evaluation.

No listening study has been run. Speakers may overlap between the training and validation sets, so these numbers do not measure generalization to unseen speakers.

Fine-tuning on your own data

This is a starting point for further training with our training code, a fork of Kyutai's Pocket TTS with the Turkish data pipeline and configs. We have not run this exact recipe end to end yet.

  1. Get the code and this model:
    git clone https://github.com/Orion-CAF/pocket-tts-turkish && cd pocket-tts-turkish
    uv sync
    hf download OrionCAF/pocket-tts-turkish-8l --local-dir pocket-tts-turkish-8l
    
  2. Prepare a JSONL manifest, one line per clip: {"path": "clip.wav", "duration": 4.2, "transcript": "..."}. Use clips of 3–10 seconds.
  3. Add word timestamps with a Turkish CTC model:
    uv run python -m training.scripts.align_data train.jsonl train_aligned.jsonl \
      --model mpoyraz/wav2vec2-xls-r-300m-cv7-turkish --device cuda
    
  4. Write a config (my_finetune.yaml):
    model_config: pocket-tts-turkish-8l/config.yaml
    start_from_pretrained: true
    reset_text_embedding: false   # keep the Turkish tokenizer and embedding
    freeze_head: true             # keep the head the student was distilled against
    data:
      train_jsonl: train_aligned.jsonl
      valid_jsonl: valid_aligned.jsonl
      max_duration_sec: 10.0
      max_voice_prompt_sec: 2.0
    text_dropout: 0.0
    voice_dropout: 0.0
    optim: {lr: 5e-5, schedule: cosine, warmup_steps: 100}
    batch_size: 8
    grad_accum_steps: 8
    max_steps: 2000
    ema_decay: 0.999
    compile: false
    run_dir: runs/my_finetune
    
  5. Train and listen:
    uv run python -m training.train my_finetune.yaml
    uv run pocket-tts generate --config pocket-tts-turkish-8l/config.yaml \
      --checkpoint runs/my_finetune/checkpoint_00002000.pt \
      --voice voice_sample.wav --text "Merhaba!"
    

A single GPU with 8 GB of memory is enough for this model. The training code does full fine-tuning; LoRA is not built in yet.

Feedback and requests

Leave a comment in the Community tab if you want a LoRA recipe, a larger or smaller variant, a write-up of the full training pipeline, or if you build something with the model.

Limitations

  • Pronunciation is weaker than the teacher's, especially on long or rare words.
  • Voice cloning from samples much longer than 2 seconds, or recorded very differently from Common Voice, sounds noticeably worse.
  • Source audio is 16 kHz, so the 24 kHz output does not contain detail above 8 kHz.
  • Trained on 14 hours of read speech. Expect a read-aloud style and weaker results on spontaneous or emotional speech.
  • Numbers, abbreviations and foreign words are not normalized.

Use policy

This model inherits the use restrictions of Kyutai's Pocket TTS. Do not use it for:

  • voice impersonation or cloning without the explicit and lawful consent of the speaker;
  • presenting generated audio as genuine recordings of real people or events;
  • fraud, harassment, or privacy-invasive or otherwise harmful content.

Label generated audio as AI-generated when you share it.

License and attribution

Released under CC-BY-4.0. This model is derived from kyutai/pocket-tts by Kyutai (CC-BY-4.0), including the Mimi codec weights. Training data comes from Mozilla Common Voice (CC0).

Downloads last month
-
Safetensors
Model size
0.1B params
Tensor type
F32
Β·
Inference Providers NEW
This model isn't deployed by any Inference Provider. πŸ™‹ Ask for provider support

Model tree for OrionCAF/pocket-tts-turkish-8l

Finetuned
(72)
this model

Dataset used to train OrionCAF/pocket-tts-turkish-8l