Categorias
Desenvolvimento Inteligência Artificial Python

Reconhecimento de fala com Python

Inteligência Artificial e Aprendizado de Máquina pode ser complexo demais de entender, mas aqui você vai fazer um simples reconhecimento e fala usando Python .

Ok Google, ligar maquina de café… Hey Siri, tocar minha playlist de pagodão… Alexa, começar nova postagem…

Este autor sobre Inteligência Artificial

Como é que estão meus amiguinhos, tudo uma beleza? Eu espero que sim, bom dia 31 de dezembro de 2020 e trago um post muito curto mas também muito legal para brincar e se divertir. Hoje vamos aprender a fazer em Python um reconhecedor de fala. Você vai falar uma palavra ou frase e o algoritmo irá transcrever tua fala. Muito legal né? Vamos com uma histórinha antes?

Nosso fascínio por Inteligência Artificial

Comecei esta postagem com uma piadinha, falando das assistentes pessoais da Google, Apple e Amazon respectivamente. Pois é, eu sou um usuário dessas assistentes de voz e sempre achei o máximo o quanto as máquinas podem nos entender e de forma mais humana possível interagir conosco. A cada dia mais estamos mergulhados em Inteligência Artificial e Aprendizado de Máquina (Machine Learning) e não damos conta disso se não pararmos e pensarmos que o maior motivo da evolução destas assistentes é porque elas treinam com a gente mesmo, maluco pensar isso né?

Mas tudo isso teve um começo muito antes de um computador pudesse estar na nossa casa, quiçá no bolso ou na tomada de nossa casa. Os registros nos mostram que os primeiros algoritmos desenvolvidos para reconhecimento de fala foram desenvolvidos na década de 50 nos Laboratórios Bell Labs, era uma máquina chamada Audrey e com uma taxa significativa de acertos, ela conseguia entender números de 0 a 9.

“Ok Audrey, eu ainda não sei o que fazer com você porque não temos internet ainda!” – Primeiro comando dado para o Audrey (to de brinks)

Alguns anos depois, a IBM apresenta a Shoebox (Caixa de sapato) que consegui entender 16 palavras em inglês. Parece que não era muito, mas estamos falando de 1962, se pensar em Inteligência Artificial e Aprendizado de Máquina pode parecer muito complexo, imagine só em 1962.

Na década de 70, o Departamento de Defesa dos Estados Unidos da América em conjunto com a Universidade CarnegieMellon, desenvolveram o Harpy, esse sistema consegui compreender o total de 1011 palavras, um vocabulário parecido com uma criança de 3 anos.

E enfim chegamos na década de 80 quando as coisas começam a ter um impulso maior com o Modelo Oculto de Markov, uma técnica de análise estatística e que a maioria dos sistemas atuais se baseiam.

Mas como isso funciona?

Boa pergunta, vamos tentar entender de um modo simples. O sinal do que falamos é divido em partes de 10 milisegundos, o espectro de energia de cada parte (nada mais é quer um gráfico) é mapeado para um vetor de números reais que leva o nome de coeficientes cepstrais (Procure no Wikipedia por Cepstrum caso queira entender o que é isso).

É como se dividissemos a fala em sílabas, então cada parte desse texto são combinadas com um ou mais fonemas. É um cálculo que requer treinamento (machine learning) já que o som desses fonemas podem variar de pessoa pra pessoa. E assim um algoritmo que determina qual palavra seja mais provável entra em ação e quase sempre acerta!

Tá.. já deu pra ter uma leve noção de como funciona e até como surgiu não é? Vamos então fazer nosso “Hello World” de reconhecimento de fala? Bora lá!

Índice

  1. Preparando ambiente (Linux)
    1. Instalando Anaconda
    2. Criando ambiente Anaconda
    3. Instalando pacotes necessários
  2. Código Python
  3. Testando
  4. Challenge

1. Preparando Ambiente (Linux)

Se você é novo aqui, saiba que sempre em meus tutorias, o sistema operacional que será utilizados nos exemplos será o Ubuntu, se você usa Windows ainda, dê uma chance ao Linux, não precisa utilizar o Ubuntu, existem muitas distros Linux que com certeza alguma delas ganhará teu coração.

Eu tenho em meu Ubuntu o Python 3.8 instalado, caso você não saiba qual versão do Python instalado em sua máquina, basta executar o seguinte comando no terminal: python --version.

No Python 3.8, alguns pacotes usados para este exemplo estão incompatíveis ainda, então precisei fazer um downgrade, mas para fazer isso de forma mais profissional, eu resolvi usar o Anaconda. O Anaconda é uma ferramenta que nos permite criar vários ambientes com seus respectivos pacotes ou versões Python sem precisar reinstalar o Python na sua máquina ou até mesmo reinstalar, você muda fácilmente entre um e outro usando apenas uma linha de comando.

1.1. Instalando Anaconda

Para o nosso exemplo, eu estou utilizando a versão 2020.02 do Anaconda, mas você deve usar a última versão estável se ela estiver disponível. Você pode encontrar a versão mais recente do Anaconda para Python 3 na página Anaconda Downloads.

Em seguida, mude para o diretório /tmp. Este é um bom diretório para baixar itens temporários como o script bash do Anaconda, que não vamos mais precisar depois de executá-lo.

cd /tmp

Use o curl para baixar o link que você copiou do site do Anaconda. Vamos usar a saída para enviar para um arquivo chamado anaconda.sh para um uso mais rápido.

curl https://repo.anaconda.com/archive/Anaconda3-2020.02-Linux-x86_64.sh --output anaconda.sh

Agora, podemos executar o script:

bash anaconda.sh

Você receberá o seguinte resultado:

Output
Welcome to Anaconda3 2020.02

In order to continue the installation process, please review the license
agreement.
Please, press ENTER to continue
>>>  

Pressione ENTER para continuar e, em seguida, pressione ENTER para ler toda a licença. Assim que terminar de ler a licença, você será solicitado a aprovar os termos da mesma:

Output
Do you approve the license terms? [yes|no]

Assim que você concordar, digite yes.

Neste ponto, você será solicitado a escolher a localização da instalação. Você pode pressionar ENTER para aceitar a localização padrão ou especificar uma localização diferente para modificá-la.

Output
Anaconda3 will now be installed into this location:
/home/darthvader/anaconda3

  - Press ENTER to confirm the location
  - Press CTRL-C to abort the installation
  - Or specify a different location below

[/home/darthvader/anaconda3] >>>

O processo de instalação irá continuar. Observe que isso pode levar algum tempo.

Quando a instalação for concluída, você receberá a seguinte saída:

Output...
Preparing transaction: done
Executing transaction: done
installation finished.
Do you wish the installer to initialize Anaconda3
by running conda init? [yes|no]
[no] >>>

Digite yes para que você possa inicializar o Anaconda3. Você receberá uma saída que informa as alterações feitas em vários diretórios. Uma das linhas que você receber o agradecerá por instalar o Anaconda.

Output...
Thank you for installing Anaconda3!
...

Agora, você pode ativar a instalação, fazendo um source no arquivo ~/.bashrc:

source ~/.bashrc

Assim que tiver feito isso, você será levado ao ambiente de programação padrão de base do Anaconda, e seu prompt de comando mudará para o seguinte:


(base) darthvader@ubuntu:~$ 

Embora o Anaconda venha com este ambiente de programação padrão de base, você deve criar ambientes separados para seus programas e mantê-los isolados um do outro.

Você pode ainda verificar sua instalação fazendo o uso do comando conda, por exemplo com list:

conda list

Você receberá a saída de todos os pacotes que você tem disponível através da instalação do Anaconda.

Output# packages in environment at /home/sammy/anaconda3:
#
# Name                    Version                   Build  Channel
_ipyw_jlab_nb_ext_conf    0.1.0                    py37_0  
_libgcc_mutex             0.1                        main  
alabaster                 0.7.12                   py37_0  
anaconda                  2020.02                  py37_0  
...

Agora que o Anaconda está instalado, podemos seguir em frente para a configuração dos ambientes dele.

1.2. Criando ambiente Anaconda

Os ambientes virtuais do Anaconda lhe permitem manter projetos organizados pelas versões do Python e pelos pacotes necessários. Para cada ambiente do Anaconda que você configurar, especifique qual versão do Python usar e mantenha todos os arquivos de programação relacionados dentro desse diretório.

Vamos criar um ambiente usando a versão do Python 3.6 que é compatível com o que precisamos. Podemos conseguir isso atribuindo a versão 3 ao argumento python. Vamos chamar o ambiente de sr_env, mas você pode usar um nome mais descritivo para o ambiente.

conda create --name sr-env python=3.6

Você receberá uma saída com informações sobre o que está baixado e quais pacotes serão instalados, e, em seguida, será solicitado a prosseguir com y ou n. Assim que você concordar, digite y.

A utilitário conda agora irá obter os pacotes para o ambiente e informá-lo assim que estiver concluído.

Você pode ativar seu novo ambiente digitando o seguinte:

conda activate sr_env

1.3. Instalando pacotes necessários

Vamos então instalar as duas bibliotecas principais: Speech-Recognition e PyAudio e é só dessas duas que precisaremos.

(sr_env) darthvader@ubuntu:~$ pip install SpeechRecognition pyaudio

Pronto, os dois módulos que precisamos estão instalados… bora botar a mão na massa!

2. Código Python

Começaremos importando tudo o que vamos precisar:

import time
from datetime import datetime
import speech_recognition as sr

Vamos começar criando um método vazio, ele será nosso método de callback, mas falaremos dele mais abaixo, faremos apenas assim:

#Começaremos criano o método de callback que será chamado quando a captura do microfone for concluído
def callback(recognizer, audio):
    return None

Então agora começaremos a criar nossa variável no Recognizer e Microphone, ambos do pacote speech_recognition

r = sr.Recognizer()
m = sr.Microphone()

Vamos calibrar nosso microfone para se adaptar ao ruído do ambiente

with m as source:
    r.adjust_for_ambient_noise(source, duration=2)  
    # Usamos este método para calibrar o microfone, ele é executado apenas uma vez

Começaremos à ouvir nosso microfone em background. Perceba que por parametro eu passei o microfone, o método de callback que apenas definimos lá em cima e um tempo limite de frase que defini a cada 5 segundos, escolhi fazer assim porque dependendo da sua configuração de microfone, se não por um tempo fixo, pode demorar muito para o algoritmo realmente reconhecer o silêncio.

print('Diga alguma coisa:')
# Começará ouvir em segundo plano. 
# Note que não temos que fazer isso dentro de uma instrução 'with'
listening = r.listen_in_background(m, callback, phrase_time_limit=5)

E para que o sistema não pare a execução, causeremos um loop infinito proporcional. Aproveitaremos para incluir a anotação do horário para que tenhamos uma noção do tempo de resposta.

# Manteremos um loop infinito com um contador que servirá para mostrar que
# continuamos a ouvir em segundo plano.
while True: 
    print(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
    time.sleep(3)

Agora vamos voltar lá no nosso método callback. O que vamos fazer nele? Nós iremos, dentro de um bloco try informar no console que o reconhecimento começou e qual a resposta do reconhecimento, utlizei um padrão de horário nos print() apenas pra gente ver o tempo com que isso acontece.

# Começaremos criando o método de callback que será chamado quando a captura do microfone for concluído
def callback(recognizer, audio):
    # Vamo usar o Google Speech Recognition para reconhecer o áudio
    try:
        now = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
        print(f"{now} - O que será que você disse?")
        recognized = recognizer.recognize_google(audio, language="pt-BR")
        now = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
        print(f"{now} - Google Speech Recognition acha que você disse: {recognized}")
    except sr.UnknownValueError:
        now = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
        print(f"{now} - Google Speech Recognition não conseguiu reconhecer o áudio")
    except sr.RequestError as e:
        now = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
        print(f"{now} - O serviço do Google Speech Recognition falhou; {0}".format(e))
Pronto… é só isso

3. Testando

4. Challenge

Acesso o meu GitHub e você terá acesso à um módulo Python chamado game.py. É um game que eu peguei e fiz algumas traduções e adaptações usando o reconhecimneto de fala. Use ele para fazer suas adaptações ou até mesmo, com base nele, criar jogos novos! Não esqueça de me mandar o projeto com teu joguinho!

Todo este tutorial está disponível em meu GitHub.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *