Quero fazer o processamento de fala no Raspberry Pi para detectar pessoas específicas (algo como identificação exclusiva).

Eu preferiria usar apenas o processador on-board para isso; você poderia assumir que a Internet não está acessível.

Além disso, quais são as limitações do Raspberry Pi executando o processamento de fala? Se eu quiser usar isso como uma máquina de atendimento automático, como devo proceder?

Este é o principal projeto ao qual meu Raspberry Pi está dedicado agora, então acho que posso adicionar meus dois centavos. Lembre-se de que este projeto ainda é um trabalho em andamento.

Eu escolhi usar a linguagem de programação C para este projeto exclusivamente no sistema operacional Raspbian, e isso pode ter afetado algumas das minhas decisões e instruções. Vou listar apenas softwares livres e de código aberto , pois é tudo o que eu uso.

Para as instruções de instalação, assumirei que você possui um sistema totalmente atualizado .

Reconhecimento de fala

Aqui estão algumas opções para os mecanismos de reconhecimento de fala :

1. Pocketsphinx - Uma versão do Sphinx que pode ser usada em sistemas embarcados (por exemplo, com base em um processador ARM).

   • Prós : em desenvolvimento ativo e incorpora recursos como aritmética de ponto fixo e algoritmos eficientes para computação GMM . Todo o processamento ocorre no Raspberry Pi, portanto ele pode ser usado offline. Suporta reconhecimento de fala em tempo real

   • Contras : é complicado de configurar e entender para iniciantes. Para mim, era muito impreciso para minha inscrição. Todo o processamento ocorre no Raspberry Pi, tornando-o um pouco mais lento.

   • Instruções de instalação :

     1. Faça o download das versões estáveis ​​mais recentes do Sphinxbase e Pocketsphinx :

        $ wget http://sourceforge.net/projects/cmusphinx/files/sphinxbase/0.8/sphinxbase-0.8.tar.gz
        $ wget http://sourceforge.net/projects/cmusphinx/files/pocketsphinx/0.8/pocketsphinx-0.8.tar.gz
        

     2. Extraia os arquivos baixados:

        $ tar -zxvf pocketsphinx-0.8.tar.gz; rm -rf pocketsphinx-0.8.tar.gz
        $ tar -zxvf sphinxbase-0.8.tar.gz; rm -rf sphinxbase-0.8.tar.gz
        

     3. Para compilar esses pacotes, você precisará instalar o bison e os cabeçalhos de desenvolvimento da ALSA.

        NOTA : É importante que os cabeçalhos da ALSA sejam instalados antes da criação do Sphinxbase. Caso contrário, o Sphinxbase não utilizará o ALSA. Parece também que o ALSA não será usado se o PulseAudio estiver instalado (algo ruim para desenvolvedores como eu).

        $ sudo apt-get install bison libasound2-dev
        

     4. cd no diretório Sphinxbase e digite os seguintes comandos:

        $ ./configure --enable-fixed
        $ sudo make
        $ sudo make install
        

     5. cd no diretório Pocketsphinx e digite os seguintes comandos:

        $ ./configure
        $ sudo make
        $ sudo make install
        

     6. Teste o Pocketsphinx executando:

        $ src/programs/pocketsphinx_continuous -samprate 48000 
        

        Se você quiser ajustá-lo, recomendo que você leia algumas informações no Wiki do CMUSphinx .

2. libsprec - Uma biblioteca de reconhecimento de fala desenvolvida pelo H2CO3 (com poucas contribuições de minha parte, principalmente correções de bugs).

   • Prós : usa a API do Google Speech , tornando-a mais precisa. O código é mais fácil de entender (na minha opinião).

   • Contras : Possui dependências de outras bibliotecas que o H2CO3 desenvolveu (como a libjsonz ). O desenvolvimento é irregular. Ele usa a API do Google Speech, ou seja, o processamento não ocorre no próprio Raspberry Pi e requer uma conexão à Internet. Requer uma pequena modificação no código-fonte antes da compilação para funcionar corretamente no Raspberry Pi.

   • Instruções de instalação :

     1. Instale libflac , libogg e libcurl :

        $ sudo apt-get install libcurl4-openssl-dev libogg-dev libflac-dev
        

     2. Baixe a versão mais recente do libsprec

        $ wget https://github.com/H2CO3/libsprec/archive/master.zip
        

     3. Descompacte o pacote baixado:

        $ unzip master.zip; rm -rf master.zip
        

        Agora você deve ter uma pasta nomeada libsprec-masterem seu diretório atual.

     4. Baixe a versão mais recente do libjsonz :

        $ wget https://github.com/H2CO3/libjsonz/archive/master.zip
        

     5. Descompacte o pacote baixado:

        $ unzip master.zip; rm -rf master.zip
        

        Agora você deve ter uma pasta nomeada libjsonz-masterem seu diretório atual.

     6. cdno libjsonz-masterdiretório, compile e instale:

        $ cd libjsonz-master
        $ mv Makefile.linux Makefile
        $ make
        $ sudo make install
        

     7. cdfora do libjsonz-masterdiretório e no libsprec-master/srcdiretório. Edite a linha 227:

        $ err = snd_pcm_open(&handle, "pulse", SND_PCM_STREAM_CAPTURE, 0);
        

        Precisamos disso para dizer:

        $ err = snd_pcm_open(&handle, "plughw:1,0", SND_PCM_STREAM_CAPTURE, 0);
        

        Isso é feito para que o programa use o ALSA para apontar para o microfone USB.

     8. Compile e instale:

        $ mv Makefile.linux Makefile
        $ make
        $ sudo make install
        

     9. Agora você pode usar a biblioteca em seus próprios aplicativos. Procure na pasta de exemplo em libsprec-masterexemplos.

3. Julius - Umsoftware de decodificador dereconhecimento contínuo de voz ( LVCSR ) dealto desempenho e duas passagenspara pesquisadores e desenvolvedores relacionados à fala.

   • Prós : ele pode executar o reconhecimento de fala quase em tempo real no próprio Raspberry Pi. Formatos padrão de modelos de fala são adotados para lidar com outros kits de ferramentas de modelagem gratuitos.

   • Contras : Desenvolvimento irregular, com sua última atualização há mais de um ano. Seu reconhecimento também é muito impreciso e lento para o meu uso. Longo tempo de instalação

   • Instruções de instalação :

     1. Existem alguns pacotes que precisamos instalar para que o sistema funcione corretamente:

        $ sudo apt-get install alsa-tools alsa-oss flex zlib1g-dev libc-bin libc-dev-bin python-pexpect libasound2 libasound2-dev cvs
        

     2. Faça o download do Julius da fonte do CVS:

        $ cvs -z3 -d:pserver:[email protected]:/cvsroot/julius co julius4
        

     3. Defina os sinalizadores do compilador pelas variáveis ​​de ambiente:

        $ export CFLAGS="-O2 -mcpu=arm1176jzf-s -mfpu=vfp -mfloat-abi=hard -pipe -fomit-frame-pointer"
        

     4. cdna pasta julius4e digite os seguintes comandos

        $ ./configure --with-mictype=alsa
        $ sudo make
        $ sudo make install
        

     5. Julius precisa de uma variável de ambiente chamada ALSADEVpara dizer qual dispositivo usar para um microfone:

        $ export ALSADEV="plughw:1,0"
        

     6. Faça o download de um modelo acústico gratuito para Julius usar. Depois de fazer o download, cdentre no diretório e execute:

        $ julius -input mic -C julius.jconf
        

        Depois disso, você poderá iniciar a entrada de fala.

4. Crie sua própria biblioteca - para o meu projeto específico, optei por criar minha própria biblioteca de reconhecimento de fala que grava áudio de um microfone USB usando ALSA via PortAudio , armazena-o em um arquivo FLAC via libsndfile e envia-o ao Google para que eles processem isto. Eles então me enviam um arquivo JSON bem compactado que eu processo para obter o que disse ao meu Raspberry Pi.

   • Prós : eu controlo tudo (do que gosto). Eu aprendo muito (do que gosto).

   • Contras : É muito trabalho. Além disso, algumas pessoas podem argumentar que, na verdade, eu não estou processando o Raspberry Pi com esta biblioteca de reconhecimento de fala. Eu sei que . O Google pode processar meus dados com muito mais precisão do que agora. Estou trabalhando na criação de uma opção precisa de reconhecimento de fala offline.

Síntese de fala

Aqui estão algumas opções para os mecanismos de síntese de fala :

1. tritium - Um mecanismo de síntese de fala de qualidade premium gratuito, escrito completamente em C (e desenvolvido verdadeiramente pelo seu).

   • Prós: Extremamente portátil (sem dependências além do CMake para construir), extremamente pequeno (o menor que eu poderia encontrar), fácil de construir.

   • Contras: A saída da fala em si pode ser imprecisa às vezes. O suporte para uma ampla variedade de idiomas está ausente, pois eu sou o único desenvolvedor no momento, com pouco tempo livre, mas esse é um dos objetivos futuros do projeto. Além disso, a partir de agora apenas uma biblioteca é impressa quando compilada e nenhum executável utilizável / testável.

2. eSpeak - Um sintetizador de fala compacto de software de código aberto para Linux, Windows e outras plataformas.

   • Prós : Ele usa um método de síntese de formantes , fornecendo muitos idiomas falados em um tamanho pequeno. Também é muito preciso e fácil de entender. Eu originalmente usei isso no meu projeto, mas por causa dos contras, tive que mudar para outro mecanismo de síntese de fala.

   • Contras : Possui algumas dependências estranhas no X11 , causando algumas vezes gaguejamento. A biblioteca também é consideravelmente grande em comparação com outras.

   • Instruções de instalação :

     1. Instale o software eSpeak:

        $ sudo apt-get install espaek
        

     2. Para dizer o que você quer no eSpeak:

        $ espeak "Hello world"
        

        Para ler de um arquivo no eSpeak:

        $ espeak -f <file>
        

3. Festival - Um sistema geral de síntese de fala multilíngue.

   • Prós : Ele foi projetado para suportar vários idiomas falados. Ele pode usar o projeto Festvox, que visa tornar a construção de novas vozes sintéticas mais sistemática e melhor documentada, possibilitando que qualquer pessoa construa uma nova voz.

   • Contras : Está escrito em C ++ (mais especificamente para mim). Ele também tem uma base de código maior, então seria difícil para mim entender e portar o código.

   • Instruções de instalação :

     1. Instale o software Festival:

        $ sudo apt-get install festival festival-freebsoft-utils
        

     2. Para executar o Festival, coloque o texto ou o arquivo que você deseja ler:

        $ echo  "Hello world" | festival --tts
        

4. Flite - Um pequeno mecanismo de síntese de fala em tempo de execução, derivado do Festival e do projeto Festvox.

   • Prós : Em constante desenvolvimento na Carnegie Mellon University. Motor muito pequeno comparado a outros. Ele também tem uma base de código menor, portanto é mais fácil passar. Ele quase não tem dependências (um grande profissional para mim e outra razão pela qual decidi usar esse mecanismo no meu projeto).

   • Contras : A saída de fala em si nem sempre é precisa. O discurso tem um som não metálico e não humano (mais do que os outros motores). Não suporta muitos idiomas.

   • Instruções de instalação :

     1. Instale o software Flite:

        $ sudo apt-get install flite
        

     2. Para executar o Flite:

        $ flite -t "text that you want flite to say"
        

Respostas para suas perguntas específicas :

Quais são as limitações do Pi executando o processamento de fala?

Programadores não têm limites. :P

Em uma nota mais séria, o Raspberry Pi possui muitos recursos para lidar com o processamento de fala. Desde que a pessoa que executa o processamento da fala saiba o que está fazendo, o Raspberry Pi deve ser capaz de lidar bem com isso.

Quero usar esta máquina de atendimento automático, como devo proceder?

Nenhuma dessas opções é precisa o suficiente para diferenciar pessoas específicas ainda . Isso é algo em que estou trabalhando no meu projeto (e provavelmente será por um tempo). Se você está procurando uma opção melhor para o comparecimento automático, eu examinaria o reconhecimento facial . Porém, existem mais limitações no reconhecimento facial para o Raspberry Pi, então lembre-se disso.

Fui com pocketsphinx_continuous e uma placa de som de US $ 4 .

Para gerenciar o fato de que ele precisa parar de ouvir ao usar o sintetizador de voz, usei o amixer para manipular a entrada de volume no microfone (essa foi a melhor prática recomendada pela CMU, pois o mecanismo de parada de partida resultará em um reconhecimento mais fraco)

echo "SETTING MIC IN TO 15 (94%)" >> ./audio.log
amixer -c 1 set Mic 15 unmute 2>&1 >/dev/null 

Com um comando correspondente para silenciar a audição quando o sintetizador de voz é reproduzido

FILE: mute.sh
#!/bin/sh

sleep $1;
amixer -c 1 set Mic 0 unmute >/dev/null 2>&1 ; 
echo  "** MIC OFF **" >> /home/pi/PIXIE/audio.log

Para calcular os horários certos para silenciar, basta executar o soxi via lua e defina o unmute.sh (oposto ao mute.sh) para executar "x" segundos a partir da inicialização. Não há dúvida de muitas maneiras de lidar com isso. Estou feliz com os resultados desse método.

LUA SNIPPET:

-- Begin parallel timing  
-- MUTE UNTIL THE SOUNDCARD FREES UP 
-- "filename" is a fully qualified path to a wav file 
-- outputted by voice synth in previous operation

-- GET THE LENGTH
local sample_length = io.popen('soxi -D '..filename);
local total_length  = sample_length:read("*a"); 
clean_length = string.gsub(total_length, "\n", "") +1;  
sample_length:close();

-- EXAMPLE LOGGING OUTPUT...
--os.execute( 'echo LENGTH WAS "'.. clean_length .. '" Seconds  >> ./audio.log');   



-- we are about to play something... 
-- MUTE, then schedule UNMUTE.sh in x seconds, then play synth output
-- (have unrolled mute.sh here for clarity)

os.execute( 'amixer -c 1 set Mic '..mic_level..' unmute 2>&1 >/dev/null ');
os.execute( 'echo "** MIC OFF **"  >> ./audio.log ');

-- EXAMPLE LOGGING OUTPUT...    
-- os.execute( 'echo PLAYING: "'.. filename..'" circa ' .. clean_length .. ' Seconds  >> ./audio.log ');

os.execute( './unmute.sh "'.. clean_length ..'" &');


-- THEN PLAY THE THING WHILE THE OTHER PROCESS IS SLEEPING  

os.execute( './sounds-uncached.sh '..filename..' 21000')

Para realmente pegar a voz no pi, eu uso:

pocketsphinx_continuous -bestpath 0 -adcdev plughw:1  -samprate 20000  \
-nfft 512 -ds2 -topn2 -maxwpf 5 -kdtreefn 3000 -kdmaxdepth 7 -kdmaxbbi 15 \
-pl_window 10 -lm ./LANGUAGE/0892-min.lm -dict ./LANGUAGE/0892-min.dic 2>&1 \
| tee -i 2>/dev/null >( sed -u -n -e 's/^.\{9\}: //p' ) \
>( sed -u -n -e 's/^READY//p' \
-e 's/^Listening//p' -e 's/^FATAL_ERROR: \"continuous\.c\"\, //p') \
> /dev/null

Novamente, existem outras maneiras, mas eu gosto da minha saída dessa maneira.

Para o sintetizador, usei a solução pi incipiente da Cepstrals, mas não está disponível on-line, você deve contatá-los diretamente para combinar a compra e custa cerca de US $ 30. Os resultados são aceitáveis, no entanto, o discurso cria alguns cliques e estalos desagradáveis, a empresa respondeu dizendo que não possui mais um RaspPi e não está disposta a melhorar o produto. YMMV

O reconhecimento de voz fica em torno de 12% da CPU quando "ocioso" e dispara rapidamente ao fazer um pedaço de reconhecimento.

A criação de voz atinge cerca de 50-80% ao renderizar.

O play / sox pesa bastante, mas aplico efeitos em tempo real às vozes renderizadas enquanto as toco;)

O pi é bastante simplificado usando todos os guias que pude encontrar para interromper serviços desnecessários e é executado no modo CLI completo. 800 mhz com over-clock (menor).

scaling_governor definido como: performance

Quando em pleno funcionamento: funciona a cerca de 50ºC sob luz solar direta e 38ºC na sombra. Eu tenho dissipadores de calor instalados.

Último ponto: na verdade, eu uso todo esse equipamento na IA "impulsionada pela Internet" como um ótimo extra.

O pi lida com tudo isso perfeitamente, e reproduz qualquer áudio em rede em tempo real, e áudio totalmente em loop para qualquer outra caixa Unix. etc.

Para lidar com a sobrecarga da CPU de fala grande, implementei um sistema de cache baseado em md5sum para que as mesmas expressões não sejam renderizadas duas vezes. (cerca de 1000 arquivos a 220 mb no total cobrem 70% das declarações que geralmente recebo da IA) isso realmente ajuda a reduzir a carga total da CPU em geral.

Na prática, tudo isso é totalmente factível. no entanto, o reconhecimento de voz será apenas tão bom quanto a qualidade de seus microfones, seu modelo de idioma, quão especificamente as vozes dos sujeitos estão próximas do público-alvo original (eu uso um modelo en_US em crianças en_UK, não é perfeito) e outras minúcias de detalhes que com esforço você pode reduzir a um resultado decente.

E para o registro, eu já fiz tudo isso uma vez antes em um Kindle (e isso também funcionou com cmu esfinge e flite). Espero que isto ajude.

Sim. use o PocketSphinx para reconhecimento de fala, o Festvox para texto para fala (TTS) e algum áudio USB com entrada de linha (ou uma webcam antiga suportada que também tenha entrada de linha).

As pesquisas do Google por esses pacotes de software e o "Raspberry Pi" fornecem muitos exemplos e tutoriais para configurar isso.

• SiriProxy - use isso somente se você tiver um dispositivo que use o Siri - você não precisa fazer o jailbreak de nada. Ele basicamente intercepta o Siri na rede em que você o instala.
• Speech2Text - você pode usar a API do Google para decodificar a fala em texto, mas o exemplo também contém alguns outros métodos.
• Julius - Um decodificador de reconhecimento de fala.

Conforme apontado por Lenik, você precisará de alguma forma para gravar áudio ou possivelmente enviar arquivos de áudio ao Raspberry Pi para que eles sejam decodificados de alguma forma.

O Raspberry Pi não possui ADC embutido nem entrada de microfone. A menos que você esteja planejando usar um microfone USB externo, basicamente não há como obter seu fluxo de áudio no dispositivo. Além disso, não há limitações sérias, a CPU é poderosa o suficiente para qualquer processamento de som que você possa tentar implementar.

Primeiro, você deve selecionar um conjunto de palavras para o processo de classificação. Depois disso, você deve coletar os dados de usuários / assuntos. Será um sinal não estacionário. Você precisa reduzir seus dados para reduzir custos computacionais / melhorar a taxa de sucesso com os métodos de extração de recursos, para procurar métodos adequados de extração de recursos para seu aplicativo. Você pode obter um vetor de recurso como resultado desses métodos (valor absoluto médio, RMS, comprimento da forma de onda, cruzamento de zero, valor absoluto integrado, coeficientes de RA, frequência mediana, frequência média, etc.). Então, você deve usar um método de classificação como knn, redes neurais etc. para classificar seus dados. Por fim, você deve verificar sua precisão. Resumindo:

1. Selecione um conjunto de palavras / frases.
2. Obtenha os dados de sujeitos humanos.
3. Pré-processo (talvez o sinal precise ser filtrado)
4. Extração / processamento de recursos.
5. Classificação.
6. Testes.

Vi projetos de processamento de vídeo com o RPi na internet para que ele possa fazer essa classificação.

Você pode usar o NI 6009 USB DAQ (que suporta RPi) para coletar dados analógicos, mas eles são um pouco caros.

Isso pode ser útil para você reconhecer o alto-falante:

https://code.google.com/p/voiceid/