Prueba los modelos de Gemini 1.5, nuestros modelos multimodales más recientes en Vertex AI y observa lo que puedes compilar con una ventana de contexto de 1 millón de tokens. Prueba los modelos de Gemini 1.5, nuestros modelos multimodales más recientes en Vertex AI y observa lo que puedes compilar con una ventana de contexto de 1 millón de tokens.

Transcribe archivos de audio largos en texto

En esta página, se demuestra cómo transcribir archivos de audio largos (de más de 1 minuto) a texto con la API de Speech-to-Text y el reconocimiento de voz asíncrono.

Información sobre el reconocimiento de voz asíncrono

El reconocimiento de voz asíncrono inicia una operación de procesamiento de audio de larga duración. Usa el reconocimiento de voz asíncrono para transcribir audios de más de 60 segundos. Para audios más cortos, el reconocimiento de voz síncrono es más rápido y sencillo. El límite superior para el reconocimiento de voz asíncrono es de 480 minutos.

Procesamiento de Speech-to-Text y asíncrono

El contenido del audio se puede enviar directamente a Speech-to-Text desde un archivo local para el procesamiento asíncrono. Sin embargo, el límite de tiempo de audio para los archivos locales es de 60 segundos. Si intentas transcribir archivos de audio locales de más de 60 segundos, se producirá un error. Si quieres usar el reconocimiento de voz asíncrono para transcribir audios de más de 60 segundos, debes guardar los datos en un bucket de Google Cloud Storage.

Puedes recuperar los resultados de la operación mediante el método google.longrunning.Operations. Los resultados permanecen disponibles para su recuperación durante 5 días (120 horas). También tienes la opción de subir los resultados directamente a un bucket de Google Cloud Storage.

Transcribe archivos de audio largos con un archivo de Google Cloud Storage

En estos ejemplos, se usa un bucket de Cloud Storage a fin de almacenar la entrada de audio sin procesar para el proceso de transcripción de larga duración. Para ver un ejemplo de una respuesta de operación longrunningrecognize típica, consulta la documentación de referencia.

Protocolo

Consulta el extremo de la API de speech:longrunningrecognize para obtener los detalles completos.

Para realizar un reconocimiento de voz síncrono, haz una solicitud POST y proporciona el cuerpo de la solicitud apropiado. A continuación, se muestra un ejemplo de una solicitud POST con curl. En el ejemplo, se usa Google Cloud CLI para generar un token de acceso. Para obtener instrucciones sobre cómo instalar gcloud CLI, consulta la guía de inicio rápido.

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 documentación de referencia de RecognitionConfig y RecognitionAudio para obtener más información sobre cómo configurar el cuerpo de la solicitud.

Si la solicitud se completa correctamente, el servidor muestra un código de estado HTTP 200 OK y la respuesta en formato JSON:

{
  "name": "7612202767953098924"
}

donde name es el nombre de la operación de larga duración creada para la solicitud.

Espera a que se complete el procesamiento. El tiempo de procesamiento varía según el audio de la fuente. En la mayoría de los casos, obtendrás resultados en la mitad de la longitud del audio de origen. Puedes obtener el estado de tu operación de larga duración si haces una solicitud GET al extremo https://speech.googleapis.com/v1/operations/. Reemplaza your-operation-name con el name recibido de tu solicitud 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"

Si la solicitud se completa de forma correcta, el servidor muestra un código de estado HTTP 200 OK y la respuesta en 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": [
          {
            ...
          }
        ]
      }
    ]
  }
}

Si la operación no se completó, puedes encuestar al extremo mediante la repetición de la solicitud GET hasta que la propiedad done de la respuesta sea true.

gcloud

Consulta el comando recognize-long-running para obtener todos los detalles.

Para realizar el reconocimiento de voz asíncrono, usa Google Cloud CLI, mediante el suministro de la ruta de acceso de un archivo local o una URL de Google Cloud Storage.

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

Si la solicitud es exitosa, el servidor muestra el ID de la operación de larga duración en formato JSON.

{
  "name": OPERATION_ID
}

A continuación, puedes obtener información sobre la operación mediante la ejecución del siguiente comando.

gcloud ml speech operations describe OPERATION_ID

También puedes encuestar a la operación hasta que finalice mediante la ejecución del siguiente comando.

gcloud ml speech operations wait OPERATION_ID

Una vez que se completa la operación, esta muestra una transcripción del audio en formato JSON.

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

Go

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Speech-to-Text, consulta las bibliotecas cliente de Speech-to-Text. Para obtener más información, consulta la documentación de referencia de la API de Speech-to-Text de Go.

Para autenticar en Speech-to-Text, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.


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

Idiomas adicionales

C#: Sigue las instrucciones de configuración de C# en la página de bibliotecas cliente y, luego, visita la documentación de referencia de Speech-to-Text para .NET

PHP: Sigue las instrucciones de configuración de PHP en la página de bibliotecas cliente y, luego, visita la documentación de referencia de Speech-to-Text para PHP.

Ruby: Sigue las instrucciones de configuración de Ruby en la página Bibliotecas cliente y, luego, visita la documentación de referencia de Speech-to-Text para Ruby.

Sube los resultados de tu transcripción a un bucket de Cloud Storage

Speech-to-Text admite la carga de los resultados de reconocimiento de larga duración directamente en un bucket de Cloud Storage. Si implementas esta función con activadores de Cloud Storage, las cargas de Cloud Storage pueden activar notificaciones que llaman a Cloud Functions y eliminan la necesidad de sondear Speech-to-Text en busca de resultados de reconocimiento.

Para que tus resultados se suban a un bucket de Cloud Storage, proporciona la configuración de salida opcional TranscriptOutputConfig en tu solicitud de reconocimiento de larga duración.

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

Protocolo

Consulta el extremo de la API de longrunningrecognize para obtener más detalles.

En el siguiente ejemplo, se muestra cómo enviar una solicitud POST con curl, en el que el cuerpo de la solicitud especifica la ruta a un bucket de Cloud Storage. Los resultados se suben a esta ubicación como un archivo JSON que almacena 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 incluye la ruta de acceso al bucket de Cloud Storage en el que se intentó subir el archivo. Si la carga no se realizó correctamente, se mostrará un error de salida. Si ya existe un archivo con el mismo nombre, la carga escribe los resultados en un archivo nuevo con una marca de tiempo como sufijo.

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

Pruébalo tú mismo

Si es la primera vez que usas Google Cloud, crea una cuenta para evaluar el rendimiento de Speech-to-Text en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Probar Speech-to-Text gratis