AI dengan Python - Speech Recognition

Pada bab ini, kita akan belajar tentang pengenalan suara menggunakan AI dengan Python.

Pidato adalah alat paling dasar komunikasi manusia dewasa. Tujuan dasar dari pemrosesan ucapan adalah untuk menyediakan interaksi antara manusia dan mesin.

Sistem pemrosesan ucapan memiliki tiga tugas utama -

First, pengenalan ucapan yang memungkinkan mesin menangkap kata, frasa, dan kalimat yang kita ucapkan
Second, pemrosesan bahasa alami untuk memungkinkan mesin memahami apa yang kita bicarakan, dan
Third, sintesis ucapan agar mesin dapat berbicara.

Bab ini berfokus pada speech recognition, Proses memahami kata-kata yang diucapkan oleh manusia. Ingatlah bahwa sinyal ucapan ditangkap dengan bantuan mikrofon dan kemudian harus dipahami oleh sistem.

Membangun Pengenal Pidato

Speech Recognition atau Automatic Speech Recognition (ASR) adalah pusat perhatian untuk proyek AI seperti robotika. Tanpa ASR, tidak mungkin membayangkan robot kognitif berinteraksi dengan manusia. Namun, tidak mudah membuat pengenal ucapan.

Kesulitan dalam mengembangkan sistem pengenalan suara

Mengembangkan sistem pengenalan suara berkualitas tinggi benar-benar merupakan masalah yang sulit. Kesulitan teknologi pengenalan suara dapat dikarakterisasi secara luas dalam sejumlah dimensi seperti yang dibahas di bawah ini -

Size of the vocabulary- Ukuran kosa kata memengaruhi kemudahan mengembangkan ASR. Pertimbangkan ukuran kosakata berikut untuk pemahaman yang lebih baik.

Kosakata ukuran kecil terdiri dari 2-100 kata, misalnya, seperti dalam sistem menu suara
Kosakata ukuran sedang terdiri dari beberapa 100 hingga 1.000 kata, misalnya, seperti dalam tugas pengambilan database
Kosakata ukuran besar terdiri dari beberapa 10.000 kata, seperti dalam tugas dikte umum.

Perhatikan bahwa, semakin besar ukuran kosakata, semakin sulit untuk melakukan pengenalan.

Channel characteristics- Kualitas saluran juga merupakan dimensi penting. Misalnya ucapan manusia mengandung bandwidth tinggi dengan rentang frekuensi penuh, sedangkan ucapan telepon terdiri dari bandwidth rendah dengan rentang frekuensi terbatas. Perhatikan bahwa lebih sulit di yang terakhir.
Speaking mode- Kemudahan mengembangkan ASR juga tergantung pada mode bicara, yaitu apakah ucapan dalam mode kata terisolasi, atau mode kata yang terhubung, atau dalam mode ucapan berkelanjutan. Perhatikan bahwa ucapan terus menerus lebih sulit untuk dikenali.
Speaking style- Pidato membaca mungkin dalam gaya formal, atau spontan dan percakapan dengan gaya kasual. Yang terakhir lebih sulit dikenali.
Speaker dependency- Ucapan dapat bergantung pada pembicara, adaptif pembicara, atau tidak bergantung pada speaker. Seorang pembicara independen adalah yang paling sulit untuk dibangun.
Type of noise- Kebisingan adalah faktor lain yang perlu dipertimbangkan saat mengembangkan ASR. Rasio sinyal terhadap kebisingan mungkin dalam berbagai kisaran, tergantung pada lingkungan akustik yang mengamati lebih sedikit kebisingan latar belakang versus lebih banyak -

Jika rasio sinyal terhadap noise lebih besar dari 30dB, itu dianggap sebagai kisaran tinggi
Jika rasio sinyal terhadap noise berada antara 30dB hingga 10db, itu dianggap sebagai SNR sedang
Jika rasio signal to noise kurang dari 10dB, itu dianggap sebagai kisaran rendah

Misalnya, jenis kebisingan latar belakang seperti stasioner, kebisingan non-manusia, ucapan latar belakang dan crosstalk oleh penutur lain juga berkontribusi pada kesulitan masalah.

Microphone characteristics- Kualitas mikrofon mungkin bagus, sedang, atau di bawah rata-rata. Selain itu, jarak antara mulut dan ponsel mikro bisa berbeda-beda. Faktor-faktor ini juga harus dipertimbangkan untuk sistem pengenalan.

Terlepas dari kesulitan ini, peneliti banyak bekerja pada berbagai aspek pidato seperti memahami sinyal ucapan, pembicara, dan mengidentifikasi aksen.

Anda harus mengikuti langkah-langkah yang diberikan di bawah ini untuk membuat pengenal ucapan -

Memvisualisasikan Sinyal Audio - Membaca dari File dan Mengerjakannya

Ini adalah langkah pertama dalam membangun sistem pengenalan suara karena memberikan pemahaman tentang bagaimana sinyal audio terstruktur. Beberapa langkah umum yang dapat diikuti untuk bekerja dengan sinyal audio adalah sebagai berikut -

Rekaman

Saat Anda harus membaca sinyal audio dari sebuah file, rekamlah dengan menggunakan mikrofon, terlebih dahulu.

Contoh

Saat merekam dengan mikrofon, sinyal disimpan dalam bentuk digital. Tetapi untuk mengerjakannya, mesin membutuhkannya dalam bentuk numerik diskrit. Oleh karena itu, kita harus melakukan sampling pada frekuensi tertentu dan mengubah sinyal tersebut menjadi bentuk numerik diskrit. Memilih frekuensi tinggi untuk pengambilan sampel menyiratkan bahwa ketika manusia mendengarkan sinyal, mereka merasakannya sebagai sinyal audio yang berkelanjutan.

Contoh

Contoh berikut menunjukkan pendekatan bertahap untuk menganalisis sinyal audio, menggunakan Python, yang disimpan dalam sebuah file. Frekuensi sinyal audio ini adalah 44.100 HZ.

Impor paket yang diperlukan seperti yang ditunjukkan di sini -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile

Sekarang, baca file audio yang disimpan. Ini akan mengembalikan dua nilai: frekuensi sampling dan sinyal audio. Berikan jalur file audio tempat disimpan, seperti yang ditunjukkan di sini -

frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")

Tampilkan parameter seperti frekuensi sampling sinyal audio, jenis data sinyal dan durasinya, menggunakan perintah yang ditunjukkan -

print('\nSignal shape:', audio_signal.shape)
print('Signal Datatype:', audio_signal.dtype)
print('Signal duration:', round(audio_signal.shape[0] / 
float(frequency_sampling), 2), 'seconds')

Langkah ini melibatkan normalisasi sinyal seperti yang ditunjukkan di bawah ini -

audio_signal = audio_signal / np.power(2, 15)

Pada langkah ini, kami mengekstraksi 100 nilai pertama dari sinyal ini untuk divisualisasikan. Gunakan perintah berikut untuk tujuan ini -

audio_signal = audio_signal [:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(frequency_sampling)

Sekarang, visualisasikan sinyal menggunakan perintah yang diberikan di bawah ini -

plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time (milliseconds)')
plt.ylabel('Amplitude')
plt.title('Input audio signal')
plt.show()

Anda akan dapat melihat grafik output dan data yang diekstraksi untuk sinyal audio di atas seperti yang ditunjukkan pada gambar di sini

Signal shape: (132300,)
Signal Datatype: int16
Signal duration: 3.0 seconds

Karakterisasi Sinyal Audio: Transformasi ke Domain Frekuensi

Karakterisasi sinyal audio melibatkan pengubahan sinyal domain waktu menjadi domain frekuensi, dan memahami komponen frekuensinya, dengan. Ini merupakan langkah penting karena memberikan banyak informasi tentang sinyal. Anda dapat menggunakan alat matematika seperti Transformasi Fourier untuk melakukan transformasi ini.

Contoh

Contoh berikut menunjukkan, langkah demi langkah, cara mengkarakterisasi sinyal, menggunakan Python, yang disimpan dalam sebuah file. Perhatikan bahwa di sini kami menggunakan alat matematika Fourier Transform untuk mengubahnya menjadi domain frekuensi.

Impor paket yang diperlukan, seperti yang ditunjukkan di sini -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile

Sekarang, baca file audio yang disimpan. Ini akan mengembalikan dua nilai: frekuensi sampling dan sinyal audio. Berikan jalur file audio tempat disimpan seperti yang ditunjukkan pada perintah di sini -

frequency_sampling, audio_signal = wavfile.read("/Users/admin/sample.wav")

Pada langkah ini, kami akan menampilkan parameter seperti frekuensi sampling sinyal audio, jenis data sinyal dan durasinya, menggunakan perintah yang diberikan di bawah ini -

print('\nSignal shape:', audio_signal.shape)
print('Signal Datatype:', audio_signal.dtype)
print('Signal duration:', round(audio_signal.shape[0] / 
float(frequency_sampling), 2), 'seconds')

Pada langkah ini, kita perlu menormalkan sinyal, seperti yang ditunjukkan pada perintah berikut -

audio_signal = audio_signal / np.power(2, 15)

Langkah ini melibatkan ekstraksi panjang dan setengah panjang sinyal. Gunakan perintah berikut untuk tujuan ini -

length_signal = len(audio_signal)
half_length = np.ceil((length_signal + 1) / 2.0).astype(np.int)

Sekarang, kita perlu menerapkan alat matematika untuk mentransformasikannya ke dalam domain frekuensi. Di sini kami menggunakan Transformasi Fourier.

signal_frequency = np.fft.fft(audio_signal)

Sekarang, lakukan normalisasi sinyal domain frekuensi dan kuadratkan -

signal_frequency = abs(signal_frequency[0:half_length]) / length_signal
signal_frequency **= 2

Selanjutnya, ekstrak panjang dan setengah panjang dari sinyal frekuensi yang diubah -

len_fts = len(signal_frequency)

Perhatikan bahwa sinyal transformasi Fourier harus disesuaikan untuk kasus genap dan ganjil.

if length_signal % 2:
   signal_frequency[1:len_fts] *= 2
else:
   signal_frequency[1:len_fts-1] *= 2

Sekarang, ekstrak kekuatan dalam desibal (dB) -

signal_power = 10 * np.log10(signal_frequency)

Sesuaikan frekuensi dalam kHz untuk sumbu X -

x_axis = np.arange(0, len_half, 1) * (frequency_sampling / length_signal) / 1000.0

Sekarang, visualisasikan karakterisasi sinyal sebagai berikut -

plt.figure()
plt.plot(x_axis, signal_power, color='black')
plt.xlabel('Frequency (kHz)')
plt.ylabel('Signal power (dB)')
plt.show()

Anda dapat mengamati grafik output dari kode di atas seperti yang ditunjukkan pada gambar di bawah ini -

Menghasilkan Sinyal Audio Monoton

Dua langkah yang Anda lihat sampai sekarang penting untuk dipelajari tentang sinyal. Sekarang, langkah ini akan berguna jika Anda ingin menghasilkan sinyal audio dengan beberapa parameter yang telah ditentukan sebelumnya. Perhatikan bahwa langkah ini akan menyimpan sinyal audio dalam file keluaran.

Contoh

Dalam contoh berikut, kami akan menghasilkan sinyal monoton, menggunakan Python, yang akan disimpan dalam sebuah file. Untuk ini, Anda harus mengambil langkah-langkah berikut -

Impor paket yang diperlukan seperti yang ditunjukkan -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io.wavfile import write

Berikan file tempat file output harus disimpan

output_file = 'audio_signal_generated.wav'

Sekarang, tentukan parameter pilihan Anda, seperti yang ditunjukkan -

duration = 4 # in seconds
frequency_sampling = 44100 # in Hz
frequency_tone = 784
min_val = -4 * np.pi
max_val = 4 * np.pi

Pada langkah ini, kita dapat menghasilkan sinyal audio, seperti yang ditunjukkan -

t = np.linspace(min_val, max_val, duration * frequency_sampling)
audio_signal = np.sin(2 * np.pi * tone_freq * t)

Sekarang, simpan file audio di file output -

write(output_file, frequency_sampling, signal_scaled)

Ekstrak 100 nilai pertama untuk grafik kami, seperti yang ditunjukkan -

audio_signal = audio_signal[:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(sampling_freq)

Sekarang, visualisasikan sinyal audio yang dihasilkan sebagai berikut -

plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time in milliseconds')
plt.ylabel('Amplitude')
plt.title('Generated audio signal')
plt.show()

Anda dapat mengamati plot seperti yang ditunjukkan pada gambar yang diberikan di sini -

Ekstraksi Fitur dari Ucapan

Ini adalah langkah terpenting dalam membangun pengenal ucapan karena setelah mengubah sinyal ucapan ke dalam domain frekuensi, kita harus mengubahnya menjadi bentuk vektor fitur yang dapat digunakan. Kami dapat menggunakan teknik ekstraksi fitur yang berbeda seperti MFCC, PLP, PLP-RASTA, dll. Untuk tujuan ini.

Contoh

Pada contoh berikut, kita akan mengekstrak fitur dari sinyal, langkah demi langkah, menggunakan Python, dengan menggunakan teknik MFCC.

Impor paket yang diperlukan, seperti yang ditunjukkan di sini -

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
from python_speech_features import mfcc, logfbank

Sekarang, baca file audio yang disimpan. Ini akan mengembalikan dua nilai - frekuensi sampling dan sinyal audio. Berikan jalur file audio tempat penyimpanannya.

frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")

Perhatikan bahwa di sini kami mengambil 15.000 sampel pertama untuk dianalisis.

audio_signal = audio_signal[:15000]

Gunakan teknik MFCC dan jalankan perintah berikut untuk mengekstrak fitur MFCC -

features_mfcc = mfcc(audio_signal, frequency_sampling)

Sekarang, cetak parameter MFCC, seperti yang ditunjukkan -

print('\nMFCC:\nNumber of windows =', features_mfcc.shape[0])
print('Length of each feature =', features_mfcc.shape[1])

Sekarang, plot dan visualisasikan fitur MFCC menggunakan perintah yang diberikan di bawah ini -

features_mfcc = features_mfcc.T
plt.matshow(features_mfcc)
plt.title('MFCC')

Pada langkah ini, kami bekerja dengan fitur bank filter seperti yang ditunjukkan -

Ekstrak fitur bank filter -

filterbank_features = logfbank(audio_signal, frequency_sampling)

Sekarang, cetak parameter filterbank.

print('\nFilter bank:\nNumber of windows =', filterbank_features.shape[0])
print('Length of each feature =', filterbank_features.shape[1])

Sekarang, plot dan visualisasikan fitur filterbank.

filterbank_features = filterbank_features.T
plt.matshow(filterbank_features)
plt.title('Filter bank')
plt.show()

Sebagai hasil dari langkah-langkah di atas, Anda dapat mengamati keluaran sebagai berikut: Gambar1 untuk MFCC dan Gambar2 untuk Bank Filter

Pengakuan Kata-Kata Lisan

Pengenalan ucapan berarti bahwa saat manusia berbicara, mesin memahaminya. Di sini kami menggunakan Google Speech API dengan Python untuk mewujudkannya. Kami perlu menginstal paket berikut untuk ini -

Pyaudio - Dapat diinstal dengan menggunakan pip install Pyaudio perintah.
SpeechRecognition - Paket ini dapat diinstal dengan menggunakan pip install SpeechRecognition.
Google-Speech-API - Dapat diinstal dengan menggunakan perintah pip install google-api-python-client.

Contoh

Perhatikan contoh berikut untuk memahami tentang pengenalan kata-kata yang diucapkan -

Impor paket yang diperlukan seperti yang ditunjukkan -

import speech_recognition as sr

Buat objek seperti yang ditunjukkan di bawah ini -

recording = sr.Recognizer()

Sekarang, Microphone() modul akan mengambil suara sebagai input -

with sr.Microphone() as source: recording.adjust_for_ambient_noise(source)
   print("Please Say something:")
   audio = recording.listen(source)

Sekarang Google API akan mengenali suara tersebut dan memberikan keluarannya.

try:
   print("You said: \n" + recording.recognize_google(audio))
except Exception as e:
   print(e)

Anda dapat melihat output berikut -

Please Say Something:
You said:

Misalnya, jika Anda berkata tutorialspoint.com, maka sistem akan mengenalinya dengan benar sebagai berikut -

tutorialspoint.com