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.

Selezione di un modello di trascrizione

Questa pagina descrive come utilizzare un modello di machine learning specifico per le richieste di trascrizione audio a Speech-to-Text.

Modelli di trascrizione

Speech-to-Text rileva le parole in un clip audio confrontando l'input con uno dei tanti modelli di machine learning. Ogni modello è stato addestrato analizzando milioni di esempi, in questo caso molte, molte registrazioni audio di persone che parlano.

Speech-to-Text dispone di modelli specializzati addestrati a partire da audio da origini specifiche, ad esempio telefonate o video. Grazie a questo processo di addestramento, questi modelli specializzati forniscono risultati migliori se applicati a tipi di dati audio simili.

Ad esempio, Speech-to-Text dispone di un modello di trascrizione addestrato a riconoscere la voce registrata al telefono. Quando Speech-to-Text utilizza il modello phone_call, telephony o telephony_short per trascrivere l'audio del telefono, produce risultati di trascrizione più accurati rispetto a quanto accadrebbe se avesse trascritto l'audio dello smartphone utilizzando i modelli default, command_and_search o video.

La seguente tabella mostra i modelli di trascrizione disponibili per l'utilizzo con Speech-to-Text.

Nome modello	Descrizione
`latest_long`	Utilizza questo modello per qualsiasi tipo di contenuti nel formato lungo, come contenuti multimediali o conversazioni e conversazioni spontanee. Valuta la possibilità di utilizzare questo modello al posto del modello video, soprattutto se il modello video non è disponibile nella tua lingua di destinazione. Puoi utilizzare questa opzione anche al posto del modello predefinito.
`latest_short`	Utilizza questo modello per gli enunciati brevi di pochi secondi. È utile per provare ad acquisire comandi o altri casi d'uso di sintesi vocale diretti. Valuta la possibilità di utilizzare questo modello anziché il modello di comando e ricerca.
`phone_call`	Ideale per l'audio proveniente da una telefonata (solitamente registrato con una frequenza di campionamento di 8 kHz).
`telephony`	Versione migliorata del modello "phone_call", ideale per l'audio proveniente da una telefonata, generalmente registrata con una frequenza di campionamento di 8 kHz.
`telephony_short`	Versione dedicata del modello moderno di "telefonia" per espressioni brevi o anche di una sola parola per l'audio proveniente da una telefonata, generalmente registrata con una frequenza di campionamento di 8 kHz.
`medical_dictation`	Utilizza questo modello per trascrivere le note dettate da un medico. Si tratta di un modello premium che costa più della tariffa standard. Consulta la pagina relativa ai prezzi per ulteriori dettagli.
`medical_conversation`	Utilizza questo modello per trascrivere una conversazione tra un medico e un paziente. Si tratta di un modello premium che costa più della tariffa standard. Consulta la pagina relativa ai prezzi per ulteriori dettagli.
I seguenti modelli sono basati su architetture classiche non conformi e vengono conservati principalmente per motivi di compatibilità precedente e con versioni precedenti.
`command_and_search`	Ideale per espressioni brevi o di una sola parola come comandi vocali o ricerca vocale.
`default`	Ideale per l'audio che non si adatta agli altri modelli audio, come l'audio di durata estesa o la dettatura. Il modello predefinito genererà risultati della trascrizione per qualsiasi tipo di audio, incluso l'audio come i video clip per i quali è disponibile un modello separato personalizzato. Tuttavia, il riconoscimento dell'audio dei video clip con il modello predefinito genererà probabilmente risultati di qualità inferiore rispetto all'utilizzo del modello video. Idealmente, l'audio è ad alta fedeltà, registrato con una frequenza di campionamento pari o superiore a 16 kHz.
`video`	Ideale per l'audio proveniente da video clip o altre fonti (ad esempio podcast) con più altoparlanti. Questo modello è spesso la scelta migliore per l'audio registrato con un microfono di alta qualità o con molto rumore di fondo. Per ottenere risultati ottimali, fornisci audio registrato a una frequenza di campionamento pari o superiore a 16.000 Hz.

Seleziona un modello per la trascrizione audio

Per specificare un modello specifico da utilizzare per la trascrizione audio, devi impostare il campo model su uno dei valori consentiti (latest_long, latest_short, video, phone_call, command_and_search o default, nei parametri RecognitionConfig per la richiesta. Speech-to-Text supporta la selezione del modello per tutti i metodi di riconoscimento vocale: speech:recognize, speech:longrunningrecognize e Streaming.

Eseguire la trascrizione di un file audio locale

Protocollo

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

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 -s -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
    https://speech.googleapis.com/v1/speech:recognize \
    --data '{
    "config": {
        "encoding": "LINEAR16",
        "sampleRateHertz": 16000,
        "languageCode": "en-US",
        "model": "video"
    },
    "audio": {
        "uri": "gs://cloud-samples-tests/speech/Google_Gnome.wav"
    }
}'

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

Se la richiesta ha esito positivo, il server restituisce un codice di stato HTTP 200 OK e la risposta in formato JSON:

{
  "results": [
    {
      "alternatives": [
        {
          "transcript": "OK Google stream stranger things from
            Netflix to my TV okay stranger things from
            Netflix playing on TV from the people that brought you
            Google home comes the next evolution of the smart home
            and it's just outside your window me Google know hi
            how can I help okay no what's the weather like outside
            the weather outside is sunny and 76 degrees he's right
            okay no turn on the hose I'm holding sure okay no I'm can
            I eat this lemon tree leaf yes what about this Daisy yes
            but I wouldn't recommend it but I could eat it okay
            Nomad milk to my shopping list I'm sorry that sounds like
            an indoor request I keep doing that sorry you do keep
            doing that okay no is this compost really we're all
            compost if you think about it pretty much everything is
            made up of organic matter and will return",
          "confidence": 0.9251011
        }
      ]
    }
  ]
}

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 modelSelection(w io.Writer, path string) error {
	ctx := context.Background()

	client, err := speech.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	// path = "../testdata/Google_Gnome.wav"
	data, err := ioutil.ReadFile(path)
	if err != nil {
		return fmt.Errorf("ReadFile: %w", err)
	}

	req := &speechpb.RecognizeRequest{
		Config: &speechpb.RecognitionConfig{
			Encoding:        speechpb.RecognitionConfig_LINEAR16,
			SampleRateHertz: 16000,
			LanguageCode:    "en-US",
			Model:           "video",
		},
		Audio: &speechpb.RecognitionAudio{
			AudioSource: &speechpb.RecognitionAudio_Content{Content: data},
		},
	}

	resp, err := client.Recognize(ctx, req)
	if err != nil {
		return fmt.Errorf("Recognize: %w", err)
	}

	for i, result := range resp.Results {
		fmt.Fprintf(w, "%s\n", strings.Repeat("-", 20))
		fmt.Fprintf(w, "Result %d\n", i+1)
		for j, alternative := range result.Alternatives {
			fmt.Fprintf(w, "Alternative %d: %s\n", j+1, alternative.Transcript)
		}
	}
	return nil
}

Java

/**
 * Performs transcription of the given audio file synchronously with the selected model.
 *
 * @param fileName the path to a audio file to transcribe
 */
public static void transcribeModelSelection(String fileName) throws Exception {
  Path path = Paths.get(fileName);
  byte[] content = Files.readAllBytes(path);

  try (SpeechClient speech = SpeechClient.create()) {
    // Configure request with video media type
    RecognitionConfig recConfig =
        RecognitionConfig.newBuilder()
            // encoding may either be omitted or must match the value in the file header
            .setEncoding(AudioEncoding.LINEAR16)
            .setLanguageCode("en-US")
            // sample rate hertz may be either be omitted or must match the value in the file
            // header
            .setSampleRateHertz(16000)
            .setModel("video")
            .build();

    RecognitionAudio recognitionAudio =
        RecognitionAudio.newBuilder().setContent(ByteString.copyFrom(content)).build();

    RecognizeResponse recognizeResponse = speech.recognize(recConfig, recognitionAudio);
    // Just print the first result here.
    SpeechRecognitionResult result = recognizeResponse.getResultsList().get(0);
    // 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("Transcript : %s\n", alternative.getTranscript());
  }
}

Node.js

// Imports the Google Cloud client library for Beta API
/**
 * TODO(developer): Update client library import to use new
 * version of API when desired features become available
 */
const speech = require('@google-cloud/speech').v1p1beta1;
const fs = require('fs');

// Creates a client
const client = new speech.SpeechClient();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const filename = 'Local path to audio file, e.g. /path/to/audio.raw';
// const model = 'Model to use, e.g. phone_call, video, default';
// 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,
  model: model,
};
const audio = {
  content: fs.readFileSync(filename).toString('base64'),
};

const request = {
  config: config,
  audio: audio,
};

// Detects speech in the audio file
const [response] = await client.recognize(request);
const transcription = response.results
  .map(result => result.alternatives[0].transcript)
  .join('\n');
console.log('Transcription: ', transcription);

Python

def transcribe_model_selection(
    speech_file: str,
    model: str,
) -> speech.RecognizeResponse:
    """Transcribe the given audio file synchronously with
    the selected model."""
    client = speech.SpeechClient()

    with open(speech_file, "rb") as audio_file:
        content = audio_file.read()

    audio = speech.RecognitionAudio(content=content)

    config = speech.RecognitionConfig(
        encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
        sample_rate_hertz=16000,
        language_code="en-US",
        model=model,
    )

    response = client.recognize(config=config, audio=audio)

    for i, result in enumerate(response.results):
        alternative = result.alternatives[0]
        print("-" * 20)
        print(f"First alternative of result {i}")
        print(f"Transcript: {alternative.transcript}")

    return response

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e poi 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 poi 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.

Esecuzione della trascrizione di un file audio di Cloud Storage

Go


import (
	"context"
	"fmt"
	"io"
	"strings"

	speech "cloud.google.com/go/speech/apiv1"
	"cloud.google.com/go/speech/apiv1/speechpb"
)

// transcribe_model_selection_gcs Transcribes the given audio file asynchronously with
// the selected model.
func transcribe_model_selection_gcs(w io.Writer, gcsUri string, model string) error {
	// Google Cloud Storage URI pointing to the audio content.
	// gcsUri := "gs://bucket-name/path_to_audio_file"

	// The speech recognition model to use
	// See, https://cloud.google.com/speech-to-text/docs/speech-to-text-requests#select-model
	// model := "default"
	ctx := context.Background()

	client, err := speech.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	audio := &speechpb.RecognitionAudio{
		AudioSource: &speechpb.RecognitionAudio_Uri{Uri: gcsUri},
	}

	recognitionConfig := &speechpb.RecognitionConfig{
		Encoding:        speechpb.RecognitionConfig_LINEAR16,
		SampleRateHertz: 16000,
		LanguageCode:    "en-US",
		Model:           model,
	}

	longRunningRecognizeRequest := &speechpb.LongRunningRecognizeRequest{
		Config: recognitionConfig,
		Audio:  audio,
	}

	operation, err := client.LongRunningRecognize(ctx, longRunningRecognizeRequest)
	if err != nil {
		return fmt.Errorf("error running recognize %v", err)
	}

	response, err := operation.Wait(ctx)
	if err != nil {
		return err
	}
	for i, result := range response.Results {
		alternative := result.Alternatives[0]
		fmt.Fprintf(w, "%s\n", strings.Repeat("-", 20))
		fmt.Fprintf(w, "First alternative of result %d", i)
		fmt.Fprintf(w, "Transcript: %s", alternative.Transcript)
	}
	return nil
}