T2 - Mel Frequency Cepstral Coefficient (MFCC) 1. Importação das bibliotecas. 2. Funções para a exibição de figuras e gráficos

Transcrição

1 T2 - Mel Frequency Cepstral Coefficient (MFCC) Disciplina: Fundamentos da Computação Gráfica Nome: Priscila Ariel da Silva Santos Matrícula: Período: Importação das bibliotecas In [1]: #Importando as libs import numpy as np import matplotlib.pyplot as plt import matplotlib.cm as cm import IPython.display import math from scipy.fftpack import dct from scipy.io import wavfile 2. Funções para a exibição de figuras e gráficos As funções abaixo exibem os gráficos correspondentes ao: Sinal de áudio (plot_wav) função Hamming window (plot_window) Filter bank na escala Mel (plot_fbank) Espectrograma do sinal (plot_spectrogram) MFCCs (plot_mfcc)

2 In [2]: # Funcao de exibicao do sinal do audio def plot_wav(sample_rate, signal, title=none): time = np.arange(len(signal))/float(sample_rate) plt.figure(figsize=(30, 4)) plt.title(title) plt.fill_between(time, signal, color='b') plt.xlim(time[0], time[-1]) plt.xlabel('time (s)') plt.ylabel('amplitude') plt.savefig('plot2.png', dpi=100) plt.grid(true) plt.show() def plot_window(frame_length): n = np.arange(frame_length) h = * np.cos((2 * np.pi * n) / (frame_length-1)) plt.figure(figsize=(6, 5)) plt.title('hamming Window') plt.plot(h, label='hamming') plt.ylabel('amplitude', fontsize=16) plt.xlabel('samples', fontsize=16) plt.legend() plt.grid(true) plt.savefig('hamming_window2.png', bbox_inches='tight', dpi=200) plt.show() def plot_fbank(fbank, sample_rate, low_freq): plt.figure(figsize=(11, 2.5)) plt.title('filter bank on a Mel-Scale') plt.plot(np.linspace(low_freq, (sample_rate / 2), 257), fbank.t) plt.ylabel('amplitude', fontsize=16) plt.xlabel('frequency', fontsize=16) plt.grid(true) plt.savefig('mel_filters2.png', bbox_inches='tight', dpi=200) plt.show() def plot_spectrogram(filter_banks): plt.figure(figsize=(11, 2.5)) plt.imshow(np.flipud(filter_banks.t), cmap=cm.jet, aspect=0.2, extent=[0,4,0,4]) plt.title('spectrogram of the Signal') plt.ylabel('frequency (khz)', fontsize=16) plt.xlabel('time (s)', fontsize=16) plt.savefig('filter_banks_raw2.png', bbox_inches='tight', dpi=200) plt.show() def plot_mfcc(num_ceps, mfcc): plt.figure(figsize=(11, 2.5)) plt.imshow(np.flipud(mfcc.t), cmap=cm.jet, aspect=0.08, extent=[0,4,1,num_ceps]) plt.title('mfccs') plt.ylabel('mfcc Coefficients', fontsize=16) plt.xlabel('time (s)', fontsize=16) plt.savefig('mfcc_raw2.png', bbox_inches='tight', dpi=200) plt.show()

3 3. Leitura do áudio Leitura e exibição do sinal original. In [3]: # Lendo o audio # rate eh medido em Hertz rate, signal = wavfile.read ('english.wav') # Exibicao do sinal original (bruto) plot_wav(rate, signal, 'Sinal original') IPython.display.Audio(data=signal, rate=rate) # play the audio Out[3]: 0:00 / 0:04 4. Filtro pré-ênfase Para amplificar as altas frequências, utiliza-se um filtro pré-ênfase. O filtro pode ser aplicado em um sinal x, usando um filtro de primeira ordem: α y(t) = x(t) αx(t 1) onde é o coeficiente do filtro. Os valores mais comuns para são 0.95 ou Este trabalho adotou α = Após o cálculo do filtro de pré-ênfase, há a exibição do sinal com o filtro aplicado. α

4 In [4]: # Filtro de pre-enfase no sinal para amplificar as altas frequencias, # utilizando um filtro de primeira ordem def PreEmphasis(sig, coeff): return np.append(sig[0], sig[1:] - coeff * sig[:-1]) # Sinal com um filtro Pre-Enfase # Coeficiente = 0,97 coeff_preemph = 0.97 signal_preemph = PreEmphasis(signal, coeff_preemph) plot_wav(rate, signal_preemph, 'Sinal com o filtro pre-enfase') IPython.display.Audio(data=signal_preEmph, rate=rate) # play the audio Out[4]: 0:00 / 0:04 5. Fragmentação do sinal 5.1. Divisão do sinal em frames Como as frequências de um sinal mudam com o tempo, não faz sentido fazer a transformada de Fourier usando o sinal inteiro. Caso usasse o sinal inteiro, perderíamos os contornos de frequência do sinal ao longo do tempo. Para que isso não aconteça, é necessário dividir o sinal em frames (ou janelas) de tempos curtos. Fazendo a tranformada de Fourier nesse curto intervalo, obtemos resultados aproximados dos contornos da frequência do sinal. Normalmente os dividimos o sinal em frames de 20ms a 40ms com 50% de sobreposição entre os quadros consecutivos. Neste trabalho, usou-se 25ms para o tamanho do frame Aplicação da função Hamming window Pode-se aplicar a função Hamming para cada frame: 2πn ω[n] = 0, 54 0, 46cos( ) N 1 n N 1 N Onde 0, é o comprimento do frame. Há dois principais motivos para aplicar o filtro Hamming: Reduzir a perda espectral Contrariar a suposição da FFt de que os dados são infinitos Na sequência dos cálculos, há a exibição do gráfico correspondente à função Hamming.

5 In [5]: # Dividindo o sinal em frames def ShortFrames(sig, rate, windowlen, windowstep): # Convertenddo de segundos para amostras framelen = int(round(rate * windowlen)) framestep = int(round(rate * windowstep)) siglen = len(sig) #Garantir que tenha pelo menos 1 frame if siglen <= framelen: numframes = 1 else: numframes = int(np.ceil(float(np.abs(siglen - framelen)) / framestep)) #Certificando que todos os quadros têm o mesmo números de amostras, #sem perder informação do sinal original padlen = numframes * framestep + framelen complement = np.zeros((padlen - siglen)) padsig = np.append(sig, complement) #Segmentando o sinal #tile1 = matriz (numframes X framelen) onde cada linhas possui valores de 0 a framelen #tile2 = matriz transposta (numframes X framelen), onde a linha 1 inicia com # valores = 0 e a cada linha os valores aumentam de acordo com o framestep # Dessa forma, unindo os dois tiles, eh possivel segmentar o sinal em frames, # onde cada frame contem um pedaço dos outros frames tile1 = np.tile(np.arange(0, framelen), (numframes, 1)) tile2 = np.tile(np.arange(0, numframes*framestep, framestep), (framelen,1)).t index = tile1 + tile2 framessig = padsig[index.astype(np.int32, copy=false)] return framelen, framessig #Aplicando a funcao Hamming em cada frame def Hamming (framessig, framelen): n = np.arange(framelen) framessig *= * np.cos((2 * np.pi * n) / (framelen-1)) return framessig # Dividindo o sinal em frames window_size = window_step = 0.01 frame_len, frames = ShortFrames(signal_preEmph, rate, window_size, window_step) # Plot da funcao Hamming, usada em cada frame para contrariar a suposicao feita pela # FFT de que os dados sao infinitos e para reduzir a perda espectral plot_window(frame_len) frames = Hamming(frames, frame_len)

6 6. Transformada de Fourier e Espectro de Potência Aplica-se a Short-Time Fourier-Transform (STFT) em cada frame para calcular a frequência do espectro, onde a variável N FFT pode assumir valores entre 256 e 512. Neste trabalho adotou-se N FFT = 512. Depois calcula-se o espectro de potência: P = FFT( x i ) 2 N FFT In [6]: # Power spectrum def PowerSpec(framesMagnitude, NFFT): framespowerspec = ((framesmagnitude)**2)/nfft return framespowerspec # Magnitude da Transformada de Fourier def Magnitude(framesSig, NFFT): framesmag = np.absolute(np.fft.rfft(framessig, NFFT)) return framesmag N_fft = 512 frames_mag = Magnitude (frames, N_fft) frames_powspec = PowerSpec(frames_Mag, N_fft) 7. Filter banks O próximo passo é aplicar filtros triangulares (geralmente 40 filtros) em uma escala Mel do espectro de potência e extrair as bandas de frequência. Usa-se a escala Mel pois ela imita a percepção do ouvido humano, que é não-linear. Para converter de Hertz para Mel: f m = 2595 lo g 10 (1 + ) 700

7 Para converter de Mel para Hertz: f = 700( 10 m/2595 1) Após os cálculos anteriores, a energia é somada em cada filtro. O modelo da descrição anterior é dado por: H m (k) = 0, k f(m 1) f(m) f(m 1), 1, f(m+1) k f(m+1) f(m), 0, k < f(m 1), f(m 1) k < f(m), k = f(m), f(m) < k f(m + 1), k > (m + 1). O gráfico do filter bank na escala Mel é exibido, assim como o espectrograma do sinal.

8 In [7]: #Conversao de Hertz para a escala Mel def HzToMel (hz): return (2595 * np.log10(1+ (hz/700.0))) # Convertendo da escala Mel para Hertz def MelToHz (mel): return (700 * (10**(mel/2595.0)-1)) # Filter bank aplicado no power spectrum, para obter o espectrograma do sinal def FilterBanks(rate, NFFT, lowfreq, highfreq, numfilters, powspec): # Calculo dos pontos igualmente espacados da escala Mel scalemelpoints = np.linspace(lowfreq, highfreq, numfilters + 2) # Convertendo os pontos mel para Hz hzpoints = MelToHz(scaleMelPoints) bin = np.floor((nfft + 1) * hzpoints/rate) fbank = np.zeros((numfilters, int (np.floor(nfft/2+1)))) for j in range(1, numfilters +1): fb_left = int(bin[j-1]) # Esquerda fb_center = int(bin[j]) # Centro fb_right = int(bin[j+1]) # Direita for i in range(fb_left, fb_center): fbank[j-1, i] = (i - bin[j-1])/(bin[j] - bin[j-1]) for i in range (fb_center, fb_right): fbank[j-1, i] = (bin[j+1] - i)/(bin[j+1] - bin[j]) # Computa as enegias dos filter banks (filter bank aplicado no power spectrum) filterbanks = np.dot(powspec, fbank.t) # Trantando valores com zero para não ter problemas com log filterbanks = np.where(filterbanks == 0, np.finfo(float).eps, filterbanks) # Obtendo o logaritmo de todas as energias dos filterbanks filterbanks = 20 * np.log10(filterbanks) return fbank, filterbanks #numero de filtros triangulares usados para o calculo dos filter banks num_filters = 40 freq_low_mel = 0 # Convertendo Hertz em Mel para obter a alta frequancia freq_high_mel = HzToMel(rate/2) # Calculo dos Filter Banks f_bank, filter_banks = FilterBanks(rate, N_fft, freq_low_mel, freq_high_mel, num_filters, f # Plot do filter bank na escala Mel plot_fbank(f_bank, rate, freq_low_mel) # Plot do espectrograma do sinal plot_spectrogram(filter_banks)

9 8. Mel-frequency Cepstral Coefficients (MFCCs) A última etapa é o cálculo dos vetores de características MFCC. Aplica-se uma Transformada Discreta de Cosseno (DCT) nos filter banks, mantendo-se um número de coeficientes resultantes e o restante é descartado. Geralmente, para o reconhecimento da fala, os coeficientes ceptrais mantidos são 2-13 e o restante é descartado. Aplica-se o sinusoidal lifttering aos MFCCs para enfatizar os MFCCs mais altos para melhorar o reconhecimento de fala em sinais com ruídos, de acordo com as equações abaixo: MFCC ˆ i = ω i MFCC i ω i ceplifter πi = 1 + sin( ) 2 ceplif ter MFCC ˆ i ω i ceplifter Onde é um coeficiente cepstral, é um sinusoidal lifttering e é o levantador dos coeficientes ceptrais finais ( ceplifter = 22). Na sequência há a exibição dos MFCCs resultantes.

10 In [8]: # MFCCs (Mel-frequency Cepstral Coefficients) # Aplicação da DCT (Discrete Cosine Transform) nos filter banks enegies para evitar # problemas em algoritmos de aprendizado de maquina def MFCCs(f_banks, coeff, ceplifter): # Mantendo os coeficientes DTC 2-13 e descartando o resto mfcc_dct = dct(f_banks, type=2, axis=1, norm='ortho')[:, 1:(coeff + 1)] # Aplicando sinusoidal lifttering aos MFCCs para enfatizar os MFCCs mais altos, # para melhorar o reconhecimento de fala em sinais com ruidos (nframes_mfcc, ncoeff_mfcc) = mfcc_dct.shape n = np.arange(ncoeff_mfcc) lift = 1 + (ceplifter / 2) * np.sin(np.pi * n / ceplifter) mfcc_dct *= lift return mfcc_dct # Calculo dos MFCCs coeff_dct = 12 cep_lifter = 22 mfcc = MFCCs(filter_Banks, coeff_dct, cep_lifter) plot_mfcc(coeff_dct, mfcc) In [ ]: