Utiliser la Google Speech API sur un Raspberry

Depuis mai 2016, Google a mis à disposition son API de reconnaissance vocale, d’abord en bêta fermée puis maintenant accessible à tous.

Avec l’émergence des chat bots et des AVC (Assistant Vocal Centralisé), l’utilisation de la voix est la prochaine interface utilisateur. Pour être sûr de ne pas rater le coche, voici un tutoriel pour apprendre à utiliser l’API Google Cloud Speech dans un Raspberry PI pour développer votre propre assistant vocal pour chez vous.

Les prérequis :

  • Un raspberry pi sous raspbian
  • Un micro usb
  • Connaissance en système Linux
  • Connaissance en NodeJS

I)               Installer le nécessaire sur le raspberry

1)    Sox

Pour la reconnaissance vocale, nous allons nous appuyer sur sox. Soc est un logiciel libre qui permet entre autres d’écouter le micro et de récupérer le flux et de le convertir en FLAC format utilisé par Google.

Pour cela, rien de plus simple dans la console du raspberry faire :

$ sudo apt-get install sox

Vous pouvez vérifier que sox est bien installé en tapant :

$ sox –version

developpement-raspberry

2)    NodeJs

Nous devons installer au minimum la version 5 de nodeJS, la version proposée par défaut dans raspbian étant une ancienne version, nous allons corriger cela.

Dans la console, il faut faire :

$ curl -sL https://deb.nodesource.com/setup_5.x | sudo -E bash

$ sudo apt-get install -y nodejs

Si vous faites un node –version, vous devriez alors avoir la bonne version de node installée.

II)               Initialiser le projet Google

Rendez-vous sur https://console.developers.google.com/apis/ . Sur cette page, commencez par créer un nouveau projet :

tuto-google-api

Une fois le projet créé, il va falloir associer l’API au projet. Dans l’onglet Bibliothèque, dans la barre de recherche, cherchez : « Google Speech API » puis cliquez sur « activer ».

Finalement, il va nous falloir créer des identifiants qui nous serviront à nous connecter au serveur Google. Dans l’onglet identifiants, créez une clé : « Compte de service », téléchargez la version json de cette clé, dont nous aurons besoin par la suite.

III)               Code

Nous allons développer nos appels au service Google via node, nous allons donc créer notre package.json et télécharger les dépendances nécessaires au projet :

Faire un npm init et renseignez les champs comme demandé. Vous devriez normalement avoir un package.json de créé. Nous allons maintenant installer les dépendances :

$ npm install async google-auto-auth google-proto-files googleapis grpc –save

Il faut ensuite créer un fichier speech.js dans lequel nous allons coder nos appels au service Google.

La première chose à faire, c’est initialiser les services Google :

var async = require('async');
 var fs = require('fs');
 var path = require('path');
 var grpc = require('grpc');
 var googleProtoFiles = require('google-proto-files');
 var googleAuth = require('google-auto-auth');
 var child_process = require("child_process");
 function SpeechAPI() {

// On initialise les proto files

   var PROTO_ROOT_DIR = googleProtoFiles('..');
 
   var protoDescriptor = grpc.load({
     root: PROTO_ROOT_DIR,
     file: path.relative(PROTO_ROOT_DIR, googleProtoFiles.speech.v1beta1)
   }, 'proto', {
     binaryAsBase64: true,
     convertFieldsToCamelCase: true
   });

// On spécifie le proto file que l’on souhaite utiliser.

   var speechProto = protoDescriptor.google.cloud.speech.v1beta1;

// cette fonction permet de s’authentifier auprès de la Google cloud-plateforme

   function getSpeechService(host, callback) {
     var googleAuthClient = googleAuth({
       scopes: [
         'https://www.googleapis.com/auth/cloud-platform'
       ]
     });
 
     googleAuthClient.getAuthClient(function (err, authClient) {
       if (err) {
         return callback(err);
       }
       var credentials = grpc.credentials.combineChannelCredentials(
         grpc.credentials.createSsl(),
         grpc.credentials.createFromGoogleCredential(authClient)
       );
       var stub = new speechProto.Speech(host, credentials);
       return callback(null, stub);
     });
   }
 
   // cette méthode nous permet de récupérer un Google Speech client authentifié

   function getClient(host, callback) {
     return new Promise(function (resolve, reject) {
       async.waterfall([
         function (cb) {
           getSpeechService(host, cb);
         },
         function sendRequest(client, cb) {
           gClient = client;
           resolve();
         }], callback);
     });
   };

}

module.exports = new SpeechAPI();

 

La méthode getClient nous permet de recevoir un service initialisé et authentifié. Nous avons donc maintenant besoin de récupérer le flux du microphone. Comme nous vous l’avions mentionné plus haut, nous allons utiliser sox.

Dans le fichier speech.js, à la fin du fichier :

// Démarre le process audio et écrit la data dans l’appel vers les services google speech

 function startAudio(call) {

// ici on créé un process enfant en lançant sox, on spécifie le type de sortie en FLAC et le rate à 16000

   audioProcess = child_process.spawn("sox", ["-d", "--type", "flac", "--channels", "1", "--bits", "16", "--rate", "16000", "-"]);

// pour chaque morceau d’audio, on appelle le service Google en continue

   audioProcess.stdout.on("data", function (data) {
     call.write({
       audioContent: data
     });
   });
 
   audioProcess.stdout.on("error", function (data) {
     if (err == null) {
       return;
     }
     console.error(err.toString());
     process.exit(1);
   });
 }
 
 // Stop le process audio
 function stopAudio() {
   return new Promise(function (resolve, reject) {
     audioProcess.stdout.on("end", function () {
       resolve();
     });
     if (audioProcess) {
       audioProcess.kill('SIGINT');
       audioProcess = null;
     }
   });
 }

 

Enfin, nous pouvons faire l’appel vers les services Google :

this.doCall = function () {
   return new Promise(function (resolve, reject) {

 

// on appelle notre méthode pour récupérer notre client

       getClient('speech.googleapis.com', console.log).then(function () {

// on démarre une session de streaming

         var call = gClient.streamingRecognize();
         call.on("data", function (feature) {
           // c'est ici que nous allons pouvoir traiter le retour
           for (var i = 0; i < feature.results.length; ++i) {
             for (var j = 0; j < feature.results[i].alternatives.length; ++j) {
               if (feature.results[i].isFinal) {
                 if (feature.results[i].alternatives[j].confidence > 0) {
                   stopAudio().then(function () {
                     call.end();
                   });
                   resolve(feature.results[i].alternatives[j].transcript);
                 }
                 break;
               }
             }
           }
         });
         call.on("end", function (err) {
         });
         call.on("error", function (err) {
           reject(err);
         });
         // Le premier appel est dédié à la configuration
         call.write({
           streamingConfig: {
             config: {
               encoding: 'FLAC', // FLAC, préconisez par Google
               sampleRate: 16000, // 16000 le même que dans sox
               languageCode: "fr-FR" // la langue à reconnaître
             },
             interimResults: false, // si l'on veut les résultats intermédiaires
             singleUtterance: true // si l'on s'arrête ou non à la première phrase trouvée.
           }
         });
         startAudio(call);
       });
     }
   );
 }

Puis, dans un fichier index.js nous aurons juste à faire :

'use strict';
 
 var speech = require('./speech.js');
 
 speech.recognize ().then (function (text) {
   console.log (text);
 }).catch (function (err) {
   console.error(err);
 });

Ensuite, pour appeler notre script nous devons au préalable indiquer où se trouve le json que l’on a téléchargé au chapitre 2 :

 

$ GOOGLE_APPLICATION_CREDENTIALS=/chemin/vers/fichier.json

Enfin, on peut lancer notre application via node :

node index.js

Grâce aux trois grandes étapes de ce tutoriel, vous avez appris à utiliser l’API de Google pour créer votre propre assistant vocal… en moins de deux heures. Il ne vous reste plus qu’à utiliser ce module dans vos projets pour ajouter le support de la voix.

Pas de panique si vous rencontrez une erreur ou si le code ci-dessus ne fonctionnait pas : vérifiez tout d’abord que votre micro est bien configuré sur votre Raspberry ! Vous pouvez tester la commande sox directement dans une console pour vous assurer que celle-ci fonctionne correctement.

Il ne vous reste plus qu’à ajouter cette nouvelle interface dans votre projet, puis d’utiliser le texte reconnu dans un moteur de reconnaissance linguistique pour développer votre propre Google Home ou Amazon Echo.

1 réponse
  1. larry dit :

    Salut Ed et merci pour ce tuto

    Je vais tenter de reproduire ton script, pour l’instant je ne fais que de la lecture, mais pourrais tu me dire a quoi sert l’instantation des google-proto-file et que faut il mettre en parametres ?

    var PROTO_ROOT_DIR = googleProtoFiles(‘..’);

    Répondre

votre commentaire

Se joindre à la discussion ?
Vous êtes libre de contribuer !

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Inscription newsletter

Ne manquez plus nos derniers articles !