C12: Speech Recognizer

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

# đọc file audio đã tạo sẵn. bạn có thể dùng window recoder hoặc recoder của điện thoại để lưu file dưới dạng wave
# Sử dụng hàm wavefile.read. Nó sẽ trả về 2 giá trị.
# sampling frequency - tần số lấy mẫu
# audio signal- tín hiệu âm thanh
sampling_freq,signal=wavfile.read("../data/chap12/abc.wav")
# In ra terminal dạng của tín hiệu, định dạng dữ liệu, và thời gian của tín hiệu âm thanh
print("Dạng tín hiệu: ",signal.shape)
print("Định dạng dữ liệu (datatype): ",signal.dtype)
print("Thời gian của tín hiệu âm thanh: ",round(signal.shape[0]/float(sampling_freq),2)," giây")
# Đơn giản lại tín hiệu âm thanh
signal=signal/np.power(3,5)
# Tách lấy khoảng 500 giá trị từ tín hiệu âm thanh để biểu diễn đồ thị (tại vì tín hiệu âm thanh của mình đoạn đầu là không có nên tín hiệu sẽ thẳng ----- nên mình sẽ lấy từ giây thứ 0.1 :
signal=signal[24500:25000]
# Xây dựng cột thời gian
time_axis=1000*np.arange(0,len(signal),1)/float(sampling_freq)
# Biểu diễn tín hiệu âm thanh
plt.plot(time_axis,signal,color='black')
plt.xlabel('Thời gian(mili giây)')
plt.ylabel('Biên độ')
plt.title('Biểu diễn tín hiệu âm thanh')
plt.show()

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

# Tải file phát âm từ apple hoặc bạn có thể dùng file tao.wav bằng tiếng việt
sampling_freq,signal=wavfile.read('../data/chap12/tao.wav')
# Normalize tín hiệu âm
signal=signal/np.power(2,15)
# Lấy độ dài của signal và chia nửa lấy 1/2
len_signal=len(signal)
len_half=np.ceil((len_signal+1)/2.0).astype(np.int)
# áp dụng biến đổi Fourier Transform
freq_signal=np.fft.fft(signal)
# Giảm tần số tín hiệu và lấy bình phương của nó
freq_signal=abs(freq_signal[0:len_half])/len_signal
freq_signal**=2
# chia tín hiệu biến đổi thành chẵn và lẻ
len_fts=len(freq_signal)
if len_signal%2:
freq_signal[1:len_fts]*=2
else:
freq_signal[1:len_fts-1]*=2
# tính độ lớn của tín hiệu đo bằng dB (decibel)
signal_power=10*np.log10(freq_signal)
# Tạo trục x đây là trục tần số được đo bằng kHz (kilog hertz):
x_axis=np.arange(0,len_half,1)*(sampling_freq/len_signal)/1000.0
# Vẽ đồ thị
plt.figure()
plt.plot(x_axis,signal_power,color='red')
plt.title('Biến đổi tín hiệu âm thanh')
plt.xlabel('Tần số (kHz)')
plt.ylabel('Độ lớn (dB)')
plt.show()

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

# Định nghĩa tên cho file đầu ra
output_file='generated_audio.wav'
# Xác định một vài tham số như độ dài, tần số mẫu, tần số cao độ, giá trị thấp nhất và giá trị cao nhất
duration=4 # Đây là tính giây
sampling_freq=44100# Tính theo Hz
tone_freq=784
min_val=-4*np.pi
max_val=4*np.pi
#Tạo tín hiệu âm thanh sử dụng những tham số trên
t=np.linspace(min_val,max_val,duration*sampling_freq)
signal=np.sin(2*np.pi*tone_freq*t)
# Tạo thêm độ nhiễu cho âm thanh (lên xuoogns 1 tẹo)
noise=1001.1*np.random.rand(duration*sampling_freq)
signal+=noise
# Giảm cường độ âm thanh và kéo dãn tín hiệu
scaling_factor=np.power(2,15)-1
signal_normalize=signal/np.max(np.abs(signal))
signal_scaled=np.int16(signal_normalize*scaling_factor)
# Ghi tín hiệu âm thanh thành file
write(output_file,sampling_freq,signal_scaled)

# vẽ tín hiệu âm thanh thành biểu đồ
# Chỉ lấy 200 giá trị đầu tiên để biểu diễn cho đẹp
signal=signal[:200]
time_axis=1000*np.arange(0,len(signal),1)/float(sampling_freq) #Trục X
plt.figure()
plt.plot(time_axis,signal,color='red')
plt.xlabel('Time milisecond')
plt.ylabel('Biên độ')
plt.title('Âm thanh được tạo bằng code')
plt.show()

import json
import numpy as np
import matplotlib.pyplot as plt

from scipy.io.wavfile import write

# Tạo một hàm để tạo ra một tone (cao độ node âm thanh) dựa trên những tham số như tần số, thời gian, biên độ, tần số hz
def tone_synthesizer(freq,duration,amplitude=1.0,sampling_freq=44100):
time_axis=np.linspace(0,duration,int(duration*sampling_freq))

# Xây dựng cấu trúc tín hiệu âm thanh sử dụng những tham số được chỉ định và trả về giá trị dưới dạng npint16
signal=amplitude*np.sin(2*np.pi*freq*time_axis)
return signal.astype(np.int16)

if __name__=="__main__":
file_tone_single='fa.wav'#input("Tên file muốn lưu")
file_tone_sequence='generated_tone_sequence.wav'
# Chúng ta sử dụng file chứa tone map chứa tên nốt (tone node - La Si Do) để tạo tần số âm thanh
mapping_file='../data/chap12/tone_mapping.json'
# Tải file vào lấy tonemap từ file
with open(mapping_file,'r') as f:
tone_map=json.loads(f.read())
#Tạo nốt Fa (F) trong 3 giây:
tone_name='D'
duration=0.5
amplitude=12000
sampling_freq=44100
# lấy tần số tương ứng từ map
tone_freq=tone_map[tone_name]
# Tạo tone sử dụng hàm tổng hợp đã tạo bên trên
synthesized_tone=tone_synthesizer(tone_freq,duration,amplitude,sampling_freq)
write(file_tone_single,sampling_freq,synthesized_tone)
# Thử tạo một chuỗi nốt nhạc để làm cho âm thanh hay hơn.
#Tạo chuỗi nốt âm thanh với thời gian tương ứng
tone_squence=[('G',0.4),('G',0.4),('G',0.4),('C',0.6),('G',0.4),('G',0.4),('G',0.4),('G',0.4),('C',0.8),('D',0.4)]
# Xây dựng âm thanh dựa trên chuỗi nốt âm thanh
signal=np.array([])
for item in tone_squence:
tone_name=item[0]
freq=tone_map[tone_name]
duration=item[1]
print(freq, duration, amplitude, sampling_freq)
synthesized_tone=tone_synthesizer(freq,duration,amplitude,sampling_freq)
signal=np.append(signal,synthesized_tone)
write(file_tone_sequence,sampling_freq,signal.astype(np.int16))
#
signal=signal[2000:5000]
plt.figure()
time_axis = 1000 * np.arange(0, len(signal), 1) / float(sampling_freq) # Trục X
plt.plot(time_axis,signal)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

from scipy.io import wavfile
from features import mfcc,logfbank

# Load wave file
sampling_freq,signal=wavfile.read('../data/chap12/apple01.wav')
# Lấy 10,000 mẫu đầu tiên trong signal để phân tích

signal=signal[:10000]

# dùng hàm mfcc để phân tích MFCC
features_mfcc=mfcc(signal,sampling_freq)
# In tham số MFCC ra terminal:
print('MFCC:\nSố lượng ô =',features_mfcc.shape[0])
print('Độ lớn của mỗi features =',features_mfcc.shape[1])
#Vẽ các tính năng (features) MFCC
features_mfcc=features_mfcc.T
plt.matshow(features_mfcc)
plt.title('MFCC')

#Phân tách các bộ lọc
features_fb=logfbank(signal,sampling_freq)
print('Bộ lọc:\nSố lượng ô: =',features_fb.shape[0])
print('Độ lớn của mỗi features =',features_fb.shape[1])
#Vẽ lên biểu đồ
features_fb=features_fb.T
plt.matshow(features_fb)
plt.title('Filter Bank')
plt.show()

import os
import argparse
import warnings

import numpy as np
from scipy.io import wavfile

from hmmlearn import hmm
from features import mfcc

# Tạo class để train sử dụng HMM:
class ModelHMM(object):
def __init__(self,num_components=4,num_iter=1000):
self.n_iter=num_iter
self.n_components=num_components
self.cov_type='diag'
self.model_names='GaussianHMM'
# Tạo biến làm nơi chúng ta sẽ lưu những model của từng từ
self.models=[]
self.model=hmm.GaussianHMM(n_components=self.n_components,covariance_type=self.cov_type,n_iter=self.n_iter)
#Tạo hàm để train model
def train(self,training_data):
np.seterr(all='ignore')
cur_model=self.model.fit(training_data)
self.models.append(cur_model)
#Tạo một hàm để tính toán điểm số cho dữ liệu đầu vào:
def compute_score(self,input_data):
return self.model.score(input_data)
#Tạo một hàm để xây dựng một model cho mỗi từ trong dữ liệu training
def build_models(input_folder):
speech_models=[]
# phân tích dữ liệu thư mục input:
for dir_name in os.listdir(input_folder):
#Lấy tên của sub foler
subfolder=os.path.join(input_folder,dir_name)
if not os.path.isdir(subfolder):
continue
# Lấy nhãn
label=subfolder[subfolder.rfind('\\')+1:]
# Tạo biến X để lưu dữ liệu train
X=np.array([])
# Tạo list file sử dụng để train
training_files=[x for x in os.listdir(subfolder) if x.endswith('.wav')][:-1]
# Tạo vòng lặp tới khi train xong và xây dựng được models
for mfilename in training_files:
file_path=os.path.join(subfolder,mfilename)
# Lấy tín hiệu (signal) âm thanh từ file hiện tại
sampling_freq,signal=wavfile.read(file_path)
# Tách các MFCC features
#print(len(signal),sampling_freq)
with warnings.catch_warnings():
warnings.simplefilter('ignore')
features_mfcc = mfcc(signal, sampling_freq)
if len(X)==0:
X=features_mfcc
else:
X=np.append(X,features_mfcc,axis=0)
model=ModelHMM()
model.train(X)
speech_models.append((model,label))
model=None
return speech_models
# Tạo hàm để chạy thử nghiệm treen dữ liệu test:
def run_test(tes_files):
# Phân loại dữu liệu input
for test_file in tes_files:
sampling_freq,signal=wavfile.read(test_file)
with warnings.catch_warnings():
warnings.simplefilter('ignore')
feature_mfcc=mfcc(signal,sampling_freq)
#Tạo số điểm max_score ở mức âm vô cùng và nhãn dự đoán
max_score=-float('inf')
predicted_label=None
for item in speech_models:
model,label=item
score=model.compute_score(feature_mfcc)
if score>max_score:
# Chọn điểm tại mức điểm lớn nhất hiện tại trong số tất cả model
max_score=score
predicted_label=label
start_index=test_file.find('\\')+1
end_index=test_file.rfind('\\')

#print(test_files)
original_label=test_file[start_index:end_index]
print('Tên gốc:',original_label)
print('Tên dự đoán: ',predicted_label)

#Tạo hàm main
if __name__=='__main__':
input_folder=input('datafolder')
speech_models=build_models(input_folder)
# Chúng ta đã để lại 1 file để test trong mỗi folder. giờ thì ta sử dụng file đó để tính độ chính xác của model
test_files=[]
for root,dirs,files in os.walk(input_folder):
for filename in(x for x in files if '15' in x):
filepath=os.path.join(root,filename)
test_files.append(filepath)
run_test(test_files)