Erkennen von Sprache

  • Artikel

Referenzdokumentation | Paket (NuGet) | Zusätzliche Beispiele auf GitHub

In dieser Schrittanleitung erfahren Sie, wie Sie Sprache in Echtzeit erkennen und in Text transkribieren.

Erstellen einer Sprachkonfiguration

Um den Speech-Dienst über das Speech SDK aufrufen zu können, muss eine SpeechConfig-Instanz erstellt werden. Diese Klasse enthält Informationen zu Ihrem Abonnement. Hierzu zählen etwa Ihr Schlüssel und der zugeordnete Standort bzw. die zugeordnete Region, der Endpunkt, der Host oder das Autorisierungstoken.

  1. Erstellen Sie mithilfe Ihres Schlüssels und dem Standort bzw. der Region eine SpeechConfig-Instanz.
  2. Erstellen Sie eine Sprachressource im Azure-Portal. Weitere Informationen finden Sie unter Erstellen einer Ressource für mehrere Dienste.
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
    }
}

Sie können SpeechConfig auf verschiedene Arten initialisieren:

  • Verwenden Sie einen Endpunkt, und übergeben Sie einen Speech-Dienstendpunkt. Ein Schlüssel oder Autorisierungstoken ist optional.
  • Verwenden Sie einen Host, und übergeben Sie eine Hostadresse. Ein Schlüssel oder Autorisierungstoken ist optional.
  • Verwenden Sie ein Autorisierungstoken mit der zugeordneten Region/dem zugehörigen Standort.

Hinweis

Eine Konfiguration ist immer erforderlich. Dabei spielt es keine Rolle, ob Sie eine Spracherkennung, eine Sprachsynthese, eine Übersetzung oder eine Absichtserkennung durchführen möchten.

Schnellstart: Erkennen von Spracheingaben per Mikrofon

Um Sprache über das Mikrofon Ihres Geräts zu erkennen, erstellen Sie mithilfe der Methode FromDefaultMicrophoneInput() eine AudioConfig-Instanz. Initialisieren Sie dann das Objekt SpeechRecognizer, indem Sie speechConfig und audioConfig übergeben.

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task FromMic(SpeechConfig speechConfig)
    {
        using var audioConfig = AudioConfig.FromDefaultMicrophoneInput();
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        Console.WriteLine("Speak into your microphone.");
        var result = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
        await FromMic(speechConfig);
    }
}

Wenn Sie ein bestimmtes Audioeingabegerät verwenden möchten, müssen Sie in AudioConfig die Geräte-ID angeben. Informationen zum Abrufen der Geräte-ID für Ihr Audioeingabegerät finden Sie hier.

Erkennen von Sprache aus einer Datei

Wenn Sie Sprache aus einer Audiodatei erkennen möchten, anstatt ein Mikrofon zu verwenden, müssen Sie trotzdem eine AudioConfig-Instanz erstellen. In diesem Fall rufen Sie jedoch nicht FromDefaultMicrophoneInput() auf. Sie rufen FromWavFileInput() auf und übergeben den Dateipfad:

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task FromFile(SpeechConfig speechConfig)
    {
        using var audioConfig = AudioConfig.FromWavFileInput("PathToFile.wav");
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        var result = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
        await FromFile(speechConfig);
    }
}

Erkennen von Sprache aus einem In-Memory-Stream (Arbeitsspeicherdatenstrom)

In vielen Anwendungsfällen ist es wahrscheinlich, dass Ihre Audiodaten aus Azure Blob Storage stammen oder sich andernfalls bereits als byte[]-Instanz oder eine ähnliche Rohdatenstruktur im Arbeitsspeicher befinden. Im folgenden Beispiel wird PushAudioInputStream verwendet, um Sprache zu erkennen. Dabei handelt es sich im Wesentlichen um einen abstrahierten Arbeitsspeicherdatenstrom. Der Beispielcode führt die folgenden Aufgaben aus:

  • Schreiben unformatierter Audiodaten (PCM) in PushAudioInputStream mithilfe der Funktion Write(), die eine byte[]-Instanz akzeptiert.
  • Liest eine WAV-Datei mithilfe von FileReader zu Demonstrationszwecken. Wenn Sie bereits über Audiodaten in einer byte[]-Instanz verfügen, können Sie direkt zum Schreiben des Inhalts in den Eingabestream springen.
  • Das Standardformat sind 16-Bit- und 16-KHz-Monopulscodemodulationsdaten (PCM). Zum Anpassen des Formats können Sie mithilfe der statischen Funktion AudioStreamFormat.GetWaveFormatPCM(sampleRate, (byte)bitRate, (byte)channels) ein AudioStreamFormat-Objekt an CreatePushStream() übergeben.
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

class Program 
{
    async static Task FromStream(SpeechConfig speechConfig)
    {
        var reader = new BinaryReader(File.OpenRead("PathToFile.wav"));
        using var audioConfigStream = AudioInputStream.CreatePushStream();
        using var audioConfig = AudioConfig.FromStreamInput(audioConfigStream);
        using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        byte[] readBytes;
        do
        {
            readBytes = reader.ReadBytes(1024);
            audioConfigStream.Write(readBytes, readBytes.Length);
        } while (readBytes.Length > 0);

        var result = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromSubscription("YourSpeechKey", "YourSpeechRegion");
        await FromStream(speechConfig);
    }
}

Bei der Verwendung eines Pushstreams als Eingabe wird davon ausgegangen, dass es sich bei den Audiodaten um unformatiertes PCM handelt, weshalb Header übersprungen werden. Die API funktioniert in bestimmten Fällen auch dann noch, wenn der Header nicht übersprungen wurde. Um die besten Ergebnisse zu erzielen, empfiehlt es sich jedoch, eine Logik zum Lesen der Header zu implementieren, sodass byte[] am Anfang der Audiodaten beginnt.

Umgang mit Fehlern

Die vorherigen Beispiele rufen einfach den erkannten Text aus der Eigenschaft result.Text ab. Um Fehler und andere Antworten zu behandeln, müssen Sie Code schreiben, der das Ergebnis verarbeitet. Der folgende Code wertet die Eigenschaft result.Reason aus und geht wie folgt vor:

  • Das Erkennungsergebnis wird ausgegeben: ResultReason.RecognizedSpeech.
  • Wurde kein Erkennungstreffer gefunden, wird der Benutzer davon in Kenntnis gesetzt: ResultReason.NoMatch.
  • Ist ein Fehler aufgetreten, wird die Fehlermeldung ausgegeben: ResultReason.Canceled.
switch (result.Reason)
{
    case ResultReason.RecognizedSpeech:
        Console.WriteLine($"RECOGNIZED: Text={result.Text}");
        break;
    case ResultReason.NoMatch:
        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled:
        var cancellation = CancellationDetails.FromResult(result);
        Console.WriteLine($"CANCELED: Reason={cancellation.Reason}");

        if (cancellation.Reason == CancellationReason.Error)
        {
            Console.WriteLine($"CANCELED: ErrorCode={cancellation.ErrorCode}");
            Console.WriteLine($"CANCELED: ErrorDetails={cancellation.ErrorDetails}");
            Console.WriteLine($"CANCELED: Did you set the speech resource key and region values?");
        }
        break;
}

Verwenden kontinuierlicher Erkennung

In den vorherigen Beispielen wird Einzelerkennung verwendet, bei der eine einzelne Äußerung erkannt wird. Zur Erkennung des Endes einer einzelnen Äußerung wird auf Stille am Ende gelauscht oder gewartet, bis maximal 15 Sekunden an Audiodaten verarbeitet wurden.

Im Gegensatz dazu verwenden Sie kontinuierliche Erkennung, wenn Sie steuern möchten, wann die Erkennung beendet wird. Für die kontinuierliche Erkennung müssen die Ereignisse Recognizing, Recognized und Canceled abonniert werden, um die Erkennungsergebnisse zu erhalten. Zum Beenden der Erkennung muss StopContinuousRecognitionAsync aufgerufen werden. Im folgenden Beispiel wird eine kontinuierliche Erkennung für eine Audioeingabedatei durchgeführt.

Beginnen Sie mit dem Definieren der Eingabe und dem Initialisieren von SpeechRecognizer:

using var audioConfig = AudioConfig.FromWavFileInput("YourAudioFile.wav");
using var speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

Erstellen Sie als Nächstes eine TaskCompletionSource<int>-Instanz, um den Zustand der Spracherkennung zu verwalten:

var stopRecognition = new TaskCompletionSource<int>();

Abonnieren Sie als Nächstes die Ereignisse, die von SpeechRecognizer gesendet werden:

  • Recognizing: Signal für Ereignisse mit Erkennungszwischenergebnissen.
  • Recognized: Signal für Ereignisse mit Endergebnissen der Erkennung, was auf einen erfolgreichen Erkennungsversuch hindeutet.
  • SessionStopped: Signal für Ereignisse, die das Ende einer Erkennungssitzung (bzw. eines Erkennungsvorgangs) anzeigen.
  • Canceled: Signal für Ereignisse mit Ergebnissen einer abgebrochenen Erkennung. Diese Ergebnisse weisen auf einen Erkennungsversuch hin, der aufgrund einer direkten Abbruchanforderung abgebrochen wurde. Alternativ weisen sie auf einen Datentransport- oder Protokollfehler hin.
speechRecognizer.Recognizing += (s, e) =>
{
    Console.WriteLine($"RECOGNIZING: Text={e.Result.Text}");
};

speechRecognizer.Recognized += (s, e) =>
{
    if (e.Result.Reason == ResultReason.RecognizedSpeech)
    {
        Console.WriteLine($"RECOGNIZED: Text={e.Result.Text}");
    }
    else if (e.Result.Reason == ResultReason.NoMatch)
    {
        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
    }
};

speechRecognizer.Canceled += (s, e) =>
{
    Console.WriteLine($"CANCELED: Reason={e.Reason}");

    if (e.Reason == CancellationReason.Error)
    {
        Console.WriteLine($"CANCELED: ErrorCode={e.ErrorCode}");
        Console.WriteLine($"CANCELED: ErrorDetails={e.ErrorDetails}");
        Console.WriteLine($"CANCELED: Did you set the speech resource key and region values?");
    }

    stopRecognition.TrySetResult(0);
};

speechRecognizer.SessionStopped += (s, e) =>
{
    Console.WriteLine("\n    Session stopped event.");
    stopRecognition.TrySetResult(0);
};

Rufen Sie nach Abschluss der Einrichtung StartContinuousRecognitionAsync auf, um die Erkennung zu starten:

await speechRecognizer.StartContinuousRecognitionAsync();

// Waits for completion. Use Task.WaitAny to keep the task rooted.
Task.WaitAny(new[] { stopRecognition.Task });

// Make the following call at some point to stop recognition:
// await speechRecognizer.StopContinuousRecognitionAsync();

Ändern der Quellsprache

Eine gängige Aufgabe für die Spracherkennung ist die Angabe der Eingabesprache (Ausgangssprache). Das folgende Beispiel zeigt, wie Sie die Eingabesprache zu Italienisch ändern. Suchen Sie in Ihrem Code Ihre SpeechConfig-Instanz, und fügen Sie direkt darunter die folgende Zeile hinzu:

speechConfig.SpeechRecognitionLanguage = "it-IT";

Von der Eigenschaft SpeechRecognitionLanguage wird eine Zeichenfolge im Format „Sprache-Gebietsschema“ erwartet. Weitere Informationen finden Sie in der Liste der unterstützten Spracherkennungsgebietsschemata.

Sprachenerkennung

Sie können die Sprachidentifikation mit Spracherkennung verwenden, wenn Sie die Sprache einer Audioquelle identifizieren und diese dann in Text transkribieren müssen.

Ein vollständiges Codebeispiel finden Sie unter Sprachenerkennung.

Verwenden Sie einen benutzerdefinierten Endpunkt

Mit Custom Speech können Sie eigene Daten hochladen, ein benutzerdefiniertes Modell testen und trainieren, die Genauigkeit zwischen Modellen vergleichen und ein Modell auf einem benutzerdefinierten Endpunkt bereitstellen. Das folgende Beispiel zeigt, wie Sie einen benutzerdefinierten Endpunkt festlegen.

var speechConfig = SpeechConfig.FromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig.EndpointId = "YourEndpointId";
var speechRecognizer = new SpeechRecognizer(speechConfig);

Ausführen und Verwenden eines Containers

Speech-Container bieten websocketbasierte Abfrageendpunkt-APIs, auf die über das Speech SDK und die Speech-CLI zugegriffen wird. Standardmäßig verwenden das Speech SDK und die Speech-CLI den öffentlichen Speech-Dienst. Um den Container verwenden zu können, müssen Sie die Initialisierungsmethode ändern. Verwenden Sie eine Containerhost-URL anstelle von Schlüssel und Region.

Weitere Informationen zu Containern finden Sie unter Host-URLs beim Installieren und Ausführen von Speech-Containern mit Docker.

Ändern der Behandlung von Stille

Wenn von einem Benutzer erwartet wird, dass er schneller oder langsamer als üblich spricht, führt das Standardverhalten für Nicht-Sprache-Stille in Eingabeaudio möglicherweise nicht zum erwarteten Ergebnis. Dies sind häufige Probleme bei der Behandlung von Stille:

  • Bei schnellem Sprechen werden viele Sätze zu einem einzelnen Erkennungsergebnis verkettet, statt die Sätze in einzelne Ergebnisse aufzuteilen.
  • Bei langsamem Sprechen werden Teile eines einzelnen Satzes in mehrere Ergebnisse aufgeteilt.
  • Eine Einzelerkennung endet beim Warten auf den Sprechbeginn zu früh.

Diese Probleme können durch Festlegen einer der zwei Timeouteigenschaften in der SpeechConfigInstanzSpeechRecognizer behoben werden, die zum Erstellen des folgenden verwendet wird:

  • Das Segmentierungs-Timeout passt an, wie viel sprachfremdes Audio innerhalb eines Ausdrucks zulässig ist, der aktuell gesprochen wird, bevor dieser Ausdruck als „fertig“ angesehen wird.
    • Höhere Werte machen die Ergebnisse in der Regel länger und lassen längere Pausen beim Sprechen innerhalb eines Satzes zu, aber führen auch dazu, dass die Erstellung der Ergebnisse länger dauert. Sie können auch einzelne Ausdrücke zu einem einzelnen Ergebnis kombinieren, wenn sie zu hoch festgelegt werden.
    • Niedrigere Werte führen im Allgemeinen zu kürzeren Ergebnissen und sorgen für schnellere und häufigere Unterbrechungen zwischen Ausdrücken, können aber auch bewirken, dass einzelne Ausdrücke in mehrere Ergebnisse getrennt werden, wenn der Wert zu niedrig ist.
    • Dieses Timeout kann auf ganzzahlige Werte zwischen 100 und 5000 Millisekunden festgelegt werden, wobei 500 einen typischen Standardwert darstellt.
  • Initial silence timeout (Anfangsstille-Timeout) passt an, wie viel sprachfremdes Audio vor einem Ausdruck zulässig ist, bevor der Erkennungsversuch mit dem Ergebnis „keine Übereinstimmung“ endet.
    • Höhere Werte geben den Sprechern mehr Zeit, zu reagieren und mit dem Sprechen zu beginnen, können aber auch zu einer langsamen Reaktion führen, wenn nichts gesprochen wird.
    • Mit niedrigeren Werten wird eine schnelle Ausgabe von „Keine Übereinstimmung“ sichergestellt, was eine schneller reagierende Benutzerumgebung und eine kontrolliertere Audioverarbeitung sicherstellt, einen Sprecher aber zu früh abschneiden kann, wenn der Wert zu niedrig festgelegt ist.
    • Da bei der fortlaufenden Erkennung viele Ergebnisse generiert werden, bestimmt dieser Wert, wie oft Ergebnisse mit „keine Übereinstimmung“ eingehen, wirkt sich aber ansonsten nicht auf den Inhalt der Erkennungsergebnisse aus.
    • Dieses Timeout kann auf jeden nicht negativen ganzzahligen Wert in Millisekunden eingestellt werden, oder auf 0, um es vollständig zu deaktivieren. 5000 ist ein typischer Standardwert für die Erkennung von Einzelaufnahmen, während 15000 ein typischer Standardwert für die kontinuierliche Erkennung ist.

Da beim Ändern dieser Timeouts Kompromisse eingegangen werden müssen, sollten die Einstellungen nur geändert werden, wenn ein Problem im Zusammenhang mit der Behandlung von Stille beobachtet wird. Mit den Standardwerten wird die Mehrheit gesprochener Audiosignale optimal behandelt, und Probleme sollten nur in ungewöhnlichen Szenarien auftreten.

Beispiel: Benutzer, die eine Seriennummer wie „ABC-123-4567“ sprechen, halten zwischen den Zeichengruppen so lange inne, dass die Seriennummer in mehrere Ergebnisse unterteilt wird. Versuchen Sie in diesem Fall einen höheren Wert wie 2000 ms für das Timeout für die Segmentierung der Stille:

speechConfig.SetProperty(PropertyId.Speech_SegmentationSilenceTimeoutMs, "2000");

Beispiel: Die Sprache eines aufgezeichneten Referenten ist so schnell, dass mehrere Sätze in einer Zeile kombiniert werden, wobei nur ein- oder zweimal pro Minute große Erkennungsergebnisse eingehen. In diesem Fall kann das Festlegen des Stille-Timeouts für die Segmentierung auf einen niedrigeren Wert wie 300 ms helfen:

speechConfig.SetProperty(PropertyId.Speech_SegmentationSilenceTimeoutMs, "300");

Beispiel: Eine Einzelerkennung, bei der ein Sprecher aufgefordert wird, eine Seriennummer zu finden und zu lesen, endet zu früh, während die Nummer gesucht wird. In diesem Fall könnte ein längeres Anfangsstille-Timeout wie 10000 ms helfen:

speechConfig.SetProperty(PropertyId.SpeechServiceConnection_InitialSilenceTimeoutMs, "10000");

Referenzdokumentation | Paket (NuGet) | Zusätzliche Beispiele auf GitHub

In dieser Schrittanleitung erfahren Sie, wie Sie Sprache in Echtzeit erkennen und in Text transkribieren.

Erstellen einer Sprachkonfiguration

Um den Speech-Dienst über das Speech SDK aufrufen zu können, muss eine SpeechConfig-Instanz erstellt werden. Diese Klasse enthält Informationen zu Ihrem Abonnement. Hierzu zählen etwa Ihr Schlüssel und der zugeordnete Standort bzw. die zugeordnete Region, der Endpunkt, der Host oder das Autorisierungstoken.

  1. Erstellen Sie mithilfe Ihres Schlüssels und der Region eine SpeechConfig-Instanz.
  2. Erstellen Sie eine Sprachressource im Azure-Portal. Weitere Informationen finden Sie unter Erstellen einer Ressource für mehrere Dienste.
using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

auto speechConfig = SpeechConfig::FromSubscription("YourSpeechKey", "YourSpeechRegion");

Sie können SpeechConfig auf verschiedene Arten initialisieren:

  • Verwenden Sie einen Endpunkt, und übergeben Sie einen Speech-Dienstendpunkt. Ein Schlüssel oder Autorisierungstoken ist optional.
  • Verwenden Sie einen Host, und übergeben Sie eine Hostadresse. Ein Schlüssel oder Autorisierungstoken ist optional.
  • Verwenden Sie ein Autorisierungstoken mit der zugeordneten Region/dem zugehörigen Standort.

Hinweis

Eine Konfiguration ist immer erforderlich. Dabei spielt es keine Rolle, ob Sie eine Spracherkennung, eine Sprachsynthese, eine Übersetzung oder eine Absichtserkennung durchführen möchten.

Schnellstart: Erkennen von Spracheingaben per Mikrofon

Um Sprache über das Mikrofon Ihres Geräts zu erkennen, erstellen Sie mithilfe von der Elementfunktion FromDefaultMicrophoneInput() eine AudioConfig-Instanz. Initialisieren Sie dann das Objekt SpeechRecognizer, indem Sie audioConfig und config übergeben.

using namespace Microsoft::CognitiveServices::Speech::Audio;

auto audioConfig = AudioConfig::FromDefaultMicrophoneInput();
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

cout << "Speak into your microphone." << std::endl;
auto result = speechRecognizer->RecognizeOnceAsync().get();
cout << "RECOGNIZED: Text=" << result->Text << std::endl;

Wenn Sie ein bestimmtes Audioeingabegerät verwenden möchten, müssen Sie in AudioConfig die Geräte-ID angeben. Weitere Informationen zum Erhalten der Geräte-ID Ihres Audioeingabegeräts finden Sie unter Auswählen eines Audioeingabegeräts mit dem Speech SDK

Erkennen von Sprache aus einer Datei

Wenn Sie Sprache aus einer Audiodatei erkennen möchten, anstatt ein Mikrofon zu verwenden, müssen Sie trotzdem eine AudioConfig-Instanz erstellen. In diesem Fall rufen Sie jedoch nicht FromDefaultMicrophoneInput() auf. Sie rufen FromWavFileInput() auf und übergeben den Dateipfad:

using namespace Microsoft::CognitiveServices::Speech::Audio;

auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

auto result = speechRecognizer->RecognizeOnceAsync().get();
cout << "RECOGNIZED: Text=" << result->Text << std::endl;

Erkennen von Sprache mithilfe der Recognizer-Klasse

Von der Klasse SpeechRecognizer für das Speech SDK für C++ werden verschiedene Methoden für die Spracherkennung verfügbar gemacht.

Einzelerkennung

Bei der Einzelerkennung wird eine einzelne Äußerung asynchron erkannt. Zur Erkennung des Endes einer einzelnen Äußerung wird auf Stille am Ende gelauscht oder gewartet, bis maximal 15 Sekunden an Audiodaten verarbeitet wurden. Das folgende Beispiel zeigt eine asynchrone Einzelerkennung mit RecognizeOnceAsync:

auto result = speechRecognizer->RecognizeOnceAsync().get();

Sie müssen etwas Code schreiben, um das Ergebnis zu behandeln. In diesem Beispiel wird result->Reason ausgewertet und:

  • Das Erkennungsergebnis wird ausgegeben: ResultReason::RecognizedSpeech.
  • Wurde kein Erkennungstreffer gefunden, wird der Benutzer davon in Kenntnis gesetzt: ResultReason::NoMatch.
  • Ist ein Fehler aufgetreten, wird die Fehlermeldung ausgegeben: ResultReason::Canceled.
switch (result->Reason)
{
    case ResultReason::RecognizedSpeech:
        cout << "We recognized: " << result->Text << std::endl;
        break;
    case ResultReason::NoMatch:
        cout << "NOMATCH: Speech could not be recognized." << std::endl;
        break;
    case ResultReason::Canceled:
        {
            auto cancellation = CancellationDetails::FromResult(result);
            cout << "CANCELED: Reason=" << (int)cancellation->Reason << std::endl;
    
            if (cancellation->Reason == CancellationReason::Error) {
                cout << "CANCELED: ErrorCode= " << (int)cancellation->ErrorCode << std::endl;
                cout << "CANCELED: ErrorDetails=" << cancellation->ErrorDetails << std::endl;
                cout << "CANCELED: Did you set the speech resource key and region values?" << std::endl;
            }
        }
        break;
    default:
        break;
}

Kontinuierliche Erkennung

Die kontinuierliche Erkennung ist etwas komplexer als die Einzelerkennung. Für die kontinuierliche Erkennung müssen die Ereignisse Recognizing, Recognized und Canceled abonniert werden, um die Erkennungsergebnisse zu erhalten. Zum Beenden der Erkennung muss StopContinuousRecognitionAsync aufgerufen werden. Im folgenden Beispiel wird eine kontinuierliche Erkennung für eine Audioeingabedatei durchgeführt.

Beginnen Sie mit dem Definieren der Eingabe und dem Initialisieren von SpeechRecognizer:

auto audioConfig = AudioConfig::FromWavFileInput("YourAudioFile.wav");
auto speechRecognizer = SpeechRecognizer::FromConfig(config, audioConfig);

Als Nächstes erstellen Sie eine Variable, um den Zustand der Spracherkennung zu verwalten. Deklarieren Sie promise<void>, da Sie zu Beginn der Erkennung sicher davon ausgehen können, dass diese nicht abgeschlossen ist:

promise<void> recognitionEnd;

Abonnieren Sie als Nächstes die Ereignisse, die von SpeechRecognizer gesendet werden:

  • Recognizing: Signal für Ereignisse mit Erkennungszwischenergebnissen.
  • Recognized: Signal für Ereignisse mit Endergebnissen der Erkennung, was auf einen erfolgreichen Erkennungsversuch hindeutet.
  • SessionStopped: Signal für Ereignisse, die das Ende einer Erkennungssitzung (bzw. eines Erkennungsvorgangs) anzeigen.
  • Canceled: Signal für Ereignisse mit Ergebnissen einer abgebrochenen Erkennung. Diese Ergebnisse weisen auf einen Erkennungsversuch hin, der aufgrund einer direkten Abbruchanforderung abgebrochen wurde. Alternativ weisen sie auf einen Datentransport- oder Protokollfehler hin.
speechRecognizer->Recognizing.Connect([](const SpeechRecognitionEventArgs& e)
    {
        cout << "Recognizing:" << e.Result->Text << std::endl;
    });

speechRecognizer->Recognized.Connect([](const SpeechRecognitionEventArgs& e)
    {
        if (e.Result->Reason == ResultReason::RecognizedSpeech)
        {
            cout << "RECOGNIZED: Text=" << e.Result->Text 
                 << " (text could not be translated)" << std::endl;
        }
        else if (e.Result->Reason == ResultReason::NoMatch)
        {
            cout << "NOMATCH: Speech could not be recognized." << std::endl;
        }
    });

speechRecognizer->Canceled.Connect([&recognitionEnd](const SpeechRecognitionCanceledEventArgs& e)
    {
        cout << "CANCELED: Reason=" << (int)e.Reason << std::endl;
        if (e.Reason == CancellationReason::Error)
        {
            cout << "CANCELED: ErrorCode=" << (int)e.ErrorCode << "\n"
                 << "CANCELED: ErrorDetails=" << e.ErrorDetails << "\n"
                 << "CANCELED: Did you set the speech resource key and region values?" << std::endl;

            recognitionEnd.set_value(); // Notify to stop recognition.
        }
    });

speechRecognizer->SessionStopped.Connect([&recognitionEnd](const SessionEventArgs& e)
    {
        cout << "Session stopped.";
        recognitionEnd.set_value(); // Notify to stop recognition.
    });

Rufen Sie nach Abschluss der Einrichtung StopContinuousRecognitionAsync auf, um die Erkennung zu starten:

// Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
speechRecognizer->StartContinuousRecognitionAsync().get();

// Waits for recognition end.
recognitionEnd.get_future().get();

// Stops recognition.
speechRecognizer->StopContinuousRecognitionAsync().get();

Ändern der Quellsprache

Eine gängige Aufgabe für die Spracherkennung ist die Angabe der Eingabesprache (Ausgangssprache). Das folgende Beispiel zeigt, wie Sie die Eingabesprache zu Deutsch ändern. Suchen Sie in Ihrem Code Ihre SpeechConfig-Instanz, und fügen Sie direkt darunter die folgende Zeile hinzu:

speechConfig->SetSpeechRecognitionLanguage("de-DE");

SetSpeechRecognitionLanguage ist ein Parameter, der eine Zeichenfolge als Argument akzeptiert. Weitere Informationen finden Sie in der Liste der unterstützten Spracherkennungsgebietsschemata.

Sprachenerkennung

Sie können die Sprachidentifikation mit Spracherkennung verwenden, wenn Sie die Sprache einer Audioquelle identifizieren und diese dann in Text transkribieren müssen.

Ein vollständiges Codebeispiel finden Sie unter Sprachenerkennung.

Verwenden Sie einen benutzerdefinierten Endpunkt

Mit Custom Speech können Sie eigene Daten hochladen, ein benutzerdefiniertes Modell testen und trainieren, die Genauigkeit zwischen Modellen vergleichen und ein Modell auf einem benutzerdefinierten Endpunkt bereitstellen. Das folgende Beispiel zeigt, wie Sie einen benutzerdefinierten Endpunkt festlegen.

auto speechConfig = SpeechConfig::FromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig->SetEndpointId("YourEndpointId");
auto speechRecognizer = SpeechRecognizer::FromConfig(speechConfig);

Ausführen und Verwenden eines Containers

Speech-Container bieten websocketbasierte Abfrageendpunkt-APIs, auf die über das Speech SDK und die Speech-CLI zugegriffen wird. Standardmäßig verwenden das Speech SDK und die Speech-CLI den öffentlichen Speech-Dienst. Um den Container verwenden zu können, müssen Sie die Initialisierungsmethode ändern. Verwenden Sie eine Containerhost-URL anstelle von Schlüssel und Region.

Weitere Informationen zu Containern finden Sie unter Host-URLs beim Installieren und Ausführen von Speech-Containern mit Docker.

Referenzdokumentation | Paket (Go) | Zusätzliche Beispiele auf GitHub

In dieser Schrittanleitung erfahren Sie, wie Sie Sprache in Echtzeit erkennen und in Text transkribieren.

Erkennen von Sprache-in-Text von einem Mikrofon

Verwenden Sie das folgende Codebeispiel, um die Spracherkennung über Ihr standardmäßiges Gerätemikrofon durchzuführen. Ersetzen Sie die Variablen subscription und region durch Ihren Schlüssel für die Spracheingabe bzw. durch Ihren Standort/Ihre Region. Erstellen Sie eine Sprachressource im Azure-Portal. Weitere Informationen finden Sie unter Erstellen einer Ressource für mehrere Dienste. Wenn Sie das Skript ausführen, wird eine Erkennungssitzung mit Ihrem Standardmikrofon gestartet und Text ausgegeben:

package main

import (
	"bufio"
	"fmt"
	"os"

	"github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
	"github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func sessionStartedHandler(event speech.SessionEventArgs) {
	defer event.Close()
	fmt.Println("Session Started (ID=", event.SessionID, ")")
}

func sessionStoppedHandler(event speech.SessionEventArgs) {
	defer event.Close()
	fmt.Println("Session Stopped (ID=", event.SessionID, ")")
}

func recognizingHandler(event speech.SpeechRecognitionEventArgs) {
	defer event.Close()
	fmt.Println("Recognizing:", event.Result.Text)
}

func recognizedHandler(event speech.SpeechRecognitionEventArgs) {
	defer event.Close()
	fmt.Println("Recognized:", event.Result.Text)
}

func cancelledHandler(event speech.SpeechRecognitionCanceledEventArgs) {
	defer event.Close()
	fmt.Println("Received a cancellation: ", event.ErrorDetails)
	fmt.Println("Did you set the speech resource key and region values?")
}

func main() {
    subscription :=  "YourSpeechKey"
    region := "YourSpeechRegion"

	audioConfig, err := audio.NewAudioConfigFromDefaultMicrophoneInput()
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer audioConfig.Close()
	config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer config.Close()
	speechRecognizer, err := speech.NewSpeechRecognizerFromConfig(config, audioConfig)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer speechRecognizer.Close()
	speechRecognizer.SessionStarted(sessionStartedHandler)
	speechRecognizer.SessionStopped(sessionStoppedHandler)
	speechRecognizer.Recognizing(recognizingHandler)
	speechRecognizer.Recognized(recognizedHandler)
	speechRecognizer.Canceled(cancelledHandler)
	speechRecognizer.StartContinuousRecognitionAsync()
	defer speechRecognizer.StopContinuousRecognitionAsync()
	bufio.NewReader(os.Stdin).ReadBytes('\n')
}

Führen Sie die folgenden Befehle aus, um eine Datei namens go.mod zu erstellen, die mit auf GitHub gehosteten Komponenten verknüpft ist:

go mod init quickstart
go get github.com/Microsoft/cognitive-services-speech-sdk-go

Erstellen Sie nun den Code, und führen Sie ihn aus:

go build
go run quickstart

Ausführliche Informationen finden Sie im Referenzinhalt für die SpeechConfig-Klasse sowie im Referenzinhalt für die SpeechRecognizer-Klasse.

Erkennen von Sprache-in-Text aus einer Audiodatei

Verwenden Sie das folgende Beispiel, um die Spracherkennung mit einer Audiodatei durchzuführen. Ersetzen Sie die Variablen subscription und region durch Ihren Schlüssel für die Spracheingabe bzw. durch Ihren Standort/Ihre Region. Erstellen Sie eine Sprachressource im Azure-Portal. Weitere Informationen finden Sie unter Erstellen einer Ressource für mehrere Dienste. Ersetzen Sie außerdem die Variable file durch einen Pfad zu einer WAV-Datei. Wenn Sie das Skript ausführen, erkennt es die Sprache aus der Datei und gibt das Textergebnis aus:

package main

import (
	"fmt"
	"time"

	"github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
	"github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
)

func main() {
    subscription :=  "YourSpeechKey"
    region := "YourSpeechRegion"
    file := "path/to/file.wav"

	audioConfig, err := audio.NewAudioConfigFromWavFileInput(file)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer audioConfig.Close()
	config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer config.Close()
	speechRecognizer, err := speech.NewSpeechRecognizerFromConfig(config, audioConfig)
	if err != nil {
		fmt.Println("Got an error: ", err)
		return
	}
	defer speechRecognizer.Close()
	speechRecognizer.SessionStarted(func(event speech.SessionEventArgs) {
		defer event.Close()
		fmt.Println("Session Started (ID=", event.SessionID, ")")
	})
	speechRecognizer.SessionStopped(func(event speech.SessionEventArgs) {
		defer event.Close()
		fmt.Println("Session Stopped (ID=", event.SessionID, ")")
	})

	task := speechRecognizer.RecognizeOnceAsync()
	var outcome speech.SpeechRecognitionOutcome
	select {
	case outcome = <-task:
	case <-time.After(5 * time.Second):
		fmt.Println("Timed out")
		return
	}
	defer outcome.Close()
	if outcome.Error != nil {
		fmt.Println("Got an error: ", outcome.Error)
	}
	fmt.Println("Got a recognition!")
	fmt.Println(outcome.Result.Text)
}

Führen Sie die folgenden Befehle aus, um eine Datei namens go.mod zu erstellen, die mit auf GitHub gehosteten Komponenten verknüpft ist:

go mod init quickstart
go get github.com/Microsoft/cognitive-services-speech-sdk-go

Erstellen Sie nun den Code, und führen Sie ihn aus:

go build
go run quickstart

Ausführliche Informationen finden Sie im Referenzinhalt für die SpeechConfig-Klasse sowie im Referenzinhalt für die SpeechRecognizer-Klasse.

Ausführen und Verwenden eines Containers

Speech-Container bieten websocketbasierte Abfrageendpunkt-APIs, auf die über das Speech SDK und die Speech-CLI zugegriffen wird. Standardmäßig verwenden das Speech SDK und die Speech-CLI den öffentlichen Speech-Dienst. Um den Container verwenden zu können, müssen Sie die Initialisierungsmethode ändern. Verwenden Sie eine Containerhost-URL anstelle von Schlüssel und Region.

Weitere Informationen zu Containern finden Sie unter Host-URLs beim Installieren und Ausführen von Speech-Containern mit Docker.

Referenzdokumentation | Zusätzliche Beispiele auf GitHub

In dieser Schrittanleitung erfahren Sie, wie Sie Sprache in Echtzeit erkennen und in Text transkribieren.

Erstellen einer Sprachkonfiguration

Um den Speech-Dienst über das Speech SDK aufrufen zu können, muss eine SpeechConfig-Instanz erstellt werden. Diese Klasse enthält Informationen zu Ihrem Abonnement. Hierzu zählen etwa Ihr Schlüssel und der zugeordnete Standort bzw. die zugeordnete Region, der Endpunkt, der Host oder das Autorisierungstoken.

  1. Erstellen Sie mithilfe Ihres Schlüssels und dem Standort bzw. der Region eine SpeechConfig-Instanz.
  2. Erstellen Sie eine Sprachressource im Azure-Portal. Weitere Informationen finden Sie unter Erstellen einer Ressource für mehrere Dienste.
import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechConfig speechConfig = SpeechConfig.fromSubscription("<paste-your-subscription-key>", "<paste-your-region>");
    }
}

Sie können SpeechConfig auf verschiedene Arten initialisieren:

  • Verwenden Sie einen Endpunkt, und übergeben Sie einen Speech-Dienstendpunkt. Ein Schlüssel oder Autorisierungstoken ist optional.
  • Verwenden Sie einen Host, und übergeben Sie eine Hostadresse. Ein Schlüssel oder Autorisierungstoken ist optional.
  • Verwenden Sie ein Autorisierungstoken mit der zugeordneten Region/dem zugehörigen Standort.

Hinweis

Eine Konfiguration ist immer erforderlich. Dabei spielt es keine Rolle, ob Sie eine Spracherkennung, eine Sprachsynthese, eine Übersetzung oder eine Absichtserkennung durchführen möchten.

Erkennen von Spracheingaben per Mikrofon

Um Sprache über das Mikrofon Ihres Geräts zu erkennen, erstellen Sie mithilfe der Methode fromDefaultMicrophoneInput() eine AudioConfig-Instanz. Initialisieren Sie dann das Objekt SpeechRecognizer, indem Sie audioConfig und config übergeben.

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechConfig speechConfig = SpeechConfig.fromSubscription("<paste-your-subscription-key>", "<paste-your-region>");
        fromMic(speechConfig);
    }

    public static void fromMic(SpeechConfig speechConfig) throws InterruptedException, ExecutionException {
        AudioConfig audioConfig = AudioConfig.fromDefaultMicrophoneInput();
        SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);

        System.out.println("Speak into your microphone.");
        Future<SpeechRecognitionResult> task = speechRecognizer.recognizeOnceAsync();
        SpeechRecognitionResult result = task.get();
        System.out.println("RECOGNIZED: Text=" + result.getText());
    }
}

Wenn Sie ein bestimmtes Audioeingabegerät verwenden möchten, müssen Sie in AudioConfig die Geräte-ID angeben. Weitere Informationen zum Erhalten der Geräte-ID Ihres Audioeingabegeräts finden Sie unter Auswählen eines Audioeingabegeräts mit dem Speech SDK.

Erkennen von Sprache aus einer Datei

Wenn Sie Sprache aus einer Audiodatei erkennen möchten, anstatt ein Mikrofon zu verwenden, müssen Sie trotzdem eine AudioConfig-Instanz erstellen. In diesem Fall rufen Sie jedoch nicht FromDefaultMicrophoneInput() auf. Sie rufen fromWavFileInput() auf und übergeben den Dateipfad:

import com.microsoft.cognitiveservices.speech.*;
import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        SpeechConfig speechConfig = SpeechConfig.fromSubscription("<paste-your-subscription-key>", "<paste-your-region>");
        fromFile(speechConfig);
    }

    public static void fromFile(SpeechConfig speechConfig) throws InterruptedException, ExecutionException {
        AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
        SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig, audioConfig);
        
        Future<SpeechRecognitionResult> task = speechRecognizer.recognizeOnceAsync();
        SpeechRecognitionResult result = task.get();
        System.out.println("RECOGNIZED: Text=" + result.getText());
    }
}

Umgang mit Fehlern

Die vorherigen Beispiele rufen einfach den erkannten Text mithilfe von result.getText() ab. Um Fehler und andere Antworten zu behandeln, müssen Sie Code schreiben, der das Ergebnis verarbeitet. Im folgenden Beispiel wird result.getReason() ausgewertet und:

  • Das Erkennungsergebnis wird ausgegeben: ResultReason.RecognizedSpeech.
  • Wurde kein Erkennungstreffer gefunden, wird der Benutzer davon in Kenntnis gesetzt: ResultReason.NoMatch.
  • Ist ein Fehler aufgetreten, wird die Fehlermeldung ausgegeben: ResultReason.Canceled.
switch (result.getReason()) {
    case ResultReason.RecognizedSpeech:
        System.out.println("We recognized: " + result.getText());
        exitCode = 0;
        break;
    case ResultReason.NoMatch:
        System.out.println("NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled: {
            CancellationDetails cancellation = CancellationDetails.fromResult(result);
            System.out.println("CANCELED: Reason=" + cancellation.getReason());

            if (cancellation.getReason() == CancellationReason.Error) {
                System.out.println("CANCELED: ErrorCode=" + cancellation.getErrorCode());
                System.out.println("CANCELED: ErrorDetails=" + cancellation.getErrorDetails());
                System.out.println("CANCELED: Did you set the speech resource key and region values?");
            }
        }
        break;
}

Verwenden kontinuierlicher Erkennung

In den vorherigen Beispielen wird Einzelerkennung verwendet, bei der eine einzelne Äußerung erkannt wird. Zur Erkennung des Endes einer einzelnen Äußerung wird auf Stille am Ende gelauscht oder gewartet, bis maximal 15 Sekunden an Audiodaten verarbeitet wurden.

Im Gegensatz dazu verwenden Sie kontinuierliche Erkennung, wenn Sie steuern möchten, wann die Erkennung beendet wird. Für die kontinuierliche Erkennung müssen die Ereignisse recognizing, recognized und canceled abonniert werden, um die Erkennungsergebnisse zu erhalten. Zum Beenden der Erkennung muss stopContinuousRecognitionAsync aufgerufen werden. Im folgenden Beispiel wird eine kontinuierliche Erkennung für eine Audioeingabedatei durchgeführt.

Beginnen Sie mit dem Definieren der Eingabe und dem Initialisieren von SpeechRecognizer:

AudioConfig audioConfig = AudioConfig.fromWavFileInput("YourAudioFile.wav");
SpeechRecognizer speechRecognizer = new SpeechRecognizer(config, audioConfig);

Als Nächstes erstellen Sie eine Variable, um den Zustand der Spracherkennung zu verwalten. Deklarieren Sie eine Semaphore-Instanz im Klassenbereich:

private static Semaphore stopTranslationWithFileSemaphore;

Abonnieren Sie als Nächstes die Ereignisse, die von SpeechRecognizer gesendet werden:

  • recognizing: Signal für Ereignisse mit Erkennungszwischenergebnissen.
  • recognized: Signal für Ereignisse mit Endergebnissen der Erkennung, was auf einen erfolgreichen Erkennungsversuch hindeutet.
  • sessionStopped: Signal für Ereignisse, die das Ende einer Erkennungssitzung (bzw. eines Erkennungsvorgangs) anzeigen.
  • canceled: Signal für Ereignisse mit Ergebnissen einer abgebrochenen Erkennung. Diese Ergebnisse weisen auf einen Erkennungsversuch hin, der aufgrund einer direkten Abbruchanforderung abgebrochen wurde. Alternativ weisen sie auf einen Datentransport- oder Protokollfehler hin.
// First initialize the semaphore.
stopTranslationWithFileSemaphore = new Semaphore(0);

speechRecognizer.recognizing.addEventListener((s, e) -> {
    System.out.println("RECOGNIZING: Text=" + e.getResult().getText());
});

speechRecognizer.recognized.addEventListener((s, e) -> {
    if (e.getResult().getReason() == ResultReason.RecognizedSpeech) {
        System.out.println("RECOGNIZED: Text=" + e.getResult().getText());
    }
    else if (e.getResult().getReason() == ResultReason.NoMatch) {
        System.out.println("NOMATCH: Speech could not be recognized.");
    }
});

speechRecognizer.canceled.addEventListener((s, e) -> {
    System.out.println("CANCELED: Reason=" + e.getReason());

    if (e.getReason() == CancellationReason.Error) {
        System.out.println("CANCELED: ErrorCode=" + e.getErrorCode());
        System.out.println("CANCELED: ErrorDetails=" + e.getErrorDetails());
        System.out.println("CANCELED: Did you set the speech resource key and region values?");
    }

    stopTranslationWithFileSemaphore.release();
});

speechRecognizer.sessionStopped.addEventListener((s, e) -> {
    System.out.println("\n    Session stopped event.");
    stopTranslationWithFileSemaphore.release();
});

Rufen Sie nach Abschluss der Einrichtung startContinuousRecognitionAsync auf, um die Erkennung zu starten:

// Starts continuous recognition. Uses StopContinuousRecognitionAsync() to stop recognition.
speechRecognizer.startContinuousRecognitionAsync().get();

// Waits for completion.
stopTranslationWithFileSemaphore.acquire();

// Stops recognition.
speechRecognizer.stopContinuousRecognitionAsync().get();

Ändern der Quellsprache

Eine gängige Aufgabe für die Spracherkennung ist die Angabe der Eingabesprache (Ausgangssprache). Das folgende Beispiel zeigt, wie Sie die Eingabesprache zu Französisch ändern. Suchen Sie in Ihrem Code Ihre SpeechConfig-Instanz, und fügen Sie direkt darunter die folgende Zeile hinzu:

config.setSpeechRecognitionLanguage("fr-FR");

setSpeechRecognitionLanguage ist ein Parameter, der eine Zeichenfolge als Argument akzeptiert. Beziehen Sie sich auf die Liste der unterstützten Gebietsschemas für die Spracherkennung.

Sprachenerkennung

Sie können die Sprachidentifikation mit Spracherkennung verwenden, wenn Sie die Sprache einer Audioquelle identifizieren und diese dann in Text transkribieren müssen.

Ein vollständiges Codebeispiel finden Sie unter Sprachenerkennung.

Verwenden Sie einen benutzerdefinierten Endpunkt

Mit Custom Speech können Sie eigene Daten hochladen, ein benutzerdefiniertes Modell testen und trainieren, die Genauigkeit zwischen Modellen vergleichen und ein Modell auf einem benutzerdefinierten Endpunkt bereitstellen. Das folgende Beispiel zeigt, wie Sie einen benutzerdefinierten Endpunkt festlegen:

SpeechConfig speechConfig = SpeechConfig.FromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig.setEndpointId("YourEndpointId");
SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig);

Ausführen und Verwenden eines Containers

Speech-Container bieten websocketbasierte Abfrageendpunkt-APIs, auf die über das Speech SDK und die Speech-CLI zugegriffen wird. Standardmäßig verwenden das Speech SDK und die Speech-CLI den öffentlichen Speech-Dienst. Um den Container verwenden zu können, müssen Sie die Initialisierungsmethode ändern. Verwenden Sie eine Containerhost-URL anstelle von Schlüssel und Region.

Weitere Informationen zu Containern finden Sie unter Host-URLs beim Installieren und Ausführen von Speech-Containern mit Docker.

Referenzdokumentation | Paket (npm) | Zusätzliche Beispiele auf GitHub | Quellcode der Bibliothek

In dieser Schrittanleitung erfahren Sie, wie Sie Sprache in Echtzeit erkennen und in Text transkribieren.

Erstellen einer Sprachkonfiguration

Um den Speech-Dienst über das Speech SDK aufrufen zu können, muss eine SpeechConfig-Instanz erstellt werden. Diese Klasse enthält Informationen zu Ihrem Abonnement. Hierzu zählen etwa Ihr Schlüssel und der zugeordnete Standort bzw. die zugeordnete Region, der Endpunkt, der Host oder das Autorisierungstoken.

  1. Erstellen Sie mithilfe Ihres Schlüssels und dem Standort bzw. der Region eine SpeechConfig-Instanz.
  2. Erstellen Sie eine Sprachressource im Azure-Portal. Weitere Informationen finden Sie unter Erstellen einer Ressource für mehrere Dienste.
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

Sie können SpeechConfig auf verschiedene Arten initialisieren:

  • Verwenden Sie einen Endpunkt, und übergeben Sie einen Speech-Dienstendpunkt. Ein Schlüssel oder Autorisierungstoken ist optional.
  • Verwenden Sie einen Host, und übergeben Sie eine Hostadresse. Ein Schlüssel oder Autorisierungstoken ist optional.
  • Verwenden Sie ein Autorisierungstoken mit der zugeordneten Region/dem zugehörigen Standort.

Hinweis

Eine Konfiguration ist immer erforderlich. Dabei spielt es keine Rolle, ob Sie eine Spracherkennung, eine Sprachsynthese, eine Übersetzung oder eine Absichtserkennung durchführen möchten.

Schnellstart: Erkennen von Spracheingaben per Mikrofon

Die Spracherkennung über ein Mikrofon wird in Node.js nicht unterstützt. Sie wird nur in einer browserbasierten JavaScript-Umgebung unterstützt. Weitere Informationen finden Sie im React-Beispiel und unter Implementierung der Spracherkennung über ein Mikrofon auf GitHub. Das React-Beispiel zeigt Entwurfsmuster für den Austausch und die Verwaltung von Authentifizierungstoken. Außerdem wird die Erfassung von Audiodaten über ein Mikrofon oder aus einer Datei für die Konvertierung von Sprache in Text veranschaulicht.

Hinweis

Wenn Sie ein bestimmtes Audioeingabegerät verwenden möchten, müssen Sie im Objekt AudioConfig die Geräte-ID angeben. Weitere Informationen finden Sie in Auswählen eines Audioeingabegeräts mit dem Speech SDK.

Erkennen von Sprache aus einer Datei

Um die Sprache aus einer Audiodatei zu erkennen, erstellen Sie mithilfe der Methode fromWavFileInput() eine AudioConfig-Instanz, die ein Buffer-Objekt akzeptiert. Initialisieren Sie dann SpeechRecognizer, indem Sie audioConfig und speechConfig übergeben.

const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

function fromFile() {
    let audioConfig = sdk.AudioConfig.fromWavFileInput(fs.readFileSync("YourAudioFile.wav"));
    let speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);

    speechRecognizer.recognizeOnceAsync(result => {
        console.log(`RECOGNIZED: Text=${result.text}`);
        speechRecognizer.close();
    });
}
fromFile();

Erkennen von Sprache aus einem In-Memory-Stream (Arbeitsspeicherdatenstrom)

In vielen Anwendungsfällen stammen Ihre Audiodaten wahrscheinlich aus Azure Blob Storage. Oder sie befinden sich bereits im Arbeitsspeicher als ArrayBuffer oder eine ähnliche Rohdatenstruktur. Der folgende Code führt folgende Aktionen aus:

  • Erstellt einen Pushstream mithilfe von createPushStream().
  • Liest eine WAV-Datei mithilfe von fs.createReadStream zu Demonstrationszwecken. Wenn Sie bereits über Audiodaten im ArrayBuffer verfügen, können Sie direkt zum Schreiben des Inhalts in den Eingabestream springen.
  • Erstellt eine Audiokonfiguration mithilfe des Pushstreams.
const fs = require('fs');
const sdk = require("microsoft-cognitiveservices-speech-sdk");
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

function fromStream() {
    let pushStream = sdk.AudioInputStream.createPushStream();

    fs.createReadStream("YourAudioFile.wav").on('data', function(arrayBuffer) {
        pushStream.write(arrayBuffer.slice());
    }).on('end', function() {
        pushStream.close();
    });
 
    let audioConfig = sdk.AudioConfig.fromStreamInput(pushStream);
    let speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);
    speechRecognizer.recognizeOnceAsync(result => {
        console.log(`RECOGNIZED: Text=${result.text}`);
        speechRecognizer.close();
    });
}
fromStream();

Bei der Verwendung eines Pushstreams als Eingabe wird davon ausgegangen, dass es sich bei den Audiodaten um unformatierte Pulscodemodulationsdaten (PCM) handelt, die jegliche Header überspringen. Die API funktioniert in bestimmten Fällen auch dann noch, wenn der Header nicht übersprungen wurde. Um die besten Ergebnisse zu erzielen, empfiehlt es sich jedoch, eine Logik zum Lesen der Header zu implementieren, sodass fs am Anfang der Audiodaten beginnt.

Umgang mit Fehlern

Die vorherigen Beispiele rufen einfach den erkannten Text aus der Eigenschaft result.text ab. Um Fehler und andere Antworten zu behandeln, müssen Sie Code schreiben, der das Ergebnis verarbeitet. Der folgende Code wertet die Eigenschaft result.reason aus und geht wie folgt vor:

  • Das Erkennungsergebnis wird ausgegeben: ResultReason.RecognizedSpeech.
  • Wurde kein Erkennungstreffer gefunden, wird der Benutzer davon in Kenntnis gesetzt: ResultReason.NoMatch.
  • Ist ein Fehler aufgetreten, wird die Fehlermeldung ausgegeben: ResultReason.Canceled.
switch (result.reason) {
    case sdk.ResultReason.RecognizedSpeech:
        console.log(`RECOGNIZED: Text=${result.text}`);
        break;
    case sdk.ResultReason.NoMatch:
        console.log("NOMATCH: Speech could not be recognized.");
        break;
    case sdk.ResultReason.Canceled:
        const cancellation = sdk.CancellationDetails.fromResult(result);
        console.log(`CANCELED: Reason=${cancellation.reason}`);

        if (cancellation.reason == sdk.CancellationReason.Error) {
            console.log(`CANCELED: ErrorCode=${cancellation.ErrorCode}`);
            console.log(`CANCELED: ErrorDetails=${cancellation.errorDetails}`);
            console.log("CANCELED: Did you set the speech resource key and region values?");
        }
        break;
    }

Verwenden kontinuierlicher Erkennung

In den vorherigen Beispielen wird Einzelerkennung verwendet, bei der eine einzelne Äußerung erkannt wird. Zur Erkennung des Endes einer einzelnen Äußerung wird auf Stille am Ende gelauscht oder gewartet, bis maximal 15 Sekunden an Audiodaten verarbeitet wurden.

Im Gegensatz dazu können Sie kontinuierliche Erkennung verwenden, wenn Sie steuern möchten, wann die Erkennung beendet wird. Für die kontinuierliche Erkennung müssen die Ereignisse Recognizing, Recognized und Canceled abonniert werden, um die Erkennungsergebnisse zu erhalten. Zum Beenden der Erkennung muss stopContinuousRecognitionAsync aufgerufen werden. Im folgenden Beispiel wird eine kontinuierliche Erkennung für eine Audioeingabedatei durchgeführt.

Beginnen Sie mit dem Definieren der Eingabe und dem Initialisieren von SpeechRecognizer:

const speechRecognizer = new sdk.SpeechRecognizer(speechConfig, audioConfig);

Abonnieren Sie anschließend die von SpeechRecognizer gesendeten Ereignisse:

  • recognizing: Signal für Ereignisse mit Erkennungszwischenergebnissen.
  • recognized: Signal für Ereignisse mit Endergebnissen der Erkennung, was auf einen erfolgreichen Erkennungsversuch hindeutet.
  • sessionStopped: Signal für Ereignisse, die das Ende einer Erkennungssitzung (bzw. eines Erkennungsvorgangs) anzeigen.
  • canceled: Signal für Ereignisse mit Ergebnissen einer abgebrochenen Erkennung. Diese Ergebnisse weisen auf einen Erkennungsversuch hin, der aufgrund einer direkten Abbruchanforderung abgebrochen wurde. Alternativ weisen sie auf einen Datentransport- oder Protokollfehler hin.
speechRecognizer.recognizing = (s, e) => {
    console.log(`RECOGNIZING: Text=${e.result.text}`);
};

speechRecognizer.recognized = (s, e) => {
    if (e.result.reason == sdk.ResultReason.RecognizedSpeech) {
        console.log(`RECOGNIZED: Text=${e.result.text}`);
    }
    else if (e.result.reason == sdk.ResultReason.NoMatch) {
        console.log("NOMATCH: Speech could not be recognized.");
    }
};

speechRecognizer.canceled = (s, e) => {
    console.log(`CANCELED: Reason=${e.reason}`);

    if (e.reason == sdk.CancellationReason.Error) {
        console.log(`"CANCELED: ErrorCode=${e.errorCode}`);
        console.log(`"CANCELED: ErrorDetails=${e.errorDetails}`);
        console.log("CANCELED: Did you set the speech resource key and region values?");
    }

    speechRecognizer.stopContinuousRecognitionAsync();
};

speechRecognizer.sessionStopped = (s, e) => {
    console.log("\n    Session stopped event.");
    speechRecognizer.stopContinuousRecognitionAsync();
};

Rufen Sie nach Abschluss der Einrichtung startContinuousRecognitionAsync auf, um die Erkennung zu starten:

speechRecognizer.startContinuousRecognitionAsync();

// Make the following call at some point to stop recognition:
// speechRecognizer.stopContinuousRecognitionAsync();

Ändern der Quellsprache

Eine gängige Aufgabe für die Spracherkennung ist die Angabe der Eingabesprache (Ausgangssprache). Das folgende Beispiel zeigt, wie Sie die Eingabesprache zu Italienisch ändern. Suchen Sie in Ihrem Code Ihre SpeechConfig-Instanz, und fügen Sie direkt darunter die folgende Zeile hinzu:

speechConfig.speechRecognitionLanguage = "it-IT";

Von der Eigenschaft speechRecognitionLanguage wird eine Zeichenfolge im Format „Sprache-Gebietsschema“ erwartet. Weitere Informationen finden Sie in der Liste der unterstützten Spracherkennungsgebietsschemata.

Sprachenerkennung

Sie können die Sprachidentifikation mit Spracherkennung verwenden, wenn Sie die Sprache einer Audioquelle identifizieren und diese dann in Text transkribieren müssen.

Ein vollständiges Codebeispiel finden Sie unter Sprachenerkennung.

Verwenden Sie einen benutzerdefinierten Endpunkt

Mit Custom Speech können Sie eigene Daten hochladen, ein benutzerdefiniertes Modell testen und trainieren, die Genauigkeit zwischen Modellen vergleichen und ein Modell auf einem benutzerdefinierten Endpunkt bereitstellen. Das folgende Beispiel zeigt, wie Sie einen benutzerdefinierten Endpunkt festlegen.

var speechConfig = SpeechSDK.SpeechConfig.fromSubscription("YourSubscriptionKey", "YourServiceRegion");
speechConfig.endpointId = "YourEndpointId";
var speechRecognizer = new SpeechSDK.SpeechRecognizer(speechConfig);

Ausführen und Verwenden eines Containers

Speech-Container bieten websocketbasierte Abfrageendpunkt-APIs, auf die über das Speech SDK und die Speech-CLI zugegriffen wird. Standardmäßig verwenden das Speech SDK und die Speech-CLI den öffentlichen Speech-Dienst. Um den Container verwenden zu können, müssen Sie die Initialisierungsmethode ändern. Verwenden Sie eine Containerhost-URL anstelle von Schlüssel und Region.

Weitere Informationen zu Containern finden Sie unter Host-URLs beim Installieren und Ausführen von Speech-Containern mit Docker.

Referenzdokumentation | Paket (Download) | Zusätzliche Beispiele auf GitHub

In dieser Schrittanleitung erfahren Sie, wie Sie Sprache in Echtzeit erkennen und in Text transkribieren.

Installieren von Speech SDK und Beispielen

Das Repository Azure-Samples/cognitive-services-speech-sdk enthält Beispiele in Objective-C für iOS und Mac. Wählen Sie einen Link aus, um Installationsanweisungen für die einzelnen Beispiele anzuzeigen:

Weitere Informationen finden Sie in der Referenz zum Speech SDK für Objective-C.

Verwenden Sie einen benutzerdefinierten Endpunkt

Mit Custom Speech können Sie eigene Daten hochladen, ein benutzerdefiniertes Modell testen und trainieren, die Genauigkeit zwischen Modellen vergleichen und ein Modell auf einem benutzerdefinierten Endpunkt bereitstellen. Das folgende Beispiel zeigt, wie Sie einen benutzerdefinierten Endpunkt festlegen:

SPXSpeechConfiguration *speechConfig = [[SPXSpeechConfiguration alloc] initWithSubscription:"YourSubscriptionKey" region:"YourServiceRegion"];
speechConfig.endpointId = "YourEndpointId";
SPXSpeechRecognizer* speechRecognizer = [[SPXSpeechRecognizer alloc] init:speechConfig];

Ausführen und Verwenden eines Containers

Speech-Container bieten websocketbasierte Abfrageendpunkt-APIs, auf die über das Speech SDK und die Speech-CLI zugegriffen wird. Standardmäßig verwenden das Speech SDK und die Speech-CLI den öffentlichen Speech-Dienst. Um den Container verwenden zu können, müssen Sie die Initialisierungsmethode ändern. Verwenden Sie eine Containerhost-URL anstelle von Schlüssel und Region.

Weitere Informationen zu Containern finden Sie unter Host-URLs beim Installieren und Ausführen von Speech-Containern mit Docker.

Referenzdokumentation | Paket (Download) | Zusätzliche Beispiele auf GitHub

In dieser Schrittanleitung erfahren Sie, wie Sie Sprache in Echtzeit erkennen und in Text transkribieren.

Installieren von Speech SDK und Beispielen

Das Repository Azure-Samples/cognitive-services-speech-sdk enthält Beispiele in Swift für iOS und Mac. Wählen Sie einen Link aus, um Installationsanweisungen für die einzelnen Beispiele anzuzeigen:

Weitere Informationen finden Sie in der Referenz zum Speech SDK für Swift.

Verwenden Sie einen benutzerdefinierten Endpunkt

Mit Custom Speech können Sie eigene Daten hochladen, ein benutzerdefiniertes Modell testen und trainieren, die Genauigkeit zwischen Modellen vergleichen und ein Modell auf einem benutzerdefinierten Endpunkt bereitstellen. Das folgende Beispiel zeigt, wie Sie einen benutzerdefinierten Endpunkt festlegen:

let speechConfig = SPXSpeechConfiguration(subscription: "YourSubscriptionKey", region: "YourServiceRegion");
speechConfig.endpointId = "YourEndpointId";
let speechRecognizer = SPXSpeechRecognizer(speechConfiguration: speechConfig);

Ausführen und Verwenden eines Containers

Speech-Container bieten websocketbasierte Abfrageendpunkt-APIs, auf die über das Speech SDK und die Speech-CLI zugegriffen wird. Standardmäßig verwenden das Speech SDK und die Speech-CLI den öffentlichen Speech-Dienst. Um den Container verwenden zu können, müssen Sie die Initialisierungsmethode ändern. Verwenden Sie eine Containerhost-URL anstelle von Schlüssel und Region.

Weitere Informationen zu Containern finden Sie unter Host-URLs beim Installieren und Ausführen von Speech-Containern mit Docker.

Referenzdokumentation | Paket (PyPi) | Zusätzliche Beispiele auf GitHub

In dieser Schrittanleitung erfahren Sie, wie Sie Sprache in Echtzeit erkennen und in Text transkribieren.

Erstellen einer Sprachkonfiguration

Um den Speech-Dienst über das Speech SDK aufrufen zu können, muss eine SpeechConfig-Instanz erstellt werden. Diese Klasse enthält Informationen zu Ihrem Abonnement. Hierzu zählen etwa Ihr Schlüssel für die Spracheingabe und der zugeordnete Standort bzw. die zugeordnete Region, der Endpunkt, der Host oder das Autorisierungstoken.

  1. Erstellen Sie mithilfe Ihres Schlüssels für die Spracheingabe und dem Standort bzw. der Region eine SpeechConfig-Instanz.
  2. Erstellen Sie eine Sprachressource im Azure-Portal. Weitere Informationen finden Sie unter Erstellen einer Ressource für mehrere Dienste.
speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")

Sie können SpeechConfig auf verschiedene Arten initialisieren:

  • Verwenden Sie einen Endpunkt, und übergeben Sie einen Speech-Dienstendpunkt. Ein Schlüssel für die Spracheingabe und ein Autorisierungstoken sind optional.
  • Verwenden Sie einen Host, und übergeben Sie eine Hostadresse. Ein Schlüssel für die Spracheingabe und ein Autorisierungstoken sind optional.
  • Verwenden Sie ein Autorisierungstoken mit der zugeordneten Region/dem zugehörigen Standort.

Hinweis

Eine Konfiguration ist immer erforderlich. Dabei spielt es keine Rolle, ob Sie eine Spracherkennung, eine Sprachsynthese, eine Übersetzung oder eine Absichtserkennung durchführen möchten.

Erkennen von Spracheingaben per Mikrofon

Um Sprache über das Mikrofon Ihres Geräts zu erkennen, erstellen Sie eine SpeechRecognizer-Instanz, ohne AudioConfig zu übergeben, und übergeben Sie dann speech_config:

import azure.cognitiveservices.speech as speechsdk

def from_mic():
    speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")
    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)

    print("Speak into your microphone.")
    result = speech_recognizer.recognize_once_async().get()
    print(result.text)

from_mic()

Wenn Sie ein bestimmtes Audioeingabegerät verwenden möchten, müssen Sie in AudioConfig die Geräte-ID angeben und dann an den audio_config-Parameter des SpeechRecognizer-Konstruktors übergeben. Weitere Informationen zum Erhalten der Geräte-ID Ihres Audioeingabegeräts finden Sie unter Auswählen eines Audioeingabegeräts mit dem Speech SDK

Erkennen von Sprache aus einer Datei

Wenn Sie Sprache aus einer Audiodatei erkennen möchten, anstatt ein Mikrofon zu verwenden, erstellen Sie eine AudioConfig-Instanz, und verwenden Sie den Parameter filename:

import azure.cognitiveservices.speech as speechsdk

def from_file():
    speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")
    audio_config = speechsdk.AudioConfig(filename="your_file_name.wav")
    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)

    result = speech_recognizer.recognize_once_async().get()
    print(result.text)

from_file()

Behandeln von Fehlern

Die vorherigen Beispiele rufen einfach den erkannten Text aus der Eigenschaft result.text ab. Um Fehler und andere Antworten zu behandeln, müssen Sie Code schreiben, der das Ergebnis verarbeitet. Der folgende Code wertet die Eigenschaft result.reason aus und geht wie folgt vor:

  • Das Erkennungsergebnis wird ausgegeben: speechsdk.ResultReason.RecognizedSpeech.
  • Wurde kein Erkennungstreffer gefunden, wird der Benutzer davon in Kenntnis gesetzt: speechsdk.ResultReason.NoMatch.
  • Ist ein Fehler aufgetreten, wird die Fehlermeldung ausgegeben: speechsdk.ResultReason.Canceled.
if result.reason == speechsdk.ResultReason.RecognizedSpeech:
    print("Recognized: {}".format(result.text))
elif result.reason == speechsdk.ResultReason.NoMatch:
    print("No speech could be recognized: {}".format(result.no_match_details))
elif result.reason == speechsdk.ResultReason.Canceled:
    cancellation_details = result.cancellation_details
    print("Speech Recognition canceled: {}".format(cancellation_details.reason))
    if cancellation_details.reason == speechsdk.CancellationReason.Error:
        print("Error details: {}".format(cancellation_details.error_details))
        print("Did you set the speech resource key and region values?")

Verwenden kontinuierlicher Erkennung

In den vorherigen Beispielen wird Einzelerkennung verwendet, bei der eine einzelne Äußerung erkannt wird. Zur Erkennung des Endes einer einzelnen Äußerung wird auf Stille am Ende gelauscht oder gewartet, bis maximal 15 Sekunden an Audiodaten verarbeitet wurden.

Im Gegensatz dazu verwenden Sie kontinuierliche Erkennung, wenn Sie steuern möchten, wann die Erkennung beendet wird. Hierfür müssen Sie eine Verbindung mit EventSignal herstellen, um die Erkennungsergebnisse zu erhalten. Um die Erkennung zu beenden, müssen Sie stop_continuous_recognition() oder stop_continuous_recognition() aufrufen. Im folgenden Beispiel wird eine kontinuierliche Erkennung für eine Audioeingabedatei durchgeführt.

Beginnen Sie mit dem Definieren der Eingabe und dem Initialisieren von SpeechRecognizer:

audio_config = speechsdk.audio.AudioConfig(filename=weatherfilename)
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)

Als Nächstes erstellen Sie eine Variable, um den Zustand der Spracherkennung zu verwalten. Legen Sie die Variable auf False fest, da Sie zu Beginn der Erkennung sicher davon ausgehen können, dass diese nicht abgeschlossen ist:

done = False

Erstellen Sie nun einen Rückruf, um die kontinuierliche Erkennung zu beenden, wenn evt empfangen wird. Beachten Sie Folgendes:

  • Wenn evt empfangen wird, wird die evt-Nachricht ausgegeben.
  • Nach dem Empfang von evt wird evt aufgerufen, um die Erkennung zu beenden.
  • Der Erkennungszustand wird in True geändert.
def stop_cb(evt):
    print('CLOSING on {}'.format(evt))
    speech_recognizer.stop_continuous_recognition()
    nonlocal done
    done = True

Im folgenden Codebeispiel wird das Herstellen einer Verbindung zwischen Rückrufen und Ereignissen gezeigt, die von SpeechRecognizer gesendet werden. Die Ereignisse sind wie folgt:

  • recognizing: Signal für Ereignisse mit Erkennungszwischenergebnissen.
  • recognized: Signal für Ereignisse mit Endergebnissen der Erkennung, was auf einen erfolgreichen Erkennungsversuch hindeutet.
  • session_started: Signal für Ereignisse, die den Anfang einer Erkennungssitzung (bzw. eines Erkennungsvorgangs) anzeigen.
  • session_stopped: Signal für Ereignisse, die das Ende einer Erkennungssitzung (bzw. eines Erkennungsvorgangs) anzeigen.
  • canceled: Signal für Ereignisse mit Ergebnissen einer abgebrochenen Erkennung. Diese Ergebnisse weisen auf einen Erkennungsversuch hin, der aufgrund einer direkten Abbruchanforderung abgebrochen wurde. Alternativ weisen sie auf einen Datentransport- oder Protokollfehler hin.
speech_recognizer.recognizing.connect(lambda evt: print('RECOGNIZING: {}'.format(evt)))
speech_recognizer.recognized.connect(lambda evt: print('RECOGNIZED: {}'.format(evt)))
speech_recognizer.session_started.connect(lambda evt: print('SESSION STARTED: {}'.format(evt)))
speech_recognizer.session_stopped.connect(lambda evt: print('SESSION STOPPED {}'.format(evt)))
speech_recognizer.canceled.connect(lambda evt: print('CANCELED {}'.format(evt)))

speech_recognizer.session_stopped.connect(stop_cb)
speech_recognizer.canceled.connect(stop_cb)

Nach Abschluss der Einrichtung kann start_continuous_recognition() aufgerufen werden:

speech_recognizer.start_continuous_recognition()
while not done:
    time.sleep(.5)

Ändern der Quellsprache

Eine gängige Aufgabe für die Spracherkennung ist die Angabe der Eingabesprache (Ausgangssprache). Das folgende Beispiel zeigt, wie Sie die Eingabesprache zu Deutsch ändern. Suchen Sie in Ihrem Code Ihre SpeechConfig-Instanz, und fügen Sie direkt darunter die folgende Zeile hinzu:

speech_config.speech_recognition_language="de-DE"

speech_recognition_language ist ein Parameter, der eine Zeichenfolge als Argument akzeptiert. Weitere Informationen finden Sie in der Liste der unterstützten Spracherkennungsgebietsschemata.

Sprachenerkennung

Sie können die Sprachidentifikation mit Spracherkennung verwenden, wenn Sie die Sprache einer Audioquelle identifizieren und diese dann in Text transkribieren müssen.

Ein vollständiges Codebeispiel finden Sie unter Sprachenerkennung.

Verwenden Sie einen benutzerdefinierten Endpunkt

Mit Custom Speech können Sie eigene Daten hochladen, ein benutzerdefiniertes Modell testen und trainieren, die Genauigkeit zwischen Modellen vergleichen und ein Modell auf einem benutzerdefinierten Endpunkt bereitstellen. Das folgende Beispiel zeigt, wie Sie einen benutzerdefinierten Endpunkt festlegen.

speech_config = speechsdk.SpeechConfig(subscription="YourSubscriptionKey", region="YourServiceRegion")
speech_config.endpoint_id = "YourEndpointId"
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)

Ausführen und Verwenden eines Containers

Speech-Container bieten websocketbasierte Abfrageendpunkt-APIs, auf die über das Speech SDK und die Speech-CLI zugegriffen wird. Standardmäßig verwenden das Speech SDK und die Speech-CLI den öffentlichen Speech-Dienst. Um den Container verwenden zu können, müssen Sie die Initialisierungsmethode ändern. Verwenden Sie eine Containerhost-URL anstelle von Schlüssel und Region.

Weitere Informationen zu Containern finden Sie unter Host-URLs beim Installieren und Ausführen von Speech-Containern mit Docker.

REST-API-Referenz zur Spracherkennung | REST-API-Referenz zur Spracherkennung für kurze Audiodaten | Zusätzliche Beispiele auf GitHub

In dieser Schrittanleitung erfahren Sie, wie Sie Sprache in Echtzeit erkennen und in Text transkribieren.

Konvertieren von Sprache in Text

Führen Sie an der Eingabeaufforderung den folgenden Befehl aus. Fügen Sie die folgenden Werte in den Befehl ein:

  • Ihr Abonnementschlüssel für den Speech-Dienst
  • Die Region Ihres Speech-Diensts.
  • Der Pfad für Audioeingabedateien. Sie können Audiodateien per Sprachsynthese generieren.
curl --location --request POST 'https://INSERT_REGION_HERE.stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1?language=en-US' \
--header 'Ocp-Apim-Subscription-Key: INSERT_SUBSCRIPTION_KEY_HERE' \
--header 'Content-Type: audio/wav' \
--data-binary @'INSERT_AUDIO_FILE_PATH_HERE'

Sie sollten eine Antwort mit einem JSON-Text wie dem folgenden erhalten:

{
    "RecognitionStatus": "Success",
    "DisplayText": "My voice is my passport, verify me.",
    "Offset": 6600000,
    "Duration": 32100000
}

Weitere Informationen finden Sie in der REST-API-Referenz zur Spracherkennung.

In dieser Schrittanleitung erfahren Sie, wie Sie Sprache in Echtzeit erkennen und in Text transkribieren.

Schnellstart: Erkennen von Spracheingaben per Mikrofon

Schließen Sie ihr PC-Mikrofon an, und schalten Sie es ein. Deaktivieren Sie alle Apps, die möglicherweise auch das Mikrofon verwenden. Einige Computer verfügen über ein eingebautes Mikrofon, während für andere die Konfiguration eines Bluetooth-Geräts erforderlich ist.

Sie sind jetzt bereit, die Speech-Befehlszeilenschnittstelle auszuführen, um über Ihr Mikrofon eingegebene Sprache zu erkennen. Wechseln Sie an der Befehlszeile in das Verzeichnis, das die Binärdatei der Speech-Befehlszeilenschnittstelle enthält. Führen Sie dann den folgenden Befehl aus:

spx recognize --microphone

Hinweis

Die Speech-Befehlszeilenschnittstelle ist standardmäßig auf Englisch eingestellt. Sie können in der Spracherkennungstabelle eine andere Sprache auswählen. Fügen Sie beispielsweise --source de-DE hinzu, um deutsche Spracheingaben zu erkennen.

Sprechen Sie in das Mikrofon, und Sie sehen in Echtzeit die Transkription Ihrer Worte in Text. Die Speech CLI wird angehalten, wenn Stille erkannt wird oder Sie STRG+C drücken.

Erkennen von Sprache aus einer Datei

Die Speech-Befehlszeilenschnittstelle kann Sprache in vielen Datenformaten und natürlichen Sprachen erkennen. Für dieses Beispiel können Sie eine beliebige WAV-Datei (16 kHz oder 8 kHz, 16-Bit und Mono-PCM) verwenden, die englische Sprache enthält. Oder wenn Sie ein schnelles Beispiel wünschen, laden Sie die Datei whattheweatherlike.wav herunter, und kopieren Sie sie in dasselbe Verzeichnis wie die Binärdatei der Speech-Befehlszeilenschnittstelle.

Verwenden Sie den folgenden Befehl, um die Speech CLI auszuführen, um die in der Audiodatei gefundene Sprache zu erkennen:

spx recognize --file whatstheweatherlike.wav

Hinweis

Die Speech-Befehlszeilenschnittstelle ist standardmäßig auf Englisch eingestellt. Sie können in der Spracherkennungstabelle eine andere Sprache auswählen. Fügen Sie beispielsweise --source de-DE hinzu, um deutsche Spracheingaben zu erkennen.

Die Speech CLI zeigt eine Texttranskription der Sprache auf dem Bildschirm an.

Ausführen und Verwenden eines Containers

Speech-Container bieten websocketbasierte Abfrageendpunkt-APIs, auf die über das Speech SDK und die Speech-CLI zugegriffen wird. Standardmäßig verwenden das Speech SDK und die Speech-CLI den öffentlichen Speech-Dienst. Um den Container verwenden zu können, müssen Sie die Initialisierungsmethode ändern. Verwenden Sie eine Containerhost-URL anstelle von Schlüssel und Region.

Weitere Informationen zu Containern finden Sie unter Host-URLs beim Installieren und Ausführen von Speech-Containern mit Docker.

Nächste Schritte