Essayez Gemini 1.5 Pro, notre modèle multimodal le plus avancé dans Vertex AI et découvrez ce que vous pouvez compiler avec une fenêtre de contexte d'un million de jetons. Essayez Gemini 1.5 Pro, notre modèle multimodal le plus avancé dans Vertex AI et découvrez ce que vous pouvez compiler avec une fenêtre de contexte d'un million de jetons.

Sélectionner un modèle de transcription

Cette page explique comment utiliser un modèle de machine learning spécifique pour les requêtes de transcription audio dans Speech-to-Text.

Modèles de transcription

Speech-to-Text détecte les mots prononcés dans un extrait audio en comparant les entrées à l'un des nombreux modèles de machine learning. Chaque modèle a été entraîné via l'analyse de millions d'exemples (dans ce cas, de très nombreux enregistrements audio de personnes qui parlent).

Speech-to-Text est doté de modèles spécialisés entraînés à partir de données audio provenant de sources spécifiques, comme des appels téléphoniques ou des vidéos. En raison de ce processus d'entraînement, ces modèles spécialisés fournissent de meilleurs résultats lorsqu'ils sont appliqués à des types de données audio similaires.

Par exemple, Speech-to-Text possède un modèle de transcription entraîné à reconnaître des phrases enregistrées au téléphone. Lorsque Speech-to-Text utilise le modèle phone_call, telephony ou telephony_short pour transcrire des enregistrements audio téléphoniques, il produit des résultats de transcription plus précis que s'il avait transcrit ces enregistrements en utilisant les modèles default, command_and_search ou video.

Le tableau suivant présente les modèles de transcription disponibles pour une utilisation avec Speech-to-Text.

Nom du modèle	Description
`latest_long`	Utilisez ce modèle pour tous types de contenus longs, tels que les flux audio présents dans des médias, ou des conversations spontanées. Privilégiez ce modèle au modèle vidéo, en particulier si celui-ci n'est pas disponible dans votre langue cible. Vous pouvez également l'utiliser à la place du modèle par défaut.
`latest_short`	Utilisez ce modèle pour des énoncés courts, de l'ordre de quelques secondes. Il est pertinent pour capturer des commandes vocales, ou d'autres cas d'utilisation supposant des énoncés brefs et orientés. Privilégiez ce modèle au modèle de commande et de recherche.
`phone_call`	Idéal pour les données audio provenant d'appels téléphoniques (généralement enregistrées à un taux d'échantillonnage de 8 kHz).
`telephony`	Version améliorée du modèle "phone_call", idéal pour les données audio provenant d'appels téléphoniques, généralement enregistrées à un taux d'échantillonnage de 8 kHz.
`telephony_short`	Version du modèle "téléphony" moderne dédiée aux énoncés courts ou d'un seul mot pour les données audio provenant d'appels téléphoniques, généralement enregistrées à un taux d'échantillonnage de 8 kHz.
`medical_dictation`	Ce modèle permet de transcrire des notes dictées par un professionnel de santé. Modèle premium plus onéreux que le tarif standard. Consultez la page Tarifs pour en savoir plus.
`medical_conversation`	Utilisez-le pour transcrire une conversation entre un professionnel de santé et un patient. Il s'agit d'un modèle premium plus onéreux que le tarif standard. Consultez la page Tarifs pour en savoir plus.
Les modèles suivants sont basés sur des architectures classiques non conformes et sont principalement conservés comme versions anciennes pour rétrocompatibilité.
`command_and_search`	Idéal pour les prononciations courtes ou simples, comme les commandes ou la recherche vocales.
`default`	Idéal pour les données audio qui ne correspondent pas aux autres modèles, comme les enregistrements sonores longue durée ou les dictées. Le modèle par défaut produit des résultats de transcription pour n'importe quel type de contenu audio, y compris des séquences audio comme des extraits vidéo disposant d'un modèle distinct spécialement adapté. Cependant, la reconnaissance audio des extraits vidéo à l'aide du modèle par défaut produira probablement des résultats de qualité inférieure à ceux du modèle vidéo. Il est préférable d'utiliser un son haute fidélité, enregistré à un taux d'échantillonnage de 16 kHz ou plus.
`video`	Idéal pour les données audio provenant d'extraits vidéo ou d'autres sources (comme des podcasts) comprenant plusieurs locuteurs. Ce modèle constitue aussi souvent le meilleur choix pour les données audio enregistrées avec un micro de haute qualité ou comportant beaucoup de bruits de fond. Pour optimiser les résultats, fournissez un contenu audio enregistré à un taux d'échantillonnage de 16 000 Hz ou plus.

Sélectionner un modèle pour la transcription audio

Pour spécifier un modèle spécifique à utiliser pour la transcription audio, vous devez définir le champ model sur l'une des valeurs autorisées (latest_long, latest_short, video, phone_call, command_and_search ou default) dans les paramètres RecognitionConfig de la requête. Speech-to-Text accepte la sélection de modèle pour toutes les méthodes de reconnaissance vocale : speech:recognize, speech:longrunningrecognize et Streaming.

Effectuer la transcription d'un fichier audio local

Protocole

Reportez-vous au point de terminaison speech:recognize de l'API pour obtenir des informations complètes.

Pour réaliser une reconnaissance vocale synchrone, exécutez une requête POST en fournissant le corps de requête approprié. Voici un exemple de requête POST utilisant curl. L'exemple utilise Google Cloud CLI pour générer un jeton d'accès. Pour obtenir des instructions sur l'installation de gcloud CLI, consultez le guide de démarrage rapide.

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"
    }
}'

Pour en savoir plus sur la configuration du corps de la requête, consultez la documentation de référence sur RecognitionConfig.

Si la requête aboutit, le serveur renvoie un code d'état HTTP 200 OK ainsi que la réponse au format 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

Pour savoir comment installer et utiliser la bibliothèque cliente pour Speech-to-Text, consultez la page Bibliothèques clientes Speech-to-Text. Pour en savoir plus, consultez la documentation de référence de l'API Speech-to-Text en langage Go.

Pour vous authentifier auprès de Speech-to-Text, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.


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

Langages supplémentaires

C# : Veuillez suivre les Instructions de configuration pour C# sur la page des bibliothèques clientes, puis consultez la page Documentation de référence sur Speech-to-Text pour .NET.

PHP : Veuillez suivre les Instructions de configuration pour PHP sur la page des bibliothèques clientes, puis consultez la page Documentation de référence sur Speech-to-Text pour PHP.

Ruby : Veuillez suivre les Instructions de configuration pour Ruby sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur Speech-to-Text pour Ruby.

Effectuer la transcription d'un fichier 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 %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
}