Pengenalan Suara Python: Kupas Tuntas Pemrosesan Sinyal Audio

Di dunia yang semakin didominasi oleh perintah suara—mulai dari meminta petunjuk arah pada smartphone hingga mengendalikan perangkat rumah pintar—teknologi Pengenalan Ucapan Otomatis (Automatic Speech Recognition/ASR) telah terintegrasi dengan mulus ke dalam kehidupan kita sehari-hari. Namun, pernahkah Anda berhenti sejenak untuk bertanya-tanya apa yang terjadi di antara saat Anda mengucapkan perintah dan perangkat Anda memahaminya? Ini bukan sihir; ini adalah proses canggih yang berakar pada penelitian selama puluhan tahun, dan fondasinya adalah pemrosesan sinyal audio.

Bagi komputer, audio mentah hanyalah serangkaian angka panjang yang mewakili gelombang tekanan. Data ini tidak memiliki makna inheren. Langkah pertama yang krusial dalam alur kerja ASR mana pun adalah mengubah data mentah yang tidak dapat dipahami ini menjadi representasi terstruktur yang dapat diinterpretasikan oleh model machine learning. Transformasi inilah yang menjadi inti dari pemrosesan sinyal audio.

Panduan ini ditujukan untuk developer Python, ilmuwan data, insinyur machine learning, dan siapa pun yang ingin tahu tentang cara kerja teknologi suara. Kita akan memulai perjalanan dari sifat fisik suara hingga pembuatan vektor fitur canggih seperti Mel-Frequency Cepstral Coefficients (MFCC). Kita akan menggunakan pustaka ilmiah Python yang andal untuk mengungkap konsep-konsep tersebut dan memberikan contoh praktis yang bisa langsung dicoba.

Memahami Sifat Suara

Sebelum kita dapat memproses suara, kita harus terlebih dahulu memahami apa itu suara. Pada intinya, suara adalah gelombang mekanis—sebuah osilasi tekanan yang merambat melalui medium seperti udara, air, atau benda padat. Saat kita berbicara, pita suara kita bergetar, menciptakan gelombang tekanan ini yang kemudian bergerak menuju mikrofon.

Properti Kunci Gelombang Suara

• Amplitudo: Ini berhubungan dengan intensitas atau kenyaringan suara. Dalam bentuk gelombang (waveform), ini adalah tinggi gelombang. Puncak yang lebih tinggi berarti suara yang lebih keras.
• Frekuensi: Ini menentukan tinggi nada (pitch) suara. Ini adalah jumlah siklus yang diselesaikan gelombang per detik, diukur dalam Hertz (Hz). Frekuensi yang lebih tinggi berarti nada yang lebih tinggi.
• Timbre: Ini adalah kualitas atau karakter suara yang membedakan berbagai jenis produksi suara, seperti suara manusia dan alat musik. Inilah yang membuat suara terompet berbeda dari biola yang memainkan nada yang sama dengan kenyaringan yang sama. Timbre adalah hasil dari konten harmonik suatu suara.

Dari Analog ke Digital: Proses Konversi

Mikrofon mengubah gelombang tekanan analog menjadi sinyal listrik analog. Namun, komputer beroperasi pada data digital yang diskrit. Proses mengubah sinyal analog menjadi sinyal digital disebut digitalisasi atau sampling.

• Tingkat Sampling (Sampling Rate): Ini adalah jumlah sampel (potret) dari sinyal audio yang diambil per detik. Sebagai contoh, audio berkualitas CD memiliki tingkat sampling 44.100 Hz (atau 44.1 kHz), yang berarti 44.100 sampel ditangkap setiap detik. Teorema sampling Nyquist-Shannon menyatakan bahwa untuk merekonstruksi sinyal secara akurat, tingkat sampling harus setidaknya dua kali frekuensi tertinggi yang ada dalam sinyal tersebut. Karena rentang pendengaran manusia mencapai puncaknya sekitar 20 kHz, tingkat sampling 44.1 kHz sudah lebih dari cukup. Untuk ucapan, tingkat 16 kHz sering kali menjadi standar karena sudah cukup mencakup rentang frekuensi suara manusia.
• Kedalaman Bit (Bit Depth): Ini menentukan jumlah bit yang digunakan untuk merepresentasikan amplitudo setiap sampel. Kedalaman bit yang lebih tinggi memberikan rentang dinamis yang lebih besar (perbedaan antara suara paling pelan dan paling keras yang mungkin) dan mengurangi noise kuantisasi. Kedalaman 16-bit, yang umum untuk ucapan, memungkinkan 65.536 (2^16) nilai amplitudo yang berbeda.

Hasil dari proses ini adalah sebuah larik (array) atau vektor satu dimensi berisi angka-angka, yang merepresentasikan amplitudo gelombang suara pada interval waktu yang diskrit. Larik inilah bahan mentah yang akan kita olah di Python.

Ekosistem Python untuk Pemrosesan Audio

Python memiliki ekosistem pustaka yang kaya yang membuat tugas pemrosesan audio yang kompleks menjadi lebih mudah diakses. Untuk tujuan kita, ada beberapa pemain kunci yang menonjol.

• Librosa: Ini adalah paket Python klasik untuk analisis musik dan audio. Librosa menyediakan abstraksi tingkat tinggi untuk memuat audio, memvisualisasikannya, dan yang paling penting, mengekstraksi berbagai macam fitur.
• SciPy: Sebagai landasan dari tumpukan ilmiah Python, modul `scipy.signal` dan `scipy.fft` dari SciPy menawarkan alat tingkat rendah yang kuat untuk tugas pemrosesan sinyal, termasuk penyaringan dan melakukan transformasi Fourier.
• NumPy: Paket fundamental untuk komputasi numerik di Python. Karena audio direpresentasikan sebagai larik angka, NumPy sangat diperlukan untuk melakukan operasi matematika pada data kita secara efisien.
• Matplotlib & Seaborn: Ini adalah pustaka standar untuk visualisasi data. Kita akan menggunakannya untuk memplot bentuk gelombang dan spektogram untuk membangun intuisi kita tentang data audio.

Pandangan Pertama: Memuat dan Memvisualisasikan Audio

Mari kita mulai dengan tugas sederhana: memuat file audio dan memvisualisasikan bentuk gelombangnya. Pertama, pastikan Anda telah menginstal pustaka yang diperlukan:

pip install librosa numpy matplotlib

Sekarang, mari kita tulis skrip untuk memuat file audio (misalnya, file `.wav`) dan melihat seperti apa bentuknya.

            
import librosa
import librosa.display
import matplotlib.pyplot as plt
import numpy as np

# Define the path to your audio file
# For a global audience, using a generic path is better
audio_path = 'path/to/your/audio.wav'

# Load the audio file
# y is the time series (the audio waveform as a NumPy array)
# sr is the sampling rate
y, sr = librosa.load(audio_path)

# Let's see the shape of our data
print(f"Waveform shape: {y.shape}")
print(f"Sampling rate: {sr} Hz")

# Visualize the waveform
plt.figure(figsize=(14, 5))
librosa.display.waveshow(y, sr=sr)
plt.title('Audio Waveform')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.grid(True)
plt.show()

            

              
                Copy
              
            
          

Saat Anda menjalankan kode ini, Anda akan melihat plot amplitudo audio dari waktu ke waktu. Representasi dalam domain waktu ini intuitif, tetapi tidak secara eksplisit memberi tahu kita tentang konten frekuensi, yang sangat penting untuk memahami ucapan.

Alur Pra-pemrosesan: Membersihkan dan Menormalisasi Audio

Audio di dunia nyata sering kali berantakan. Audio berisi kebisingan latar belakang, periode hening, dan variasi volume. Prinsip "sampah masuk, sampah keluar" sangat berlaku dalam machine learning. Pra-pemrosesan adalah langkah penting untuk membersihkan dan menstandarisasi audio untuk memastikan ekstraksi fitur kita kuat dan konsisten.

1. Normalisasi

File audio bisa memiliki tingkat volume yang sangat berbeda. Model yang dilatih pada rekaman yang keras mungkin berkinerja buruk pada rekaman yang pelan. Normalisasi menskalakan nilai amplitudo ke rentang yang konsisten, biasanya antara -1.0 dan 1.0. Metode yang umum adalah normalisasi puncak (peak normalization), di mana Anda membagi seluruh sinyal dengan amplitudo absolut maksimumnya.

            
# Peak normalization
max_amplitude = np.max(np.abs(y))
if max_amplitude > 0:
    y_normalized = y / max_amplitude
else:
    y_normalized = y # Avoid division by zero for silent audio

print(f"Original max amplitude: {np.max(np.abs(y)):.2f}")
print(f"Normalized max amplitude: {np.max(np.abs(y_normalized)):.2f}")

            

              
                Copy
              
            
          

2. Resampling

Sebuah model ASR mengharapkan semua inputnya memiliki tingkat sampling yang sama. Namun, file audio bisa berasal dari berbagai sumber dengan tingkat yang berbeda (misalnya, 48 kHz, 44.1 kHz, 22.05 kHz). Kita harus melakukan resampling ke tingkat target, sering kali 16 kHz untuk tugas pengenalan ucapan.

            
target_sr = 16000
if sr != target_sr:
    y_resampled = librosa.resample(y=y, orig_sr=sr, target_sr=target_sr)
    print(f"Resampled waveform shape: {y_resampled.shape}")
    sr = target_sr # Update the sampling rate variable
else:
    y_resampled = y

            

              
                Copy
              
            
          

3. Framing dan Windowing

Ucapan adalah sinyal dinamis dan non-stasioner; properti statistiknya (seperti konten frekuensi) berubah seiring waktu. Sebagai contoh, bunyi 'sh' memiliki konten frekuensi tinggi, sedangkan vokal 'o' memiliki konten frekuensi lebih rendah. Menganalisis seluruh klip audio sekaligus akan menggaburkan detail-detail ini.

Untuk mengatasi ini, kita menggunakan teknik yang disebut framing. Kita memotong sinyal audio menjadi frame-frame pendek yang tumpang tindih, biasanya sepanjang 20-40 milidetik. Di dalam setiap frame pendek, kita dapat mengasumsikan sinyal tersebut kuasi-stasioner, sehingga cocok untuk analisis frekuensi.

Namun, memotong sinyal menjadi frame begitu saja akan menciptakan diskontinuitas tajam di tepinya, yang akan menimbulkan artefak yang tidak diinginkan di domain frekuensi (sebuah fenomena yang disebut kebocoran spektral/spectral leakage). Untuk mengatasinya, kita menerapkan fungsi jendela (window function) (misalnya, jendela Hamming, Hanning, atau Blackman) pada setiap frame. Fungsi ini meruncingkan amplitudo frame menjadi nol di awal dan akhir, menghaluskan transisi dan mengurangi artefak.

Librosa menangani framing dan windowing secara otomatis saat kita melakukan Transformasi Fourier Jangka Pendek (Short-Time Fourier Transform/STFT), yang akan kita bahas selanjutnya.

Dari Waktu ke Frekuensi: Kekuatan Transformasi Fourier

Bentuk gelombang menunjukkan kepada kita bagaimana amplitudo berubah seiring waktu, tetapi untuk ucapan, kita lebih tertarik pada frekuensi apa yang ada pada setiap saat. Di sinilah Transformasi Fourier berperan. Ini adalah alat matematis yang menguraikan sinyal dari domain waktu menjadi komponen-komponen frekuensi penyusunnya.

Anggap saja seperti prisma. Prisma mengambil seberkas cahaya putih (sinyal domain waktu) dan memecahnya menjadi pelangi warna (komponen domain frekuensi). Transformasi Fourier melakukan hal yang sama untuk suara.

Transformasi Fourier Jangka Pendek (STFT)

Karena konten frekuensi ucapan berubah seiring waktu, kita tidak bisa hanya menerapkan satu Transformasi Fourier pada seluruh sinyal. Sebaliknya, kita menggunakan Transformasi Fourier Jangka Pendek (STFT). STFT adalah proses dari:

1. Memotong sinyal menjadi frame-frame pendek yang tumpang tindih (framing).
2. Menerapkan fungsi jendela pada setiap frame (windowing).
3. Menghitung Transformasi Fourier Diskrit (Discrete Fourier Transform/DFT) pada setiap frame yang telah dijendela. Transformasi Fourier Cepat (Fast Fourier Transform/FFT) hanyalah sebuah algoritma yang sangat efisien untuk menghitung DFT.

Hasil dari STFT adalah matriks bernilai kompleks di mana setiap kolom mewakili sebuah frame, dan setiap baris mewakili sebuah bin frekuensi. Besaran (magnitude) dari nilai-nilai dalam matriks ini memberi tahu kita intensitas setiap frekuensi pada setiap titik waktu.

Memvisualisasikan Frekuensi: Spektogram

Cara paling umum untuk memvisualisasikan output dari STFT adalah spektogram. Ini adalah plot 2D dengan:

• Sumbu X: Waktu
• Sumbu Y: Frekuensi
• Warna/Intensitas: Amplitudo (atau energi) dari frekuensi tertentu pada waktu tertentu.

Spektogram adalah alat yang ampuh yang memungkinkan kita "melihat" suara. Kita dapat mengidentifikasi vokal, konsonan, dan ritme ucapan hanya dengan melihatnya. Mari kita buat satu dengan Librosa.

            
# We'll use the resampled audio from the previous step
y_audio = y_resampled

# STFT parameters
# n_fft is the window size for the FFT. A common value is 2048.
# hop_length is the number of samples between successive frames. Determines the overlap.
# win_length is the length of the window function. Usually same as n_fft.
n_fft = 2048
hop_length = 512

# Perform STFT
stft_result = librosa.stft(y_audio, n_fft=n_fft, hop_length=hop_length)

# The result is complex. We take the magnitude and convert to decibels (dB) for visualization.
D = librosa.amplitude_to_db(np.abs(stft_result), ref=np.max)

# Display the spectrogram
plt.figure(figsize=(14, 5))
librosa.display.specshow(D, sr=sr, hop_length=hop_length, x_axis='time', y_axis='log')
plt.colorbar(format='%+2.0f dB')
plt.title('Spectrogram (log frequency scale)')
plt.xlabel('Time (s)')
plt.ylabel('Frequency (Hz)')
plt.show()

            

              
                Copy
              
            
          

Visualisasi ini mengungkapkan tekstur spektral yang kaya dari ucapan. Pita-pita horizontal yang terang disebut forman, yang merupakan konsentrasi energi akustik di sekitar frekuensi tertentu. Forman sangat penting untuk membedakan antara bunyi vokal yang berbeda.

Ekstraksi Fitur Lanjutan: Mel-Frequency Cepstral Coefficients (MFCC)

Meskipun spektogram adalah representasi yang hebat, ia memiliki dua masalah untuk ASR:

1. Inkonsistensi Persepsi: Sumbu frekuensi bersifat linear. Namun, pendengaran manusia tidak. Kita mempersepsikan nada pada skala logaritmik; kita jauh lebih sensitif terhadap perubahan pada frekuensi rendah daripada frekuensi tinggi. Sebagai contoh, perbedaan antara 100 Hz dan 200 Hz jauh lebih terasa daripada perbedaan antara 10.000 Hz dan 10.100 Hz.
2. Dimensionalitas dan Korelasi Tinggi: Spektogram berisi banyak data, dan bin frekuensi yang berdekatan sering kali sangat berkorelasi. Hal ini dapat menyulitkan beberapa model machine learning untuk belajar secara efektif.

Mel-Frequency Cepstral Coefficients (MFCC) dirancang untuk mengatasi masalah ini. Mereka adalah fitur standar emas untuk ASR tradisional dan tetap menjadi dasar yang kuat hingga saat ini. Proses pembuatan MFCC meniru aspek pendengaran manusia.

Skala Mel

Untuk mengatasi masalah persepsi, kita menggunakan skala Mel. Ini adalah skala persepsi nada yang dinilai oleh pendengar memiliki jarak yang sama satu sama lain. Skala ini kira-kira linear di bawah 1 kHz dan logaritmik di atasnya. Kita mengonversi frekuensi dari Hertz ke skala Mel agar lebih selaras dengan persepsi manusia.

Alur Perhitungan MFCC

Berikut adalah rincian langkah demi langkah yang disederhanakan tentang bagaimana MFCC dihitung dari sinyal audio:

1. Framing & Windowing: Sama seperti untuk STFT.
2. FFT & Spektrum Daya: Hitung FFT untuk setiap frame lalu hitung spektrum daya (kuadrat dari magnitudo).
3. Terapkan Filterbank Mel: Ini adalah langkah kunci. Satu set filter segitiga (sebuah filterbank) diterapkan pada spektrum daya. Filter-filter ini diberi jarak secara linear pada frekuensi rendah dan secara logaritmik pada frekuensi tinggi, mensimulasikan skala Mel. Langkah ini menggabungkan energi dari bin frekuensi yang berbeda ke dalam sejumlah kecil bin skala Mel, sehingga mengurangi dimensionalitas.
4. Ambil Logaritma: Ambil logaritma dari energi filterbank. Ini meniru persepsi kenyaringan manusia, yang juga bersifat logaritmik.
5. Transformasi Kosinus Diskrit (DCT): Terapkan DCT pada energi log filterbank. DCT mirip dengan FFT tetapi hanya menggunakan bilangan real. Tujuannya di sini adalah untuk mendekorelasi energi filterbank. Koefisien DCT yang dihasilkan sangat ringkas dan menangkap informasi spektral yang esensial.

Koefisien yang dihasilkan adalah MFCC. Biasanya, kita hanya menyimpan 13-20 koefisien pertama, karena mereka berisi sebagian besar informasi yang relevan untuk fonem ucapan, sementara koefisien yang lebih tinggi sering kali mewakili noise atau detail halus yang kurang relevan dengan konten ucapan.

Menghitung MFCC di Python

Untungnya, Librosa membuat proses kompleks ini menjadi sangat sederhana dengan satu panggilan fungsi.

            
# Calculate MFCCs
# n_mfcc is the number of MFCCs to return
n_mfcc = 13

mfccs = librosa.feature.mfcc(y=y_audio, sr=sr, n_fft=n_fft, hop_length=hop_length, n_mfcc=n_mfcc)

print(f"MFCCs shape: {mfccs.shape}")

# Visualize the MFCCs
plt.figure(figsize=(14, 5))
librosa.display.specshow(mfccs, sr=sr, hop_length=hop_length, x_axis='time')
plt.colorbar(label='MFCC Coefficient Value')
plt.title('MFCCs')
plt.xlabel('Time (s)')
plt.ylabel('MFCC Coefficient Index')
plt.show()

            

              
                Copy
              
            
          

Outputnya adalah larik 2D di mana setiap kolom adalah sebuah frame dan setiap baris adalah koefisien MFCC. Matriks yang ringkas, relevan secara persepsi, dan terdekorelasi ini adalah input yang sempurna untuk model machine learning.

Menyatukan Semuanya: Alur Kerja Praktis

Mari kita gabungkan semua yang telah kita pelajari ke dalam satu fungsi yang dapat digunakan kembali yang mengambil path file audio dan mengembalikan fitur MFCC yang telah diproses.

            
import librosa
import numpy as np

def extract_features_mfcc(audio_path):
    """Extracts MFCC features from an audio file.

    Args:
        audio_path (str): Path to the audio file.

    Returns:
        np.ndarray: A 2D array of MFCC features (n_mfcc x n_frames).
    """
    try:
        # 1. Load the audio file
        y, sr = librosa.load(audio_path, duration=30) # Load first 30 seconds

        # 2. Resample to a standard rate (e.g., 16 kHz)
        target_sr = 16000
        if sr != target_sr:
            y = librosa.resample(y=y, orig_sr=sr, target_sr=target_sr)
            sr = target_sr

        # 3. Normalize the audio
        max_amp = np.max(np.abs(y))
        if max_amp > 0:
            y = y / max_amp

        # 4. Extract MFCCs
        # Common parameters for speech
        n_fft = 2048
        hop_length = 512
        n_mfcc = 13

        mfccs = librosa.feature.mfcc(
            y=y,
            sr=sr,
            n_fft=n_fft,
            hop_length=hop_length,
            n_mfcc=n_mfcc
        )

        # (Optional but recommended) Feature scaling
        # Standardize features to have zero mean and unit variance
        from sklearn.preprocessing import StandardScaler
        scaler = StandardScaler()
        mfccs_scaled = scaler.fit_transform(mfccs.T).T

        return mfccs_scaled

    except Exception as e:
        print(f"Error processing {audio_path}: {e}")
        return None

# --- Example Usage ---
audio_file = 'path/to/your/audio.wav'
features = extract_features_mfcc(audio_file)

if features is not None:
    print(f"Successfully extracted features with shape: {features.shape}")
    # This 'features' array is now ready to be fed into a machine learning model.

            

              
                Copy
              
            
          

Di Luar MFCC: Fitur Audio Penting Lainnya

Meskipun MFCC adalah fitur yang kuat dan banyak digunakan, bidang pemrosesan audio sangat luas. Dengan munculnya deep learning, fitur-fitur lain, terkadang yang lebih sederhana, telah terbukti sangat efektif.

• Spektogram Log-Mel: Ini adalah langkah perantara dalam perhitungan MFCC tepat sebelum DCT. Jaringan Saraf Konvolusional (Convolutional Neural Networks/CNN) modern sangat baik dalam mempelajari pola spasial. Dengan memasukkan seluruh spektogram log-Mel ke dalam CNN, model dapat mempelajari korelasi yang relevan dengan sendirinya, terkadang mengungguli MFCC yang didekorelasi secara manual. Ini adalah pendekatan yang sangat umum dalam sistem ASR modern yang bersifat end-to-end.
• Tingkat Perlintasan Nol (Zero-Crossing Rate/ZCR): Ini adalah laju di mana sinyal berubah tanda (dari positif ke negatif atau sebaliknya). Ini adalah ukuran sederhana dari tingkat kebisingan atau konten frekuensi sinyal. Bunyi tak bersuara seperti 's' atau 'f' memiliki ZCR yang jauh lebih tinggi daripada bunyi bersuara seperti vokal.
• Sentroid Spektral: Ini mengidentifikasi "pusat massa" dari spektrum. Ini adalah ukuran kecerahan suara. Sentroid spektral yang lebih tinggi sesuai dengan suara yang lebih cerah dengan lebih banyak konten frekuensi tinggi.
• Fitur Chroma: Ini adalah fitur yang merepresentasikan energi di masing-masing dari 12 kelas nada standar (C, C#, D, dll.). Meskipun terutama digunakan untuk analisis musik (misalnya, pengenalan akor), fitur ini bisa berguna dalam bahasa tonal atau untuk menganalisis prosodi.

Kesimpulan dan Langkah Selanjutnya

Kita telah melakukan perjalanan dari fisika dasar suara hingga pembuatan fitur canggih yang dapat dibaca mesin. Poin kunci yang dapat diambil adalah bahwa pemrosesan sinyal audio adalah proses transformasi—mengambil bentuk gelombang mentah yang kompleks dan secara sistematis menyaringnya menjadi representasi yang ringkas dan bermakna yang menyoroti karakteristik penting untuk ucapan.

Anda sekarang memahami bahwa:

• Audio digital adalah representasi diskrit dari gelombang suara kontinu, yang didefinisikan oleh tingkat sampling dan kedalaman bit-nya.
• Langkah-langkah pra-pemrosesan seperti normalisasi dan resampling sangat penting untuk menciptakan sistem yang kuat.
• Transformasi Fourier (STFT) adalah gerbang dari domain waktu ke domain frekuensi, yang divisualisasikan oleh spektogram.
• MFCC adalah set fitur yang kuat yang meniru persepsi pendengaran manusia dengan menggunakan skala Mel dan mendekorelasi informasi menggunakan DCT.

Ekstraksi fitur berkualitas tinggi adalah landasan di mana semua sistem pengenalan ucapan yang sukses dibangun. Meskipun model deep learning end-to-end modern mungkin tampak seperti kotak hitam, mereka pada dasarnya masih belajar untuk melakukan jenis transformasi ini secara internal.

Ke Mana Selanjutnya?

1. Eksperimen: Gunakan kode dalam panduan ini dengan file audio yang berbeda. Coba suara pria, suara wanita, rekaman yang bising, dan yang bersih. Amati bagaimana bentuk gelombang, spektogram, dan MFCC berubah.
2. Jelajahi Pustaka Tingkat Tinggi: Untuk membangun aplikasi cepat, pustaka seperti `SpeechRecognition` dari Google menyediakan API yang mudah digunakan yang menangani semua pemrosesan sinyal dan pemodelan untuk Anda. Ini adalah cara yang bagus untuk melihat hasil akhirnya.
3. Bangun Model: Sekarang setelah Anda dapat mengekstrak fitur, langkah logis berikutnya adalah memasukkannya ke dalam model machine learning. Mulailah dengan model pendeteksi kata kunci sederhana menggunakan TensorFlow/Keras atau PyTorch. Anda dapat menggunakan MFCC yang telah Anda hasilkan sebagai input ke jaringan saraf sederhana.
4. Temukan Kumpulan Data: Untuk melatih model ASR yang sesungguhnya, Anda memerlukan banyak data. Jelajahi kumpulan data sumber terbuka terkenal seperti LibriSpeech, Mozilla Common Voice, atau TED-LIUM untuk melihat seperti apa data audio skala besar itu.

Dunia audio dan ucapan adalah bidang yang dalam dan menarik. Dengan menguasai prinsip-prinsip pemrosesan sinyal, Anda telah membuka pintu untuk membangun teknologi berbasis suara generasi berikutnya.