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
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 :
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.
Edouard Bataille creative developer, SQLI
Ajouter un commentaire