Prova Gemini 1.5 Pro, il nostro modello multimodale più avanzato di Vertex AI e scopri cosa puoi creare con una finestra di contesto dei token da 1 milione. Prova Gemini 1.5 Pro, il nostro modello multimodale più avanzato di Vertex AI e scopri cosa puoi creare con una finestra di contesto di 1 milione di token.

Questa pagina è stata tradotta dall'API Cloud Translation.

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. Usa il riconoscimento vocale asincrono per trascrivere audio più lunghi di 60 secondi. Per un audio più breve, il riconoscimento vocale sincrono è più semplice e veloce. Il limite massimo per il riconoscimento vocale asincrono è 480 minuti.

Speech-to-Text e l'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. Se provi a trascrivere file audio locali di durata superiore a 60 secondi, verrà visualizzato un errore. Per utilizzare il riconoscimento vocale asincrono per trascrivere audio di durata superiore a 60 secondi, devi aver salvato i tuoi 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). Puoi anche caricare i risultati direttamente in un bucket Google Cloud Storage.

Trascrizione di file audio lunghi utilizzando un file di 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 di un'operazione longrunningrecognize, consulta la documentazione di riferimento.

Protocollo

Fai riferimento all'endpoint API speech:longrunningrecognize per i dettagli completi.

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 token di accesso. Per istruzioni sull'installazione di gcloud CLI, consulta la quickstart.

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 la documentazione di riferimento di RecognitionConfig e RecognitionAudio 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 a seconda dell'audio della sorgente. Nella maggior parte dei casi, i risultati saranno a metà della durata dell'audio sorgente. 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 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 non sarà 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 ha esito positivo, il server restituisce l'ID dell'operazione a lunga esecuzione in formato JSON.

{
  "name": OPERATION_ID
}

Puoi quindi ottenere informazioni sull'operazione eseguendo questo comando.

gcloud ml speech operations describe OPERATION_ID

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

gcloud ml speech operations wait OPERATION_ID

Al termine, 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, consulta la pagina relativa alle librerie client di Speech-to-Text. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Speech-to-Text Go.

Per eseguire l'autenticazione 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

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

// 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: 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 di configurazione di C# nella pagina delle librerie client e consulta la 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 consulta la documentazione di riferimento di Speech-to-Text per PHP.

Ruby: segui le istruzioni per la configurazione di Ruby nella pagina delle librerie client e 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 lunga esecuzione direttamente in un bucket Cloud Storage. Se implementi questa funzionalità con i attivatori di 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 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

Per informazioni dettagliate, fai riferimento all'endpoint API longrunningrecognize.

L'esempio seguente mostra come inviare una richiesta POST utilizzando curl, in cui il corpo della richiesta specifica il percorso a un bucket Cloud Storage. I risultati vengono caricati in questa posizione come un file JSON in cui sono archiviati 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"

Il 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 hai mai utilizzato 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