Trascrivere in testo file audio lunghi

Questa pagina mostra come trascrivere file audio lunghi (più di 1 minuto) in testo 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 audio di durata superiore a 60 secondi. Per l'audio più breve, il riconoscimento vocale sincrono è più rapido e semplice. Il limite superiore 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 per l'audio dei file locali è di 60 secondi. Il tentativo di trascrivere file audio locali più lunghi di 60 secondi restituirà un errore. Per utilizzare il riconoscimento vocale asincrono per trascrivere audio di durata superiore a 60 secondi, devi salvare 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 il processo di trascrizione a lunga esecuzione. 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 a seconda dell'audio di origine. Nella maggior parte dei casi, i risultati saranno disponibili in metà del tempo di riproduzione dell'audio sorgente. Puoi ottenere lo stato dell'operazione a lunga esecuzione effettuando una richiesta GET all'endpoint https://speech.googleapis.com/v1/operations/. 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 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 effettuando ripetutamente la richiesta GET finché la proprietà done della risposta non è true.

gcloud

Per informazioni complete, 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 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 a lunga esecuzione in formato JSON.

{
  "name": OPERATION_ID
}

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

gcloud ml speech operations describe OPERATION_ID

Puoi anche eseguire il polling dell'operazione finché non viene completata eseguendo questo 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 la sezione Librerie client di Speech-to-Text. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Speech-to-Text per Go.

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

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

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

Per autenticarti in Speech-to-Text, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura 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 di C# nella pagina delle librerie client e poi visita 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 visita 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 di lunga durata direttamente in un bucket Cloud Storage. Se implementi questa funzionalità con i trigger Cloud Storage, i caricamenti di Cloud Storage possono attivare notifiche che chiamano Cloud Functions ed eliminano la necessità di eseguire il polling di Speech-to-Text per i risultati del riconoscimento.

Per caricare i risultati in un bucket Cloud Storage, fornisci la configurazione di output TranscriptOutputConfig facoltativa nella richiesta di riconoscimento di lunga durata.

  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.

Il seguente esempio 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 è riuscito, verrà restituito un errore di output. Se esiste già un file con lo stesso nome, il caricamento scrive i risultati 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 senza addebiti per l'esecuzione, il test e il deployment dei workload.

Prova Speech-to-Text gratuitamente