Transcrire en texte des fichiers audio longs

Vous trouverez sur cette page la procédure à suivre pour transcrire en texte des fichiers audio longs (de plus d'une minute) à l'aide de l'API Speech-to-Text et de la reconnaissance vocale asynchrone.

À propos de la reconnaissance vocale asynchrone

La reconnaissance vocale asynchrone lance une opération de traitement audio de longue durée. Servez-vous de cette fonctionnalité pour transcrire des fichiers audio d'une durée supérieure à 60 secondes. Pour des contenus audio plus courts, la reconnaissance vocale synchrone est plus rapide et plus simple. La limite supérieure pour la reconnaissance vocale asynchrone est de 480 minutes.

Speech-to-Text et traitement asynchrone

Le contenu audio peut être envoyé directement à Speech-to-Text à partir d'un fichier local en vue d'un traitement asynchrone. Cependant, la limite de temps audio pour les fichiers locaux est de 60 secondes. Toute tentative de transcription de fichiers audio locaux de plus de 60 secondes génère une erreur. Pour utiliser la reconnaissance vocale asynchrone afin de transcrire des fichiers audio d'une durée supérieure à 60 secondes, vous devez enregistrer vos données dans un bucket Google Cloud Storage.

Vous pouvez récupérer les résultats de l'opération à l'aide de la méthode google.longrunning.Operations. Les résultats restent disponibles pendant cinq jours (120 heures). Vous avez également la possibilité d'importer directement vos résultats dans un bucket Google Cloud Storage.

Transcrire des fichiers audio longs à l'aide d'un fichier Google Cloud Storage

Ces exemples utilisent un bucket Cloud Storage afin de stocker les données d'entrée audio brutes pour le processus de transcription de longue durée. Pour obtenir un exemple de réponse type d'une opération longrunningrecognize classique, consultez la documentation de référence.

Protocole

Reportez-vous au point de terminaison speech:longrunningrecognize 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. L'exemple utilise Google Cloud CLI pour générer un jeton d'accès. Pour obtenir des instructions sur l'installation de gcloud CLI, consultez le quickstart.

curl -X POST \
     -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
     -H "Content-Type: application/json; charset=utf-8" \
     --data "{
  'config': {
    'language_code': 'en-US'
  },
  'audio':{
    'uri':'gs://cloud-samples-tests/speech/brooklyn.flac'
  }
}" "https://speech.googleapis.com/v1/speech:longrunningrecognize"

Pour savoir comment configurer le corps de la requête, consultez la documentation de référence sur RecognitionConfig et RecognitionAudio.

Si la requête aboutit, le serveur renvoie un code d'état HTTP 200 OK et la réponse au format JSON :

{
  "name": "7612202767953098924"
}

où name est le nom de l'opération de longue durée créée pour la requête.

Attendez la fin du traitement. La durée de traitement diffère suivant la source audio. Dans la plupart des cas, vous obtiendrez des résultats dans un délai correspondant à la moitié de la durée de la source audio. Vous pouvez obtenir l'état de votre opération de longue durée en envoyant une requête GET au point de terminaison https://speech.googleapis.com/v1/operations/. Remplacez your-operation-name par la valeur name reçue en tant que résultat de la requête longrunningrecognize.

curl -H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
     -H "Content-Type: application/json; charset=utf-8" \
     "https://speech.googleapis.com/v1/operations/your-operation-name"

Si la requête aboutit, le serveur renvoie un code d'état HTTP 200 OK et la réponse au format JSON :

{
  "name": "7612202767953098924",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.speech.v1.LongRunningRecognizeMetadata",
    "progressPercent": 100,
    "startTime": "2017-07-20T16:36:55.033650Z",
    "lastUpdateTime": "2017-07-20T16:37:17.158630Z"
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.speech.v1.LongRunningRecognizeResponse",
    "results": [
      {
        "alternatives": [
          {
            "transcript": "how old is the Brooklyn Bridge",
            "confidence": 0.96096134,
          }
        ]
      },
      {
        "alternatives": [
          {
            ...
          }
        ]
      }
    ]
  }
}

Si l'opération n'est pas terminée, vous pouvez interroger le point de terminaison en exécutant plusieurs fois la requête GET jusqu'à ce que la propriété done de la réponse passe à la valeur true.

gcloud

Reportez-vous à la commande recognize-long-running pour obtenir tous les détails.

Pour effectuer une reconnaissance vocale asynchrone, servez-vous de la Google Cloud CLI en fournissant le chemin d'accès à un fichier local ou une URL Google Cloud Storage.

gcloud ml speech recognize-long-running \
    'gs://cloud-samples-tests/speech/brooklyn.flac' \
     --language-code='en-US' --async

Si la requête aboutit, le serveur renvoie l'ID de l'opération de longue durée au format JSON.

{
  "name": OPERATION_ID
}

Vous pouvez ensuite obtenir des informations sur l'opération en exécutant la commande suivante :

gcloud ml speech operations describe OPERATION_ID

Vous avez également la possibilité d'interroger l'opération jusqu'à ce qu'elle soit terminée en exécutant la commande suivante :

gcloud ml speech operations wait OPERATION_ID

Une fois l'opération terminée, le serveur renvoie une transcription du contenu audio au format JSON.

{
  "@type": "type.googleapis.com/google.cloud.speech.v1.LongRunningRecognizeResponse",
  "results": [
    {
      "alternatives": [
        {
          "confidence": 0.9840146,
          "transcript": "how old is the Brooklyn Bridge"
        }
      ]
    }
  ]
}

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour Speech-to-Text, consultez la page Bibliothèques clientes Speech-to-Text. Pour en savoir plus, consultez la documentation de référence de l'API Speech-to-Text en langage Go.

Pour vous authentifier auprès de Speech-to-Text, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.


func sendGCS(w io.Writer, client *speech.Client, gcsURI string) error {
	ctx := context.Background()

	// Send the contents of the audio file with the encoding and
	// and sample rate information to be transcripted.
	req := &speechpb.LongRunningRecognizeRequest{
		Config: &speechpb.RecognitionConfig{
			Encoding:        speechpb.RecognitionConfig_LINEAR16,
			SampleRateHertz: 16000,
			LanguageCode:    "en-US",
		},
		Audio: &speechpb.RecognitionAudio{
			AudioSource: &speechpb.RecognitionAudio_Uri{Uri: gcsURI},
		},
	}

	op, err := client.LongRunningRecognize(ctx, req)
	if err != nil {
		return err
	}
	resp, err := op.Wait(ctx)
	if err != nil {
		return err
	}

	// Print the results.
	for _, result := range resp.Results {
		for _, alt := range result.Alternatives {
			fmt.Fprintf(w, "\"%v\" (confidence=%3f)\n", alt.Transcript, alt.Confidence)
		}
	}
	return nil
}

Java

/**
 * Performs non-blocking speech recognition on remote FLAC file and prints the transcription.
 *
 * @param gcsUri the path to the remote LINEAR16 audio file to transcribe.
 */
public static void asyncRecognizeGcs(String gcsUri) throws Exception {
  // Configure polling algorithm
  SpeechSettings.Builder speechSettings = SpeechSettings.newBuilder();
  TimedRetryAlgorithm timedRetryAlgorithm =
      OperationTimedPollAlgorithm.create(
          RetrySettings.newBuilder()
              .setInitialRetryDelay(Duration.ofMillis(500L))
              .setRetryDelayMultiplier(1.5)
              .setMaxRetryDelay(Duration.ofMillis(5000L))
              .setInitialRpcTimeout(Duration.ZERO) // ignored
              .setRpcTimeoutMultiplier(1.0) // ignored
              .setMaxRpcTimeout(Duration.ZERO) // ignored
              .setTotalTimeout(Duration.ofHours(24L)) // set polling timeout to 24 hours
              .build());
  speechSettings.longRunningRecognizeOperationSettings().setPollingAlgorithm(timedRetryAlgorithm);

  // Instantiates a client with GOOGLE_APPLICATION_CREDENTIALS
  try (SpeechClient speech = SpeechClient.create(speechSettings.build())) {

    // Configure remote file request for FLAC
    RecognitionConfig config =
        RecognitionConfig.newBuilder()
            .setEncoding(AudioEncoding.FLAC)
            .setLanguageCode("en-US")
            .setSampleRateHertz(16000)
            .build();
    RecognitionAudio audio = RecognitionAudio.newBuilder().setUri(gcsUri).build();

    // Use non-blocking call for getting file transcription
    OperationFuture<LongRunningRecognizeResponse, LongRunningRecognizeMetadata> response =
        speech.longRunningRecognizeAsync(config, audio);
    while (!response.isDone()) {
      System.out.println("Waiting for response...");
      Thread.sleep(10000);
    }

    List<SpeechRecognitionResult> results = response.get().getResultsList();

    for (SpeechRecognitionResult result : results) {
      // 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);
      System.out.printf("Transcription: %s\n", alternative.getTranscript());
    }
  }
}

Node.js

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

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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const gcsUri = 'gs://my-bucket/audio.raw';
// const encoding = 'Encoding of the audio file, e.g. LINEAR16';
// const sampleRateHertz = 16000;
// const languageCode = 'BCP-47 language code, e.g. en-US';

const config = {
  encoding: encoding,
  sampleRateHertz: sampleRateHertz,
  languageCode: languageCode,
};

const audio = {
  uri: gcsUri,
};

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

// Detects speech in the audio file. This creates a recognition job that you
// can wait for now, or get its result later.
const [operation] = await client.longRunningRecognize(request);
// Get a Promise representation of the final result of the job
const [response] = await operation.promise();
const transcription = response.results
  .map(result => result.alternatives[0].transcript)
  .join('\n');
console.log(`Transcription: ${transcription}`);

Python

def transcribe_gcs(gcs_uri: str) -> str:
    """Asynchronously transcribes the audio file specified by the gcs_uri.

    Args:
        gcs_uri: The Google Cloud Storage path to an audio file.

    Returns:
        The generated transcript from the audio file provided.
    """
    from google.cloud import speech

    client = speech.SpeechClient()

    audio = speech.RecognitionAudio(uri=gcs_uri)
    config = speech.RecognitionConfig(
        encoding=speech.RecognitionConfig.AudioEncoding.FLAC,
        sample_rate_hertz=44100,
        language_code="en-US",
    )

    operation = client.long_running_recognize(config=config, audio=audio)

    print("Waiting for operation to complete...")
    response = operation.result(timeout=90)

    transcript_builder = []
    # Each result is for a consecutive portion of the audio. Iterate through
    # them to get the transcripts for the entire audio file.
    for result in response.results:
        # The first alternative is the most likely one for this portion.
        transcript_builder.append(f"\nTranscript: {result.alternatives[0].transcript}")
        transcript_builder.append(f"\nConfidence: {result.alternatives[0].confidence}")

    transcript = "".join(transcript_builder)
    print(transcript)

    return transcript

Langages supplémentaires

C# : Veuillez suivre les Instructions de configuration pour C# sur la page des bibliothèques clientes, puis consultez la page Documentation de référence sur Speech-to-Text pour .NET.

PHP : Veuillez suivre les Instructions de configuration pour PHP sur la page des bibliothèques clientes, puis consultez la page Documentation de référence sur Speech-to-Text pour PHP.

Ruby : Veuillez suivre les Instructions de configuration pour Ruby sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur Speech-to-Text pour Ruby.

Importer des résultats de transcription dans un bucket Cloud Storage

Speech-to-Text permet d'importer vos résultats de reconnaissance de longue durée directement dans un bucket Cloud Storage. Si vous mettez en œuvre cette fonctionnalité avec des déclencheurs Cloud Storage, les importations Cloud Storage peuvent déclencher des notifications qui appellent Cloud Functions et éliminent la nécessité d'interroger Speech-to-Text afin d'obtenir les résultats de la reconnaissance.

Pour que vos résultats soient importés dans un bucket Cloud Storage, indiquez la configuration de sortie facultative TranscriptOutputConfig dans votre requête de reconnaissance de longue durée.

  message TranscriptOutputConfig {

    oneof output_type {
      // Specifies a Cloud Storage URI for the recognition results. Must be
      // specified in the format: `gs://bucket_name/object_name`
      string gcs_uri = 1;
    }
  }

Protocole

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

L'exemple suivant montre comment envoyer une requête POST en utilisant curl, où le corps de la requête spécifie le chemin d'accès à un bucket Cloud Storage. Les résultats sont importés dans cet emplacement sous la forme d'un fichier JSON qui stocke SpeechRecognitionResult.

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     --data "{
  'config': {...},
  'output_config': {
     'gcs_uri':'gs://bucket/result-output-path.json'
  },
  'audio': {
    'uri': 'gs://bucket/audio-path'
  }
}" "https://speech.googleapis.com/v1p1beta1/speech:longrunningrecognize"

Le LongRunningRecognizeResponse inclut le chemin d'accès au bucket Cloud Storage où l'importation a été tentée. Si l'importation a échoué, une erreur de sortie est renvoyée. Si un fichier portant le même nom existe déjà, l'importation écrit les résultats dans un nouveau fichier avec un horodatage comme suffixe.

{
  ...
  "metadata": {
    ...
    "outputConfig": {...}
  },
  ...
  "response": {
    ...
    "results": [...],
    "outputConfig": {
      "gcs_uri":"gs://bucket/result-output-path"
    },
    "outputError": {...}
  }
}

Faites l'essai

Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de Speech-to-Text en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

Profiter d'un essai gratuit de Speech-to-Text