IA com Python - reconhecimento de fala

Neste capítulo, aprenderemos sobre o reconhecimento de fala usando IA com Python.

A fala é o meio mais básico de comunicação humana adulta. O objetivo básico do processamento da fala é fornecer uma interação entre um ser humano e uma máquina.

O sistema de processamento de voz tem principalmente três tarefas -

  • First, reconhecimento de fala que permite que a máquina capte as palavras, frases e sentenças que falamos

  • Second, processamento de linguagem natural para permitir que a máquina entenda o que falamos, e

  • Third, síntese de voz para permitir que a máquina fale.

Este capítulo enfoca speech recognition, o processo de compreensão das palavras faladas por seres humanos. Lembre-se de que os sinais de fala são captados com o auxílio de um microfone e então devem ser compreendidos pelo sistema.

Construindo um Reconhecedor de Fala

O reconhecimento de fala ou reconhecimento automático de fala (ASR) é o centro das atenções para projetos de IA, como a robótica. Sem ASR, não é possível imaginar um robô cognitivo interagindo com um humano. No entanto, não é muito fácil construir um reconhecedor de fala.

Dificuldades em desenvolver um sistema de reconhecimento de voz

O desenvolvimento de um sistema de reconhecimento de voz de alta qualidade é realmente um problema difícil. A dificuldade da tecnologia de reconhecimento de voz pode ser amplamente caracterizada ao longo de uma série de dimensões, conforme discutido abaixo -

  • Size of the vocabulary- O tamanho do vocabulário afeta a facilidade de desenvolvimento de um ASR. Considere os seguintes tamanhos de vocabulário para uma melhor compreensão.

    • Um vocabulário de tamanho pequeno consiste em 2-100 palavras, por exemplo, como em um sistema de menu de voz

    • Um vocabulário de tamanho médio consiste em várias centenas a 1.000 de palavras, por exemplo, como em uma tarefa de recuperação de banco de dados

    • Um vocabulário de tamanho grande consiste em vários 10.000 palavras, como em uma tarefa de ditado geral.

    Observe que quanto maior o tamanho do vocabulário, mais difícil é realizar o reconhecimento.

  • Channel characteristics- A qualidade do canal também é uma dimensão importante. Por exemplo, a fala humana contém alta largura de banda com faixa de frequência total, enquanto a fala por telefone consiste em baixa largura de banda com faixa de frequência limitada. Observe que é mais difícil no último.

  • Speaking mode- A facilidade de desenvolver um ASR também depende do modo de fala, ou seja, se a fala está em modo de palavra isolada, ou modo de palavra conectada, ou em modo de fala contínua. Observe que uma fala contínua é mais difícil de reconhecer.

  • Speaking style- Um discurso lido pode ser em estilo formal ou espontâneo e coloquial com estilo casual. Este último é mais difícil de reconhecer.

  • Speaker dependency- A fala pode ser dependente do locutor, adaptável do locutor ou independente do locutor. Um alto-falante independente é o mais difícil de construir.

  • Type of noise- O ruído é outro fator a considerar ao desenvolver um ASR. A relação sinal-ruído pode estar em vários intervalos, dependendo do ambiente acústico que observa menos ou mais ruído de fundo -

    • Se a relação sinal-ruído for maior que 30dB, é considerada uma faixa alta

    • Se a relação sinal-ruído estiver entre 30dB e 10db, é considerado como SNR médio

    • Se a relação sinal-ruído for inferior a 10dB, é considerada uma faixa baixa

    Por exemplo, o tipo de ruído de fundo como estacionário, ruído não humano, fala de fundo e diafonia de outros alto-falantes também contribui para a dificuldade do problema.

  • Microphone characteristics- A qualidade do microfone pode ser boa, média ou abaixo da média. Além disso, a distância entre a boca e o microfone pode variar. Esses fatores também devem ser considerados para sistemas de reconhecimento.

Apesar dessas dificuldades, os pesquisadores trabalharam muito em vários aspectos da fala, como entender o sinal da fala, o locutor e identificar os sotaques.

Você terá que seguir as etapas abaixo para construir um reconhecedor de fala -

Visualizando sinais de áudio - Lendo de um arquivo e trabalhando nele

Esta é a primeira etapa na construção de um sistema de reconhecimento de voz, pois dá uma compreensão de como um sinal de áudio é estruturado. Algumas etapas comuns que podem ser seguidas para trabalhar com sinais de áudio são as seguintes -

Gravação

Quando você tiver que ler o sinal de áudio de um arquivo, grave-o usando um microfone, primeiro.

Amostragem

Ao gravar com microfone, os sinais são armazenados em formato digitalizado. Mas para trabalhar nisso, a máquina precisa deles na forma numérica discreta. Portanto, devemos realizar a amostragem em uma certa frequência e converter o sinal na forma numérica discreta. A escolha da alta frequência para amostragem implica que, quando os humanos ouvem o sinal, eles o sentem como um sinal de áudio contínuo.

Exemplo

O exemplo a seguir mostra uma abordagem passo a passo para analisar um sinal de áudio, usando Python, que é armazenado em um arquivo. A frequência deste sinal de áudio é 44.100 Hz.

Importe os pacotes necessários conforme mostrado aqui -

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

Agora, leia o arquivo de áudio armazenado. Ele retornará dois valores: a frequência de amostragem e o sinal de áudio. Forneça o caminho do arquivo de áudio onde ele está armazenado, conforme mostrado aqui -

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

Exiba os parâmetros como frequência de amostragem do sinal de áudio, tipo de dados do sinal e sua duração, usando os comandos mostrados -

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')

Esta etapa envolve a normalização do sinal conforme mostrado abaixo -

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

Nesta etapa, estamos extraindo os primeiros 100 valores desse sinal para visualização. Use os seguintes comandos para este propósito -

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

Agora, visualize o sinal usando os comandos fornecidos abaixo -

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

Você seria capaz de ver um gráfico de saída e dados extraídos para o sinal de áudio acima, conforme mostrado na imagem aqui 

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

Caracterizando o Sinal de Áudio: Transformando em Domínio de Freqüência

A caracterização de um sinal de áudio envolve a conversão do sinal do domínio do tempo em domínio da frequência e a compreensão de seus componentes de frequência. Esta é uma etapa importante porque fornece muitas informações sobre o sinal. Você pode usar uma ferramenta matemática como a transformada de Fourier para realizar essa transformação.

Exemplo

O exemplo a seguir mostra, passo a passo, como caracterizar o sinal, em Python, que fica armazenado em um arquivo. Observe que aqui estamos usando a ferramenta matemática transformada de Fourier para convertê-la no domínio da frequência.

Importe os pacotes necessários, conforme mostrado aqui -

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

Agora, leia o arquivo de áudio armazenado. Ele retornará dois valores: a frequência de amostragem e o sinal de áudio. Forneça o caminho do arquivo de áudio onde ele está armazenado, conforme mostrado no comando aqui -

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

Nesta etapa, exibiremos os parâmetros como frequência de amostragem do sinal de áudio, tipo de dados do sinal e sua duração, usando os comandos fornecidos abaixo -

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')

Nesta etapa, precisamos normalizar o sinal, conforme mostrado no seguinte comando -

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

Esta etapa envolve a extração do comprimento e metade do comprimento do sinal. Use os seguintes comandos para este propósito -

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

Agora, precisamos aplicar ferramentas matemáticas para a transformação no domínio da frequência. Aqui estamos usando a transformada de Fourier.

signal_frequency = np.fft.fft(audio_signal)

Agora, faça a normalização do sinal no domínio da frequência e eleve-o ao quadrado -

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

Em seguida, extraia o comprimento e metade do comprimento do sinal transformado de frequência -

len_fts = len(signal_frequency)

Observe que o sinal transformado de Fourier deve ser ajustado para casos pares e ímpares.

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

Agora, extraia a potência em decibal (dB) -

signal_power = 10 * np.log10(signal_frequency)

Ajuste a frequência em kHz para o eixo X -

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

Agora, visualize a caracterização do sinal da seguinte forma -

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

Você pode observar o gráfico de saída do código acima, conforme mostrado na imagem abaixo -

Gerando Sinal de Áudio Monótono

As duas etapas que você viu até agora são importantes para aprender sobre os sinais. Agora, esta etapa será útil se você deseja gerar o sinal de áudio com alguns parâmetros predefinidos. Observe que esta etapa salvará o sinal de áudio em um arquivo de saída.

Exemplo

No exemplo a seguir, vamos gerar um sinal monótono, usando Python, que será armazenado em um arquivo. Para isso, você terá que seguir os seguintes passos -

Importe os pacotes necessários conforme mostrado -

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

Forneça o arquivo onde o arquivo de saída deve ser salvo

output_file = 'audio_signal_generated.wav'

Agora, especifique os parâmetros de sua escolha, como mostrado -

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

Nesta etapa, podemos gerar o sinal de áudio, conforme mostrado -

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

Agora, salve o arquivo de áudio no arquivo de saída -

write(output_file, frequency_sampling, signal_scaled)

Extraia os primeiros 100 valores para o nosso gráfico, conforme mostrado -

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

Agora, visualize o sinal de áudio gerado da seguinte forma -

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

Você pode observar o gráfico conforme mostrado na figura dada aqui -

Extração de recurso da fala

Esta é a etapa mais importante na construção de um reconhecedor de fala porque, depois de converter o sinal de fala no domínio da frequência, devemos convertê-lo na forma utilizável de vetor de características. Podemos usar diferentes técnicas de extração de recursos como MFCC, PLP, PLP-RASTA etc. para esse propósito.

Exemplo

No exemplo a seguir, vamos extrair os recursos do sinal, passo a passo, usando Python, usando a técnica MFCC.

Importe os pacotes necessários, conforme mostrado aqui -

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

Agora, leia o arquivo de áudio armazenado. Ele retornará dois valores - a frequência de amostragem e o sinal de áudio. Forneça o caminho do arquivo de áudio onde ele está armazenado.

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

Observe que aqui estamos pegando as primeiras 15.000 amostras para análise.

audio_signal = audio_signal[:15000]

Use as técnicas do MFCC e execute o seguinte comando para extrair os recursos do MFCC -

features_mfcc = mfcc(audio_signal, frequency_sampling)

Agora, imprima os parâmetros MFCC, como mostrado -

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

Agora, plote e visualize os recursos MFCC usando os comandos fornecidos abaixo -

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

Nesta etapa, trabalhamos com os recursos do banco de filtros, conforme mostrado -

Extraia os recursos do banco de filtros -

filterbank_features = logfbank(audio_signal, frequency_sampling)

Agora, imprima os parâmetros do banco de filtros.

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

Agora, plote e visualize os recursos do banco de filtros.

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

Como resultado das etapas acima, você pode observar as seguintes saídas: Figura 1 para MFCC e Figura 2 para Banco de filtros

Reconhecimento de palavras faladas

O reconhecimento de fala significa que, quando os humanos estão falando, uma máquina o entende. Aqui, estamos usando a API do Google Speech em Python para fazer isso acontecer. Precisamos instalar os seguintes pacotes para isso -

  • Pyaudio - Pode ser instalado usando pip install Pyaudio comando.

  • SpeechRecognition - Este pacote pode ser instalado usando pip install SpeechRecognition.

  • Google-Speech-API - Pode ser instalado usando o comando pip install google-api-python-client.

Exemplo

Observe o exemplo a seguir para entender sobre o reconhecimento de palavras faladas -

Importe os pacotes necessários conforme mostrado -

import speech_recognition as sr

Crie um objeto como mostrado abaixo -

recording = sr.Recognizer()

Agora o Microphone() o módulo terá a voz como entrada -

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

Agora, a API do Google reconheceria a voz e forneceria a saída.

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

Você pode ver a seguinte saída -

Please Say Something:
You said:

Por exemplo, se você disse tutorialspoint.com, então o sistema o reconhece corretamente da seguinte maneira -

tutorialspoint.com