A 34 MB Turkish Text-to-Speech Model: I Tested It on My Laptop

Author: Prompt Engineer 48 · Watch on YouTube

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: A 34 MB Turkish Text-to-Speech Model: I Tested It on My Laptop · Channel: Prompt Engineer 48 · 12:10 · Watch on YouTube

Topics: AI evaluation and benchmarks, Model inference and optimization, Local and open-source models, Multimodal models

Summary

The video tests EMA Lightning, a Turkish-only text-to-speech model with 8.6 million parameters and roughly 34 MB of weights, on the creator’s laptop. It generates speech at 4.9–12.4 times real time on CPU and 95 times real time on an RTX 4060 laptop GPU, with the first streaming audio arriving after 0.13 seconds. The creator could not get the compiled Lightning mode working on Windows and did not independently verify the model card’s accuracy or quality scores. The model offers one voice, no voice cloning or emotion control, and an Apache 2.0 license.

Key points

EMA Lightning is a Turkish-only text-to-speech model by Canberk Aslan, with 8.6 million parameters and approximately 34 MB of weights.
The model card reports a 0.92% word error rate, but the creator did not run the benchmark and notes it was scored using Whisper.
The model generated audio at 4.9–12.4 times real time on CPU in the creator’s tests.
On an RTX 4060 laptop GPU, plain PyTorch generated a 13.37-second paragraph in an average of 0.14 seconds, or 95 times real time.
The compiled Lightning path did not finish compiling on the creator’s Windows setup, so the model card’s 440-times-real-time figure was not reproduced.
GPU streaming produced the first chunk in 0.13 seconds and finished the paragraph in 0.39 seconds across six chunks.
The speech.words method returns each spoken word with start and end times, which can support captions or karaoke.
A fixed seed reproduced an identical audio file, while changing the seed produced a different file of the same length.
The model has one voice, no voice cloning or emotion control, and supports Turkish only.
The model and code are licensed under Apache 2.0, according to the model card.

Chapters

Start	Chapter	Summary
00:01	Model overview and published claims	The creator introduces EMA Lightning, its size and architecture, and the model card’s benchmark and licensing claims.
03:36	Setup and CPU tests	After covering the demo and installation, the creator tests short, longer, and foreign-word sentences on CPU.
06:58	GPU speed and Windows compilation	The GPU test reaches 95 times real time, while the compiled Lightning path fails to complete on the creator’s Windows machine.
09:01	Streaming, word timestamps, and controls	The creator demonstrates streaming latency, per-word timestamps, speed settings, and repeatable output using a fixed seed.
10:36	Results, limitations, and verdict	The video summarizes what worked, notes unverified claims and model limitations, and recommends trying the small Apache-licensed model when one Turkish voice is sufficient.

Quotes

a Turkish text-to-speech model that is only 34 megabytes. — 00:01

It was generated in 1.34 seconds on the CPU — 05:56

for a model this small, the GPU itself is not the bottleneck — 07:29

The first chunk arrived after 0.13 seconds — 09:01

It has one voice, there’s no voice cloning, and no emotion control. — 11:07

Concepts and entities

EMA-lightning, Canberk Aslan, Canberk7/EMA-lightning, Hugging Face, PyTorch, Triton, DMD2, Whisper, normalizer-tr, Apache License 2.0

Full transcript (original language)

00:01 All right. In this video, we will see a Turkish text-to-speech model that is only 34 megabytes. And you can see here that it turned a 13-second Turkish paragraph into audio in about 1 and 1/2 seconds on the CPU. Now, mind you that everything here is running on my local system, this laptop with an RTX 4060 and 8 GB of memory. Let’s go ahead and test this out. So, this is called EMA lightning and it’s on Hugging Face from Canberk Aslan under the name EMA-lightning. It’s a

00:32 text-to-speech model for Turkish only. If you look here at the files, there are just two weight files. EMA.pt is 22.3 megabytes and decoder.pt is 12.1 megabytes and the whole repo is 36.9 megabytes. The card says the acoustic model has 5.6 million parameters. It’s a DIT and the vocoder has 3 million parameters, which gives you 8.6 million in total. The vocoder gives you 48 kHz audio and the generator runs in four sampling steps because it was distilled with something

01:02 called DMD2. So, it doesn’t need dozens of steps like a normal diffusion model. The license is Apache 2.0 for both the weights and the code. So, commercial use is allowed. That’s on the card. So, check it yourself before you ship anything. Now, if you look at the benchmark table, they test it on 495 Turkish sentences from Freya TR Eval and the word error rate they report is 0.92% in the same table. Trendyol TTS, which has 2.38 billion parameters, is at 0.98

01:33 and Eleven Labs V4 is at 1.43. Mind you, these are the authors’ numbers and the word error rate is scored by Whisper. So, some of the errors counted could be Whisper’s mistakes and not the voices. We’re going to test what we can on our own. The page we just saw on Hugging Face is the model card. The main repo is on GitHub under Canberk7/EMA-lightning. If you look here, it has 158 stars, 23 forks, five tags, and 15 commits. And the latest commit is a merged pull

02:03 request that fixes how a stream’s first window is decoded on CPU. In the file list, there’s src_ema_lightning for the package, tests, examples, a benches folder with the benchmark scripts, a docs folder, a change log, and a file called performance.md. That last file is where the speed numbers on the card come from. In performance.md, the word error rate is from Whisper large V3 on an 8 kHz band with three seeds, and the range is 0.79 to 1.05%.

02:34 The speed numbers are on an RTX 4090 three passes after warm-up. So, the claims come with a method, and that is why I could compare my laptop against them. On the change log, version 1.0.4 makes the weights load with weights only equals true, so a checkpoint can only hold tensors and cannot run code when it loads. And version 1.0.3 added speech.words, which I’ll show you in a minute. The PyPI page is version 1.0.4 released on October 8th. It links back to the GitHub repo, to the model on Hugging

03:06 Face, and to a package called normalizer-tr. That’s the text front end. And per the card, it reads numbers, dates, times, money, units, and abbreviations allowed before the model sees them. Back on Hugging Face, the files tab shows 17 commits, and the model has 323 likes. On the author’s page, Canberk Aslan has two models, this one and an older one called ema-tts. And there is a space, which is a web demo. The official space is called EMA

03:36 lightning Turkish text-to-speech. You type Turkish text, press generate speech, and it has speed, seed, and sample rate options. The same ones we used in code. It runs on zero GPU, so you can try it without installing anything. I’m not going to type into it in this video, but the link is in the description. Setup is very simple. I made a fresh virtual environment and then pip install e main lightning. The version I got is 1.0.4. One thing to note here, the plain install pulled the CPU build of PyTorch for me. That’s fine for the first test.

04:08 Later, I’ll swap it to the CUDA build for the GPU run. Now, for using it, what you can do is import EMA from e main lightning, make one EMA object, and call dot say with your text. I’m passing device equals CPU. If you look at the signature, say takes text, speed, a seed, a sample rate, and a path where it saves the wave file. The default sample rate is 48,000. Let’s go ahead and run my first test. The text is a short one, a greeting and a comment about the weather.

04:39 The first load took 10.2 seconds on my machine and loading again afterwards takes about 1 and 1/2 seconds. That clip is 2.52 seconds of audio. It took 0.27 seconds to generate, so about nine times faster than real time on CPU with no GPU at all. Now, let’s make it harder. I wrote a sentence with a date, a time, and a price.

05:10 That one is 7.32 seconds of audio generated in 0.59 seconds, so about 12 times real time. If you are Turkish speaker, listen to how it reads the date and the price because that’s where text-to-speech usually breaks. I’m not a native speaker, so put your own opinion in the comments. Next, a long one. It’s a paragraph about the Bosphorus, 241 characters, and the output is 13.37 seconds of audio.

05:56 >> It was generated in 1.34 seconds on the CPU, which is 9.95 times faster than real time. So, that’s roughly a paragraph of a book in a second and a half on a laptop CPU from a 34 megabyte model. Now, the last CPU test is the one the card warns about. The card says foreign words get read with Turkish spelling rules. So, I wrote a sentence with the words GitHub and YouTube inside it. That one is 4.2 seconds of audio, we

06:27 0.86 seconds to generate, and it’s the slowest of the four at 4.9 times real time. It’s a short clip, so the fixed cost shows up more. Listen to how GitHub and YouTube come out, and you’ll hear whether the Turkish spelling rule hurts you. So, across these four CPU runs, you can see the speed is between 4.9 and 12.4 times real time. The card says about six times on CPU, and my numbers are in the same range on a 16-core laptop.

06:58 Now, for the GPU, the first thing I did was replace the CPU PyTorch with the CUDA build. I used that CU128 wheel, and torch.cuda.is available now prints true. I’m running the same Boss First Paragraph, 13.37 seconds of audio, five times after one warm-up call and averaging. The average was 0.14 seconds per call, which is 95 times real time on an RTX 4060 laptop GPU. Here’s the part worth noticing. The card says plain PyTorch gets 87 times real

07:29 time on an RTX 4090. My laptop card got 95, so for a model this small, the GPU itself is not the bottleneck, and a 4060 is enough. The 440 times real time number on the card is for the compiled path and that one I could not reproduce. So, let me show you what happened. The card says to call {dot} lightning on the model to turn on the fast path. On Windows, the first time I called it, PyTorch complained that it cannot find a working Triton installation and recorded graphs without compiling. So, I

08:00 installed the Triton Windows package and ran it again. This time it started compiling and I let it run for 5 minutes and it did not finish. I stopped it there. So, I can’t tell you the lightning number for this laptop. It may work on Linux, it may need the Visual Studio build tools or it may just need more time. If you have it working on Windows, tell me how in the comments. What I can tell you is that you don’t need it. Plain mode is already 95 times real time here. One more thing in the API, there’s a method called best batch size and on my

08:30 card it says 32. The card says batch 64 reaches 1,316 times real time with compile and 952 with plain PyTorch on a 4090. I did not run batch mode, so I’m just pointing at the card for that one. Now, streaming, instead of say you call {dot} stream with the text and it gives you audio chunks as they’re generated. This is what you’d use for a voice assistant where you want sound to start before the sentence is finished. I timed it on the GPU with the same Bosphorus paragraph. The first chunk

09:01 arrived after 0.13 seconds and the whole thing finished in 0.39 seconds in six chunks. The card says the first chunk is about 1 second of audio, so you hear speech about a seventh of a second after you ask for it. And that’s with plain PyTorch. No compile for a chatbot that talks Turkish, that’s already fast enough that you wouldn’t notice a delay. The card also mentions a scheduler called playhead for serving multiple callers at once. I haven’t tested that, so I’m not going to claim anything about it. Now, speech {dot} words from that change

09:32 log, every spoken word comes back with a start and an end in seconds, so you can build captions or karaoke from it. I ran it on the short greeting Merhaba starts at zero and ends at 0.6, then ben, then emma, then bugun, hava, chok, and zilan. And the last word ends at 2.52 seconds, which matches the clip length exactly. The fields on each word are just text, start, and end. Two more options before the verdict speed. I ran the same short greeting at 0.8, 1.0, and 1.5. The clip is 3.12

10:05 seconds, 2.52 seconds, and 1.72 seconds. So, speed changes the length of the audio and the card says it goes from 0.25 to 4. And seed, I generated the same sentence with seed one twice, and the two wave files are byte for byte identical. I checked with an MD5 hash. With seed two, the file is different, but the length is the same, 2.52 seconds. So, if you want

10:36 the same take again, keep the seed. So, let me go through what I actually saw, what worked. pip install and the first say call on a fresh environment, 34 megabytes of weights. On CPU, 4.9 to 12.4 times real time. On the GPU, 95 times real time. And the first streaming chunk in 0.13 seconds. What didn’t work for me, the lightning compile on Windows. I couldn’t get a

11:07 number for it, and the 440 times on the card is not something I reproduced. What I did not check, the word error rate. That takes the 495 sentences and a whisper pass, and I did not run it. So, 0.92% is the author’s number, not mine. Same for the quality score, UT MOS of 3.3 and the playhead scheduler. And the limits, the card states itself. It has one voice, there’s no voice cloning, and no emotion control. It’s Turkish only. The card says it was

11:37 trained on about 1,000 hours of internal single speaker data, so you can’t pick another speaker. So, in this video we have seen how we can run EMA Lightning at Turkish text-to-speech model of 8.6 million parameters with pip install and a few lines of Python. On my laptop, it ran at up to 12 times real time on the CPU and 95 times on the RTX 4060. If you need Turkish speech for an app, uh bot, or an offline tool, and one voice is enough, this is worth trying because the whole thing is uh 34 megabytes and the license is Apache 2.0.

12:10 If you’re interested, you can go ahead and check this out and try this out on your own system as well, and let me know how it goes, especially if you got the lightning mode working on Windows. The model is EMA Lightning by Canberk Aslan on Hugging Face, and the link is in the description. I’ll see you in another one. Check out the next video.