Jak rozpoznawać mowę

  • Artykuł

Dokumentacja referencyjna | Package (NuGet) | Dodatkowe przykłady w usłudze GitHub

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać i transkrybować mowę do tekstu w czasie rzeczywistym.

Tworzenie konfiguracji mowy

Aby wywołać usługę Rozpoznawanie mowy przy użyciu zestawu SPEECH SDK, należy utworzyć SpeechConfig wystąpienie. Ta klasa zawiera informacje o subskrypcji, takie jak klucz i skojarzony lokalizacja/region, punkt końcowy, host lub token autoryzacji.

  1. SpeechConfig Utwórz wystąpienie przy użyciu klucza i lokalizacji/regionu.
  2. Utwórz zasób usługi Mowa w witrynie Azure Portal. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu z wieloma usługami.
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");
    }
}

Można zainicjować SpeechConfig na kilka innych sposobów:

  • Użyj punktu końcowego i przekaż punkt końcowy usługi Rozpoznawanie mowy. Klucz lub token autoryzacji jest opcjonalny.
  • Użyj hosta i przekaż adres hosta. Klucz lub token autoryzacji jest opcjonalny.
  • Użyj tokenu autoryzacji ze skojarzonym regionem/lokalizacją.

Uwaga

Niezależnie od tego, czy wykonujesz rozpoznawanie mowy, syntezę mowy, tłumaczenie, czy rozpoznawanie intencji, zawsze tworzysz konfigurację.

Rozpoznawanie mowy przy użyciu mikrofonu

Aby rozpoznawać mowę AudioConfig przy użyciu mikrofonu urządzenia, utwórz wystąpienie przy użyciu FromDefaultMicrophoneInput() metody . Następnie zainicjuj SpeechRecognizer obiekt, przekazując speechConfig polecenie i audioConfig.

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);
    }
}

Jeśli chcesz użyć określonego urządzenia wejściowego audio, musisz określić identyfikator urządzenia w pliku AudioConfig. Dowiedz się , jak uzyskać identyfikator urządzenia dla urządzenia wejściowego audio.

Rozpoznawanie mowy z pliku

Jeśli chcesz rozpoznać mowę AudioConfig z pliku audio zamiast mikrofonu, nadal musisz utworzyć wystąpienie. Ale w tym przypadku nie wywołujesz metody FromDefaultMicrophoneInput(). FromWavFileInput() Wywołasz metodę i przekażesz ścieżkę pliku:

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);
    }
}

Rozpoznawanie mowy ze strumienia w pamięci

W wielu przypadkach użycia prawdopodobnie dane audio pochodzą z usługi Azure Blob Storage lub są już w pamięci jako byte[] wystąpienie lub podobna struktura danych pierwotnych. W poniższym przykładzie użyto PushAudioInputStream metody rozpoznawania mowy, która jest zasadniczo abstrakcyjnym strumieniem pamięci. Przykładowy kod wykonuje następujące akcje:

  • Zapisuje nieprzetworzone dane audio (PCM) PushAudioInputStream przy użyciu Write() funkcji, która akceptuje byte[] wystąpienie.
  • Odczytuje plik .wav przy użyciu FileReader do celów demonstracyjnych. Jeśli masz już dane audio w wystąpieniu byte[] , możesz przejść bezpośrednio do zapisywania zawartości do strumienia wejściowego.
  • Domyślny format to 16-bitowe, 16-KHz mono modulacji kodu impulsu (PCM). Aby dostosować format, możesz przekazać AudioStreamFormat obiekt do CreatePushStream() przy użyciu funkcji AudioStreamFormat.GetWaveFormatPCM(sampleRate, (byte)bitRate, (byte)channels)statycznej .
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);
    }
}

Użycie strumienia wypychania jako danych wejściowych zakłada, że dane dźwiękowe są nieprzetworzonym komputerem PCM i pomija wszystkie nagłówki. Interfejs API nadal działa w niektórych przypadkach, jeśli nagłówek nie został pominięty. Aby uzyskać najlepsze wyniki, rozważ zaimplementowanie logiki w celu odczytania nagłówków tak, aby byte[] zaczynały się od początku danych dźwiękowych.

Obsługa błędów

Poprzednie przykłady pobierają tylko rozpoznany tekst z result.Text właściwości . Aby obsłużyć błędy i inne odpowiedzi, musisz napisać kod, aby obsłużyć wynik. Poniższy kod ocenia result.Reason właściwość i:

  • Wyświetla wynik rozpoznawania: ResultReason.RecognizedSpeech.
  • Jeśli nie ma dopasowania do rozpoznawania, informuje użytkownika: ResultReason.NoMatch.
  • Jeśli wystąpi błąd, zostanie wyświetlony komunikat o błędzie: 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;
}

Korzystanie z funkcji ciągłego rozpoznawania

W poprzednich przykładach użyto funkcji rozpoznawania pojedynczego strzału, która rozpoznaje jedną wypowiedź. Koniec pojedynczej wypowiedzi jest określany przez nasłuchiwanie ciszy na końcu lub do momentu przetworzenia maksymalnie 15 sekund dźwięku.

Natomiast używasz funkcji rozpoznawania ciągłego, gdy chcesz kontrolować, kiedy zatrzymać rozpoznawanie. Wymaga ona zasubskrybowania zdarzeń Recognizing, Recognizedi Canceled w celu uzyskania wyników rozpoznawania. Aby zatrzymać rozpoznawanie, należy wywołać metodę StopContinuousRecognitionAsync. Oto przykład sposobu wykonywania ciągłego rozpoznawania w pliku wejściowym audio.

Zacznij od zdefiniowania danych wejściowych i inicjowania SpeechRecognizer:

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

Następnie utwórz TaskCompletionSource<int> wystąpienie do zarządzania stanem rozpoznawania mowy:

var stopRecognition = new TaskCompletionSource<int>();

Następnie zasubskrybuj zdarzenia, które SpeechRecognizer wysyła:

  • Recognizing: Sygnał dla zdarzeń zawierających wyniki rozpoznawania pośredniego.
  • Recognized: sygnał dla zdarzeń zawierających końcowe wyniki rozpoznawania, które wskazują pomyślną próbę rozpoznawania.
  • SessionStopped: Sygnał dla zdarzeń, które wskazują koniec sesji rozpoznawania (operacja).
  • Canceled: Sygnał dla zdarzeń zawierających anulowane wyniki rozpoznawania. Te wyniki wskazują próbę rozpoznawania, która została anulowana w wyniku żądania bezpośredniego anulowania. Alternatywnie wskazują one awarię transportu lub protokołu.
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);
};

Po skonfigurowaniu wszystkiego wywołaj metodę StartContinuousRecognitionAsync , aby rozpocząć rozpoznawanie:

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();

Zmienianie języka źródłowego

Typowym zadaniem rozpoznawania mowy jest określenie języka wejściowego (lub źródłowego). W poniższym przykładzie pokazano, jak zmienić język wejściowy na włoski. W kodzie znajdź SpeechConfig wystąpienie i dodaj ten wiersz bezpośrednio pod nim:

speechConfig.SpeechRecognitionLanguage = "it-IT";

Właściwość SpeechRecognitionLanguage oczekuje ciągu formatu ustawień regionalnych języka. Aby uzyskać więcej informacji, zobacz listę obsługiwanych ustawień regionalnych zamiany mowy na tekst.

Identyfikacja języka

Można użyć identyfikacji języka z rozpoznawaniem mowy do rozpoznawania tekstu, gdy trzeba zidentyfikować język w źródle audio, a następnie transkrybować go do tekstu.

Aby zapoznać się z kompletnym przykładem kodu, zobacz Identyfikacja języka.

Używanie niestandardowego punktu końcowego

Za pomocą mowy niestandardowej możesz przekazać własne dane, przetestować i wytrenować model niestandardowy, porównać dokładność między modelami i wdrożyć model w niestandardowym punkcie końcowym. W poniższym przykładzie pokazano, jak ustawić niestandardowy punkt końcowy.

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

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają internetowe interfejsy API punktów końcowych zapytań oparte na protokole Websocket, które są dostępne za pośrednictwem zestawu SPEECH SDK i interfejsu wiersza polecenia usługi Mowa. Domyślnie zestaw SDK usługi Mowa i interfejs wiersza polecenia usługi Mowa używają publicznej usługi rozpoznawania mowy. Aby użyć kontenera, należy zmienić metodę inicjowania. Użyj adresu URL hosta kontenera zamiast klucza i regionu.

Aby uzyskać więcej informacji na temat kontenerów, zobacz Host URL in Install and run Speech containers with Docker (Adresy URL hostów w temacie Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker).

Zmienianie sposobu obsługi ciszy

Jeśli oczekuje się, że użytkownik będzie mówić szybciej lub wolniej niż zwykle, domyślne zachowania dla ciszy niespeech w dźwięku wejściowego mogą nie skutkować tym, czego oczekujesz. Typowe problemy z obsługą ciszy obejmują:

  • Szybkie łączenie wielu zdań w jeden wynik rozpoznawania, a nie podział zdań na poszczególne wyniki.
  • Powolna mowa oddzielająca części pojedynczego zdania na wiele wyników.
  • Rozpoznawanie pojedynczego strzału kończy się zbyt szybko, czekając na rozpoczęcie mowy.

Te problemy można rozwiązać, ustawiając jedną z dwóch właściwości limitu czasu w wystąpieniu SpeechConfig użytym do utworzenia elementu SpeechRecognizer:

  • Limit czasu wyciszenia segmentacji dostosowuje, ile dźwięku niespeech jest dozwolony w frazie, która jest obecnie mówiona, zanim ta fraza zostanie uznana za "gotowe".
    • Wyższe wartości zwykle wydłużają wyniki i umożliwiają dłuższe wstrzymanie od osoby mówiącej w ramach frazy, ale wyniki mogą trwać dłużej. Mogą one również łączyć oddzielne frazy w jeden wynik po ustawieniu zbyt wysoki.
    • Niższe wartości zwykle sprawiają, że wyniki są krótsze i zapewniają większą liczbę monitów i częstszych podziałów między frazami, ale mogą również powodować oddzielenie pojedynczych fraz na wiele wyników po ustawieniu zbyt małej wartości.
    • Ten limit czasu można ustawić na wartości całkowite z zakresu od 100 do 5000 w milisekundach z wartością 500 typową wartością domyślną.
  • Początkowy limit czasu ciszy dostosowuje, ile dźwięku niespeech jest dozwolony przed wyrażeniem przed zakończeniem próby rozpoznawania w wyniku "brak dopasowania".
    • Wyższe wartości zapewniają głośnikom więcej czasu na reagowanie i rozpoczynanie mówienia, ale może również spowodować spowolnienie reakcji, gdy nic nie jest mówione.
    • Niższe wartości zapewniają monit "brak dopasowania" w celu szybszego środowiska użytkownika i bardziej kontrolowanej obsługi dźwięku, ale może odciąć głośnik zbyt szybko po ustawieniu zbyt małej ilości.
    • Ponieważ funkcja ciągłego rozpoznawania generuje wiele wyników, ta wartość określa, jak często docierają wyniki "brak dopasowania", ale w przeciwnym razie nie wpływają na zawartość wyników rozpoznawania.
    • Ten limit czasu można ustawić na dowolną nieujemną wartość całkowitą, w milisekundach lub na wartość 0, aby całkowicie ją wyłączyć. 5000 jest typowym ustawieniem domyślnym dla rozpoznawania pojedynczego strzału, podczas gdy 15000 jest typowym ustawieniem domyślnym dla ciągłego rozpoznawania.

Ponieważ występują kompromisy podczas modyfikowania tych limitów czasu, należy zmienić ustawienia tylko wtedy, gdy masz problem związany z obsługą ciszy. Wartości domyślne optymalnie obsługują większość dźwięku mówionego i powinny napotykać problemy tylko w rzadkich scenariuszach.

Przykład: Użytkownicy mówiący numer seryjny, taki jak "ABC-123-4567", mogą wstrzymać się między grupami znaków wystarczająco długo, aby numer seryjny został podzielony na wiele wyników. W takim przypadku spróbuj użyć wyższej wartości, takiej jak 2000 ms dla limitu czasu ciszy segmentacji:

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

Przykład: Nagrana mowa prezentera może być wystarczająco szybka, że kilka zdań w wierszu zostanie połączonych, a duże wyniki rozpoznawania docierają tylko raz lub dwa razy na minutę. W tym przypadku ustaw limit czasu ciszy segmentacji na niższą wartość, taką jak 300 ms:

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

Przykład: rozpoznawanie pojedynczego strzału z prośbą osoby mówiącej o znalezienie i odczytanie numeru seryjnego kończy się zbyt szybko podczas znajdowania numeru. W takim przypadku spróbuj dłuższy początkowy limit czasu ciszy, taki jak 10 000 ms:

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

Dokumentacja referencyjna | Package (NuGet) | Dodatkowe przykłady w usłudze GitHub

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać i transkrybować mowę do tekstu w czasie rzeczywistym.

Tworzenie konfiguracji mowy

Aby wywołać usługę rozpoznawania mowy przy użyciu zestawu SPEECH SDK, należy utworzyć SpeechConfig wystąpienie. Ta klasa zawiera informacje o subskrypcji, takie jak klucz i skojarzony lokalizacja/region, punkt końcowy, host lub token autoryzacji.

  1. SpeechConfig Utwórz wystąpienie przy użyciu klucza i regionu.
  2. Utwórz zasób usługi Mowa w witrynie Azure Portal. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu z wieloma usługami.
using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

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

Można zainicjować SpeechConfig na kilka innych sposobów:

  • Użyj punktu końcowego i przekaż punkt końcowy usługi Rozpoznawanie mowy. Klucz lub token autoryzacji jest opcjonalny.
  • Użyj hosta i przekaż adres hosta. Klucz lub token autoryzacji jest opcjonalny.
  • Użyj tokenu autoryzacji ze skojarzonym regionem/lokalizacją.

Uwaga

Niezależnie od tego, czy wykonujesz rozpoznawanie mowy, syntezę mowy, tłumaczenie, czy rozpoznawanie intencji, zawsze tworzysz konfigurację.

Rozpoznawanie mowy przy użyciu mikrofonu

Aby rozpoznawać mowę AudioConfig przy użyciu mikrofonu urządzenia, utwórz wystąpienie przy użyciu funkcji składowej FromDefaultMicrophoneInput() . Następnie zainicjujSpeechRecognizer obiekt, przekazując audioConfig polecenie i config.

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;

Jeśli chcesz użyć określonego urządzenia wejściowego audio, musisz określić identyfikator urządzenia w pliku AudioConfig. Aby uzyskać więcej informacji na temat pobierania identyfikatora urządzenia dla urządzenia wejściowego audio, zobacz Wybieranie urządzenia wejściowego audio za pomocą zestawu Speech SDK

Rozpoznawanie mowy z pliku

Jeśli chcesz rozpoznawać mowę z pliku audio zamiast używać mikrofonu, nadal musisz utworzyć AudioConfig wystąpienie. Ale w tym przypadku nie wywołujesz metody FromDefaultMicrophoneInput(). FromWavFileInput() Wywołasz metodę i przekażesz ścieżkę pliku:

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;

Rozpoznawanie mowy przy użyciu klasy Recognizer

Klasa Recognizer dla zestawu SPEECH SDK dla języka C++ uwidacznia kilka metod, których można użyć do rozpoznawania mowy.

Rozpoznawanie pojedynczego strzału

Funkcja rozpoznawania pojedynczego strzału asynchronicznie rozpoznaje jedną wypowiedź. Koniec pojedynczej wypowiedzi jest określany przez nasłuchiwanie ciszy na końcu lub do momentu przetworzenia maksymalnie 15 sekund dźwięku. Oto przykład asynchronicznego rozpoznawania pojedynczego strzału za pomocą metody RecognizeOnceAsync:

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

Aby obsłużyć wynik, musisz napisać kod. Ta przykładowa result->Reason ocena i:

  • Wyświetla wynik rozpoznawania: ResultReason::RecognizedSpeech.
  • Jeśli nie ma dopasowania do rozpoznawania, informuje użytkownika: ResultReason::NoMatch.
  • Jeśli wystąpi błąd, zostanie wyświetlony komunikat o błędzie: 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;
}

Ciągłe rozpoznawanie

Ciągłe rozpoznawanie jest nieco bardziej zaangażowane niż rozpoznawanie pojedynczych zdjęć. Wymaga ona zasubskrybowania zdarzeń Recognizing, Recognizedi Canceled w celu uzyskania wyników rozpoznawania. Aby zatrzymać rozpoznawanie, należy wywołać metodę StopContinuousRecognitionAsync. Oto przykład sposobu wykonywania ciągłego rozpoznawania w pliku wejściowym audio.

Zacznij od zdefiniowania danych wejściowych i inicjowania SpeechRecognizer:

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

Następnie utwórz zmienną do zarządzania stanem rozpoznawania mowy. Zadeklaruj promise<void> , ponieważ na początku rozpoznawania można bezpiecznie założyć, że nie zostało zakończone:

promise<void> recognitionEnd;

Następnie zasubskrybuj zdarzenia, które SpeechRecognizer wysyła:

  • Recognizing: Sygnał dla zdarzeń zawierających wyniki rozpoznawania pośredniego.
  • Recognized: sygnał dla zdarzeń zawierających końcowe wyniki rozpoznawania, które wskazują pomyślną próbę rozpoznawania.
  • SessionStopped: Sygnał dla zdarzeń, które wskazują koniec sesji rozpoznawania (operacja).
  • Canceled: Sygnał dla zdarzeń zawierających anulowane wyniki rozpoznawania. Te wyniki wskazują próbę rozpoznawania, która została anulowana w wyniku żądania anulowania bezpośredniego. Alternatywnie wskazują one awarię transportu lub protokołu.
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.
    });

Po skonfigurowaniu wszystkiego wywołaj metodę StopContinuousRecognitionAsync , aby rozpocząć rozpoznawanie:

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

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

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

Zmienianie języka źródłowego

Typowym zadaniem rozpoznawania mowy jest określenie języka wejściowego (lub źródłowego). W poniższym przykładzie pokazano, jak zmienić język wejściowy na niemiecki. W kodzie znajdź SpeechConfig wystąpienie i dodaj ten wiersz bezpośrednio pod nim:

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

SetSpeechRecognitionLanguage jest parametrem, który przyjmuje ciąg jako argument. Aby uzyskać więcej informacji, zobacz listę obsługiwanych ustawień regionalnych zamiany mowy na tekst.

Identyfikacja języka

Można użyć identyfikacji języka z rozpoznawaniem mowy do rozpoznawania tekstu, gdy trzeba zidentyfikować język w źródle audio, a następnie transkrybować go do tekstu.

Aby zapoznać się z kompletnym przykładem kodu, zobacz Identyfikacja języka.

Używanie niestandardowego punktu końcowego

Za pomocą mowy niestandardowej możesz przekazać własne dane, przetestować i wytrenować model niestandardowy, porównać dokładność między modelami i wdrożyć model w niestandardowym punkcie końcowym. W poniższym przykładzie pokazano, jak ustawić niestandardowy punkt końcowy.

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

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają internetowe interfejsy API punktów końcowych zapytań oparte na protokole Websocket, które są dostępne za pośrednictwem zestawu SPEECH SDK i interfejsu wiersza polecenia usługi Mowa. Domyślnie zestaw SDK usługi Mowa i interfejs wiersza polecenia usługi Mowa używają publicznej usługi rozpoznawania mowy. Aby użyć kontenera, należy zmienić metodę inicjowania. Użyj adresu URL hosta kontenera zamiast klucza i regionu.

Aby uzyskać więcej informacji na temat kontenerów, zobacz Host URL in Install and run Speech containers with Docker (Adresy URL hostów w temacie Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker).

Dokumentacja referencyjna Package (Go)Additional Samples on GitHub (Dodatkowe przykłady w witrynie GitHub) | |

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać i transkrybować mowę do tekstu w czasie rzeczywistym.

Rozpoznawanie mowy na tekst z mikrofonu

Użyj poniższego przykładu kodu, aby uruchomić rozpoznawanie mowy z domyślnego mikrofonu urządzenia. Zastąp zmienne subscription odpowiednio region kluczem mowy i lokalizacją/regionem. Utwórz zasób usługi Mowa w witrynie Azure Portal. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu z wieloma usługami. Uruchomienie skryptu powoduje uruchomienie sesji rozpoznawania w domyślnym mikrofonie i tekście wyjściowym:

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

Uruchom następujące polecenia, aby utworzyć plik go.mod , który łączy się ze składnikami hostowanymi w usłudze GitHub:

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

Teraz skompiluj i uruchom kod:

go build
go run quickstart

Aby uzyskać szczegółowe informacje, zobacz zawartość referencyjną SpeechConfig klasy i zawartość referencyjną SpeechRecognizer dla klasy.

Rozpoznawanie mowy na tekst z pliku audio

Użyj poniższego przykładu, aby uruchomić rozpoznawanie mowy z pliku audio. Zastąp zmienne subscription odpowiednio region kluczem mowy i lokalizacją/regionem. Utwórz zasób usługi Mowa w witrynie Azure Portal. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu z wieloma usługami. Ponadto zastąp zmienną file ścieżką do pliku .wav . Po uruchomieniu skryptu rozpoznaje mowę z pliku i generuje wynik tekstowy:

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)
}

Uruchom następujące polecenia, aby utworzyć plik go.mod , który łączy się ze składnikami hostowanymi w usłudze GitHub:

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

Teraz skompiluj i uruchom kod:

go build
go run quickstart

Aby uzyskać szczegółowe informacje, zobacz zawartość referencyjną SpeechConfig klasy i zawartość referencyjną SpeechRecognizer dla klasy.

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają internetowe interfejsy API punktów końcowych zapytań oparte na protokole Websocket, które są dostępne za pośrednictwem zestawu SPEECH SDK i interfejsu wiersza polecenia usługi Mowa. Domyślnie zestaw SDK usługi Mowa i interfejs wiersza polecenia usługi Mowa używają publicznej usługi rozpoznawania mowy. Aby użyć kontenera, należy zmienić metodę inicjowania. Użyj adresu URL hosta kontenera zamiast klucza i regionu.

Aby uzyskać więcej informacji na temat kontenerów, zobacz Host URL in Install and run Speech containers with Docker (Adresy URL hostów w temacie Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker).

| Dokumentacja referencyjna — dodatkowe przykłady w usłudze GitHub

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać i transkrybować mowę do tekstu w czasie rzeczywistym.

Tworzenie konfiguracji mowy

Aby wywołać usługę Rozpoznawanie mowy przy użyciu zestawu SPEECH SDK, musisz utworzyć wystąpienie usługi SpeechConfig . Ta klasa zawiera informacje o subskrypcji, takie jak klucz i skojarzony lokalizacja/region, punkt końcowy, host lub token autoryzacji.

  1. SpeechConfig Utwórz wystąpienie przy użyciu klucza i lokalizacji/regionu.
  2. Utwórz zasób usługi Mowa w witrynie Azure Portal. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu z wieloma usługami.
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>");
    }
}

Można zainicjować SpeechConfig na kilka innych sposobów:

  • Użyj punktu końcowego i przekaż punkt końcowy usługi Rozpoznawanie mowy. Klucz lub token autoryzacji jest opcjonalny.
  • Użyj hosta i przekaż adres hosta. Klucz lub token autoryzacji jest opcjonalny.
  • Użyj tokenu autoryzacji ze skojarzonym regionem/lokalizacją.

Uwaga

Niezależnie od tego, czy wykonujesz rozpoznawanie mowy, syntezę mowy, tłumaczenie, czy rozpoznawanie intencji, zawsze utworzysz konfigurację.

Rozpoznawanie mowy przy użyciu mikrofonu

Aby rozpoznawać mowę AudioConfig przy użyciu mikrofonu urządzenia, utwórz wystąpienie przy użyciu fromDefaultMicrophoneInput() metody . Następnie zainicjuj SpeechRecognizer obiekt, przekazując audioConfig polecenie i config.

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());
    }
}

Jeśli chcesz użyć określonego urządzenia wejściowego audio, musisz określić identyfikator urządzenia w pliku AudioConfig. Aby uzyskać więcej informacji na temat pobierania identyfikatora urządzenia dla urządzenia wejściowego audio, zobacz Wybieranie urządzenia wejściowego audio za pomocą zestawu SPEECH SDK.

Rozpoznawanie mowy z pliku

Jeśli chcesz rozpoznawać mowę z pliku audio zamiast używać mikrofonu, nadal musisz utworzyć AudioConfig wystąpienie. Ale w tym przypadku nie wywołujesz metody FromDefaultMicrophoneInput(). fromWavFileInput() Wywołasz metodę i przekażesz ścieżkę pliku:

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());
    }
}

Obsługa błędów

Poprzednie przykłady pobierają tylko rozpoznany tekst przy użyciu polecenia result.getText(). Aby obsłużyć błędy i inne odpowiedzi, musisz napisać kod, aby obsłużyć wynik. Poniższy przykład ocenia result.getReason() i:

  • Wyświetla wynik rozpoznawania: ResultReason.RecognizedSpeech.
  • Jeśli nie ma dopasowania do rozpoznawania, informuje użytkownika: ResultReason.NoMatch.
  • Jeśli wystąpi błąd, zostanie wyświetlony komunikat o błędzie: 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;
}

Korzystanie z funkcji ciągłego rozpoznawania

W poprzednich przykładach użyto funkcji rozpoznawania pojedynczego strzału, która rozpoznaje jedną wypowiedź. Koniec pojedynczej wypowiedzi jest określany przez nasłuchiwanie ciszy na końcu lub do momentu przetworzenia maksymalnie 15 sekund dźwięku.

Natomiast używasz funkcji rozpoznawania ciągłego, gdy chcesz kontrolować, kiedy zatrzymać rozpoznawanie. Wymaga ona zasubskrybowania zdarzeń recognizing, recognizedi canceled w celu uzyskania wyników rozpoznawania. Aby zatrzymać rozpoznawanie, należy wywołać metodę stopContinuousRecognitionAsync. Oto przykładowy sposób wykonywania ciągłego rozpoznawania w pliku wejściowym audio.

Zacznij od zdefiniowania danych wejściowych i inicjowania SpeechRecognizer:

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

Następnie utwórz zmienną do zarządzania stanem rozpoznawania mowy. Zadeklaruj Semaphore wystąpienie w zakresie klasy:

private static Semaphore stopTranslationWithFileSemaphore;

Następnie zasubskrybuj zdarzenia, które SpeechRecognizer wysyła:

  • recognizing: Sygnał dla zdarzeń zawierających wyniki rozpoznawania pośredniego.
  • recognized: sygnał dla zdarzeń zawierających końcowe wyniki rozpoznawania, które wskazują pomyślną próbę rozpoznawania.
  • sessionStopped: Sygnał dla zdarzeń, które wskazują koniec sesji rozpoznawania (operacja).
  • canceled: Sygnał dla zdarzeń zawierających anulowane wyniki rozpoznawania. Te wyniki wskazują próbę rozpoznawania, która została anulowana w wyniku żądania bezpośredniego anulowania. Alternatywnie wskazują one awarię transportu lub protokołu.
// 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();
});

Po skonfigurowaniu wszystkiego wywołaj metodę startContinuousRecognitionAsync , aby rozpocząć rozpoznawanie:

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

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

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

Zmienianie języka źródłowego

Typowym zadaniem rozpoznawania mowy jest określenie języka wejściowego (lub źródłowego). W poniższym przykładzie pokazano, jak zmienić język wejściowy na francuski. W kodzie znajdź SpeechConfig wystąpienie i dodaj ten wiersz bezpośrednio poniżej:

config.setSpeechRecognitionLanguage("fr-FR");

setSpeechRecognitionLanguage jest parametrem, który przyjmuje ciąg jako argument. Zapoznaj się z listą obsługiwanych ustawień regionalnych mowy do tekstu.

Identyfikacja języka

Można użyć identyfikacji języka z rozpoznawaniem mowy do rozpoznawania tekstu, gdy trzeba zidentyfikować język w źródle audio, a następnie transkrybować go do tekstu.

Aby zapoznać się z kompletnym przykładem kodu, zobacz Identyfikacja języka.

Używanie niestandardowego punktu końcowego

Za pomocą mowy niestandardowej możesz przekazać własne dane, przetestować i wytrenować model niestandardowy, porównać dokładność między modelami i wdrożyć model w niestandardowym punkcie końcowym. W poniższym przykładzie pokazano, jak ustawić niestandardowy punkt końcowy:

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

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają internetowe interfejsy API punktów końcowych zapytań oparte na protokole Websocket, które są dostępne za pośrednictwem zestawu SPEECH SDK i interfejsu wiersza polecenia usługi Mowa. Domyślnie zestaw SDK usługi Mowa i interfejs wiersza polecenia usługi Mowa używają publicznej usługi rozpoznawania mowy. Aby użyć kontenera, należy zmienić metodę inicjowania. Użyj adresu URL hosta kontenera zamiast klucza i regionu.

Aby uzyskać więcej informacji na temat kontenerów, zobacz Host URL in Install and run Speech containers with Docker (Adresy URL hostów w temacie Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker).

Dokumentacja referencyjna | Package (npm)Additional Samples on GitHub Library source code (Dodatkowe przykłady w kodzie źródłowym biblioteki GitHub) | |

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać i transkrybować mowę do tekstu w czasie rzeczywistym.

Tworzenie konfiguracji mowy

Aby wywołać usługę Rozpoznawanie mowy przy użyciu zestawu SPEECH SDK, należy utworzyć SpeechConfig wystąpienie. Ta klasa zawiera informacje o subskrypcji, takie jak klucz i skojarzony lokalizacja/region, punkt końcowy, host lub token autoryzacji.

  1. SpeechConfig Utwórz wystąpienie przy użyciu klucza i lokalizacji/regionu.
  2. Utwórz zasób usługi Mowa w witrynie Azure Portal. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu z wieloma usługami.
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

Można zainicjować SpeechConfig na kilka innych sposobów:

  • Użyj punktu końcowego i przekaż punkt końcowy usługi Rozpoznawanie mowy. Klucz lub token autoryzacji jest opcjonalny.
  • Użyj hosta i przekaż adres hosta. Klucz lub token autoryzacji jest opcjonalny.
  • Użyj tokenu autoryzacji ze skojarzonym regionem/lokalizacją.

Uwaga

Niezależnie od tego, czy wykonujesz rozpoznawanie mowy, syntezę mowy, tłumaczenie, czy rozpoznawanie intencji, zawsze tworzysz konfigurację.

Rozpoznawanie mowy przy użyciu mikrofonu

Rozpoznawanie mowy z mikrofonu nie jest obsługiwane w Node.js. Jest on obsługiwany tylko w środowisku JavaScript opartym na przeglądarce. Aby uzyskać więcej informacji, zobacz przykład React i implementację mowy na tekst z mikrofonu w usłudze GitHub. Przykład platformy React przedstawia wzorce projektowe dotyczące wymiany tokenów uwierzytelniania i zarządzania nimi. Przedstawia również przechwytywanie dźwięku z mikrofonu lub pliku do konwersji mowy na tekst.

Uwaga

Jeśli chcesz użyć określonego urządzenia wejściowego audio, musisz określić identyfikator urządzenia w AudioConfig obiekcie. Aby uzyskać więcej informacji, zobacz Select an audio input device with the Speech SDK (Wybieranie urządzenia wejściowego audio przy użyciu zestawu SDK usługi Mowa).

Rozpoznawanie mowy z pliku

Aby rozpoznać mowę AudioConfig z pliku audio, utwórz wystąpienie przy użyciu fromWavFileInput() metody , która akceptuje Buffer obiekt. Następnie zainicjuj SpeechRecognizer , przekazując audioConfig i speechConfig.

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();

Rozpoznawanie mowy ze strumienia w pamięci

W wielu przypadkach użycia dane audio prawdopodobnie pochodzą z usługi Azure Blob Storage. Lub jest już w pamięci jako ArrayBuffer lub podobnej pierwotnej struktury danych. Następujący kod powoduje:

  • Tworzy strumień wypychania przy użyciu polecenia createPushStream().
  • Odczytuje plik .wav przy użyciu fs.createReadStream do celów demonstracyjnych. Jeśli masz już dane audio w programie ArrayBuffer, możesz przejść bezpośrednio do zapisywania zawartości w strumieniu wejściowym.
  • Tworzy konfigurację dźwięku przy użyciu strumienia wypychania.
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();

Użycie strumienia wypychania jako danych wejściowych zakłada, że dane audio są nieprzetworzonymi danymi modulacji kodu impulsowego (PCM), które pomijają wszystkie nagłówki. Interfejs API nadal działa w niektórych przypadkach, jeśli nagłówek nie został pominięty. Aby uzyskać najlepsze wyniki, rozważ zaimplementowanie logiki w celu odczytania nagłówków tak, aby fs zaczynały się od początku danych dźwiękowych.

Obsługa błędów

Poprzednie przykłady pobierają tylko rozpoznany tekst z result.text właściwości . Aby obsłużyć błędy i inne odpowiedzi, musisz napisać kod, aby obsłużyć wynik. Poniższy kod ocenia result.reason właściwość i:

  • Wyświetla wynik rozpoznawania: ResultReason.RecognizedSpeech.
  • Jeśli nie ma dopasowania do rozpoznawania, informuje użytkownika: ResultReason.NoMatch.
  • Jeśli wystąpi błąd, zostanie wyświetlony komunikat o błędzie: 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;
    }

Korzystanie z funkcji ciągłego rozpoznawania

W poprzednich przykładach użyto funkcji rozpoznawania pojedynczego strzału, która rozpoznaje jedną wypowiedź. Koniec pojedynczej wypowiedzi jest określany przez nasłuchiwanie ciszy na końcu lub do momentu przetworzenia maksymalnie 15 sekund dźwięku.

Z kolei możesz użyć funkcji rozpoznawania ciągłego, gdy chcesz kontrolować, kiedy zatrzymać rozpoznawanie. Wymaga ona zasubskrybowania zdarzeń Recognizing, Recognizedi Canceled w celu uzyskania wyników rozpoznawania. Aby zatrzymać rozpoznawanie, należy wywołać metodę stopContinuousRecognitionAsync. Oto przykład sposobu wykonywania ciągłego rozpoznawania w pliku wejściowym audio.

Zacznij od zdefiniowania danych wejściowych i inicjowania SpeechRecognizer:

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

Następnie zasubskrybuj zdarzenia wysyłane z programu SpeechRecognizer:

  • recognizing: Sygnał dla zdarzeń zawierających wyniki rozpoznawania pośredniego.
  • recognized: sygnał dla zdarzeń zawierających końcowe wyniki rozpoznawania, które wskazują pomyślną próbę rozpoznawania.
  • sessionStopped: Sygnał dla zdarzeń, które wskazują koniec sesji rozpoznawania (operacja).
  • canceled: Sygnał dla zdarzeń zawierających anulowane wyniki rozpoznawania. Te wyniki wskazują próbę rozpoznawania, która została anulowana w wyniku żądania bezpośredniego anulowania. Alternatywnie wskazują one awarię transportu lub protokołu.
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();
};

Po skonfigurowaniu wszystkiego wywołaj metodę startContinuousRecognitionAsync , aby rozpocząć rozpoznawanie:

speechRecognizer.startContinuousRecognitionAsync();

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

Zmienianie języka źródłowego

Typowym zadaniem rozpoznawania mowy jest określenie języka wejściowego (lub źródłowego). W poniższym przykładzie pokazano, jak zmienić język wejściowy na włoski. W kodzie znajdź SpeechConfig wystąpienie i dodaj ten wiersz bezpośrednio pod nim:

speechConfig.speechRecognitionLanguage = "it-IT";

Właściwość speechRecognitionLanguage oczekuje ciągu formatu ustawień regionalnych języka. Aby uzyskać więcej informacji, zobacz listę obsługiwanych ustawień regionalnych zamiany mowy na tekst.

Identyfikacja języka

Można użyć identyfikacji języka z rozpoznawaniem mowy do rozpoznawania tekstu, gdy trzeba zidentyfikować język w źródle audio, a następnie transkrybować go do tekstu.

Aby zapoznać się z kompletnym przykładem kodu, zobacz Identyfikacja języka.

Używanie niestandardowego punktu końcowego

Za pomocą mowy niestandardowej możesz przekazać własne dane, przetestować i wytrenować model niestandardowy, porównać dokładność między modelami i wdrożyć model w niestandardowym punkcie końcowym. W poniższym przykładzie pokazano, jak ustawić niestandardowy punkt końcowy.

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

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają internetowe interfejsy API punktów końcowych zapytań oparte na protokole Websocket, które są dostępne za pośrednictwem zestawu SPEECH SDK i interfejsu wiersza polecenia usługi Mowa. Domyślnie zestaw SDK usługi Mowa i interfejs wiersza polecenia usługi Mowa używają publicznej usługi rozpoznawania mowy. Aby użyć kontenera, należy zmienić metodę inicjowania. Użyj adresu URL hosta kontenera zamiast klucza i regionu.

Aby uzyskać więcej informacji na temat kontenerów, zobacz Host URL in Install and run Speech containers with Docker (Adresy URL hostów w temacie Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker).

Dokumentacja referencyjna Pakietu (Pobierz) | Dodatkowe przykłady w usłudze GitHub |

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać i transkrybować mowę do tekstu w czasie rzeczywistym.

Instalowanie zestawu SPEECH SDK i przykładów

Repozytorium Azure-Samples/cognitive-services-speech-sdk zawiera przykłady napisane w języku Objective-C dla systemów iOS i Mac. Wybierz link, aby wyświetlić instrukcje instalacji dla każdego przykładu:

Aby uzyskać więcej informacji, zobacz dokumentację zestawu SPEECH SDK dla języka Objective-C.

Używanie niestandardowego punktu końcowego

Za pomocą mowy niestandardowej możesz przekazać własne dane, przetestować i wytrenować model niestandardowy, porównać dokładność między modelami i wdrożyć model w niestandardowym punkcie końcowym. W poniższym przykładzie pokazano, jak ustawić niestandardowy punkt końcowy:

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

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają internetowe interfejsy API punktów końcowych zapytań oparte na protokole Websocket, które są dostępne za pośrednictwem zestawu SPEECH SDK i interfejsu wiersza polecenia usługi Mowa. Domyślnie zestaw SDK usługi Mowa i interfejs wiersza polecenia usługi Mowa używają publicznej usługi rozpoznawania mowy. Aby użyć kontenera, należy zmienić metodę inicjowania. Użyj adresu URL hosta kontenera zamiast klucza i regionu.

Aby uzyskać więcej informacji na temat kontenerów, zobacz Host URL in Install and run Speech containers with Docker (Adresy URL hostów w temacie Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker).

Dokumentacja referencyjna Pakietu (Pobierz) | Dodatkowe przykłady w usłudze GitHub |

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać i transkrybować mowę do tekstu w czasie rzeczywistym.

Instalowanie zestawu SPEECH SDK i przykładów

Repozytorium Azure-Samples/cognitive-services-speech-sdk zawiera przykłady napisane w języku Swift dla systemów iOS i Mac. Wybierz link, aby wyświetlić instrukcje instalacji dla każdego przykładu:

Aby uzyskać więcej informacji, zobacz dokumentację zestawu Speech SDK dla języka Swift.

Używanie niestandardowego punktu końcowego

Za pomocą mowy niestandardowej możesz przekazać własne dane, przetestować i wytrenować model niestandardowy, porównać dokładność między modelami i wdrożyć model w niestandardowym punkcie końcowym. W poniższym przykładzie pokazano, jak ustawić niestandardowy punkt końcowy:

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

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają internetowe interfejsy API punktów końcowych zapytań oparte na protokole Websocket, które są dostępne za pośrednictwem zestawu SPEECH SDK i interfejsu wiersza polecenia usługi Mowa. Domyślnie zestaw SDK usługi Mowa i interfejs wiersza polecenia usługi Mowa używają publicznej usługi rozpoznawania mowy. Aby użyć kontenera, należy zmienić metodę inicjowania. Użyj adresu URL hosta kontenera zamiast klucza i regionu.

Aby uzyskać więcej informacji na temat kontenerów, zobacz Host URL in Install and run Speech containers with Docker (Adresy URL hostów w temacie Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker).

Dokumentacja referencyjna | Package (PyPi) | Dodatkowe przykłady w witrynie GitHub

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać i transkrybować mowę do tekstu w czasie rzeczywistym.

Tworzenie konfiguracji mowy

Aby wywołać usługę Rozpoznawanie mowy przy użyciu zestawu SPEECH SDK, należy utworzyć SpeechConfig wystąpienie. Ta klasa zawiera informacje o subskrypcji, takie jak klucz mowy i skojarzona lokalizacja/region, punkt końcowy, host lub token autoryzacji.

  1. SpeechConfig Utwórz wystąpienie przy użyciu klucza mowy i lokalizacji/regionu.
  2. Utwórz zasób usługi Mowa w witrynie Azure Portal. Aby uzyskać więcej informacji, zobacz Tworzenie zasobu z wieloma usługami.
speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")

Można zainicjować SpeechConfig na kilka innych sposobów:

  • Użyj punktu końcowego i przekaż punkt końcowy usługi Rozpoznawanie mowy. Klucz mowy lub token autoryzacji jest opcjonalny.
  • Użyj hosta i przekaż adres hosta. Klucz mowy lub token autoryzacji jest opcjonalny.
  • Użyj tokenu autoryzacji ze skojarzonym regionem/lokalizacją.

Uwaga

Niezależnie od tego, czy wykonujesz rozpoznawanie mowy, syntezę mowy, tłumaczenie, czy rozpoznawanie intencji, zawsze tworzysz konfigurację.

Rozpoznawanie mowy przy użyciu mikrofonu

Aby rozpoznać mowę SpeechRecognizer przy użyciu mikrofonu urządzenia, utwórz wystąpienie bez przekazywania AudioConfig, a następnie przekaż polecenie 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()

Jeśli chcesz użyć określonego urządzenia wejściowego audio, musisz określić identyfikator urządzenia w AudioConfigpliku i przekazać go do parametru SpeechRecognizer konstruktoraaudio_config. Aby uzyskać więcej informacji na temat pobierania identyfikatora urządzenia dla urządzenia wejściowego audio, zobacz Wybieranie urządzenia wejściowego audio za pomocą zestawu Speech SDK

Rozpoznawanie mowy z pliku

Jeśli chcesz rozpoznać mowę z pliku audio zamiast używać mikrofonu, utwórz AudioConfig wystąpienie i użyj parametru 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()

Obsługa błędów

Poprzednie przykłady pobierają tylko rozpoznany tekst z result.text właściwości . Aby obsłużyć błędy i inne odpowiedzi, musisz napisać kod, aby obsłużyć wynik. Poniższy kod ocenia result.reason właściwość i:

  • Wyświetla wynik rozpoznawania: speechsdk.ResultReason.RecognizedSpeech.
  • Jeśli nie ma dopasowania do rozpoznawania, informuje użytkownika: speechsdk.ResultReason.NoMatch.
  • Jeśli wystąpi błąd, zostanie wyświetlony komunikat o błędzie: 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?")

Korzystanie z funkcji ciągłego rozpoznawania

W poprzednich przykładach użyto funkcji rozpoznawania pojedynczego strzału, która rozpoznaje jedną wypowiedź. Koniec pojedynczej wypowiedzi jest określany przez nasłuchiwanie ciszy na końcu lub do momentu przetworzenia maksymalnie 15 sekund dźwięku.

Natomiast używasz funkcji rozpoznawania ciągłego, gdy chcesz kontrolować, kiedy zatrzymać rozpoznawanie. Wymaga to nawiązania połączenia z usługą , aby EventSignal uzyskać wyniki rozpoznawania. Aby zatrzymać rozpoznawanie, należy wywołać metodę stop_continuous_recognition() lub stop_continuous_recognition().. Oto przykład sposobu wykonywania ciągłego rozpoznawania w pliku wejściowym audio.

Zacznij od zdefiniowania danych wejściowych i inicjowania SpeechRecognizer:

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

Następnie utwórz zmienną do zarządzania stanem rozpoznawania mowy. Ustaw zmienną na , False ponieważ na początku rozpoznawania można bezpiecznie założyć, że nie została zakończona:

done = False

Teraz utwórz wywołanie zwrotne, aby zatrzymać ciągłe rozpoznawanie po evt odebraniu. Pamiętaj o tych kwestiach:

  • Po evt odebraniu evt zostanie wyświetlony komunikat.
  • Po evt odebraniu stop_continuous_recognition() jest wywoływana w celu zatrzymania rozpoznawania.
  • Stan rozpoznawania jest zmieniany na True.
def stop_cb(evt):
    print('CLOSING on {}'.format(evt))
    speech_recognizer.stop_continuous_recognition()
    nonlocal done
    done = True

Poniższy przykładowy kod pokazuje, jak połączyć wywołania zwrotne z zdarzeniami wysyłanymi z usługi SpeechRecognizer. Dostępne są następujące zdarzenia:

  • recognizing: Sygnał dla zdarzeń zawierających wyniki rozpoznawania pośredniego.
  • recognized: sygnał dla zdarzeń zawierających końcowe wyniki rozpoznawania, które wskazują pomyślną próbę rozpoznawania.
  • session_started: Sygnał dla zdarzeń, które wskazują początek sesji rozpoznawania (operacja).
  • session_stopped: Sygnał dla zdarzeń, które wskazują koniec sesji rozpoznawania (operacja).
  • canceled: Sygnał dla zdarzeń zawierających anulowane wyniki rozpoznawania. Te wyniki wskazują próbę rozpoznawania, która została anulowana w wyniku żądania bezpośredniego anulowania. Alternatywnie wskazują one awarię transportu lub protokołu.
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)

Po skonfigurowaniu wszystkiego możesz wywołać metodę start_continuous_recognition():

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

Zmienianie języka źródłowego

Typowym zadaniem rozpoznawania mowy jest określenie języka wejściowego (lub źródłowego). W poniższym przykładzie pokazano, jak zmienić język wejściowy na niemiecki. W kodzie znajdź SpeechConfig wystąpienie i dodaj ten wiersz bezpośrednio pod nim:

speech_config.speech_recognition_language="de-DE"

speech_recognition_language jest parametrem, który przyjmuje ciąg jako argument. Aby uzyskać więcej informacji, zobacz listę obsługiwanych ustawień regionalnych zamiany mowy na tekst.

Identyfikacja języka

Można użyć identyfikacji języka z rozpoznawaniem mowy do rozpoznawania tekstu, gdy trzeba zidentyfikować język w źródle audio, a następnie transkrybować go do tekstu.

Aby zapoznać się z kompletnym przykładem kodu, zobacz Identyfikacja języka.

Używanie niestandardowego punktu końcowego

Za pomocą mowy niestandardowej możesz przekazać własne dane, przetestować i wytrenować model niestandardowy, porównać dokładność między modelami i wdrożyć model w niestandardowym punkcie końcowym. W poniższym przykładzie pokazano, jak ustawić niestandardowy punkt końcowy.

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

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają internetowe interfejsy API punktów końcowych zapytań oparte na protokole Websocket, które są dostępne za pośrednictwem zestawu SPEECH SDK i interfejsu wiersza polecenia usługi Mowa. Domyślnie zestaw SDK usługi Mowa i interfejs wiersza polecenia usługi Mowa używają publicznej usługi rozpoznawania mowy. Aby użyć kontenera, należy zmienić metodę inicjowania. Użyj adresu URL hosta kontenera zamiast klucza i regionu.

Aby uzyskać więcej informacji na temat kontenerów, zobacz Host URL in Install and run Speech containers with Docker (Adresy URL hostów w temacie Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker).

Interfejs API REST zamiany mowy na tekst — dokumentacja | interfejsu API REST zamiany mowy na tekst w celu uzyskania krótkiej dokumentacji | audio — dodatkowe przykłady w usłudze GitHub

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać i transkrybować mowę do tekstu w czasie rzeczywistym.

Konwersja mowy na tekst

W wierszu polecenia uruchom następujące polecenie. Wstaw następujące wartości do polecenia:

  • Klucz subskrypcji usługi Mowa.
  • Region usługi Rozpoznawanie mowy.
  • Ścieżka dla wejściowych plików audio. Pliki audio można wygenerować przy użyciu tekstu na mowę.
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'

Powinna zostać odebrana odpowiedź z treścią JSON podobną do następującego przykładu:

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

Aby uzyskać więcej informacji, zobacz Dokumentacja interfejsu API REST zamiany mowy na tekst.

W tym przewodniku z instrukcjami dowiesz się, jak rozpoznawać i transkrybować mowę do tekstu w czasie rzeczywistym.

Rozpoznawanie mowy przy użyciu mikrofonu

Podłącz i włącz mikrofon komputera. Wyłącz wszystkie aplikacje, które mogą również używać mikrofonu. Niektóre komputery mają wbudowany mikrofon, natomiast inne wymagają konfiguracji urządzenia Bluetooth.

Teraz możesz uruchomić interfejs wiersza polecenia usługi Mowa w celu rozpoznawania mowy z mikrofonu. W wierszu polecenia przejdź do katalogu zawierającego plik binarny interfejsu wiersza polecenia usługi Mowa. Uruchom następujące polecenie:

spx recognize --microphone

Uwaga

Interfejs wiersza polecenia usługi Mowa jest domyślnie w języku angielskim. Możesz wybrać inny język od mowy do tabeli tekstowej. Dodaj na przykład, --source de-DE aby rozpoznać mowę niemiecką.

Porozmawiaj z mikrofonem i możesz zobaczyć transkrypcję słów w tekście w czasie rzeczywistym. Interfejs wiersza polecenia usługi Mowa zatrzymuje się po upływie okresu ciszy lub po wybraniu klawiszy Ctrl+C.

Rozpoznawanie mowy z pliku

Interfejs wiersza polecenia usługi Mowa może rozpoznawać mowę w wielu formatach plików i językach naturalnych. W tym przykładzie można użyć dowolnego pliku .wav (16 KHz lub 8 KHz, 16-bitowego i mono PCM), który zawiera mowę angielską. Możesz też pobrać plik whatstheweatherlike.wav i skopiować go do tego samego katalogu co plik binarny interfejsu wiersza polecenia usługi Mowa.

Użyj następującego polecenia, aby uruchomić interfejs wiersza polecenia usługi Mowa w celu rozpoznawania mowy znalezionej w pliku audio:

spx recognize --file whatstheweatherlike.wav

Uwaga

Interfejs wiersza polecenia usługi Mowa jest domyślnie w języku angielskim. Możesz wybrać inny język od mowy do tabeli tekstowej. Dodaj na przykład, --source de-DE aby rozpoznać mowę niemiecką.

Interfejs wiersza polecenia usługi Mowa przedstawia transkrypcję tekstu mowy na ekranie.

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają internetowe interfejsy API punktów końcowych zapytań oparte na protokole Websocket, które są dostępne za pośrednictwem zestawu SPEECH SDK i interfejsu wiersza polecenia usługi Mowa. Domyślnie zestaw SDK usługi Mowa i interfejs wiersza polecenia usługi Mowa używają publicznej usługi rozpoznawania mowy. Aby użyć kontenera, należy zmienić metodę inicjowania. Użyj adresu URL hosta kontenera zamiast klucza i regionu.

Aby uzyskać więcej informacji na temat kontenerów, zobacz Host URL in Install and run Speech containers with Docker (Adresy URL hostów w temacie Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker).

Następne kroki