Instructions to use OrionCAF/pocket-tts-turkish-8l with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Pocket-TTS
How to use OrionCAF/pocket-tts-turkish-8l with Pocket-TTS:
from pocket_tts import TTSModel import scipy.io.wavfile tts_model = TTSModel.load_model("OrionCAF/pocket-tts-turkish-8l") voice_state = tts_model.get_state_for_audio_prompt( "hf://kyutai/tts-voices/alba-mackenna/casual.wav" ) audio = tts_model.generate_audio(voice_state, "Hello world, this is a test.") # Audio is a 1D torch tensor containing PCM data. scipy.io.wavfile.write("output.wav", tts_model.sample_rate, audio.numpy()) - Notebooks
- Google Colab
- Kaggle
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
- 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.
- 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.
- 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.
- 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 - Prepare a JSONL manifest, one line per clip:
{"path": "clip.wav", "duration": 4.2, "transcript": "..."}. Use clips of 3β10 seconds. - 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 - 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 - 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
- -
Model tree for OrionCAF/pocket-tts-turkish-8l
Base model
kyutai/pocket-tts