Détecter automatiquement la langue parlée

Cette page explique comment fournir plusieurs codes de langues pour les requêtes de transcription audio envoyées à Speech-to-Text.

Dans certaines situations, vous ne connaissez pas avec certitude la langue de vos enregistrements audio. Par exemple, si vous publiez votre service, votre application ou votre produit dans un pays où plusieurs langues officielles sont parlées, il est possible que vous receviez des entrées audio des utilisateurs dans différentes langues. Ainsi, il peut devenir bien plus compliqué de spécifier un seul code de langue pour les requêtes de transcription.

Reconnaissance multilingue

Speech-to-Text vous permet de spécifier un ensemble de langues alternatives que vos données audio peuvent contenir. Lorsque vous envoyez une requête de transcription audio à Speech-to-Text, vous pouvez fournir une liste de langues supplémentaires pouvant être parlées dans les données audio. Si vous incluez une liste de langues dans votre requête, Speech-to-Text tente de transcrire le fichier audio en se basant sur la langue correspondant le mieux à l'échantillon par les alternatives que vous spécifiez. Speech-to-Text identifie ensuite les résultats de la transcription en leur attribuant le code de langue prédit.

L'utilisation de cette fonctionnalité convient parfaitement aux applications devant transcrire des instructions courtes, telles que des commandes vocales ou une recherche vocale. Vous pouvez répertorier jusqu'à trois langues alternatives parmi celles disponibles dans Speech-to-Text en plus de votre langue principale, soit un total de quatre langues.

Même si vous pouvez spécifier des langues alternatives dans votre requête de transcription vocale, vous devez tout de même fournir un code de langue principal dans le champ languageCode. De plus, vous devez limiter autant que possible le nombre de codes de langues que vous spécifiez. Plus le nombre de codes de langues alternatives est faible, plus la sélection du code approprié sera facile pour Speech-to-Text. Une requête ne spécifiant qu'une seule langue renvoie les meilleurs résultats.

Activer la reconnaissance de la langue dans les requêtes de transcription audio

Pour spécifier des langues alternatives dans la transcription de votre fichier audio, vous devez définir le champ alternativeLanguageCodes sur une liste de codes de langues dans les paramètres RecognitionConfig de la requête. Speech-to-Text autorise la spécification de langues alternatives pour toutes les méthodes de reconnaissance vocale, à savoir speech:recognize, speech:longrunningrecognize et Streaming.

Utiliser un fichier local

Protocole

Reportez-vous au point de terminaison speech:recognize de l'API pour obtenir des informations complètes.

Pour réaliser une reconnaissance vocale synchrone, exécutez une requête POST en fournissant le corps de requête approprié. Voici un exemple de requête POST utilisant curl. Cet exemple fait intervenir le jeton d'accès associé à un compte de service configuré pour le projet à l'aide du SDK Cloud de Google Cloud. Pour obtenir des instructions sur l'installation du SDK Cloud, la configuration d'un projet avec un compte de service et l'obtention d'un jeton d'accès, consultez le guide de démarrage rapide.

L'exemple suivant montre comment demander la transcription d'un fichier audio pouvant inclure des phrases prononcées en allemand, en anglais ou en français.

    curl -s -H "Content-Type: application/json" \
        -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
        https://speech.googleapis.com/v1p1beta1/speech:recognize \
        --data '{
        "config": {
            "encoding": "LINEAR16",
            "languageCode": "en-US",
            "alternativeLanguageCodes": ["fr-FR", "de-DE"],
            "model": "command_and_search"
        },
        "audio": {
            "uri": "gs://cloud-samples-tests/speech/commercial_mono.wav"
        }
    }' > multi-language.txt
    

Si la requête aboutit, le serveur affiche un code d'état HTTP 200 OK et la réponse au format JSON, enregistrée dans un fichier nommé multi-language.txt.

    {
      "results": [
        {
          "alternatives": [
            {
              "transcript": "hi I'd like to buy a Chromecast I'm ..."
              "confidence": 0.9466864
            }
          ],
          "languageCode": "en-us"
        },
        {
          "alternatives": [
            {
              "transcript": " let's go with the black one",
              "confidence": 0.9829583
            }
          ],
          "languageCode": "en-us"
        },
      ]
    }
    

Java

/**
     * Transcribe a local audio file with multi-language recognition
     *
     * @param fileName the path to the audio file
     */
    public static void transcribeMultiLanguage(String fileName) throws Exception {
      Path path = Paths.get(fileName);
      // Get the contents of the local audio file
      byte[] content = Files.readAllBytes(path);

      try (SpeechClient speechClient = SpeechClient.create()) {

        RecognitionAudio recognitionAudio =
            RecognitionAudio.newBuilder().setContent(ByteString.copyFrom(content)).build();
        ArrayList<String> languageList = new ArrayList<>();
        languageList.add("es-ES");
        languageList.add("en-US");

        // Configure request to enable multiple languages
        RecognitionConfig config =
            RecognitionConfig.newBuilder()
                .setEncoding(AudioEncoding.LINEAR16)
                .setSampleRateHertz(16000)
                .setLanguageCode("ja-JP")
                .addAllAlternativeLanguageCodes(languageList)
                .build();
        // Perform the transcription request
        RecognizeResponse recognizeResponse = speechClient.recognize(config, recognitionAudio);

        // Print out the results
        for (SpeechRecognitionResult result : recognizeResponse.getResultsList()) {
          // There can be several alternative transcripts for a given chunk of speech. Just use the
          // first (most likely) one here.
          SpeechRecognitionAlternative alternative = result.getAlternatives(0);
          System.out.format("Transcript : %s\n\n", alternative.getTranscript());
        }
      }
    }

Node.js

const fs = require('fs');

    // Imports the Google Cloud client library
    const speech = require('@google-cloud/speech').v1p1beta1;

    // Creates a client
    const client = new speech.SpeechClient();

    /**
     * TODO(developer): Uncomment the following lines before running the sample.
     */
    // const fileName = 'Local path to audio file, e.g. /path/to/audio.raw';

    const config = {
      encoding: 'LINEAR16',
      sampleRateHertz: 44100,
      languageCode: 'en-US',
      alternativeLanguageCodes: ['es-ES', 'en-US'],
    };

    const audio = {
      content: fs.readFileSync(fileName).toString('base64'),
    };

    const request = {
      config: config,
      audio: audio,
    };

    const [response] = await client.recognize(request);
    const transcription = response.results
      .map(result => result.alternatives[0].transcript)
      .join('\n');
    console.log(`Transcription: ${transcription}`);

Python

from google.cloud import speech_v1p1beta1
    import io

    def sample_recognize(local_file_path):
        """
        Transcribe a short audio file with language detected from a list of possible
        languages

        Args:
          local_file_path Path to local audio file, e.g. /path/audio.wav
        """

        client = speech_v1p1beta1.SpeechClient()

        # local_file_path = 'resources/brooklyn_bridge.flac'

        # The language of the supplied audio. Even though additional languages are
        # provided by alternative_language_codes, a primary language is still required.
        language_code = "fr"

        # Specify up to 3 additional languages as possible alternative languages
        # of the supplied audio.
        alternative_language_codes_element = "es"
        alternative_language_codes_element_2 = "en"
        alternative_language_codes = [
            alternative_language_codes_element,
            alternative_language_codes_element_2,
        ]
        config = {
            "language_code": language_code,
            "alternative_language_codes": alternative_language_codes,
        }
        with io.open(local_file_path, "rb") as f:
            content = f.read()
        audio = {"content": content}

        response = client.recognize(config, audio)
        for result in response.results:
            # The language_code which was detected as the most likely being spoken in the audio
            print(u"Detected language: {}".format(result.language_code))
            # First alternative is the most probable result
            alternative = result.alternatives[0]
            print(u"Transcript: {}".format(alternative.transcript))

    

Utiliser un fichier distant

Java

/**
     * Transcribe a remote audio file with multi-language recognition
     *
     * @param gcsUri the path to the remote audio file
     */
    public static void transcribeMultiLanguageGcs(String gcsUri) throws Exception {
      try (SpeechClient speechClient = SpeechClient.create()) {

        ArrayList<String> languageList = new ArrayList<>();
        languageList.add("es-ES");
        languageList.add("en-US");

        // Configure request to enable multiple languages
        RecognitionConfig config =
            RecognitionConfig.newBuilder()
                .setEncoding(AudioEncoding.LINEAR16)
                .setSampleRateHertz(16000)
                .setLanguageCode("ja-JP")
                .addAllAlternativeLanguageCodes(languageList)
                .build();

        // Set the remote path for the audio file
        RecognitionAudio audio = RecognitionAudio.newBuilder().setUri(gcsUri).build();

        // Use non-blocking call for getting file transcription
        OperationFuture<LongRunningRecognizeResponse, LongRunningRecognizeMetadata> response =
            speechClient.longRunningRecognizeAsync(config, audio);

        while (!response.isDone()) {
          System.out.println("Waiting for response...");
          Thread.sleep(10000);
        }

        for (SpeechRecognitionResult result : response.get().getResultsList()) {

          // There can be several alternative transcripts for a given chunk of speech. Just use the
          // first (most likely) one here.
          SpeechRecognitionAlternative alternative = result.getAlternativesList().get(0);

          // Print out the result
          System.out.printf("Transcript : %s\n\n", alternative.getTranscript());
        }
      }
    }

Node.js

// Imports the Google Cloud client library
    const speech = require('@google-cloud/speech').v1p1beta1;

    // Creates a client
    const client = new speech.SpeechClient();

    /**
     * TODO(developer): Uncomment the following line before running the sample.
     */
    // const uri = path to GCS audio file e.g. `gs:/bucket/audio.wav`;

    const config = {
      encoding: 'LINEAR16',
      sampleRateHertz: 44100,
      languageCode: 'en-US',
      alternativeLanguageCodes: ['es-ES', 'en-US'],
    };

    const audio = {
      uri: gcsUri,
    };

    const request = {
      config: config,
      audio: audio,
    };

    const [operation] = await client.longRunningRecognize(request);
    const [response] = await operation.promise();
    const transcription = response.results
      .map(result => result.alternatives[0].transcript)
      .join('\n');
    console.log(`Transcription: ${transcription}`);