Je souhaite effectuer un traitement de la parole sur Raspberry Pi afin de détecter des personnes spécifiques (par exemple, une identification unique).

Je préférerais utiliser uniquement le processeur embarqué pour cela, vous pouvez supposer qu'Internet n'est pas accessible.

En outre, quelles sont les limites du traitement de la parole par le Raspberry Pi? Si je veux utiliser cela comme un système de présence automatique, comment dois-je procéder?

C’est le projet principal auquel mon Raspberry Pi est dédié en ce moment, je pense donc pouvoir ajouter mes deux sous. Gardez à l'esprit que ce projet est toujours un travail en cours.

J'ai choisi d'utiliser le langage de programmation C pour ce projet exclusivement sur le système d'exploitation Raspbian, ce qui peut avoir affecté certaines de mes décisions et instructions. Je vais seulement lister les logiciels libres et open source , car c'est tout ce que j'utilise.

Pour les instructions d'installation, je supposerai que vous disposez d'un système entièrement à jour .

Reconnaissance de la parole

Voici quelques options pour les moteurs de reconnaissance vocale :

1. Pocketsphinx - Une version de Sphinx pouvant être utilisée dans des systèmes embarqués (basée sur un processeur ARM, par exemple).

   • Avantages : En cours de développement actif et intégrant des fonctionnalités telles que l'arithmétique en virgule fixe et des algorithmes efficaces pour le calcul GMM . Tous les traitements ont lieu sur le Raspberry Pi, il est donc possible de l’utiliser hors ligne. Il supporte la reconnaissance vocale en temps réel

   • Inconvénients : Il est compliqué à configurer et à comprendre pour les débutants. Pour moi, c'était trop inexact pour mon application. Tout le traitement a lieu sur le Raspberry Pi, le rendant un peu plus lent.

   • Instructions d'installation :

     1. Téléchargez les dernières versions stables de Sphinxbase et de 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. Extrayez les fichiers téléchargés:

        $ 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. Pour compiler ces packages, vous devez installer bison et les en-têtes de développement ALSA.

        REMARQUE : il est important que les en-têtes ALSA soient installés avant de créer Sphinxbase. Sinon, Sphinxbase n'utilisera pas ALSA. Il semble également que ALSA ne sera pas utilisé si PulseAudio est installé (ce qui est une mauvaise chose pour les développeurs comme moi).

        $ sudo apt-get install bison libasound2-dev
        

     4. cd dans le répertoire Sphinxbase et tapez les commandes suivantes:

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

     5. cd dans le répertoire Pocketsphinx et tapez les commandes suivantes:

        $ ./configure
        $ sudo make
        $ sudo make install
        

     6. Testez Pocketsphinx en lançant:

        $ src/programs/pocketsphinx_continuous -samprate 48000 
        

        Si vous voulez le modifier, je vous recommande de lire quelques informations sur le wiki CMUSphinx .

2. libsprec - Une bibliothèque de reconnaissance vocale développée par H2CO3 (avec quelques contributions de ma part, principalement des corrections de bugs).

   • Avantages : Il utilise l' API Google Speech , ce qui le rend plus précis. Le code est plus facile à comprendre (à mon avis).

   • Inconvénients : Il a des dépendances sur d’autres bibliothèques développées par H2CO3 (comme libjsonz ). Le développement est inégal. Il utilise l'API Google Speech, ce qui signifie que le traitement n'a pas lieu sur le Raspberry Pi lui-même et nécessite une connexion Internet. Avant la compilation, il nécessite une petite modification du code source pour fonctionner correctement sur le Raspberry Pi.

   • Instructions d'installation :

     1. Installez libflac , libogg et libcurl :

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

     2. Téléchargez la version la plus récente de libsprec

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

     3. Décompressez le package téléchargé:

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

        Vous devriez maintenant avoir un dossier nommé libsprec-masterdans votre répertoire actuel.

     4. Téléchargez la version la plus récente de libjsonz :

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

     5. Décompressez le package téléchargé:

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

        Vous devriez maintenant avoir un dossier nommé libjsonz-masterdans votre répertoire actuel.

     6. cddans le libjsonz-masterrépertoire, compilez et installez:

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

     7. cdhors du libjsonz-masterrépertoire et dans le libsprec-master/srcrépertoire. Modifier la ligne 227:

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

        Nous avons besoin de ceci pour dire:

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

        Ceci afin que le programme utilise ALSA pour pointer vers le microphone USB.

     8. Compiler et installer:

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

     9. Vous pouvez maintenant utiliser la bibliothèque dans vos propres applications. Regardez dans le dossier libsprec-masterdes exemples pour des exemples.

3. Julius -Logiciel de décodeur dereconnaissance vocale continue ( LVCSR ) àgrand vocabulaire et hautes performancespour les chercheurs et les développeurs du domaine de la parole.

   • Avantages : Il peut effectuer une reconnaissance vocale presque en temps réel sur le Raspberry Pi lui-même. Les formats de modèle de parole standard sont adoptés pour faire face à d’autres outils de modélisation gratuits.

   • Inconvénients : Développement inégal, sa dernière mise à jour datant de plus d’un an. Sa reconnaissance est également trop imprécise et lente pour mon utilisation. Long temps d'installation

   • Instructions d'installation :

     1. Il y a quelques paquets que nous devons installer pour que le système fonctionne correctement:

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

     2. Téléchargez Julius depuis la source CVS:

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

     3. Définissez les indicateurs du compilateur à l'aide des variables d'environnement:

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

     4. cddans le dossier julius4et tapez les commandes suivantes

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

     5. Julius a besoin d'une variable d'environnement appelée ALSADEVpour lui dire quel périphérique utiliser comme microphone:

        $ export ALSADEV="plughw:1,0"
        

     6. Téléchargez un modèle acoustique gratuit que Julius pourra utiliser. Une fois que vous l'avez téléchargé, cddans le répertoire et lancez:

        $ julius -input mic -C julius.jconf
        

        Après cela, vous devriez pouvoir commencer la saisie vocale.

4. Rouler votre propre bibliothèque - Pour mon projet spécifique, j'ai choisi de créer ma propre bibliothèque de reconnaissance vocale qui enregistre l'audio à partir d'un microphone USB à l'aide d' ALSA via PortAudio , la stocke dans un fichier FLAC via libsndfile et l'envoie à Google pour qu'elle puisse la traiter. il. Ils m'envoient ensuite un fichier JSON bien emballé que je traite ensuite pour obtenir ce que j'ai dit à mon Raspberry Pi.

   • Avantages : je contrôle tout (ce que j'aime). J'apprends beaucoup (ce que j'aime).

   • Inconvénients : c'est beaucoup de travail. En outre, certaines personnes peuvent affirmer que je ne traite aucun traitement sur le Raspberry Pi avec cette bibliothèque de reconnaissance vocale. Je sais que . Google peut traiter mes données avec beaucoup plus de précision que je peux le faire maintenant. Je travaille sur la création d'une option de reconnaissance vocale hors ligne précise.

Synthèse de discours

Voici quelques options pour les moteurs de synthèse vocale :

1. tritium - Un moteur de synthèse vocale gratuit, de première qualité, entièrement écrit en C (et développé par le vôtre).

   • Points forts: Extrêmement portable (pas de dépendances à part CMake à construire), extrêmement petit (le plus petit que j'ai pu trouver), facile à construire.

   • Inconvénients: La sortie vocale elle-même peut parfois être inexacte. Le support pour une grande variété de langues fait défaut car je suis le seul développeur avec peu de temps libre pour le moment, mais c'est l'un des objectifs futurs du projet. En outre, à partir de maintenant, seule une bibliothèque est générée lors de la compilation et aucun exécutable utilisable / testable.

2. eSpeak - Un synthétiseur vocal logiciel open source compact pour Linux, Windows et d'autres plates-formes.

   • Avantages : Il utilise une méthode de synthèse de formants , fournissant de nombreuses langues parlées dans une petite taille. Il est également très précis et facile à comprendre. À l'origine, je l'utilisais dans mon projet, mais à cause des inconvénients, je devais passer à un autre moteur de synthèse vocale.

   • Inconvénients : Il a des dépendances étranges sur X11 , le bégayant parfois. La bibliothèque est également considérablement plus grande que d’autres.

   • Instructions d'installation :

     1. Installez le logiciel eSpeak:

        $ sudo apt-get install espaek
        

     2. Pour dire ce que vous voulez dans eSpeak:

        $ espeak "Hello world"
        

        Pour lire à partir d'un fichier dans eSpeak:

        $ espeak -f <file>
        

3. Festival - Un système général de synthèse de la parole multilingue.

   • Avantages : Il est conçu pour prendre en charge plusieurs langues parlées. Il peut utiliser le projet Festvox qui vise à rendre la construction de nouvelles voix synthétiques plus systématique et mieux documentée, ce qui permet à quiconque de construire une nouvelle voix.

   • Inconvénients : Il est écrit en C ++ (plus d'une con pour moi en particulier). Il a également une base de code plus grande, il serait donc difficile pour moi de comprendre et de transférer le code.

   • Instructions d'installation :

     1. Installez le logiciel du festival:

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

     2. Pour exécuter Festival, transmettez-lui le texte ou le fichier que vous souhaitez lire:

        $ echo  "Hello world" | festival --tts
        

4. Flite - Un petit moteur de synthèse vocale dérivé de Festival et du projet Festvox.

   • Avantages : En développement constant à l'Université Carnegie Mellon. Très petit moteur comparé aux autres. Il a également une base de code plus petite, il est donc plus facile à parcourir. Il n'a presque pas de dépendances (un énorme pro pour moi et une autre raison pour laquelle j'ai décidé d'utiliser ce moteur dans mon projet).

   • Inconvénients : La sortie vocale elle-même n'est pas toujours précise. Le discours a un son très métallique et non humain (plus que les autres moteurs). Il ne supporte pas beaucoup de langues.

   • Instructions d'installation :

     1. Installez le logiciel Flite:

        $ sudo apt-get install flite
        

     2. Pour exécuter Flite:

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

Réponses à vos questions spécifiques :

Quelles sont les limites du traitement de la parole par le Pi?

Les programmeurs n'ont pas de limites. :P

Plus sérieusement, le Raspberry Pi dispose de nombreuses ressources pour gérer le traitement de la parole. Tant que la personne effectuant le traitement de la parole sait ce qu'elle fait, le Raspberry Pi devrait être en mesure de le gérer.

Je veux utiliser cette machine de présence automatique, comment dois-je procéder?

Aucune de ces options n'est assez précise pour faire la différence entre des personnes spécifiques pour le moment . C'est quelque chose sur lequel je travaille dans mon projet (et ce sera probablement pour un moment). Si vous recherchez une meilleure option pour la participation automatique, je voudrais examiner la reconnaissance faciale . Cependant, la reconnaissance faciale du Raspberry Pi est plus limitée, alors gardez cela à l'esprit.

J'y suis allé avec pochesphinx_continuous et une carte son à 4 $ .

Pour gérer le fait qu'il doit cesser d'écouter lorsque j'utilise un synthétiseur vocal, j'ai utilisé amixer pour entrer le volume dans le micro (cette pratique a été recommandée par la CMU, car le moteur d'arrêt / redémarrage entraînerait une moins bonne reconnaissance).

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

Avec une commande correspondante pour couper l'écoute lorsque le synthétiseur vocal joue

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

Pour calculer les bons moments de mise en sourdine, exécutez simplement soxi via lua, puis réglez le fichier unmute.sh (à l'opposé du mute.sh) sur "x" secondes à partir du démarrage. Il y a sans doute beaucoup de façons de gérer cela. Je suis content des résultats de cette méthode.

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

Pour saisir réellement la voix sur le pi que j'utilise:

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

Encore une fois, il y a d'autres moyens, mais j'aime ma sortie de cette façon.

Pour le synthé, j'ai utilisé la solution pi naissante de Cepstrals, mais elle n'est pas disponible en ligne, vous devez les contacter directement pour prendre les dispositions nécessaires pour l'acheter. Le prix d'achat est d'environ 30 $. Les résultats sont acceptables, mais le discours crée quelques clics et bruits désagréables. La société a répondu en affirmant qu'elle ne possédait plus de RaspPi et qu'elle ne souhaitait pas améliorer le produit. YMMV

La reconnaissance vocale se situe à environ 12% de l’UC quand elle est "inactive" et s’accroît brièvement lorsqu’une partie de la reconnaissance est faite.

La création de voix atteint environ 50 à 80% lors du rendu.

Le jeu / sox pèse assez lourdement mais j’applique des effets en temps réel aux voix rendues au fur et à mesure que je les joue;)

Le pi est fortement dépouillé en utilisant chaque guide que je pourrais trouver pour arrêter les services non requis et fonctionne en mode CLI complet. 800 MHz surchargé (le plus petit).

scaling_governor défini sur: performance

En fonctionnement complet: il fonctionne à environ 50 ° C sous la lumière directe du soleil et à 38 ° C à l'ombre. Je fais installer des dissipateurs de chaleur.

Dernier point: en fait, je lance tout ce matériel à l'IA "Internet".

Le pi gère tout cela de manière transparente, et reproduit tous les fichiers audio en réseau en temps réel, et les boucles audio intégralement en boucle sur n'importe quel autre boîtier Unix. etc.

Pour gérer la surcharge de temps processeur de la parole, j'ai implémenté un système de mise en cache basé sur md5sum afin que les mêmes énoncés ne soient pas rendus deux fois. (environ 1000 fichiers @ 220 mb au total couvrent 70% des énoncés que je tire en général de l’intelligence artificielle), ce qui aide vraiment à réduire la charge totale du processeur.

En résumé, tout cela est totalement faisable. cependant, la reconnaissance vocale dépendra uniquement de la qualité de vos micros, de votre modèle de langage, de la proximité des voix de vos sujets avec le public cible initial (j'utilise un modèle en_US sur des enfants en_UK, mais pas parfait) et d'autres détails qu'avec un effort, vous pouvez obtenir un résultat décent.

Et pour l’information, j’avais déjà fait tout cela une fois auparavant sur une feuille (et cela fonctionnait aussi avec cmu sphinx et flite). J'espère que cela t'aides.

Oui. utilisez PocketSphinx pour la reconnaissance vocale, Festvox pour le synthèse vocale (TTS) et certains fichiers audio USB avec entrée de ligne (ou une ancienne webcam prise en charge qui comporte également une entrée de ligne).

Google recherche ces progiciels et "Raspberry Pi" fournit de nombreux exemples et tutoriels pour le configurer.

• SiriProxy - Ne l'utilisez que si vous possédez un appareil utilisant Siri - vous n'avez pas besoin de jailbreaker quoi que ce soit. Il intercepte essentiellement Siri sur le réseau sur lequel vous l'installez.
• Speech2Text - Vous pouvez utiliser l'API Googles pour décoder la parole en texte, mais l'exemple contient également d'autres méthodes.
• Julius - Un décodeur de reconnaissance vocale.

Comme Lenik l'a fait remarquer, vous aurez besoin d'une certaine manière d'enregistrer de l'audio ou éventuellement d'envoyer des fichiers audio au Raspberry Pi pour qu'ils soient décodés d'une manière ou d'une autre.

Raspberry Pi n'a pas d'entrée ADC ni de microphone intégrée. Sauf si vous envisagez d'utiliser un micro USB externe, il n'y a pratiquement aucun moyen de transférer votre flux audio sur le périphérique. De plus, le processeur est assez puissant pour tout traitement audio que vous pourriez essayer de mettre en œuvre.

Tout d'abord, vous devez sélectionner un ensemble de mots pour le processus de classification. Après cela, vous devez collecter les données auprès des utilisateurs / sujets. Ce sera un signal non stationnaire. Vous devez réduire vos données pour réduire les coûts de calcul / pour améliorer le taux de réussite avec les méthodes d'extraction de caractéristiques. Vous devez donc rechercher des méthodes d'extraction de caractéristiques adaptées à votre application. Vous pouvez obtenir un vecteur de caractéristiques à la suite de ces méthodes (valeur absolue moyenne, RMS, longueur de la forme d'onde, passage par zéro, valeur absolue intégrée, coefficients AR, fréquence médiane, fréquence moyenne, etc.). Ensuite, vous devez utiliser une méthode de classification telle que knn, réseaux de neurones, etc. pour classifier vos données. Enfin, vous devez vérifier son exactitude. Pour résumer:

1. Sélectionnez un ensemble de mots / phrases.
2. Obtenez les données des sujets humains.
3. Prétraitement (le signal doit peut-être être filtré)
4. Extraction de fonctionnalités / traitement.
5. Classification.
6. Tests.

J'ai vu des projets de traitement vidéo avec RPi sur Internet afin qu'il puisse réussir à faire cette classification.

Vous pouvez utiliser le DAQ USB NI 6009 (qui prend en charge RPi) pour collecter toutes les données analogiques, mais elles sont un peu chères.

Cela peut vous être utile pour reconnaître le locuteur:

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