Tutorial Kokoro TTS: Text-to-Speech Open-Source yang Ringan dan Cepat

# Tutorial Lengkap Kokoro TTS: Text-to-Speech Open-Source yang Ringan dan Cepat **Penulis: Ruby Abdullah** **Tanggal: 8 September 2026** ## 1. Pendahuluan Text-to-Speech (TTS) adalah teknologi yang...

By Ruby Abdullah · · tutorial
Kokoro TTSText-to-SpeechOpen SourcePythonSpeech Synthesis

Tutorial Lengkap Kokoro TTS: Text-to-Speech Open-Source yang Ringan dan Cepat

Penulis: Ruby Abdullah Tanggal: 8 September 2026

1. 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 getpipeline(langcode):

if langcode 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

Artikel Terkait

Tutorial Lengkap Flower (flwr): Framework Federated Learning dengan Python

Tutorial Lengkap Flower (flwr): Framework Federated Learning dengan Python Federated learning adalah paradigma machine l...

Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng

Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng Apa itu Aisuite? Aisuite adalah library Python open...

Tutorial Lengkap Google Gemma: Model Open-Source dari Google DeepMind

Tutorial Lengkap Google Gemma: Model Open-Source dari Google DeepMind Google Gemma adalah keluarga model bahasa open-sou...

Tutorial Lengkap Neo4j: Graph Database untuk Knowledge Graphs dan AI

Tutorial Lengkap Neo4j: Graph Database untuk Knowledge Graphs dan AI Graph database telah menjadi komponen penting dalam...