Tutorial Lengkap Kokoro TTS: Text-to-Speech Open-Source yang Ringan dan Cepat
Penulis: Ruby Abdullah Tanggal: 8 September 20261. Pendahuluan
Text-to-Speech (TTS) adalah teknologi yang mengubah teks menjadi suara secara otomatis. Teknologi ini digunakan di berbagai bidang mulai dari aksesibilitas, asisten virtual, pembuatan konten audio, hingga aplikasi edukasi. Namun, sebagian besar solusi TTS berkualitas tinggi bersifat proprietary dan berbayar, seperti Google Cloud TTS, Amazon Polly, atau ElevenLabs.
Di sinilah Kokoro TTS hadir sebagai alternatif yang menarik. Kokoro TTS adalah model text-to-speech open-source yang dikembangkan oleh komunitas dan tersedia di Hugging Face dengan nama hexgrad/Kokoro-82M. Dengan hanya sekitar 82 juta parameter, model ini sangat ringan dibandingkan model TTS lainnya yang biasanya memiliki ratusan juta hingga miliaran parameter.
Mengapa Memilih Kokoro TTS?
Ada beberapa alasan kuat mengapa Kokoro TTS layak menjadi pilihan utama untuk proyek text-to-speech Anda:
Open-Source dan Gratis: Kokoro TTS dirilis sebagai proyek open-source, sehingga Anda bebas menggunakannya untuk keperluan pribadi maupun komersial tanpa biaya lisensi. Kode sumbernya terbuka dan dapat dimodifikasi sesuai kebutuhan. Ringan dan Efisien: Dengan hanya 82 juta parameter, Kokoro TTS jauh lebih kecil dibandingkan model TTS modern lainnya. Ukuran model yang kecil ini berarti kebutuhan memori lebih rendah dan waktu loading lebih cepat. Inferensi Cepat: Salah satu keunggulan utama Kokoro TTS adalah kecepatannya. Model ini mampu melakukan inferensi dengan sangat cepat, bahkan ketika dijalankan hanya menggunakan CPU tanpa GPU. Hal ini membuatnya ideal untuk deployment di server dengan spesifikasi standar atau bahkan di perangkat edge. Dukungan Multi-Bahasa: Kokoro TTS mendukung berbagai bahasa termasuk Inggris (American dan British), Jepang, Korea, Mandarin, Prancis, Italia, Portugis (Brasil), dan Spanyol. Dukungan multi-bahasa ini membuatnya cocok untuk aplikasi internasional. Berbasis StyleTTS2: Kokoro menggunakan arsitektur yang terinspirasi dari StyleTTS2, sebuah pendekatan yang menggabungkan style transfer dengan text-to-speech. Hasilnya adalah suara yang natural dan ekspresif dengan kemampuan mengontrol gaya bicara. Voice Cloning dan Multi-Voice: Kokoro mendukung berbagai preset suara dan bahkan memungkinkan pencampuran suara (voice mixing) untuk menciptakan karakteristik suara yang unik.Dalam tutorial ini, kita akan membahas secara mendalam cara menginstal, menggunakan, dan mengoptimalkan Kokoro TTS untuk berbagai kebutuhan proyek Anda.
2. Instalasi
2.1 Prasyarat Sistem
Sebelum menginstal Kokoro TTS, pastikan sistem Anda memenuhi persyaratan berikut:
- Python 3.9 atau lebih baru
- pip (Python package manager)
- Minimal 2 GB ruang disk kosong
- RAM minimal 4 GB (disarankan 8 GB untuk performa optimal)
2.2 Instalasi espeak-ng
Kokoro TTS menggunakan espeak-ng sebagai backend untuk phonemization, yaitu proses mengubah teks menjadi representasi fonetik. Library ini harus diinstal terlebih dahulu di level sistem operasi.
Untuk Ubuntu/Debian:sudo apt-get update
sudo apt-get install -y espeak-ng
Untuk macOS:
brew install espeak-ng
Untuk Windows:
Download installer espeak-ng dari halaman resmi GitHub releases di https://github.com/espeak-ng/espeak-ng/releases, kemudian jalankan installer dan pastikan path-nya ditambahkan ke environment variable PATH.
Verifikasi instalasi espeak-ng:
espeak-ng --version
2.3 Instalasi Kokoro TTS via pip
Setelah espeak-ng terinstal, instalasi Kokoro TTS sangat sederhana menggunakan pip:
pip install kokoro
Perintah ini akan menginstal library kokoro beserta semua dependensinya termasuk PyTorch, soundfile, dan library pendukung lainnya.
Jika Anda ingin menginstal dengan dukungan GPU (CUDA), pastikan Anda sudah menginstal versi PyTorch yang sesuai terlebih dahulu:
pip install torch torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install kokoro
2.4 Instalasi Dependensi Tambahan
Untuk fitur lengkap, instal juga beberapa library pendukung:
pip install soundfile numpy scipy
2.5 Verifikasi Instalasi
Jalankan skrip berikut untuk memastikan instalasi berhasil:
import kokoro
print(f"Kokoro version: {kokoro.version}")
from kokoro import KPipeline
pipeline = KPipeline(langcode="a")
print("Kokoro TTS berhasil diinstal dan siap digunakan!")
Jika tidak ada error, berarti instalasi sudah berhasil. Saat pertama kali dijalankan, Kokoro akan mengunduh model dari Hugging Face secara otomatis. Model tersebut akan di-cache di direktori lokal sehingga tidak perlu diunduh ulang pada penggunaan berikutnya.
3. Penggunaan Dasar
3.1 Generate Suara dari Teks
Berikut adalah contoh paling dasar untuk menghasilkan suara dari teks menggunakan Kokoro TTS:
from kokoro import KPipeline
import soundfile as sf
Inisialisasi pipeline
langcode: 'a' = American English, 'b' = British English
'j' = Japanese, 'k' = Korean, 'z' = Chinese Mandarin
pipeline = KPipeline(langcode="a")
Generate suara dari teks
text = "Hello, welcome to Kokoro TTS tutorial. This is an open-source text to speech model."
generator = pipeline(text, voice="afheart")
Simpan hasil ke file WAV
for i, (gs, ps, audio) in enumerate(generator):
sf.write(f"output{i}.wav", audio, 24000)
print(f"Segment {i} berhasil disimpan ke output{i}.wav")
Pada kode di atas, KPipeline mengembalikan generator yang menghasilkan segmen-segmen audio. Setiap segmen terdiri dari graphemes (gs), phonemes (ps), dan data audio dalam format numpy array. Sample rate default adalah 24000 Hz.
3.2 Memilih Suara (Voice)
Kokoro TTS menyediakan berbagai preset suara yang bisa dipilih. Setiap suara memiliki karakteristik yang berbeda:
from kokoro import KPipeline
import soundfile as sf
pipeline = KPipeline(langcode="a")
Daftar beberapa voice yang tersedia untuk American English
voices = [
"afheart", # Female, warm and expressive
"afbella", # Female, clear and professional
"afnicole", # Female, soft and gentle
"afsarah", # Female, energetic
"amadam", # Male, deep and authoritative
"ammichael", # Male, natural and conversational
]
text = "Kokoro TTS supports multiple voice styles for natural speech synthesis."
for voice in voices:
generator = pipeline(text, voice=voice)
for i, (gs, ps, audio) in enumerate(generator):
filename = f"sample{voice}{i}.wav"
sf.write(filename, audio, 24000)
print(f"Voice '{voice}' disimpan ke {filename}")
3.3 Menggunakan Bahasa Lain
Kokoro TTS mendukung berbagai bahasa. Berikut cara menggunakan bahasa yang berbeda:
from kokoro import KPipeline
import soundfile as sf
Bahasa Jepang
pipelineja = KPipeline(langcode="j")
textja = "こんにちは、ココロテキストトゥスピーチへようこそ。"
generator = pipelineja(textja, voice="jfalpha")
for i, (gs, ps, audio) in enumerate(generator):
sf.write(f"japanese{i}.wav", audio, 24000)
Bahasa Korea
pipelineko = KPipeline(langcode="k")
textko = "안녕하세요, 코코로 텍스트 투 스피치에 오신 것을 환영합니다."
generator = pipelineko(textko, voice="kfalpha")
for i, (gs, ps, audio) in enumerate(generator):
sf.write(f"korean{i}.wav", audio, 24000)
Bahasa Mandarin
pipelinezh = KPipeline(langcode="z")
textzh = "你好,欢迎使用Kokoro文本转语音系统。"
generator = pipelinezh(textzh, voice="zfalpha")
for i, (gs, ps, audio) in enumerate(generator):
sf.write(f"mandarin{i}.wav", audio, 24000)
print("Semua file audio multi-bahasa berhasil di-generate!")
3.4 Menggabungkan Segmen Audio
Karena Kokoro memecah teks panjang menjadi beberapa segmen, Anda mungkin ingin menggabungkan semua segmen menjadi satu file audio:
from kokoro import KPipeline
import soundfile as sf
import numpy as np
pipeline = KPipeline(langcode="a")
text = """
Kokoro TTS is a remarkable open-source text to speech system.
It can generate high quality speech from text input.
The model is lightweight and can run efficiently on CPU.
This makes it perfect for various applications.
"""
Kumpulkan semua segmen audio
allaudio = []
generator = pipeline(text, voice="afheart")
for gs, ps, audio in generator:
allaudio.append(audio)
Gabungkan semua segmen
combinedaudio = np.concatenate(allaudio)
Simpan sebagai satu file
sf.write("combinedoutput.wav", combinedaudio, 24000)
print(f"Audio gabungan disimpan. Durasi: {len(combinedaudio)/24000:.2f} detik")
4. Penggunaan Lanjutan
4.1 Mengontrol Kecepatan Bicara
Anda dapat mengontrol kecepatan bicara dengan parameter speed:
from kokoro import KPipeline
import soundfile as sf
import numpy as np
pipeline = KPipeline(langcode="a")
text = "This sentence will be spoken at different speeds for demonstration purposes."
speeds = [0.7, 1.0, 1.3, 1.6]
for speed in speeds:
allaudio = []
generator = pipeline(text, voice="afheart", speed=speed)
for gs, ps, audio in generator:
allaudio.append(audio)
combined = np.concatenate(allaudio)
filename = f"speed{speed}.wav"
sf.write(filename, combined, 24000)
print(f"Speed {speed}x disimpan ke {filename} (durasi: {len(combined)/24000:.2f}s)")
Nilai speed 1.0 adalah kecepatan normal. Nilai lebih kecil dari 1.0 menghasilkan bicara yang lebih lambat, sedangkan nilai lebih besar dari 1.0 menghasilkan bicara yang lebih cepat. Disarankan untuk menggunakan rentang 0.5 hingga 2.0 untuk hasil yang optimal.
4.2 Voice Mixing
Fitur menarik dari Kokoro adalah kemampuan mencampur dua suara untuk menghasilkan karakteristik suara baru:
from kokoro import KPipeline
import soundfile as sf
import numpy as np
import torch
pipeline = KPipeline(langcode="a")
Load dua voice pack
voicea = pipeline.loadvoice("afheart")
voiceb = pipeline.loadvoice("afbella")
Campurkan dua suara dengan rasio tertentu
0.7 berarti 70% voicea dan 30% voiceb
mixratio = 0.7
mixedvoice = torch.lerp(voiceb, voicea, mixratio)
text = "This speech is generated using a mixed voice, combining two different voice styles."
allaudio = []
generator = pipeline(text, voice=mixedvoice)
for gs, ps, audio in generator:
allaudio.append(audio)
combined = np.concatenate(allaudio)
sf.write("mixedvoiceoutput.wav", combined, 24000)
print("Voice mixing berhasil! File disimpan ke mixedvoiceoutput.wav")
Voice mixing memungkinkan Anda menciptakan suara unik yang tidak tersedia dalam preset bawaan. Anda bisa bereksperimen dengan berbagai kombinasi dan rasio untuk menemukan karakter suara yang sesuai dengan kebutuhan proyek Anda.
4.3 Batch Processing
Untuk memproses banyak teks sekaligus, Anda bisa membuat fungsi batch processing:
from kokoro import KPipeline
import soundfile as sf
import numpy as np
import os
import time
def batchtts(texts, outputdir="batchoutput", voice="afheart", langcode="a"):
"""
Proses banyak teks sekaligus dan simpan ke file WAV terpisah.
Args:
texts: List of (filename, text) tuples
outputdir: Direktori output
voice: Voice preset yang digunakan
langcode: Kode bahasa
"""
os.makedirs(outputdir, existok=True)
pipeline = KPipeline(langcode=langcode)
results = []
starttime = time.time()
for filename, text in texts:
allaudio = []
generator = pipeline(text, voice=voice)
for gs, ps, audio in generator:
allaudio.append(audio)
combined = np.concatenate(allaudio)
outputpath = os.path.join(outputdir, f"{filename}.wav")
sf.write(outputpath, combined, 24000)
duration = len(combined) / 24000
results.append({
"file": outputpath,
"duration": duration,
"textlength": len(text)
})
print(f" Selesai: {filename}.wav ({duration:.2f}s)")
totaltime = time.time() - starttime
totalduration = sum(r["duration"] for r in results)
print(f"\nBatch processing selesai!")
print(f"Total file: {len(results)}")
print(f"Total durasi audio: {totalduration:.2f} detik")
print(f"Waktu proses: {totaltime:.2f} detik")
print(f"Real-time factor: {totaltime/totalduration:.3f}x")
return results
Contoh penggunaan
texts = [
("intro", "Welcome to our application. We are glad to have you here."),
("notification", "You have received a new message. Please check your inbox."),
("goodbye", "Thank you for using our service. Have a great day!"),
("error", "An error has occurred. Please try again later or contact support."),
("success", "Your operation was completed successfully. All changes have been saved."),
]
results = batchtts(texts, outputdir="appaudio", voice="afbella")
4.4 Streaming Audio
Kokoro TTS secara natural mendukung streaming karena menggunakan generator pattern. Berikut contoh integrasi streaming dengan aplikasi:
from kokoro import KPipeline
import soundfile as sf
import numpy as np
def streamtts(text, voice="afheart", langcode="a", callback=None):
"""
Stream audio segments satu per satu.
Setiap segmen bisa langsung diputar atau diproses lebih lanjut.
Args:
text: Teks yang akan di-convert
voice: Voice preset
langcode: Kode bahasa
callback: Fungsi yang dipanggil untuk setiap segmen audio
"""
pipeline = KPipeline(langcode=langcode)
generator = pipeline(text, voice=voice)
segmentcount = 0
for gs, ps, audio in generator:
segmentcount += 1
duration = len(audio) / 24000
print(f"Segment {segmentcount}: '{gs[:50]}...' ({duration:.2f}s)")
if callback:
callback(audio, segmentcount)
yield audio
Contoh: streaming dan simpan per segmen
longtext = """
Artificial intelligence has transformed many aspects of our daily lives.
From voice assistants to recommendation systems, AI is everywhere.
Text to speech technology is one of the most practical applications of AI.
It enables computers to communicate with humans through natural sounding speech.
Kokoro TTS makes this technology accessible to everyone through open source.
"""
allsegments = []
for audiosegment in streamtts(longtext, voice="afheart"):
allsegments.append(audiosegment)
Gabungkan semua segmen jika diperlukan
fullaudio = np.concatenate(allsegments)
sf.write("streamedoutput.wav", fullaudio, 24000)
print(f"\nTotal segmen: {len(allsegments)}")
print(f"Total durasi: {len(fullaudio)/24000:.2f} detik")
4.5 Integrasi dengan Flask API
Berikut contoh cara mengintegrasikan Kokoro TTS ke dalam REST API menggunakan Flask:
from flask import Flask, request, sendfile, jsonify
from kokoro import KPipeline
import soundfile as sf
import numpy as np
import io
import tempfile
app = Flask(name)
Inisialisasi pipeline saat startup (lazy loading)
pipelines = {}
def get
pipeline(langcode):
if lang
code not in pipelines:
pipelines[langcode] = KPipeline(langcode=langcode)
return pipelines[langcode]
@app.route("/tts", methods=["POST"])
def texttospeech():
data = request.json
text = data.get("text", "")
voice = data.get("voice", "afheart")
langcode = data.get("lang", "a")
speed = data.get("speed", 1.0)
if not text:
return jsonify({"error": "Parameter 'text' tidak boleh kosong"}), 400
if len(text) > 5000:
return jsonify({"error": "Teks terlalu panjang. Maksimal 5000 karakter."}), 400
try:
pipeline = getpipeline(langcode)
allaudio = []
generator = pipeline(text, voice=voice, speed=speed)
for gs, ps, audio in generator:
allaudio.append(audio)
combined = np.concatenate(allaudio)
# Simpan ke temporary file
tmp = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
sf.write(tmp.name, combined, 24000)
return sendfile(
tmp.name,
mimetype="audio/wav",
asattachment=True,
downloadname="speech.wav"
)
except Exception as e:
return jsonify({"error": str(e)}), 500
@app.route("/voices", methods=["GET"])
def listvoices():
voices = {
"americanenglish": [
{"id": "afheart", "gender": "female", "description": "Warm and expressive"},
{"id": "afbella", "gender": "female", "description": "Clear and professional"},
{"id": "afnicole", "gender": "female", "description": "Soft and gentle"},
{"id": "afsarah", "gender": "female", "description": "Energetic"},
{"id": "amadam", "gender": "male", "description": "Deep and authoritative"},
{"id": "ammichael", "gender": "male", "description": "Natural and conversational"},
],
"britishenglish": [
{"id": "bfemma", "gender": "female", "description": "British female"},
{"id": "bmgeorge", "gender": "male", "description": "British male"},
],
}
return jsonify(voices)
if name == "main":
app.run(host="0.0.0.0", port=5000, debug=True)
Untuk menggunakan API ini, Anda bisa mengirim request dengan curl:
curl -X POST http://localhost:5000/tts \
-H "Content-Type: application/json" \
-d '{"text": "Hello, this is a test.", "voice": "afheart", "speed": 1.0}' \
--output speech.wav
4.6 Konversi Format Audio
Secara default Kokoro menghasilkan audio WAV. Jika Anda membutuhkan format lain seperti MP3, gunakan library pydub:
from kokoro import KPipeline
import soundfile as sf
import numpy as np
from pydub import AudioSegment
import tempfile
import os
def generateaudio(text, voice="afheart", outputformat="mp3", outputpath="output"):
"""Generate audio dan konversi ke format yang diinginkan."""
pipeline = KPipeline(langcode="a")
allaudio = []
generator = pipeline(text, voice=voice)
for gs, ps, audio in generator:
allaudio.append(audio)
combined = np.concatenate(allaudio)
# Simpan sementara sebagai WAV
tmpwav = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
sf.write(tmpwav.name, combined, 24000)
# Konversi ke format target
audiosegment = AudioSegment.fromwav(tmpwav.name)
finalpath = f"{outputpath}.{outputformat}"
if outputformat == "mp3":
audiosegment.export(finalpath, format="mp3", bitrate="192k")
elif outputformat == "ogg":
audiosegment.export(finalpath, format="ogg")
elif outputformat == "flac":
audiosegment.export(finalpath, format="flac")
else:
finalpath = f"{outputpath}.wav"
os.rename(tmpwav.name, finalpath)
# Bersihkan file temporary
if os.path.exists(tmpwav.name):
os.unlink(tmpwav.name)
print(f"Audio disimpan ke {finalpath}")
return finalpath
Contoh penggunaan
text = "This audio will be exported in MP3 format for better compression."
generateaudio(text, outputformat="mp3", outputpath="compressedaudio")
5. Best Practices
5.1 Preprocessing Teks
Kualitas output audio sangat dipengaruhi oleh kualitas teks input. Berikut beberapa tips preprocessing teks sebelum dikirim ke Kokoro TTS:
import re
def preprocesstext(text):
"""
Bersihkan dan format teks sebelum di-convert ke speech.
"""
# Hapus whitespace berlebih
text = re.sub(r'\s+', ' ', text).strip()
# Ganti singkatan umum agar dibaca dengan benar
abbreviations = {
"Dr.": "Doctor",
"Mr.": "Mister",
"Mrs.": "Missus",
"etc.": "etcetera",
"vs.": "versus",
"e.g.": "for example",
"i.e.": "that is",
}
for abbr, full in abbreviations.items():
text = text.replace(abbr, full)
# Ganti simbol dengan kata
text = text.replace("&", " and ")
text = text.replace("%", " percent")
text = text.replace("+", " plus ")
text = text.replace("=", " equals ")
# Hapus karakter yang tidak perlu
text = re.sub(r'[~#]', '', text)
# Hapus URL
text = re.sub(r'https?://\S+', '', text)
# Pastikan ada spasi setelah tanda baca
text = re.sub(r'([.!?])([A-Z])', r'\1 \2', text)
return text.strip()
Contoh penggunaan
rawtext = "Dr. Smith said the results were great!Check https://example.com for details & more info."
cleantext = preprocesstext(rawtext)
print(f"Sebelum: {rawtext}")
print(f"Sesudah: {cleantext}")
5.2 Memilih Voice yang Tepat
Pemilihan suara yang tepat sangat berpengaruh terhadap kualitas dan kenyamanan mendengarkan audio yang dihasilkan. Berikut panduan pemilihan voice:
Untuk konten formal dan profesional (presentasi, laporan, narasi bisnis): Gunakan voice dengan karakter jelas dan tenang seperti afbella atau amadam. Kecepatan bicara sebaiknya diatur pada 0.9 hingga 1.0 agar terdengar profesional dan mudah diikuti.
Untuk konten edukatif (tutorial, e-learning, audiobook): Gunakan voice dengan karakter hangat dan ekspresif seperti afheart. Kecepatan bicara pada 0.85 hingga 0.95 memberi waktu bagi pendengar untuk mencerna informasi.
Untuk notifikasi dan sistem (alert, pesan singkat, navigasi): Gunakan voice yang jelas dan ringkas. Kecepatan bicara bisa sedikit lebih cepat pada 1.0 hingga 1.2 karena pesannya biasanya pendek.
Untuk konten kreatif (cerita, podcast, narasi): Eksperimen dengan voice mixing untuk menciptakan karakter suara yang unik. Variasikan kecepatan bicara sesuai konteks cerita.
5.3 Menangani Teks Panjang
Kokoro TTS secara otomatis memecah teks panjang menjadi segmen-segmen yang lebih kecil. Namun, untuk hasil terbaik, sebaiknya Anda melakukan segmentasi secara manual berdasarkan konteks semantik:
import re
import numpy as np
import soundfile as sf
from kokoro import KPipeline
def smartsegment(text, maxlength=500):
"""
Pecah teks panjang menjadi segmen berdasarkan paragraf dan kalimat.
Menjaga konteks agar intonasi lebih natural.
"""
# Pecah berdasarkan paragraf dulu
paragraphs = text.split('\n\n')
segments = []
for para in paragraphs:
para = para.strip()
if not para:
continue
if len(para) <= maxlength:
segments.append(para)
else:
# Pecah paragraf panjang berdasarkan kalimat
sentences = re.split(r'(?<=[.!?])\s+', para)
currentsegment = ""
for sentence in sentences:
if len(currentsegment) + len(sentence) + 1 <= maxlength:
currentsegment += (" " if currentsegment else "") + sentence
else:
if currentsegment:
segments.append(currentsegment)
currentsegment = sentence
if currentsegment:
segments.append(currentsegment)
return segments
def processlongtext(text, voice="afheart", outputpath="longoutput.wav"):
"""Proses teks panjang dengan segmentasi cerdas."""
pipeline = KPipeline(langcode="a")
segments = smartsegment(text)
allaudio = []
# Tambahkan jeda kecil antar paragraf (silence 0.3 detik)
silence = np.zeros(int(24000 0.3))
for i, segment in enumerate(segments):
print(f"Memproses segmen {i+1}/{len(segments)}: {segment[:60]}...")
generator = pipeline(segment, voice=voice)
for gs, ps, audio in generator:
allaudio.append(audio)
# Tambahkan jeda antar segmen
allaudio.append(silence)
combined = np.concatenate(allaudio)
sf.write(outputpath, combined, 24000)
duration = len(combined) / 24000
print(f"\nSelesai! Durasi total: {duration:.2f} detik")
print(f"File disimpan ke: {outputpath}")
return outputpath
Contoh dengan teks panjang
article = """
Artificial intelligence continues to evolve at a remarkable pace.
Recent advances in large language models have opened new possibilities
for human computer interaction. These models can understand context,
generate creative content, and assist with complex problem solving.
Text to speech technology has also seen significant improvements.
Modern TTS systems can produce speech that is nearly indistinguishable
from human voice. This has important implications for accessibility,
content creation, and education.
Kokoro TTS represents a new wave of open source TTS solutions.
By making high quality speech synthesis available to everyone,
it democratizes access to technology that was previously only
available through expensive commercial services.
"""
processlongtext(article, outputpath="articlenarration.wav")
5.4 Optimasi Performa
Untuk mendapatkan performa terbaik dari Kokoro TTS, perhatikan hal-hal berikut:
Gunakan pipeline tunggal: Buat satu instance KPipeline dan gunakan berulang kali. Jangan membuat instance baru untuk setiap request karena loading model membutuhkan waktu.
Cache voice pack: Jika Anda menggunakan voice yang sama berulang kali, load voice pack sekali dan simpan di variabel:
from kokoro import KPipeline
Singleton pattern untuk pipeline
class TTSEngine:
instance = None
pipelines = {}
voices = {}
@classmethod
def getinstance(cls):
if cls.instance is None:
cls.instance = cls()
return cls.instance
def getpipeline(self, langcode="a"):
if langcode not in self.pipelines:
self.pipelines[langcode] = KPipeline(langcode=langcode)
return self.pipelines[langcode]
def getvoice(self, pipeline, voicename):
if voicename not in self.voices:
self.voices[voicename] = pipeline.loadvoice(voicename)
return self.voices[voicename]
def synthesize(self, text, voice="afheart", langcode="a", speed=1.0):
pipeline = self.getpipeline(langcode)
allaudio = []
generator = pipeline(text, voice=voice, speed=speed)
for gs, ps, audio in generator:
allaudio.append(audio)
import numpy as np
return np.concatenate(allaudio) if allaudio else np.array([])
Penggunaan
engine = TTSEngine.getinstance()
audio = engine.synthesize("Hello world!", voice="afheart")
Batasi panjang teks per request: Proses teks dalam segmen yang wajar (300-500 karakter) untuk menjaga penggunaan memori tetap rendah dan mendapatkan latensi yang konsisten.
Monitor penggunaan memori: Untuk aplikasi yang berjalan lama seperti server API, pastikan untuk memantau penggunaan memori dan melakukan garbage collection secara berkala jika diperlukan.
5.5 Penanganan Error
Selalu implementasikan penanganan error yang baik dalam kode produksi:
from kokoro import KPipeline
import soundfile as sf
import numpy as np
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(name)
def safetts(text, voice="afheart", langcode="a", outputpath="output.wav"):
"""Generate TTS dengan penanganan error yang robust."""
# Validasi input
if not text or not text.strip():
logger.error("Teks input kosong")
return None
if len(text) > 10000:
logger.warning("Teks terlalu panjang, memotong ke 10000 karakter")
text = text[:10000]
try:
pipeline = KPipeline(langcode=langcode)
except Exception as e:
logger.error(f"Gagal inisialisasi pipeline: {e}")
logger.info("Pastikan espeak-ng sudah terinstal dan model sudah terunduh")
return None
try:
allaudio = []
generator = pipeline(text, voice=voice)
for gs, ps, audio in generator:
if audio is not None and len(audio) > 0:
allaudio.append(audio)
if not allaudio:
logger.error("Tidak ada audio yang dihasilkan")
return None
combined = np.concatenate(allaudio)
sf.write(outputpath, combined, 24000)
duration = len(combined) / 24000
logger.info(f"Audio berhasil disimpan ke {outputpath} ({duration:.2f}s)")
return outputpath
except Exception as e:
logger.error(f"Error saat generate audio: {e}")
return None
Penggunaan
result = safetts("Hello, this is a safe TTS call.", outputpath="safeoutput.wav")
if result:
print(f"Berhasil: {result}")
else:
print("Gagal generate audio")
6. Kesimpulan
Kokoro TTS adalah solusi text-to-speech open-source yang sangat menjanjikan. Dengan ukuran model hanya 82 juta parameter, Kokoro berhasil menawarkan kualitas suara yang natural dan ekspresif tanpa membutuhkan hardware yang mahal. Kemampuannya untuk berjalan dengan cepat di CPU membuatnya ideal untuk berbagai skenario deployment, mulai dari pengembangan lokal hingga server produksi.
Beberapa poin penting yang perlu diingat:
Kemudahan penggunaan: Instalasi Kokoro TTS sangat straightforward melalui pip, dan API-nya intuitif dengan pattern generator yang memungkinkan streaming secara natural. Dalam hitungan menit, Anda sudah bisa menghasilkan audio berkualitas tinggi dari teks.
Fleksibilitas: Dukungan multi-bahasa, berbagai preset suara, voice mixing, dan kontrol kecepatan memberikan fleksibilitas yang besar dalam menghasilkan audio sesuai kebutuhan. Anda bisa menggunakannya untuk berbagai keperluan mulai dari narasi audiobook, notifikasi aplikasi, hingga asisten virtual.
Kesiapan produksi: Dengan arsitektur yang ringan dan inferensi yang cepat, Kokoro TTS cocok untuk diintegrasikan ke dalam aplikasi produksi. Pattern singleton, caching voice pack, dan segmentasi teks yang cerdas akan membantu Anda membangun sistem TTS yang andal dan efisien.
Komunitas aktif: Sebagai proyek open-source di Hugging Face, Kokoro TTS terus berkembang dengan dukungan komunitas yang aktif. Model dan voice baru terus ditambahkan, dan Anda bisa berkontribusi langsung ke proyek ini.
Untuk memulai, cukup jalankan
pip install kokoro`, pastikan espeak-ng sudah terinstal di sistem Anda, dan mulai bereksperimen dengan contoh-contoh kode yang telah disediakan dalam tutorial ini. Selamat mencoba dan semoga tutorial ini bermanfaat untuk proyek Anda!
Referensi dan Sumber Daya:
- Repository Hugging Face: https://huggingface.co/hexgrad/Kokoro-82M
- Dokumentasi espeak-ng: https://github.com/espeak-ng/espeak-ng
- StyleTTS2 Paper: https://arxiv.org/abs/2306.07691