How to Achieve 10x Faster, Real-Time, offline, Human-Like Voice Text-to-Speech with Piper TTS: A Tutorial for Local and Google Colab Setup

Learn How to Use Piper TTS for Local, CPU-Based AI-Driven Speech with Human-Like Quality — Step-by-Step Guide in Google Colab

👨🏾‍💻 GitHub ⭐️ | 👔LinkedIn |📝 Medium

Introduction

Text-to-speech (TTS) technology has become an essential tool in various fields, from accessibility enhancements to content creation. With AI-powered solutions, it’s now possible to generate natural-sounding voices in real-time, bringing an entirely new dimension to how we interact with technology. One such powerful tool is Piper TTS, an open-source, lightweight, and fast speech synthesis engine that can convert text into human-like speech with incredible efficiency.

In this blog, I’ll explore how you can leverage Piper TTS in Google Colab to create voice content quickly and efficiently. By the end, you’ll be equipped to generate speech using Piper TTS and understand why it stands out in the growing world of TTS solutions.

Why Piper TTS?

Piper TTS, developed by the Rhasspy community, offers several advantages that make it a compelling choice for developers, hobbyists, and content creators:

Speed: Piper is designed to be fast. Unlike cloud-based TTS systems that require network communication and can introduce latency, Piper operates locally, significantly reducing the time it takes to synthesize speech.
Quality: Piper offers high-quality, human-like voices using deep learning models such as ONNX, producing natural intonation and clarity.
Flexibility: Piper supports multiple languages and voices, allowing for a wide range of applications, from multilingual apps to region-specific projects. It supports over 30 languages and dialects, including Arabic, English (US and UK), Chinese, Spanish, French, and more.
Open-source: Being open-source means that Piper is free to use and can be modified and extended according to specific needs, making it a great choice for developers looking for customization.

Piper TTS supports over 30 languages and dialects. Here is the list of supported languages:

Arabic (ar_JO)
Catalan (ca_ES)
Czech (cs_CZ)
Welsh (cy_GB)
Danish (da_DK)
German (de_DE)
Greek (el_GR)
English (en_GB, en_US)
Spanish (es_ES, es_MX)
Finnish (fi_FI)
French (fr_FR)
Hungarian (hu_HU)
Icelandic (is_IS)
Italian (it_IT)
Georgian (ka_GE)
Kazakh (kk_KZ)
Luxembourgish (lb_LU)
Nepali (ne_NP)
Dutch (nl_BE, nl_NL)
Norwegian (no_NO)
Polish (pl_PL)
Portuguese (pt_BR, pt_PT)
Romanian (ro_RO)
Russian (ru_RU)
Serbian (sr_RS)
Swedish (sv_SE)
Swahili (sw_CD)
Turkish (tr_TR)
Ukrainian (uk_UA)
Vietnamese (vi_VN)
Chinese (zh_CN)

This wide range of language support makes Piper TTS versatile and suitable for a variety of global and regional applications.

Quality

Voices are trained at one of 4 “quality” levels:

x_low — 16Khz audio, 5–7M params
low — 16Khz audio, 15–20M params
medium — 22.05Khz audio, 15–20M params
high — 22.05Khz audio, 28–32M params

Multi-Speaker

Some voices contain multiple speakers, which captures the style of multiple people within a single model. Multi-speaker models can quickly switch between different speakers, but the quality of an individual speaker may be less than a single-speaker model.

Pros and Cons of Piper TTS

Pros

No Cloud Dependency: Since Piper runs entirely on local machines, there’s no need for an internet connection after installation. This makes it ideal for privacy-conscious users and applications in offline environments.
Fast Response: Local processing ensures low latency, enabling real-time speech synthesis in many use cases.
Customizability: Users have full control over the code and models, allowing for specific adaptations and optimizations.
Broad Language Support: With a wide range of supported languages, Piper caters to a global audience.

Cons

Initial Setup: Setting up Piper, especially on different platforms, might require some manual installation of dependencies and configuration, which could be challenging for beginners.
Hardware Requirements: Running Piper TTS locally requires a reasonably powerful machine, especially when working with high-quality voice models. Devices with limited computational power may struggle with performance.
Smaller Community: Being relatively new, Piper has a smaller community compared to well-established TTS solutions, which might limit the availability of pre-built models or resources.

Exploring Piper TTS with locally or Google Colab

I will demonstrate how to use Piper TTS on Google Colab, though the same process can be easily followed for local machines. Google Colab is a powerful platform for running Python code in the cloud. It provides free access to GPUs, making it an excellent environment for testing and deploying AI models. Let’s walk through the code that sets up and runs Piper TTS on Colab to create a voice from the text in real-time.

Step-by-Step Breakdown of the Code

Step 1: Install Required Dependencies

To start, I need to install the essential libraries and tools required for running Piper on a Colab environment. This includes libsndfile1, which is necessary for audio processing:

!apt-get update
!apt-get install -y build-essential wget unzip libsndfile1

Step 2: Download and Extract Piper Binary

Next, I create a directory for Piper TTS and download the Piper binary. This binary is the core executable that will handle the TTS operations:

!mkdir piper_tts
%cd piper_tts

!wget https://github.com/rhasspy/piper/releases/download/v1.2.0/piper_amd64.tar.gz
!tar -xzvf piper_amd64.tar.gz

I also make sure that the Piper binary is executable:

!chmod +x ./piper/piper

Step 3: Download the Voice Model

Piper supports a range of voices. In this example, I downloaded the en_US-amy-medium voice model, which provides a medium-sized model with high-quality synthesis:

!wget -O en_US-amy-medium.onnx https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_US/amy/medium/en_US-amy-medium.onnx?download=true
!wget -O en_US-amy-medium.onnx.json https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_US/amy/medium/en_US-amy-medium.onnx.json?download=true

For additional voice models in different languages, you can explore and download them directly from Hugging Face. Find a broader selection of voices here: Explore Piper Voices on Hugging Face.

Step 4: Define the text_to_speech Function

Now, I define a function that will convert text into speech using Piper TTS. The function uses a thread to handle the speech generation and playback, ensuring it runs smoothly in the Colab environment:

import threading
import os
import subprocess
from IPython.display import Audio, display

def text_to_speech(text):
    def run_speech():
        # Run Piper to generate the audio file
        subprocess.call(f'echo "{text}" | ./piper/piper --model en_US-amy-medium.onnx --output_file output.wav', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        
        # Play the audio using IPython.display.Audio
        display(Audio('output.wav', autoplay=True))

    # Create and start a thread for TTS
    tts_thread = threading.Thread(target=run_speech)
    tts_thread.start()
    tts_thread.join()  # Ensure TTS completes before returning

This function:

Executes the Piper binary with the provided text, voice model, and output file parameters.
Plays the generated audio file directly in the Colab notebook using IPython.display.Audio.

Example Usage

Finally, test the function by inputting some text for Piper to convert into speech:

text = "Coronavirus refers to a family of viruses known as Coronaviridae. These viruses are characterized by their crownlike spikes on their surfaces."
text_to_speech(text)

Get GitHub code: click here

Why This Approach is 10x Faster?

Piper’s speed comes from its local processing capabilities. Unlike cloud-based TTS services that require sending data over the internet, waiting for processing, and then receiving the audio, Piper performs all these steps locally on your machine or Colab’s VM. This reduces latency significantly and accelerates the response time, making it up to 10x faster for real-time applications. One of the key advantages of the Piper TTS model is its compact size, allowing it to deliver high-quality speech synthesis without requiring a powerful GPU. This makes it highly efficient and accessible, even for low-resource environments.

For example, Piper can run seamlessly on a Raspberry Pi, making it an excellent choice for edge devices and embedded systems.

Official GitHub Repo: https://github.com/rhasspy/piper?tab=readme-ov-file

Sample Voices: https://rhasspy.github.io/piper-samples/

Conclusion

Piper TTS is an excellent choice for those looking to implement fast and efficient TTS solutions without relying on the cloud. With its wide language support, high-quality voice models, and open-source nature, Piper empowers developers to create custom speech applications that are both powerful and private. Integrating Piper with Google Colab enhances its utility by providing a cloud-based environment for rapid prototyping and development.

If you’re looking for a TTS engine that offers flexibility, speed, and quality, Piper TTS is definitely worth exploring. Get started today and bring your text to life with the power of AI-driven speech synthesis.

Happy coding! 🎉

👨🏾‍💻 GitHub ⭐️ | 👔LinkedIn |📝 Medium

Thank you for your time in reading this post!

Make sure to leave your feedback and comments. See you in the next blog, stay tuned 📢

References

[1] Official GitHub Repo: https://github.com/rhasspy/piper?tab=readme-ov-file [2] Sample Voices: https://rhasspy.github.io/piper-samples/ [3] Hugging Face Piper models: https://huggingface.co/rhasspy/piper-voices

Enjoyed this article? Check out more of my work:

Unlock the Future of Document Retrieval: Explore the innovative fusion of Hypothetical Document Embedding (HyDE) and Retrieval-Augmented Generation (RAG) to transform how queries and documents align. Read more here.
Build Your Own AI Assistant: Discover a step-by-step guide to creating an AI assistant using GPT4All and Langchain, along with a performance comparison of Mixtral vs. Llama3. Check out the guide.
Run LLaMA3.1 and Gemma2 with Ollama: Learn how to run LLaMA3.1 and Gemma2 models locally or on Google Colab using Ollama. Find out how here.