Accueil Java Reconnaissance vocale – Google Cloud Speech

Reconnaissance vocale – Google Cloud Speech

,

Pour la partie reconnaissance vocale de mon robot, j’ai décidé de comparer et d’utiliser des services web de différents groupes, leur système de reconnaissance vocale étant extrêmement performante, simple à mettre en place et moins gourmandes en ressources, contrairement à certaines librairies JAVA que j’ai pu tester.
Dans ce tutoriel, je vous présente brièvement l’API Cloud Speech de Google et son utilisation au travers d’une classe JAVA.

  • Documentation : API Cloud Speech
  • Authentification : j’ai utilisé l’authentification simple par une clé d’API. D’autres systèmes d’authentification existent comme OAuth2.
  • Prix: facturé $0.006 / 15 secondes sachant que quelque soit la durée de l’extrait à reconnaître, il sera facturé au multiple des 15 secondes supérieur. Etant donné qu’en pratique, une phrase à reconnaître dure au maximum 5 secondes, 15 secondes seront donc débitées de votre crédit.
  • Quota gratuit : 1 heure / mois soit 240 requêtes / mois de 15 secondes.

Pour appeler le service web REST, je transforme le fichier WAV en fichier FLAC avec javaFlacEncoder , j’utilise Unirest pour faire l’appel en REST et la librairie Gson de Google pour transformer le résultat JSON en objets JAVA (objets que j’ai créés spécialement). Il faudra donc rajouter les dépendances suivantes :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<dependency>
    <groupId>net.sourceforge.javaflacencoder</groupId>
    <artifactId>java-flac-encoder</artifactId>
    <version>0.3.7</version>
</dependency>
     
<dependency>
    <groupId>com.mashape.unirest</groupId>
    <artifactId>unirest-java</artifactId>
    <version>1.4.9</version>
</dependency>
 
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.3.1</version>
</dependency>

Voici maintenant le code du moteur de reconnaissance vocale que vous pouvez retrouver sur GitHub :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
package fr.roboteek.robot.sandbox.reconnaissance.vocale.google;
 
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
 
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.StringUtils;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.mashape.unirest.http.Unirest;
import com.mashape.unirest.http.exceptions.UnirestException;
 
import fr.roboteek.robot.sandbox.reconnaissance.vocale.DetecteurVocal;
import fr.roboteek.robot.sandbox.reconnaissance.vocale.SpeechRecognizer;
import fr.roboteek.robot.sandbox.reconnaissance.vocale.google.RecognitionConfig.AudioEncoding;
import net.sourceforge.javaflacencoder.FLAC_FileEncoder;
 
/**
 * Moteur de reconnaissance vocale utilisant le service web Cloud Speech de Google.
 * @author Nicolas Peltier
 *
 */
public class GoogleSpeechRecognizerRest implements SpeechRecognizer {
 
    /** URL du service web. */
    private static String WEB_SERVICE_SPEECH_URL = "https://speech.googleapis.com/v1beta1/speech:syncrecognize";
 
    /** Singleton de la classe. */
    private static GoogleSpeechRecognizerRest instance;
 
    /** Classe GSON permettant la création des objets JSON. */
    private Gson gson;
 
    /** Clé API Cloud Speech (à récupérer sur le le site Cloud Speech). */
    private String paramApiKey = "?key=XXXXXXXXXXXXXXXXXXX_XXXXXXXX-XXXXXXXXXX";
 
    /** Objet contenant les infos nécessaires pour l'appel du service web. */
    private RecognizeRequest request;
 
    /** Encodeur de fichiers WAV --> FLAC. */
    private FLAC_FileEncoder flacEncoder;
 
    /** Chemin du fichier FLAC. */
    private String cheminFichierFlac;
 
    /** Constructeur privé. */
    private GoogleSpeechRecognizerRest() {
 
        flacEncoder = new FLAC_FileEncoder();
        cheminFichierFlac = "reconnaissance.flac";
 
        gson = new GsonBuilder().create();
 
        // Paramètre fixe de la requête
        RecognitionConfig config = new RecognitionConfig();
        config.setEncoding(AudioEncoding.FLAC);
        config.setSampleRate(44100);
        config.setLanguageCode("FR");
 
        // Objet permettant de faire la requête
        // Cet objet sera complété par le fichier audio à reconnaitre à chaque appel du service
        request = new RecognizeRequest();
        request.setConfig(config);
    }
 
    /**
     * Récupère l'instance du moteur de reconnaissance.
     * @return l'instance du moteur de reconnaissance
     */
    public static GoogleSpeechRecognizerRest getInstance() {
        if (instance == null) {
            instance = new GoogleSpeechRecognizerRest();
        }
        return instance;
    }
 
    public String reconnaitre(String cheminFichierWav) {
         
        // Encodage du fichier WAV en fichier FLAC
        File fichierWav = new File(cheminFichierWav);
        File fichierFlac = new File(cheminFichierFlac);
        flacEncoder.encode(fichierWav, fichierFlac);
         
        // Récupération du fichier FLAC
        Path path = Paths.get(cheminFichierFlac);
        RecognitionAudio audioRequest = new RecognitionAudio();
        try {
            // Passage à l'objet de requêtage du fichier FLAC encodé en Base 64
            audioRequest.setContent(StringUtils.newStringUtf8(Base64.encodeBase64(Files.readAllBytes(path), false)));
        } catch (IOException e) {
            e.printStackTrace();
        }
        request.setAudio(audioRequest);
 
 
        RecognizeResponse response = null;
 
        try {
            // Appel du service web avec Unirest et transformation de la réponse JSON
            response = gson.fromJson(
                    Unirest.post(WEB_SERVICE_SPEECH_URL + paramApiKey)
                    .body(gson.toJson(request))
                    .asString()
                    .getBody(),
                    RecognizeResponse.class);
        } catch (UnirestException e) {
            e.printStackTrace();
        }
 
        // Récupération du résultat
        if (response != null) {
            List<SpeechRecognitionResult> listeRecognitionResults = response.getResults();
            if (listeRecognitionResults != null && !listeRecognitionResults.isEmpty()) {
                SpeechRecognitionResult result = listeRecognitionResults.get(0);
                final List<SpeechRecognitionAlternative> listeAlternatives = result.getAlternatives();
                if (listeAlternatives != null && !listeAlternatives.isEmpty()) {
                    SpeechRecognitionAlternative alternative = listeAlternatives.get(0);
                    return alternative.getTranscript();
                }
            }
        }
        //      fichierFlac.delete();
        return "";
    }
 
    public static void main(String[] args) throws IOException {
        final SpeechRecognizer googleRecognizerRest = GoogleSpeechRecognizerRest.getInstance();
        // Création et lancement du détecteur vocal en passant le moteur de reconnaissance à utiliser
        final DetecteurVocal detecteurVocal = new DetecteurVocal(googleRecognizerRest);
        detecteurVocal.demarrer();
    }
}

Laisser un commentaire

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