Prova i modelli Gemini 1.5, gli ultimi modelli multimodali di Vertex AI, e scopri cosa puoi creare con una finestra contestuale fino a 2 milioni di token. Prova i modelli Gemini 1.5, i più recenti modelli multimodali di Vertex AI, e scopri cosa puoi creare con una finestra contestuale fino a 2 milioni di token.

Questa pagina è stata tradotta dall'API Cloud Translation.

Selezione di un modello di trascrizione

In questa pagina viene descritto 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 numerosi 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 da audio provenienti 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 telephony o telephony_short per trascrivere l'audio del telefono, produce risultati di trascrizione più accurati rispetto a quando avesse trascritto l'audio dello smartphone utilizzando i modelli latest_short o latest_long.

La tabella seguente 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 contenuto nel formato lungo, come contenuti multimediali o discorsi e conversazioni spontanee. Valuta la possibilità di utilizzare questo modello al posto di quello video, soprattutto se quest'ultimo non è disponibile nella tua lingua di destinazione. Puoi anche utilizzarlo al posto del modello predefinito.
`latest_short`	Utilizza questo modello per frasi brevi di pochi secondi. È utile per cercare di acquisire comandi o altri casi d'uso di parlato diretta a un solo colpo. Valuta la possibilità di utilizzare questo modello anziché il modello di comando e ricerca.
`telephony`	Versione migliorata del modello "phone_call", migliore per l'audio proveniente da una telefonata, generalmente registrata con una frequenza di campionamento di 8 kHz.
`telephony_short`	Versione dedicata del moderno modello di "telefonia" per frasi brevi o anche composte da 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 note dettate da un medico. Si tratta di un modello premium che ha un costo maggiore rispetto alla 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 ha un costo maggiore rispetto alla tariffa standard. Consulta la pagina relativa ai prezzi per ulteriori dettagli.
I seguenti modelli sono basati principalmente su architetture classiche non conformi e sono conservati principalmente per motivi legacy e di compatibilità con le versioni precedenti.
`command_and_search`	Ideale per frasi brevi o composte da una sola parola, come comandi vocali o ricerca vocale.
`default`	Ideale per audio non compatibile con gli altri modelli audio, come l'audio di durata estesa o la dettatura. Il modello predefinito produrrà i risultati della trascrizione per qualsiasi tipo di audio, incluso audio come video clip che hanno un modello separato su misura per lui. Tuttavia, il riconoscimento dell'audio del video clip utilizzando il modello predefinito probabilmente produrrà 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.
`phone_call`	Ideale per l'audio proveniente da una telefonata (solitamente registrata con una frequenza di campionamento di 8 kHz).
`video`	Ideale per l'audio di video clip o altre sorgenti (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 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, ad esempio latest_long, latest_short, telephony o telephony_short, 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 mediante 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"
    }
}'

Consulta la documentazione di riferimento di RecognitionConfig per ulteriori informazioni su come configurare il corpo della richiesta.

Se la richiesta riesce, 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, vedi Librerie client di Speech-to-Text. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Go di Speech-to-Text.

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 per la 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 di 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 visita la documentazione di riferimento di Speech-to-Text per Ruby.

Eseguire la trascrizione di un file audio 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 %w", 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
}