Trascrivere in testo file audio lunghi

Questa pagina mostra come trascrivere in testo file audio lunghi (più di 1 minuto) utilizzando l'API Speech-to-Text e il riconoscimento vocale asincrono.

Informazioni sul riconoscimento vocale asincrono

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

Speech-to-Text ed elaborazione 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 audio per i file locali è di 60 secondi. Il tentativo di trascrivere file audio locali più lunghi di 60 secondi causerà un errore. Per utilizzare il riconoscimento vocale asincrono per trascrivere audio di durata superiore a 60 secondi, devi aver salvato i dati in un bucket Google Cloud Storage.

Puoi recuperare i risultati dell'operazione utilizzando il metodo google.longrunning.Operations. I risultati rimangono disponibili per il recupero per 5 giorni (120 ore). Hai anche la possibilità di caricare 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 archiviare l'input audio non elaborato per la procedura di trascrizione a lungo termine. Per un esempio di risposta tipica dell'operazione longrunningrecognize, consulta la documentazione di riferimento.

Protocollo

Per informazioni dettagliate, consulta l'endpoint API speech:longrunningrecognize.

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 mediante curl. L'esempio utilizza Google Cloud CLI per generare un token 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"

Per ulteriori informazioni sulla configurazione del corpo della richiesta, consulta la documentazione di riferimento di RecognitionConfig e RecognitionAudio.

Se la richiesta riesce, 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. I tempi di elaborazione variano in base all'audio di origine. Nella maggior parte dei casi, otterrai risultati in metà della durata dell'audio di origine. Puoi ottenere lo stato dell'operazione a lunga esecuzione inviando una richiesta GET all'endpoint https://speech.googleapis.com/v1/operations/. Sostituisci your-operation-name con il valore name restituito dalla 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 riesce, 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 inviando ripetutamente la richiesta GET finché la proprietà done della risposta non è true.

gcloud

Per informazioni dettagliate, consulta il comando recognize-long-running.

Per eseguire il riconoscimento vocale asincrono, utilizza Google Cloud CLI, fornendo il percorso di un file locale o 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 dell'operazione di lunga durata 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 il seguente comando.

gcloud ml speech operations wait OPERATION_ID

Al termine dell'operazione, viene restituita 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, consulta Librerie client di Speech-to-Text. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Speech-to-Text Go.

Per autenticarti a Speech-to-Text, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare 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, consulta Librerie client di Speech-to-Text. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Speech-to-Text Java.

Per autenticarti a Speech-to-Text, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare 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, consulta Librerie client di Speech-to-Text. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Speech-to-Text Node.js.

Per autenticarti a Speech-to-Text, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare 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, consulta Librerie client di Speech-to-Text. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Speech-to-Text Python.

Per autenticarti a Speech-to-Text, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

from google.cloud import speech


def transcribe_gcs(gcs_uri: str) -> str:
    """Asynchronously transcribes the audio file from Cloud Storage
    Args:
        gcs_uri: The Google Cloud Storage path to an audio file.
            E.g., "gs://storage-bucket/file.flac".
    Returns:
        The generated transcript from the audio file provided.
    """
    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 di configurazione per C# riportate nella pagina delle librerie client e consulta la documentazione di riferimento di Speech-to-Text per .NET.

PHP: segui le istruzioni di configurazione di PHP nella pagina delle librerie client e poi consulta la documentazione di riferimento di Speech-to-Text per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi consulta la 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 lungo termine direttamente in un bucket Cloud Storage. Se implementi questa funzionalità con gli attivatori Cloud Storage, i caricamenti di Cloud Storage possono attivare notifiche che richiamano Cloud Functions e non è più necessario eseguire il polling di Speech-to-Text per i risultati di riconoscimento.

Per fare in modo che i risultati vengano caricati in un bucket Cloud Storage, fornisci la configurazione di output facoltativa TranscriptOutputConfig nella richiesta di riconoscimento a lungo termine.

  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

Per informazioni dettagliate, consulta l'endpoint API longrunningrecognize.

L'esempio seguente mostra come inviare una richiesta POST utilizzando curl, dove il corpo della richiesta specifica il percorso di un bucket Cloud Storage. I risultati vengono caricati in questa posizione come file JSON che memorizza 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 include il percorso del bucket Cloud Storage in cui è stato tentato il caricamento. Se il caricamento non è andato a buon fine, verrà restituito un errore di output. Se esiste già un file con lo stesso nome, i risultati vengono scritti in un nuovo file con un timestamp come suffisso.

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

Provalo

Se non conosci Google Cloud, crea un account per valutare le prestazioni di Speech-to-Text in scenari reali. 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 gratuitamente