AI พร้อม Python - การรู้จำเสียง
ในบทนี้เราจะเรียนรู้เกี่ยวกับการรู้จำเสียงโดยใช้ AI กับ Python
การพูดเป็นวิธีการสื่อสารขั้นพื้นฐานที่สุดของมนุษย์ในวัยผู้ใหญ่ เป้าหมายพื้นฐานของการประมวลผลคำพูดคือเพื่อให้เกิดการโต้ตอบระหว่างมนุษย์กับเครื่องจักร
ระบบประมวลผลคำพูดมีสามงานหลัก -
First, การรู้จำเสียงที่ทำให้เครื่องสามารถจับคำวลีและประโยคที่เราพูดได้
Second, การประมวลผลภาษาธรรมชาติเพื่อให้เครื่องเข้าใจสิ่งที่เราพูดและ
Thirdการสังเคราะห์เสียงเพื่อให้เครื่องสามารถพูดได้
บทนี้เน้นที่ speech recognition, กระบวนการทำความเข้าใจคำพูดที่มนุษย์พูด. โปรดจำไว้ว่าสัญญาณเสียงพูดถูกจับด้วยความช่วยเหลือของไมโครโฟนจากนั้นระบบจะต้องเข้าใจ
การสร้าง Speech Recognizer
Speech Recognition หรือ Automatic Speech Recognition (ASR) เป็นศูนย์กลางของความสนใจสำหรับโครงการ AI เช่นหุ่นยนต์ หากไม่มี ASR จะไม่สามารถจินตนาการได้ว่าหุ่นยนต์องค์ความรู้กำลังโต้ตอบกับมนุษย์ อย่างไรก็ตามการสร้างโปรแกรมจดจำเสียงนั้นไม่ใช่เรื่องง่าย
ความยากลำบากในการพัฒนาระบบรู้จำเสียง
การพัฒนาระบบจดจำเสียงพูดคุณภาพสูงเป็นปัญหาที่ยากมาก ความยากของเทคโนโลยีการรู้จำเสียงสามารถจำแนกได้อย่างกว้าง ๆ ตามมิติต่างๆตามที่กล่าวไว้ด้านล่าง
Size of the vocabulary- ขนาดของคำศัพท์มีผลต่อความง่ายในการพัฒนา ASR พิจารณาขนาดของคำศัพท์ต่อไปนี้เพื่อความเข้าใจที่ดีขึ้น
คำศัพท์ขนาดเล็กประกอบด้วย 2-100 คำเช่นในระบบเมนูเสียง
คำศัพท์ขนาดกลางประกอบด้วยคำหลาย 100 ถึง 1,000 คำเช่นในงานการดึงฐานข้อมูล
คำศัพท์ขนาดใหญ่ประกอบด้วยคำหลาย 10,000 คำเช่นเดียวกับงานเขียนตามคำบอกทั่วไป
Channel characteristics- คุณภาพช่องยังเป็นมิติที่สำคัญ ตัวอย่างเช่นคำพูดของมนุษย์มีแบนด์วิดท์สูงพร้อมช่วงความถี่เต็มในขณะที่คำพูดทางโทรศัพท์ประกอบด้วยแบนด์วิดท์ต่ำและมีช่วงความถี่ที่ จำกัด สังเกตว่ามันยากกว่าในช่วงหลัง
Speaking mode- ความง่ายในการพัฒนา ASR ยังขึ้นอยู่กับโหมดการพูดนั่นคือการพูดนั้นอยู่ในโหมดคำแยกหรือโหมดคำที่เชื่อมต่อหรือในโหมดการพูดต่อเนื่อง สังเกตว่าคำพูดต่อเนื่องนั้นยากที่จะจดจำ
Speaking style- คำพูดในการอ่านอาจอยู่ในรูปแบบที่เป็นทางการหรือเกิดขึ้นเองและเป็นการสนทนาในรูปแบบสบาย ๆ อย่างหลังยากที่จะรับรู้
Speaker dependency- เสียงพูดอาจขึ้นอยู่กับลำโพงปรับลำโพงหรือลำโพงอิสระ ลำโพงอิสระเป็นสิ่งที่ยากที่สุดในการสร้าง
Type of noise- เสียงรบกวนเป็นอีกปัจจัยหนึ่งที่ควรพิจารณาในขณะที่พัฒนา ASR อัตราส่วนสัญญาณต่อเสียงรบกวนอาจอยู่ในช่วงต่างๆขึ้นอยู่กับสภาพแวดล้อมอะคูสติกที่สังเกตได้น้อยกว่าเมื่อเทียบกับเสียงพื้นหลังที่มากขึ้น -
หากอัตราส่วนสัญญาณต่อเสียงรบกวนมากกว่า 30dB ถือว่าเป็นช่วงที่สูง
หากอัตราส่วนสัญญาณต่อเสียงรบกวนอยู่ระหว่าง 30dB ถึง 10db จะถือว่าเป็น SNR ขนาดกลาง
หากอัตราส่วนสัญญาณต่อเสียงรบกวนน้อยกว่า 10dB ถือว่าเป็นช่วงต่ำ
Microphone characteristics- คุณภาพของไมโครโฟนอาจดีปานกลางหรือต่ำกว่าค่าเฉลี่ย นอกจากนี้ระยะห่างระหว่างปากกับไมโครโฟนอาจแตกต่างกันไป ปัจจัยเหล่านี้ควรได้รับการพิจารณาสำหรับระบบการรับรู้
โปรดทราบว่ายิ่งขนาดของคำศัพท์มีขนาดใหญ่เท่าใดการจดจำก็จะยากขึ้นเท่านั้น
ตัวอย่างเช่นประเภทของเสียงรบกวนในพื้นหลังเช่นเสียงที่อยู่นิ่งเสียงที่ไม่ใช่ของมนุษย์เสียงพูดในพื้นหลังและเสียงครอสทอล์คโดยผู้พูดคนอื่นก็มีส่วนทำให้เกิดปัญหา
แม้จะมีปัญหาเหล่านี้นักวิจัยได้ทำงานมากมายในแง่มุมต่างๆของการพูดเช่นการทำความเข้าใจสัญญาณเสียงผู้พูดและการระบุสำเนียง
คุณจะต้องทำตามขั้นตอนด้านล่างเพื่อสร้างโปรแกรมจดจำเสียง -
การแสดงสัญญาณเสียง - อ่านจากไฟล์และดำเนินการกับมัน
นี่เป็นขั้นตอนแรกในการสร้างระบบรู้จำเสียงเนื่องจากจะช่วยให้เข้าใจว่าสัญญาณเสียงมีโครงสร้างอย่างไร ขั้นตอนทั่วไปบางประการที่สามารถปฏิบัติตามเพื่อทำงานกับสัญญาณเสียงมีดังนี้ -
การบันทึก
เมื่อคุณต้องอ่านสัญญาณเสียงจากไฟล์ให้บันทึกโดยใช้ไมโครโฟนในตอนแรก
การสุ่มตัวอย่าง
เมื่อบันทึกด้วยไมโครโฟนสัญญาณจะถูกจัดเก็บในรูปแบบดิจิทัล แต่ในการดำเนินการกับมันเครื่องต้องการให้อยู่ในรูปแบบตัวเลขที่ไม่ต่อเนื่อง ดังนั้นเราควรทำการสุ่มตัวอย่างที่ความถี่หนึ่งและแปลงสัญญาณให้อยู่ในรูปแบบตัวเลขที่ไม่ต่อเนื่อง การเลือกความถี่สูงสำหรับการสุ่มตัวอย่างหมายความว่าเมื่อมนุษย์ฟังสัญญาณพวกเขารู้สึกว่าเป็นสัญญาณเสียงต่อเนื่อง
ตัวอย่าง
ตัวอย่างต่อไปนี้แสดงวิธีการวิเคราะห์สัญญาณเสียงแบบขั้นตอนโดยใช้ Python ซึ่งเก็บไว้ในไฟล์ ความถี่ของสัญญาณเสียงนี้คือ 44,100 HZ
นำเข้าแพ็คเกจที่จำเป็นตามที่แสดงไว้ที่นี่ -
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
ตอนนี้อ่านไฟล์เสียงที่เก็บไว้ มันจะคืนค่าสองค่าคือความถี่ในการสุ่มตัวอย่างและสัญญาณเสียง ระบุเส้นทางของไฟล์เสียงที่จัดเก็บดังแสดงที่นี่ -
frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")
แสดงพารามิเตอร์เช่นความถี่การสุ่มตัวอย่างของสัญญาณเสียงประเภทข้อมูลของสัญญาณและระยะเวลาโดยใช้คำสั่งที่แสดง -
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')
ขั้นตอนนี้เกี่ยวข้องกับการปรับสัญญาณให้เป็นปกติดังที่แสดงด้านล่าง -
audio_signal = audio_signal / np.power(2, 15)
ในขั้นตอนนี้เรากำลังแยกค่า 100 ค่าแรกจากสัญญาณนี้เพื่อให้เห็นภาพ ใช้คำสั่งต่อไปนี้เพื่อจุดประสงค์นี้ -
audio_signal = audio_signal [:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(frequency_sampling)
ตอนนี้ให้เห็นภาพสัญญาณโดยใช้คำสั่งด้านล่าง -
plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time (milliseconds)')
plt.ylabel('Amplitude')
plt.title('Input audio signal')
plt.show()
คุณจะสามารถดูกราฟเอาต์พุตและข้อมูลที่แยกออกมาสำหรับสัญญาณเสียงด้านบนดังที่แสดงในภาพที่นี่
Signal shape: (132300,)
Signal Datatype: int16
Signal duration: 3.0 seconds
การกำหนดลักษณะของสัญญาณเสียง: การเปลี่ยนเป็นโดเมนความถี่
การกำหนดลักษณะของสัญญาณเสียงเกี่ยวข้องกับการแปลงสัญญาณโดเมนเวลาเป็นโดเมนความถี่และการทำความเข้าใจส่วนประกอบความถี่โดย นี่เป็นขั้นตอนที่สำคัญเนื่องจากให้ข้อมูลจำนวนมากเกี่ยวกับสัญญาณ คุณสามารถใช้เครื่องมือทางคณิตศาสตร์เช่น Fourier Transform เพื่อทำการแปลงนี้
ตัวอย่าง
ตัวอย่างต่อไปนี้แสดงให้เห็นทีละขั้นตอนวิธีกำหนดลักษณะสัญญาณโดยใช้ Python ซึ่งเก็บไว้ในไฟล์ โปรดทราบว่าที่นี่เรากำลังใช้เครื่องมือทางคณิตศาสตร์ Fourier Transform เพื่อแปลงเป็นโดเมนความถี่
นำเข้าแพ็คเกจที่จำเป็นดังแสดงที่นี่ -
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
ตอนนี้อ่านไฟล์เสียงที่เก็บไว้ จะคืนค่าสองค่าคือความถี่ในการสุ่มตัวอย่างและสัญญาณเสียง ระบุเส้นทางของไฟล์เสียงที่จัดเก็บดังแสดงในคำสั่งที่นี่ -
frequency_sampling, audio_signal = wavfile.read("/Users/admin/sample.wav")
ในขั้นตอนนี้เราจะแสดงพารามิเตอร์เช่นความถี่ในการสุ่มตัวอย่างของสัญญาณเสียงประเภทข้อมูลของสัญญาณและระยะเวลาโดยใช้คำสั่งที่ระบุด้านล่าง -
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')
ในขั้นตอนนี้เราต้องทำให้สัญญาณเป็นปกติดังที่แสดงในคำสั่งต่อไปนี้ -
audio_signal = audio_signal / np.power(2, 15)
ขั้นตอนนี้เกี่ยวข้องกับการแยกความยาวและความยาวครึ่งหนึ่งของสัญญาณ ใช้คำสั่งต่อไปนี้เพื่อจุดประสงค์นี้ -
length_signal = len(audio_signal)
half_length = np.ceil((length_signal + 1) / 2.0).astype(np.int)
ตอนนี้เราจำเป็นต้องใช้เครื่องมือทางคณิตศาสตร์เพื่อเปลี่ยนเป็นโดเมนความถี่ เรากำลังใช้การแปลงฟูเรียร์
signal_frequency = np.fft.fft(audio_signal)
ตอนนี้ทำการ normalization ของสัญญาณโดเมนความถี่และยกกำลังสอง -
signal_frequency = abs(signal_frequency[0:half_length]) / length_signal
signal_frequency **= 2
จากนั้นแยกความยาวและความยาวครึ่งหนึ่งของสัญญาณแปลงความถี่ -
len_fts = len(signal_frequency)
โปรดทราบว่าสัญญาณที่แปลงฟูเรียร์จะต้องได้รับการปรับเปลี่ยนสำหรับกรณีคู่และแบบคี่
if length_signal % 2:
signal_frequency[1:len_fts] *= 2
else:
signal_frequency[1:len_fts-1] *= 2
ตอนนี้แยกกำลังเป็นเดซิบาล (dB) -
signal_power = 10 * np.log10(signal_frequency)
ปรับความถี่เป็น kHz สำหรับแกน X -
x_axis = np.arange(0, len_half, 1) * (frequency_sampling / length_signal) / 1000.0
ตอนนี้ให้เห็นภาพลักษณะของสัญญาณดังนี้ -
plt.figure()
plt.plot(x_axis, signal_power, color='black')
plt.xlabel('Frequency (kHz)')
plt.ylabel('Signal power (dB)')
plt.show()
คุณสามารถสังเกตกราฟผลลัพธ์ของโค้ดด้านบนดังแสดงในภาพด้านล่าง -
การสร้างสัญญาณเสียงแบบโมโนโทน
สองขั้นตอนที่คุณเห็นจนถึงตอนนี้มีความสำคัญในการเรียนรู้เกี่ยวกับสัญญาณ ตอนนี้ขั้นตอนนี้จะเป็นประโยชน์หากคุณต้องการสร้างสัญญาณเสียงด้วยพารามิเตอร์ที่กำหนดไว้ล่วงหน้า โปรดทราบว่าขั้นตอนนี้จะบันทึกสัญญาณเสียงในไฟล์เอาต์พุต
ตัวอย่าง
ในตัวอย่างต่อไปนี้เราจะสร้างสัญญาณเสียงเดียวโดยใช้ Python ซึ่งจะถูกเก็บไว้ในไฟล์ สำหรับสิ่งนี้คุณจะต้องทำตามขั้นตอนต่อไปนี้ -
นำเข้าแพ็คเกจที่จำเป็นตามที่แสดง -
import numpy as np
import matplotlib.pyplot as plt
from scipy.io.wavfile import write
ระบุไฟล์ที่ควรบันทึกไฟล์เอาต์พุต
output_file = 'audio_signal_generated.wav'
ตอนนี้ระบุพารามิเตอร์ที่คุณเลือกดังที่แสดง -
duration = 4 # in seconds
frequency_sampling = 44100 # in Hz
frequency_tone = 784
min_val = -4 * np.pi
max_val = 4 * np.pi
ในขั้นตอนนี้เราสามารถสร้างสัญญาณเสียงดังที่แสดง -
t = np.linspace(min_val, max_val, duration * frequency_sampling)
audio_signal = np.sin(2 * np.pi * tone_freq * t)
ตอนนี้บันทึกไฟล์เสียงในไฟล์เอาต์พุต -
write(output_file, frequency_sampling, signal_scaled)
แยก 100 ค่าแรกสำหรับกราฟของเราดังที่แสดง -
audio_signal = audio_signal[:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(sampling_freq)
ตอนนี้ให้เห็นภาพสัญญาณเสียงที่สร้างขึ้นดังนี้ -
plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time in milliseconds')
plt.ylabel('Amplitude')
plt.title('Generated audio signal')
plt.show()
คุณสามารถสังเกตพล็อตดังแสดงในรูปที่ให้ไว้ที่นี่ -
คุณลักษณะการแยกจากเสียงพูด
นี่เป็นขั้นตอนที่สำคัญที่สุดในการสร้างเครื่องมือจดจำเสียงเพราะหลังจากแปลงสัญญาณเสียงพูดเป็นโดเมนความถี่แล้วเราต้องแปลงเป็นเวกเตอร์คุณลักษณะที่ใช้งานได้ เราสามารถใช้เทคนิคการแยกคุณลักษณะต่างๆเช่น MFCC, PLP, PLP-RASTA เป็นต้นเพื่อจุดประสงค์นี้
ตัวอย่าง
ในตัวอย่างต่อไปนี้เราจะแยกคุณสมบัติจากสัญญาณทีละขั้นตอนโดยใช้ Python โดยใช้เทคนิค MFCC
นำเข้าแพ็คเกจที่จำเป็นดังแสดงที่นี่ -
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
from python_speech_features import mfcc, logfbank
ตอนนี้อ่านไฟล์เสียงที่เก็บไว้ มันจะคืนค่าสองค่า - ความถี่ในการสุ่มตัวอย่างและสัญญาณเสียง ระบุเส้นทางของไฟล์เสียงที่จัดเก็บ
frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")
โปรดทราบว่าที่นี่เรากำลังทำการวิเคราะห์ตัวอย่าง 15,000 ตัวอย่างแรก
audio_signal = audio_signal[:15000]
ใช้เทคนิค MFCC และดำเนินการคำสั่งต่อไปนี้เพื่อแยกคุณสมบัติ MFCC -
features_mfcc = mfcc(audio_signal, frequency_sampling)
ตอนนี้พิมพ์พารามิเตอร์ MFCC ดังที่แสดง -
print('\nMFCC:\nNumber of windows =', features_mfcc.shape[0])
print('Length of each feature =', features_mfcc.shape[1])
ตอนนี้พล็อตและแสดงภาพคุณสมบัติ MFCC โดยใช้คำสั่งที่ระบุด้านล่าง -
features_mfcc = features_mfcc.T
plt.matshow(features_mfcc)
plt.title('MFCC')
ในขั้นตอนนี้เราทำงานร่วมกับคุณสมบัติตัวกรองธนาคารดังที่แสดง -
แยกคุณสมบัติของธนาคารตัวกรอง -
filterbank_features = logfbank(audio_signal, frequency_sampling)
ตอนนี้พิมพ์พารามิเตอร์ filterbank
print('\nFilter bank:\nNumber of windows =', filterbank_features.shape[0])
print('Length of each feature =', filterbank_features.shape[1])
ตอนนี้พล็อตและแสดงภาพคุณสมบัติของ filterbank
filterbank_features = filterbank_features.T
plt.matshow(filterbank_features)
plt.title('Filter bank')
plt.show()
จากขั้นตอนข้างต้นคุณสามารถสังเกตผลลัพธ์ต่อไปนี้: รูปที่ 1 สำหรับ MFCC และรูปที่ 2 สำหรับ Filter Bank
การรับรู้คำพูด
การรู้จำเสียงหมายความว่าเมื่อมนุษย์กำลังพูดเครื่องจักรจะเข้าใจมัน ที่นี่เรากำลังใช้ Google Speech API ใน Python เพื่อให้มันเกิดขึ้น เราจำเป็นต้องติดตั้งแพ็คเกจต่อไปนี้สำหรับสิ่งนี้ -
Pyaudio - สามารถติดตั้งโดยใช้ pip install Pyaudio คำสั่ง
SpeechRecognition - สามารถติดตั้งแพ็คเกจนี้ได้โดยใช้ pip install SpeechRecognition.
Google-Speech-API - สามารถติดตั้งได้โดยใช้คำสั่ง pip install google-api-python-client.
ตัวอย่าง
สังเกตตัวอย่างต่อไปนี้เพื่อทำความเข้าใจเกี่ยวกับการจดจำคำพูด -
นำเข้าแพ็คเกจที่จำเป็นตามที่แสดง -
import speech_recognition as sr
สร้างวัตถุตามที่แสดงด้านล่าง -
recording = sr.Recognizer()
ตอนนี้ Microphone() โมดูลจะรับเสียงเป็นอินพุต -
with sr.Microphone() as source: recording.adjust_for_ambient_noise(source)
print("Please Say something:")
audio = recording.listen(source)
ตอนนี้ Google API จะจดจำเสียงและให้ผลลัพธ์
try:
print("You said: \n" + recording.recognize_google(audio))
except Exception as e:
print(e)
คุณสามารถดูผลลัพธ์ต่อไปนี้ -
Please Say Something:
You said:
ตัวอย่างเช่นถ้าคุณพูดว่า tutorialspoint.comจากนั้นระบบจะจดจำได้อย่างถูกต้องดังนี้ -
tutorialspoint.com