Testen Sie Gemini 1.5-Modelle, die neuesten multimodalen Modelle in Vertex AI, und sehen Sie selbst, was Sie mit einem Kontextfenster von bis zu 2 Mio. Tokens erstellen können. Testen Sie Gemini 1.5-Modelle, die neuesten multimodalen Modelle in Vertex AI, und sehen Sie selbst, was Sie mit einem Kontextfenster von bis zu 2 Mio. Tokens erstellen können.

Transkriptionsmodell auswählen

Auf dieser Seite wird beschrieben, wie Sie ein bestimmtes Modell für maschinelles Lernen für Audiotranskriptionsanfragen an Speech-to-Text verwenden.

Transkriptionsmodelle

Speech-to-Text erkennt Wörter in einem Audioclip durch den Vergleich der Eingabe mit einem von vielen Modellen für maschinelles Lernen. Jedes Modell wurde durch die Analyse von Millionen Beispielen trainiert – in diesem Fall durch sehr viele Audioaufnahmen von sprechenden Personen.

Speech-to-Text verfügt über spezielle Modelle, die anhand von Audiodaten aus bestimmten Quellen wie Telefonanrufen oder Videos trainiert wurden. Aufgrund dieses Trainings liefern diese speziellen Modelle bessere Ergebnisse, wenn sie auf ähnliche Audiodaten angewendet werden.

Zum Beispiel hat Speech-to-Text ein Transkriptionsmodell, das dafür trainiert wurde, von einem Telefon aufgenommene Sprache zu erkennen. Wenn Speech-to-Text die Modelle telephony oder telephony_short zur Transkription von Telefon-Audiodaten verwendet, so erzeugt es genauere Transkriptionsergebnisse als mit latest_short- oder latest_long-Modellen.

Die folgende Tabelle zeigt die Transkriptionsmodelle, die für Speech-to-Text verwendet werden können.

Modellname	Beschreibung
`latest_long`	Verwenden Sie dieses Modell für alle Arten von langen Inhalten wie Medien oder spontane Sprache und Unterhaltungen. Verwenden Sie dieses Modell anstelle des Videomodells, insbesondere wenn das Videomodell nicht in Ihrer Zielsprache verfügbar ist. Sie können dies auch anstelle des Standardmodells verwenden.
`latest_short`	Verwenden Sie dieses Modell für kurze Äußerungen, die einige Sekunden lang sind. Diese Methode ist hilfreich, um Befehle oder andere Anwendungsfälle für die gezielte Sprachausgabe zu erfassen. Verwenden Sie dieses Modell anstelle des Befehls- und Suchmodells.
`telephony`	Verbesserte Version des Modells „phone_call“. Optimal für Audiodaten, die aus einem Telefonanruf stammen und in der Regel mit einer Abtastrate von 8 kHz aufgezeichnet wurden.
`telephony_short`	Dedizierte Version des modernen „Telefoniemodells“ für kurze oder sogar aus einem Wort bestehende Äußerungen, die aus einem Telefonanruf stammen und in der Regel mit einer Abtastrate von 8 kHz aufgezeichnet wurden.
`medical_dictation`	Verwenden Sie dieses Modell zum Transkribieren von Notizen, die von medizinischen Fachkräften diktiert wurden. Dies ist ein Premium-Modell, das teurer als der Standardpreis ist. Weitere Informationen finden Sie auf der Seite Preise.
`medical_conversation`	Verwenden Sie dieses Modell, um Unterhaltungen zwischen einem Arzt und einem Patienten zu transkribieren. Dies ist ein Premium-Modell, das teurer als der Standardpreis ist. Weitere Informationen finden Sie auf der Seite Preise.
Die folgenden Modelle basieren zumeist auf klassischen, nicht konformen Architekturen und werden in erster Linie aus Legacy-Gründen und Gründen der Rückwärtskompatibilität beibehalten.
`command_and_search`	Optimal für kurze Ausdrücke oder Einzelworte wie Sprachbefehle oder Sprachsuchen
`default`	Optimal für Audiodaten, für die sich die anderen Audiomodelle nicht eignen, wie langformatige Audioinhalte oder Diktate. Das Standardmodell erstellt Transkriptionsergebnisse für jede Art von Audio, einschließlich Audio, z. B. Videoclips mit einem separaten Modell, das speziell auf diese zugeschnitten ist. Die Erkennung von Videoclip-Audios mit dem Standardmodell führt jedoch wahrscheinlich zu schlechteren Ergebnissen als bei der Verwendung des Videomodells. Idealerweise sollten dies High-Fidelity-Audiodaten sein, die mit einer Abtastrate von 16 kHz oder mehr aufgezeichnet sind.
`phone_call`	Optimal für Audiodaten, die aus einem Telefonanruf stammen (normalerweise mit einer Abtastrate von 8 kHz aufgezeichnet).
`video`	Optimal für Audiodaten aus Videoclips oder anderen Quellen wie Podcasts, die mehrere Sprecher haben. Dieses Modell ist auch oft die beste Wahl für Audiodaten, die mit einem hochwertigen Mikrofon aufgenommen wurden oder viele Hintergrundgeräusche haben. Optimale Ergebnisse erzielen Sie, wenn Sie Audiodaten bereitstellen, die mit einer Abtastrate von mindestens 16.000 Hz aufgezeichnet wurden.

Ein Modell für die Audiotranskription wählen

Wenn Sie ein bestimmtes Modell angeben möchten, das für die Audiotranskription verwendet werden soll, müssen Sie im Parameter RecognitionConfig für die Anfrage für das Feld model einen der erlaubten Werte (latest_long, latest_short, telephony oder telephony_short) festlegen. Speech-to-Text unterstützt die Modellauswahl für alle Spracherkennungsmethoden: speech:recognize, speech:longrunningrecognize und Streaming.

Lokale Audiodatei transkribieren

Protokoll

Ausführliche Informationen finden Sie unter dem API-Endpunkt speech:recognize.

Für eine synchrone Spracherkennung senden Sie eine POST-Anfrage und geben den entsprechenden Anfragetext an. Das folgende Beispiel zeigt eine POST-Anfrage mit curl. In diesem Beispiel wird die Google Cloud CLI verwendet, um ein Zugriffstoken zu generieren. Eine Anleitung zur Installation der gcloud CLI finden Sie in der Kurzanleitung.

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

Weitere Informationen zum Konfigurieren des Anfragetexts erhalten Sie in der Referenzdokumentation zu RecognitionConfig.

Wenn die Anfrage erfolgreich ist, gibt der Server den HTTP-Statuscode 200 OK und die Antwort im JSON-Format zurück:

{
  "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

Informationen zum Installieren und Verwenden der Clientbibliothek für Speech-to-Text finden Sie unter Speech-to-Text-Clientbibliotheken Weitere Informationen finden Sie in der Speech-to-Text Go API Referenzdokumentation.

Richten Sie zur Authentifizierung bei Speech-to-Text Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.


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

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite "Clientbibliotheken" und rufen Sie dann die Speech-to-Text-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite "Clientbibliotheken" und rufen Sie dann die Speech-to-Text-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite "Clientbibliotheken" und rufen Sie dann die Speech-to-Text-Referenzdokumentation für Ruby auf.

Cloud Storage-Audiodatei transkribieren

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
}