Trascrivi lunghi file audio in testo

Questa pagina mostra come trascrivere file audio lunghi (più lunghi di 1 minuto) in testo utilizzando l'API Speech-to-Text e la sintesi vocale di riconoscimento dei volti delle celebrità basata su rigidi criteri di controllo.

Informazioni sul riconoscimento vocale asincrono

Il riconoscimento vocale asincrono avvia un'elaborazione audio a lunga esecuzione operativa. Utilizza il riconoscimento vocale asincrono per trascrivere l'audio più di 60 secondi. Per un audio più breve, riconoscimento vocale sincrono è più semplice e veloce. Il limite massimo per il riconoscimento vocale asincrono è 480 minuti.

Elaborazione Speech-to-Text e asincrona

I contenuti audio possono essere inviati direttamente a Speech-to-Text da un file locale per l'elaborazione asincrona. Tuttavia, il limite di tempo per i file locali è 60 secondi. Tentativo di trascrizione di file audio locali di dimensioni superiori a 60 secondi, produrranno un errore. Per utilizzare il riconoscimento vocale asincrono più di 60 secondi, devi aver salvato i dati in una Bucket Google Cloud Storage.

Puoi recuperare i risultati dell'operazione utilizzando google.longrunning.Operations. Risultati rimanenti disponibili per il recupero per 5 giorni (120 ore). Hai anche la possibilità di caricando i risultati direttamente in un bucket Google Cloud Storage.

Trascrivere file audio lunghi utilizzando un file Google Cloud Storage

Questi esempi utilizzano un Bucket Cloud Storage per memorizzare l'input audio RAW per il processo di trascrizione a lunga durata. Per un esempio di un tipico Risposta dell'operazione longrunningrecognize, consulta le documentazione di riferimento.

Protocollo

Per informazioni complete, consulta l'endpoint API speech:longrunningrecognize i dettagli.

Per eseguire il riconoscimento vocale sincrono, effettua una richiesta POST e fornisci il corpo della richiesta appropriato. Di seguito è riportato un esempio di richiesta POST che utilizza curl. L'esempio utilizza Google Cloud CLI per generare un accesso di accesso. Per istruzioni sull'installazione di gcloud CLI, consulta la guida rapida.

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"

Consulta RecognitionConfig e RecognitionAudio documentazione di riferimento per ulteriori informazioni sulla configurazione del corpo della richiesta.

Se la richiesta ha esito positivo, il server restituisce un codice di stato HTTP 200 OK e la risposta in formato JSON:

{
  "name": "7612202767953098924"
}

dove name è il nome dell'operazione a lunga esecuzione creata per la richiesta.

Attendi il completamento dell'elaborazione. Il tempo di elaborazione varia in base al sorgente audio. Nella maggior parte dei casi, i risultati saranno la lunghezza dell'audio di origine. Puoi ottenere lo stato dell'operazione a lunga esecuzione effettuando un GET richiesta al https://speech.googleapis.com/v1/operations/ endpoint. Sostituisci your-operation-name con name restituito dalla tua richiesta 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"

Se la richiesta ha esito positivo, il server restituisce un codice di stato HTTP 200 OK e la risposta in formato 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": [
          {
            ...
          }
        ]
      }
    ]
  }
}

Se l'operazione non è stata completata, puoi eseguire il polling dell'endpoint ripetutamente effettuando la richiesta GET finché la proprietà done della risposta è true.

gcloud

Consulta le recognize-long-running per avere informazioni dettagliate.

Per eseguire il riconoscimento vocale asincrono, utilizza Google Cloud CLI, il percorso di un file locale o di un URL di Google Cloud Storage.

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

Se la richiesta riesce, il server restituisce l'ID del modello in formato JSON.

{
  "name": OPERATION_ID
}

Puoi quindi ottenere informazioni sull'operazione eseguendo il comando seguente.

gcloud ml speech operations describe OPERATION_ID

Puoi anche eseguire il polling dell'operazione fino al completamento eseguendo questo comando .

gcloud ml speech operations wait OPERATION_ID

Al termine dell'operazione, l'operazione restituisce una trascrizione dell'audio in formato JSON.

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

Go

Per scoprire come installare e utilizzare la libreria client per Speech-to-Text, vedi Librerie client di Speech-to-Text. Per ulteriori informazioni, consulta API Go di Speech-to-Text documentazione di riferimento.

Per eseguire l'autenticazione a Speech-to-Text, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per Speech-to-Text, vedi Librerie client di Speech-to-Text. Per ulteriori informazioni, consulta API Java di Speech-to-Text documentazione di riferimento.

Per eseguire l'autenticazione a Speech-to-Text, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

/**
 * 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

Per scoprire come installare e utilizzare la libreria client per Speech-to-Text, vedi Librerie client di Speech-to-Text. Per ulteriori informazioni, consulta API Node.js di Speech-to-Text documentazione di riferimento.

Per eseguire l'autenticazione a Speech-to-Text, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

// 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

Per scoprire come installare e utilizzare la libreria client per Speech-to-Text, vedi Librerie client di Speech-to-Text. Per ulteriori informazioni, consulta API Python di Speech-to-Text documentazione di riferimento.

Per eseguire l'autenticazione a Speech-to-Text, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Linguaggi aggiuntivi

C#: Segui le Istruzioni per la configurazione di C# Nella pagina delle librerie client e poi visita Documentazione di riferimento di Speech-to-Text per .NET.

PHP Segui le Istruzioni per la configurazione dei file PHP Nella pagina delle librerie client e poi visita Documentazione di riferimento di Speech-to-Text per PHP.

Rubino: Segui le Istruzioni per la configurazione di Ruby Nella pagina delle librerie client e poi visita Documentazione di riferimento di Speech-to-Text per Ruby.

Carica i risultati della trascrizione in un bucket Cloud Storage

Speech-to-Text supporta il caricamento dei risultati del riconoscimento a lunga esecuzione direttamente in un bucket Cloud Storage. Se implementi questa funzionalità con Trigger di Cloud Storage, I caricamenti su Cloud Storage possono attivare notifiche che richiamano Cloud Functions e rimuovi la necessità per eseguire il polling di Speech-to-Text per ottenere i risultati del riconoscimento.

Per fare in modo che i risultati vengano caricati in un bucket Cloud Storage, fornisci facoltativo TranscriptOutputConfig configurazione dell'output nella richiesta di riconoscimento a lunga esecuzione.

  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;
    }
  }

Protocollo

Consulta il longrunningrecognize Endpoint API per i dettagli completi.

L'esempio seguente mostra come inviare una richiesta POST utilizzando curl, in cui il corpo della richiesta specifica il percorso di un di sincronizzare la directory di una VM con un bucket. I risultati vengono caricati in questa posizione come file JSON che archivia 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"

La LongRunningRecognizeResponse include il percorso del bucket Cloud Storage in cui è stato tentato il caricamento. Se il caricamento non è riuscito, verrà restituito un errore di output. Se un file con lo stesso nome esiste già, il caricamento scrive i risultati in un nuovo file con come suffisso.

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

Provalo

Se non hai mai utilizzato Google Cloud, crea un account per valutare in che modo Speech-to-Text funziona nel mondo reale diversi scenari. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Prova Speech-to-Text senza costi