Transcrire 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 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 données audio d'une durée supérieure à une minute. Pour des contenus audio plus courts, la reconnaissance vocale synchrone est plus rapide et plus simple.

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 vos résultats directement 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, consultez la documentation sur les Principes de base de Speech-to-Text.

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é. Vous trouverez ci-dessous un exemple de requête POST effectuée avec 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 la page Démarrage rapide.

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://gcs-test-data/vr.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"
}

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. Vous pouvez obtenir une estimation de l'avancement de votre requête dans le champ progressPercent.

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": "okay so what am I doing here...(etc)...",
            "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 l'outil de ligne de commande gcloud en fournissant le chemin d'accès d'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


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 {
  // Instantiates a client with GOOGLE_APPLICATION_CREDENTIALS
  try (SpeechClient speech = SpeechClient.create()) {

    // 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):
    """Asynchronously transcribes the audio file specified by the gcs_uri."""
    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=16000,
        language_code="en-US",
    )

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

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

    # 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.
        print(u"Transcript: {}".format(result.alternatives[0].transcript))
        print("Confidence: {}".format(result.alternatives[0].confidence))

Langues supplémentaires

C# : suivez les instructions de configuration C# sur la page des bibliothèques clientes, puis consultez le{ 10.1 Documentation de référence Speech-to-Text pour .NET.

PHP : suivez les instructions de configuration PHP sur la page des bibliothèques clientes, puis consultez le{ 10.1 Documentation de référence Speech-to-Text pour PHP.

Ruby : suivez les instructions de configuration de Ruby sur la page des bibliothèques clientes, puis accédez à la page { 10.1 Documentation de référence Speech-to-Text pour Ruby.

Importer les 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. Cette fonctionnalité est une fonctionnalité d'aperçu. 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 suppriment le besoin. pour interroger Speech-to-Text pour obtenir les résultats de reconnaissance.

Pour que vos résultats soient importés dans un bucket Cloud Storage, indiquez la configuration de sortie TranscriptOutputConfig facultative 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 à l'aide de curl, dont le corps spécifie le chemin d'accès à un bucket Cloud Storage. Les résultats sont importés dans cet emplacement en tant que fichier JSON qui stocke les fichiers 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"

LongRunningRecognizeResponse inclut le chemin d'accès au bucket GCS où la tentative d'importation a été effectuée. Si l'importation a échoué, une erreur de sortie est renvoyée. S'il existe déjà un fichier portant le même nom, l'importation écrit les résultats dans un nouveau fichier avec un horodatage en tant que suffixe.

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

Faites l'essai

Si vous débutez avec Google Cloud, créez un compte pour évaluer les performances de Speech-to-Text dans des scénarios réels. 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