Trascrivere in testo file audio lunghi

Questa pagina mostra come trascrivere file audio lunghi (di durata superiore a 1 minuto) in testo utilizzando l'API Cloud 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 massimo per il riconoscimento vocale asincrono è di 480 minuti.

Cloud Speech-to-Text ed elaborazione asincrona

I contenuti audio possono essere inviati direttamente a Cloud Speech-to-Text da un file locale per l'elaborazione asincrona. Tuttavia, il limite di tempo per i file audio 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 più lunghi di 60 secondi, devi salvare i dati in un bucket 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 Cloud Storage.

Trascrivere file audio lunghi utilizzando un bucket 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 all'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 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 vengono generati in metà del tempo 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 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 effettuando 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 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 Cloud STT, consulta la sezione Librerie client Cloud STT. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud STT Go.

Per eseguire l'autenticazione in Cloud STT, 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 Cloud STT, consulta la sezione Librerie client Cloud STT. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud STT Java.

Per eseguire l'autenticazione in Cloud STT, 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 Cloud STT, consulta la sezione Librerie client Cloud STT. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud STT Node.js.

Per eseguire l'autenticazione in Cloud STT, 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 Cloud STT, consulta la sezione Librerie client Cloud STT. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud STT Python.

Per eseguire l'autenticazione in Cloud STT, 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, poi consulta la documentazione di riferimento di Cloud STT per .NET.

PHP: segui le istruzioni di configurazione di PHP nella pagina delle librerie client, poi consulta la documentazione di riferimento di Cloud STT per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client, poi consulta la documentazione di riferimento di Cloud STT per Ruby.

Carica i risultati della trascrizione in un bucket Cloud Storage

Cloud 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 Cloud Speech-to-Text per i risultati del riconoscimento.

Per caricare i risultati in un bucket Cloud Storage, fornisci la configurazione di output facoltativa TranscriptOutputConfig 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.

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/v2/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 Cloud STT in scenari reali. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei workload.

Prova Cloud STT gratuitamente