Jak rozpoznawać mowę

Speech to Text REST API dokumentacja | Speech to Text REST API dla krótkiego audio | Dodatkowe przykłady na GitHubie

W tym przewodniku dowiesz się, jak używać Azure Speech w narzędziach Foundry Tools do konwersji mowy w czasie rzeczywistym na tekst. Rozpoznawanie mowy w czasie rzeczywistym jest idealne dla aplikacji wymagających natychmiastowej transkrypcji, takich jak dyktowanie, pomoc w centrum obsługi telefonicznej i transkrypcja na żywo.

Aby dowiedzieć się, jak skonfigurować środowisko dla przykładowej aplikacji, zobacz Szybki start: rozpoznawanie i konwertowanie mowy na tekst.

Konwertowanie mowy na tekst

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

• Klucz interfejsu API do usługi rozpoznawania mowy
• Region usługi Mowa
• Ścieżka wejściowego pliku audio

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ć wyświetlona odpowiedź podobna do poniższego 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.

Dokumentacja referencyjna | Paczka (PyPi) | Dodatkowe przykłady na GitHub

W tym przewodniku dowiesz się, jak używać usługi Azure Speech w narzędziach Foundry do konwersji mowy na tekst w czasie rzeczywistym. Rozpoznawanie mowy w czasie rzeczywistym jest idealne dla aplikacji wymagających natychmiastowej transkrypcji, takich jak dyktowanie, pomoc w centrum obsługi telefonicznej i transkrypcja na żywo.

Aby dowiedzieć się, jak skonfigurować środowisko dla przykładowej aplikacji, zobacz Szybki start: rozpoznawanie i konwertowanie mowy na tekst.

Utwórz wystąpienie konfiguracji mowy

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

1. Utwórz zasób Foundry dotyczący Mowy w portalu Azure. Pobierz klucz zasobu Speech i region.
2. SpeechConfig Utwórz wystąpienie przy użyciu następującego kodu. Zastąp YourSpeechKey i YourSpeechRegion swoimi kluczami zasobu usługi Mowa i regionem.

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 podaj 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 z mikrofonu

Aby rozpoznać mowę przy użyciu mikrofonu urządzenia, utwórz wystąpienie SpeechRecognizer bez przekazywania AudioConfig, a następnie przekaż 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.")
    speech_recognition_result = speech_recognizer.recognize_once_async().get()
    print(speech_recognition_result.text)

from_mic()

Jeśli chcesz użyć określonego urządzenia wejściowego audio, musisz określić identyfikator urządzenia w AudioConfig, a następnie przekazać go do parametru audio_config konstruktora SpeechRecognizer. Aby dowiedzieć się, jak uzyskać identyfikator urządzenia, 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

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)

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

from_file()

Obsługa błędów

Poprzednie przykłady pobierają tylko rozpoznany tekst z speech_recognition_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 właściwość speech_recognition_result.reason.

• Wyświetla wynik rozpoznawania: speechsdk.ResultReason.RecognizedSpeech.
• Jeśli nie ma dopasowania w rozpoznawaniu, informuje użytkownika: speechsdk.ResultReason.NoMatch.
• Jeśli wystąpi błąd, zostanie wyświetlony komunikat o błędzie: speechsdk.ResultReason.Canceled.

if speech_recognition_result.reason == speechsdk.ResultReason.RecognizedSpeech:
    print("Recognized: {}".format(speech_recognition_result.text))
elif speech_recognition_result.reason == speechsdk.ResultReason.NoMatch:
    print("No speech could be recognized: {}".format(speech_recognition_result.no_match_details))
elif speech_recognition_result.reason == speechsdk.ResultReason.Canceled:
    cancellation_details = speech_recognition_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 połączenia z usługą EventSignal, aby uzyskać wyniki rozpoznawania. Aby zatrzymać rozpoznawanie, należy wywołać metodę stop_continuous_recognition() lub stop_continuous_recognition_async(). 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 procesu rozpoznawania można bezpiecznie założyć, że nie jest zakończony.

done = False

Teraz utwórz wywołanie zwrotne, aby zatrzymać ciągłe rozpoznawanie po evt odebraniu. Należy pamiętać o następujących kwestiach:

• Po evt odebraniu evt komunikat jest drukowany.
• Po odebraniu evt, wywoływana jest funkcja stop_continuous_recognition(), aby zatrzymać rozpoznawanie.
• Stan rozpoznawania jest zmieniany na True.

def stop_cb(evt):
    print('CLOSING on {}'.format(evt))
    speech_recognizer.stop_continuous_recognition()
    global done
    done = True

Poniższy przykładowy kod pokazuje, jak połączyć wywołania zwrotne z zdarzeniami wysyłanymi z usługi SpeechRecognizer. Zdarzenia to:

• 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 rezultaty wskazują na próbę rozpoznawania, która została anulowana na skutek bezpośredniego żądania 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 wszystkich elementów można 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 swoim kodzie znajdź wystąpienie SpeechConfig i dodaj ten wiersz bezpośrednio poniżej:

speech_config.speech_recognition_language="de-DE"

speech_recognition_language jest parametrem, który przyjmuje ciąg jako argument. Aby uzyskać listę obsługiwanych ustawień regionalnych, zobacz Obsługa języka i głosu dla usługi Mowa.

Identyfikacja języka

Można użyć identyfikacji języka przy rozpoznawaniu mowy na tekst, gdy trzeba zidentyfikować język w źródle audio, a następnie transkrybować go na tekst.

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

Użyj 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="YourSpeechResoureKey", region="YourServiceRegion")
speech_config.endpoint_id = "YourEndpointId"
speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają interfejsy API punktów końcowych zapytań, oparte na protokole WebSocket, które są dostępne za pośrednictwem zestawu SDK SPEECH i interfejsu wiersza polecenia Speech CLI. 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 adresy URL hosta w Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker.

Segmentacja semantyczna

Segmentacja semantyczna to strategia segmentacji rozpoznawania mowy zaprojektowana w celu ograniczenia problemów związanych z segmentacją opartą na ciszy:

• Gdy użytkownicy mówią przez długi czas bez przerw, mogą zobaczyć długą sekwencję tekstu bez przerwań ("ściana tekstu"), co poważnie obniża czytelność tekstu.
• Nadmierna segmentacja: gdy użytkownik wstrzymuje się przez krótki czas, mechanizm wykrywania ciszy może niepoprawnie podzielić segmenty.

Zamiast polegać tylko na limitach czasu ciszy, segmentacja semantyczna częściej segmentuje i zwraca końcowe wyniki, gdy wykrywa interpunkcję kończącą zdania (np. „.” lub „?”). Poprawia to środowisko użytkownika dzięki wyższej jakości, semantycznie kompletnym segmentom i zapobiega długim wynikom pośrednim.

Aby użyć segmentacji semantycznej, należy ustawić następującą właściwość w wystąpieniu SpeechConfig użytym do utworzenia elementu SpeechRecognizer:

speech_config.set_property(speechsdk.PropertyId.Speech_SegmentationStrategy, "Semantic") 

Niektóre ograniczenia segmentacji semantycznej są następujące:

• Do korzystania z segmentacji semantycznej potrzebny jest zestaw Speech SDK w wersji 1.41 lub nowszej.
• Segmentacja semantyczna jest przeznaczona tylko do użytku w funkcji ciągłego rozpoznawania. Obejmuje to scenariusze, takie jak dyktowanie i napisy. Nie należy jej używać w trybie rozpoznawania pojedynczego ani w scenariuszach interaktywnych.
• Segmentacja semantyczna nie jest dostępna dla wszystkich języków i ustawień regionalnych.
• Segmentacja semantyczna nie obsługuje jeszcze wyników ufności i list NBest. W związku z tym nie zalecamy segmentacji semantycznej, jeśli używasz współczynników ufności ani list NBest.

Doprecyzowanie poprzetwarzaniu strumienia (wersja zapoznawcza)

Doprecyzowanie po strumieniowaniu poprawia ostateczną dokładność transkrypcji, uruchamiając drugi etap rozpoznawania równolegle z przesyłaniem strumieniowym w czasie rzeczywistym. Wyniki pośrednie i częściowe pozostają o niskich opóźnieniach. Tylko wynik końcowy jest zastępowany bardziej dokładną wersją, która używa szerszego kontekstu audio.

Aby włączyć doprecyzowanie po strumieniu, ustaw właściwość SpeechServiceResponse_PostProcessingOption na wystąpieniu SpeechConfig.

speechConfig->SetProperty(PropertyId::SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.SetProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.setProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speech_config.set_property(
    speechsdk.PropertyId.SpeechServiceResponse_PostProcessingOption,
    "PostRefinement"
)

Niektóre ważne zagadnienia dotyczące doskonalenia po przesyle danych:

• Doprecyzowanie po przetwarzaniu strumieniowym sprawdza się najlepiej przy dłuższych wypowiedziach, takich jak konwersacje, spotkania i dyktowania. W przypadku bardzo krótkich fraz uściśliony wynik może być identyczny z wynikiem standardowym.
• Nie można używać razem uściślinia po strumieniu i semantycznej segmentacji.
• Uściślenie po strumieniu i Wartość TrueText są oddzielnymi wartościami tej samej SpeechServiceResponse_PostProcessingOption właściwości. Jednocześnie można ustawić tylko jedną wartość.
• Uściślenie po strumieniu jest dostępne tylko w wybranych regionach Azure podczas publicznej wersji zapoznawczej.

Aby uzyskać więcej informacji na temat opcji przetwarzania końcowego, zobacz Jak używać przetwarzania końcowego.

Ważne

Uściślenie po strumieniu jest obecnie dostępne w publicznej wersji zapoznawczej. Ulepszenia dokładności różnią się w zależności od języka i ustawień regionalnych. Niektóre ustawienia regionalne mogą nie wykazywać znaczącej poprawy jakości, a wyniki mogą się różnić od obserwowanych przy użyciu standardowego rozpoznawania. W wersji zapoznawczej jest obsługiwane tylko rozpoznawanie jednojęzyczne. Wielojęzyczna i automatyczna identyfikacja języka nie jest dostępna w przypadku rafinacji po strumieniowej.

Dokumentacja referencyjna Reference | Package (NuGet) | Dodatkowe przykłady na GitHub

W tym poradniku dowiesz się, jak używać Azure Speech w Foundry Tools do konwersji mowy na tekst w czasie rzeczywistym. Rozpoznawanie mowy w czasie rzeczywistym jest idealne dla aplikacji wymagających natychmiastowej transkrypcji, takich jak dyktowanie, pomoc w centrum obsługi telefonicznej i transkrypcja na żywo.

Aby dowiedzieć się, jak skonfigurować środowisko dla przykładowej aplikacji, zobacz Szybki start: rozpoznawanie i konwertowanie mowy na tekst.

Utwórz instancję 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 zasobie usługi Mowa, takie jak klucz i skojarzony region, punkt końcowy, host lub token autoryzacji.

1. Utwórz zasób Foundry dla usługi Mowa w portalu Azure. Pobierz klucz zasobu usługi rozpoznawania mowy i punkt końcowy.
2. SpeechConfig Utwórz wystąpienie przy użyciu następującego kodu. Zastąp YourSpeechKey kluczem zasobu usługi Mowa i YourSpeechEndpoint punktem końcowym.

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.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
    }
}

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 podaj 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 z mikrofonu

Aby rozpoznawać mowę AudioConfig przy użyciu mikrofonu urządzenia, utwórz wystąpienie przy użyciu FromDefaultMicrophoneInput() metody . Następnie zainicjuj obiekt SpeechRecognizer, przekazując speechConfig 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 speechRecognitionResult = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
        await FromMic(speechConfig);
    }
}

Jeśli chcesz użyć określonego urządzenia wejściowego audio, musisz określić identyfikator urządzenia w pliku AudioConfig. Aby dowiedzieć się, jak uzyskać identyfikator urządzenia, 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

Jeśli chcesz rozpoznać mowę z pliku audio, zamiast z mikrofonu, nadal musisz utworzyć wystąpienie AudioConfig. Jednak nie wywołujesz FromDefaultMicrophoneInput(). Wywołujesz FromWavFileInput() i przekazujesz ścieżkę do 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 speechRecognitionResult = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
        await FromFile(speechConfig);
    }
}

Rozpoznawanie mowy ze strumienia w pamięci

W wielu przypadkach użycia prawdopodobnie dane audio pochodzą z Azure Blob Storage lub są już w pamięci jako wystąpienie byte[] 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 do PushAudioInputStream przy użyciu funkcji Write(), która akceptuje wystąpienie byte[].
• 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-bitowa, 16-kHz, mono modulacja z kodek impulsowy (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 speechRecognitionResult = await speechRecognizer.RecognizeOnceAsync();
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
    }

    async static Task Main(string[] args)
    {
        var speechConfig = SpeechConfig.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
        await FromStream(speechConfig);
    }
}

Użycie strumienia przesyłania jako danych wejściowych zakłada, że dane audio są surowymi danymi PCM i pomija wszelkie nagłówki. API nadal działa w pewnych przypadkach, gdy nagłówek nie zostanie pominięty. Aby uzyskać najlepsze wyniki, rozważ zaimplementowanie logiki do odczytywania nagłówków, aby byte[] rozpoczynało się od początku danych audio.

Obsługa błędów

Poprzednie przykłady pobierają tylko rozpoznany tekst z speechRecognitionResult.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 właściwość speechRecognitionResult.Reason.

• Wyświetla wynik rozpoznawania: ResultReason.RecognizedSpeech.
• Jeśli nie ma dopasowania w rozpoznawaniu, informuje użytkownika: ResultReason.NoMatch.
• Jeśli wystąpi błąd, zostanie wyświetlony komunikat o błędzie: ResultReason.Canceled.

switch (speechRecognitionResult.Reason)
{
    case ResultReason.RecognizedSpeech:
        Console.WriteLine($"RECOGNIZED: Text={speechRecognitionResult.Text}");
        break;
    case ResultReason.NoMatch:
        Console.WriteLine($"NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled:
        var cancellation = CancellationDetails.FromResult(speechRecognitionResult);
        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 endpoint 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 wystąpienie TaskCompletionSource<int> w celu 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ą, że próba rozpoznania została anulowana na skutek bezpośredniej prośby o anulowanie. 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 endpoint 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 locale językowego. Aby uzyskać listę obsługiwanych ustawień regionalnych, zobacz Obsługa języka i głosu dla usługi Mowa.

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.FromEndpoint(new Uri("YourSpeechEndpoint"), "YourSpeechKey");
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 w Install and run Speech containers with Docker.

Zmienianie sposobu obsługi ciszy

Jeśli użytkownik mówi szybciej lub wolniej niż zwykle, domyślne zachowania dla niesłownej ciszy w dźwięku wejściowym mogą nie spowodować oczekiwanych rezultatów. Typowe problemy z obsługą ciszy obejmują:

• Szybka mowa, która łączy wiele zdań w jeden wynik rozpoznawania, zamiast rozbijać zdania na poszczególne wyniki.
• Powolna mowa, która dzieli części jednego zdania na kilka wyników.
• Rozpoznawanie pojedynczej próbki, które kończy się zbyt szybko podczas oczekiwania 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 niesłownego dźwięku jest dozwolone w wypowiadanej frazie, zanim ta fraza zostanie uznana za "gotowa".
  • Wyższe wartości zazwyczaj wydłużają czas pojawiania się wyników i pozwalają na dłuższe przerwy w mowie wewnątrz frazy, ale powodują, że wyniki pojawiają się później. Mogą również łączyć oddzielne frazy w jeden wynik po ustawieniu parametru na zbyt dużą wartość.
  • Niższe wartości zwykle sprawiają, że wyniki są krótsze i zapewniają częstsze przerwy między frazami, ale mogą również powodować oddzielenie pojedynczych fraz na wiele wyników, jeśli wartość jest ustawiona zbyt nisko.
  • 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 głosu jest dozwolone przed wypowiedzią, zanim próba rozpoznawania kończy się wynikiem "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ą komunikat "brak dopasowania" dla szybszego doświadczenia użytkownika i bardziej kontrolowanego przetwarzania audio, ale mogą odciąć głośnik zbyt szybko przy ustawieniu zbyt niskiej wartości.
  • Ponieważ funkcja ciągłego rozpoznawania generuje wiele wyników, ta wartość określa, jak często pojawiają się wyniki "brak dopasowania", ale nie wpływa inaczej 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ż podczas modyfikowania tych limitów czasu występują kompromisy, 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 podający numer seryjny, taki jak "ABC-123-4567", mogą robić przerwy między grupami znaków wystarczająco długie, aby numer seryjny został podzielony na wiele części. W takim przypadku spróbuj użyć wyższej wartości, takiej jak 2000 milisekund 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ń z rzędu 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 pojedynczym zapytaniem proszące mówiącego o znalezienie i odczytanie numeru seryjnego kończy się zbyt szybko, zanim numer zostanie znaleziony. W takim przypadku spróbuj dłuższy początkowy limit czasu ciszy, taki jak 10 000 ms:

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

Segmentacja semantyczna

Segmentacja semantyczna to strategia segmentacji rozpoznawania mowy zaprojektowana w celu ograniczenia problemów związanych z segmentacją opartą na ciszy:

• Gdy użytkownicy mówią przez długi czas bez przerw, mogą zobaczyć długą sekwencję tekstu bez przerw ("ściana tekstu"), co poważnie pogarsza odbiór tekstu.
• Nadmierna segmentacja: gdy użytkownik zatrzymuje się na chwilę, mechanizm wykrywania ciszy może dokonać niewłaściwego podziału.

Zamiast polegać tylko na limitach czasu ciszy, segmentacja semantyczna głównie segmentuje i zwraca końcowe wyniki, gdy wykrywa znaki interpunkcyjne kończące zdanie, takie jak '.' lub '?'. Poprawia to środowisko użytkownika dzięki wyższej jakości, semantycznie kompletnym segmentom i zapobiega długim wynikom pośrednim.

Aby użyć segmentacji semantycznej, należy ustawić następującą właściwość w wystąpieniu SpeechConfig użytym do utworzenia elementu SpeechRecognizer:

speechConfig.SetProperty(PropertyId.Speech_SegmentationStrategy, "Semantic");

Niektóre ograniczenia segmentacji semantycznej są następujące:

• Do korzystania z segmentacji semantycznej potrzebny jest zestaw Speech SDK w wersji 1.41 lub nowszej.
• Segmentacja semantyczna jest przeznaczona tylko do użytku w funkcji ciągłego rozpoznawania. Scenariusze, które obejmuje, to m.in. dyktowanie i napisy. Nie należy jej używać w trybie rozpoznawania pojedynczego ani w scenariuszach interaktywnych.
• Segmentacja semantyczna nie jest dostępna dla wszystkich języków i ustawień regionalnych.
• Segmentacja semantyczna nie obsługuje jeszcze wyników ufności i list NBest. W związku z tym nie zalecamy segmentacji semantycznej, jeśli używasz współczynników ufności ani list NBest.

Doprecyzowanie po strumieniu (wersja próbna)

Udokładnianie po zakończeniu przesyłania strumieniowego poprawia ostateczną dokładność transkrypcji, przeprowadzając drugie przejście rozpoznawania równolegle z przesyłaniem strumieniowym w czasie rzeczywistym. Wyniki pośrednie i częściowe pozostają o niskich opóźnieniach. Tylko wynik końcowy jest zastępowany bardziej dokładną wersją, która używa szerszego kontekstu audio.

Aby włączyć doprecyzowanie po strumieniu, ustaw właściwość SpeechServiceResponse_PostProcessingOption na wystąpieniu SpeechConfig.

speechConfig->SetProperty(PropertyId::SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.SetProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.setProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speech_config.set_property(
    speechsdk.PropertyId.SpeechServiceResponse_PostProcessingOption,
    "PostRefinement"
)

Niektóre ważne zagadnienia dotyczące doskonalenia po przesyle danych:

• Doprecyzowanie po przetwarzaniu strumieniowym sprawdza się najlepiej przy dłuższych wypowiedziach, takich jak konwersacje, spotkania i dyktowania. W przypadku bardzo krótkich fraz uściśliony wynik może być identyczny z wynikiem standardowym.
• Nie można używać razem uściślinia po strumieniu i semantycznej segmentacji.
• Uściślenie po strumieniu i Wartość TrueText są oddzielnymi wartościami tej samej SpeechServiceResponse_PostProcessingOption właściwości. Jednocześnie można ustawić tylko jedną wartość.
• Uściślenie po strumieniu jest dostępne tylko w wybranych regionach Azure podczas publicznej wersji zapoznawczej.

Aby uzyskać więcej informacji na temat opcji przetwarzania końcowego, zobacz Jak używać przetwarzania końcowego.

Ważne

Uściślenie po strumieniu jest obecnie dostępne w publicznej wersji zapoznawczej. Ulepszenia dokładności różnią się w zależności od języka i ustawień regionalnych. Niektóre ustawienia regionalne mogą nie wykazywać znaczącej poprawy jakości, a wyniki mogą się różnić od obserwowanych przy użyciu standardowego rozpoznawania. W wersji zapoznawczej jest obsługiwane tylko rozpoznawanie jednojęzyczne. Wielojęzyczna i automatyczna identyfikacja języka nie jest dostępna w przypadku rafinacji po strumieniowej.

Dokumentacja referencyjna | Package (npm) | Dodatkowe przykłady na GitHubie | Kod źródłowy biblioteki

W tym poradniku dowiesz się, jak używać Azure Speech w Foundry Tools do konwersji mowy na tekst w czasie rzeczywistym. Rozpoznawanie mowy w czasie rzeczywistym jest idealne dla aplikacji wymagających natychmiastowej transkrypcji, takich jak dyktowanie, pomoc w centrum obsługi telefonicznej i transkrypcja na żywo.

Aby dowiedzieć się, jak skonfigurować środowisko dla przykładowej aplikacji, zobacz Szybki start: rozpoznawanie i konwertowanie mowy na tekst.

Utwórz instancję 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 zasobie usługi Mowa, takie jak klucz i skojarzony region, punkt końcowy, host lub token autoryzacji.

1. Utwórz zasób Foundry dla usługi Mowa w portalu Azure. Pobierz klucz zasobu usługi rozpoznawania mowy i punkt końcowy.
2. SpeechConfig Utwórz wystąpienie przy użyciu następującego kodu. Zastąp YourSpeechEndpoint i YourSpeechKey swoim zasobem usługi Mowa i punktem końcowym kluczem.

const speechConfig = sdk.SpeechConfig.fromEndpoint(new URL("YourSpeechEndpoint"), "YourSpeechKey");

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 podaj 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 z 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 oraz implementacja mowy na tekst z mikrofonu na 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 pliku AudioConfig. Aby dowiedzieć się, jak uzyskać identyfikator urządzenia, 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ę z pliku audio, utwórz wystąpienie AudioConfig, używając metody fromWavFileInput(), która przyjmuje obiekt Buffer. Następnie zainicjuj SpeechRecognizer , przekazując audioConfig i speechConfig.

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

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 podobna pierwotna struktura danych. Następujący kod:

• Tworzy strumień wypychania przy użyciu 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 do strumienia wejściowego.
• Tworzy konfigurację dźwięku przy użyciu strumienia push.

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

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. API nadal działa w pewnych przypadkach, gdy nagłówek nie zostanie pominięty. Aby uzyskać najlepsze wyniki, rozważ zaimplementowanie logiki do odczytywania nagłówków, aby fs rozpoczynało się od początku danych audio.

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 właściwość result.reason.

• Wyświetla wynik rozpoznawania: ResultReason.RecognizedSpeech.
• Jeśli nie ma dopasowania w rozpoznawaniu, 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 endpoint 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, musisz wywołać metodę [stopContinuousRecognitionAsync] (/javascript/api/microsoft-cognitiveservices-speech-sdk/speechrecognizer#microsoft-cognitiveservices-speech-sdk-speechrecognizer-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 rezultaty wskazują na próbę rozpoznawania, która została anulowana na skutek bezpośredniego żądania 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 endpoint values?");
    }

    speechRecognizer.stopContinuousRecognitionAsync();
};

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

Po skonfigurowaniu wszystkiego wywołaj metodę [startContinuousRecognitionAsync] (/javascript/api/microsoft-cognitiveservices-speech-sdk/speechrecognizer#microsoft-cognitiveservices-speech-speechrecognizer-startkeywordrecognitionasync), 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 swoim kodzie znajdź wystąpienie SpeechConfig i dodaj ten wiersz bezpośrednio poniżej:

speechConfig.speechRecognitionLanguage = "it-IT";

Właściwość speechRecognitionLanguage oczekuje ciągu formatu locale językowego. Aby uzyskać listę obsługiwanych ustawień regionalnych, zobacz Obsługa języka i głosu dla usługi Mowa.

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żyj 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("YourSpeechResoureKey", "YourServiceRegion");
speechConfig.endpointId = "YourEndpointId";
var speechRecognizer = new SpeechSDK.SpeechRecognizer(speechConfig);

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają interfejsy API punktów końcowych zapytań, oparte na protokole WebSocket, które są dostępne za pośrednictwem zestawu SDK SPEECH i interfejsu wiersza polecenia Speech CLI. 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 adresy URL hosta w Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker.

dokumentacja referencyjna | Dodatkowe przykłady na GitHub

W tym poradniku dowiesz się, jak używać Azure Speech w Foundry Tools do konwersji mowy na tekst w czasie rzeczywistym. Rozpoznawanie mowy w czasie rzeczywistym jest idealne dla aplikacji wymagających natychmiastowej transkrypcji, takich jak dyktowanie, pomoc w centrum obsługi telefonicznej i transkrypcja na żywo.

Aby dowiedzieć się, jak skonfigurować środowisko dla przykładowej aplikacji, zobacz Szybki start: rozpoznawanie i konwertowanie mowy na tekst.

Utwórz instancję konfiguracji mowy

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

1. Utwórz zasób Foundry dla usługi Mowa w portalu Azure. Pobierz klucz zasobu Speech i region.
2. SpeechConfig Utwórz wystąpienie przy użyciu klucza i regionu usługi Mowa.

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

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException, URISyntaxException {
        SpeechConfig speechConfig = SpeechConfig.fromEndpoint(new URI("<paste-your-speech-endpoint>"), "<paste-your-speech-key>");
    }
}

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 podaj 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 z mikrofonu

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

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

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException, URISyntaxException {
        SpeechConfig speechConfig = SpeechConfig.fromEndpoint(new URI("<paste-your-speech-endpoint>"), "<paste-your-speech-key>");
        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 speechRecognitionResult = task.get();
        System.out.println("RECOGNIZED: Text=" + speechRecognitionResult.getText());
    }
}

Jeśli chcesz użyć określonego urządzenia wejściowego audio, musisz określić identyfikator urządzenia w pliku AudioConfig. Aby dowiedzieć się, jak uzyskać identyfikator urządzenia, 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

Jeśli chcesz rozpoznawać mowę z pliku audio zamiast używać mikrofonu, nadal musisz utworzyć AudioConfig wystąpienie. Jednak nie wywołujesz FromDefaultMicrophoneInput(). Wywołujesz fromWavFileInput() i przekazujesz ścieżkę do pliku:

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

public class Program {
    public static void main(String[] args) throws InterruptedException, ExecutionException, URISyntaxException {
        SpeechConfig speechConfig = SpeechConfig.fromEndpoint(new URI("<paste-your-speech-endpoint>"), "<paste-your-speech-key>");
        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 speechRecognitionResult = task.get();
        System.out.println("RECOGNIZED: Text=" + speechRecognitionResult.getText());
    }
}

Obsługa błędów

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

• Wyświetla wynik rozpoznawania: ResultReason.RecognizedSpeech.
• Jeśli nie ma dopasowania w rozpoznawaniu, informuje użytkownika: ResultReason.NoMatch.
• Jeśli wystąpi błąd, zostanie wyświetlony komunikat o błędzie: ResultReason.Canceled.

switch (speechRecognitionResult.getReason()) {
    case ResultReason.RecognizedSpeech:
        System.out.println("We recognized: " + speechRecognitionResult.getText());
        exitCode = 0;
        break;
    case ResultReason.NoMatch:
        System.out.println("NOMATCH: Speech could not be recognized.");
        break;
    case ResultReason.Canceled: {
            CancellationDetails cancellation = CancellationDetails.fromResult(speechRecognitionResult);
            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 rezultaty wskazują na próbę rozpoznawania, która została anulowana na skutek bezpośredniego żądania 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 swoim kodzie znajdź wystąpienie SpeechConfig i dodaj tę linię 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żyj 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("YourSpeechKey", "YourServiceRegion");
speechConfig.setEndpointId("YourEndpointId");
SpeechRecognizer speechRecognizer = new SpeechRecognizer(speechConfig);

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają interfejsy API punktów końcowych zapytań, oparte na protokole WebSocket, które są dostępne za pośrednictwem zestawu SDK SPEECH i interfejsu wiersza polecenia Speech CLI. 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 adresy URL hosta w Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker.

Segmentacja semantyczna

Segmentacja semantyczna to strategia segmentacji rozpoznawania mowy zaprojektowana w celu ograniczenia problemów związanych z segmentacją opartą na ciszy:

• Gdy użytkownicy mówią przez długi czas bez przerw, mogą zobaczyć długą sekwencję tekstu bez przerwań ("ściana tekstu"), co poważnie obniża czytelność tekstu.
• Nadmierna segmentacja: gdy użytkownik wstrzymuje się przez krótki czas, mechanizm wykrywania ciszy może niepoprawnie podzielić segmenty.

Zamiast polegać tylko na limitach czasu ciszy, segmentacja semantyczna częściej segmentuje i zwraca końcowe wyniki, gdy wykrywa interpunkcję kończącą zdania (np. „.” lub „?”). Poprawia to środowisko użytkownika dzięki wyższej jakości, semantycznie kompletnym segmentom i zapobiega długim wynikom pośrednim.

Aby użyć segmentacji semantycznej, należy ustawić następującą właściwość w wystąpieniu SpeechConfig użytym do utworzenia elementu SpeechRecognizer:

speechConfig.SetProperty(PropertyId.Speech_SegmentationStrategy, "Semantic");

Niektóre ograniczenia segmentacji semantycznej są następujące:

• Do korzystania z segmentacji semantycznej potrzebny jest zestaw Speech SDK w wersji 1.41 lub nowszej.
• Segmentacja semantyczna jest przeznaczona tylko do użytku w funkcji ciągłego rozpoznawania. Obejmuje to scenariusze, takie jak dyktowanie i napisy. Nie należy jej używać w trybie rozpoznawania pojedynczego ani w scenariuszach interaktywnych.
• Segmentacja semantyczna nie jest dostępna dla wszystkich języków i ustawień regionalnych.
• Segmentacja semantyczna nie obsługuje jeszcze wyników ufności i list NBest. W związku z tym nie zalecamy segmentacji semantycznej, jeśli używasz współczynników ufności ani list NBest.

Doprecyzowanie poprzetwarzaniu strumienia (wersja zapoznawcza)

Doprecyzowanie po strumieniowaniu poprawia ostateczną dokładność transkrypcji, uruchamiając drugi etap rozpoznawania równolegle z przesyłaniem strumieniowym w czasie rzeczywistym. Wyniki pośrednie i częściowe pozostają o niskich opóźnieniach. Tylko wynik końcowy jest zastępowany bardziej dokładną wersją, która używa szerszego kontekstu audio.

Aby włączyć doprecyzowanie po strumieniu, ustaw właściwość SpeechServiceResponse_PostProcessingOption na wystąpieniu SpeechConfig.

speechConfig->SetProperty(PropertyId::SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.SetProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.setProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speech_config.set_property(
    speechsdk.PropertyId.SpeechServiceResponse_PostProcessingOption,
    "PostRefinement"
)

Niektóre ważne zagadnienia dotyczące doskonalenia po przesyle danych:

• Doprecyzowanie po przetwarzaniu strumieniowym sprawdza się najlepiej przy dłuższych wypowiedziach, takich jak konwersacje, spotkania i dyktowania. W przypadku bardzo krótkich fraz uściśliony wynik może być identyczny z wynikiem standardowym.
• Nie można używać razem uściślinia po strumieniu i semantycznej segmentacji.
• Uściślenie po strumieniu i Wartość TrueText są oddzielnymi wartościami tej samej SpeechServiceResponse_PostProcessingOption właściwości. Jednocześnie można ustawić tylko jedną wartość.
• Uściślenie po strumieniu jest dostępne tylko w wybranych regionach Azure podczas publicznej wersji zapoznawczej.

Aby uzyskać więcej informacji na temat opcji przetwarzania końcowego, zobacz Jak używać przetwarzania końcowego.

Ważne

Uściślenie po strumieniu jest obecnie dostępne w publicznej wersji zapoznawczej. Ulepszenia dokładności różnią się w zależności od języka i ustawień regionalnych. Niektóre ustawienia regionalne mogą nie wykazywać znaczącej poprawy jakości, a wyniki mogą się różnić od obserwowanych przy użyciu standardowego rozpoznawania. W wersji zapoznawczej jest obsługiwane tylko rozpoznawanie jednojęzyczne. Wielojęzyczna i automatyczna identyfikacja języka nie jest dostępna w przypadku rafinacji po strumieniowej.

Dokumentacja referencyjna Reference | Package (NuGet) | Dodatkowe przykłady na GitHub

W tym poradniku dowiesz się, jak używać Azure Speech w Foundry Tools do konwersji mowy na tekst w czasie rzeczywistym. Rozpoznawanie mowy w czasie rzeczywistym jest idealne dla aplikacji wymagających natychmiastowej transkrypcji, takich jak dyktowanie, pomoc w centrum obsługi telefonicznej i transkrypcja na żywo.

Aby dowiedzieć się, jak skonfigurować środowisko dla przykładowej aplikacji, zobacz Szybki start: rozpoznawanie i konwertowanie mowy na tekst.

Utwórz instancję 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 zasobie usługi Mowa, takie jak klucz i skojarzony region, punkt końcowy, host lub token autoryzacji.

1. Utwórz zasób Foundry dla usługi Mowa w portalu Azure. Pobierz klucz zasobu usługi rozpoznawania mowy i punkt końcowy.
2. SpeechConfig Utwórz wystąpienie przy użyciu następującego kodu. Zastąp YourSpeechKey kluczem zasobu usługi Mowa i YourSpeechEndpoint punktem końcowym.

using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

auto speechConfig = SpeechConfig::FromEndpoint("YourServiceEndpoint", "YourSpeechResourceKey");

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 podaj 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 czy tłumaczenie, zawsze tworzysz konfigurację.

Rozpoznawanie mowy z mikrofonu

Aby rozpoznawać mowę przy użyciu mikrofonu urządzenia, utwórz instancję AudioConfig przy użyciu funkcji składowej FromDefaultMicrophoneInput(). Następnie zainicjujSpeechRecognizer obiekt, przekazując audioConfig 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 dowiedzieć się, jak uzyskać identyfikator urządzenia, 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

Jeśli chcesz rozpoznawać mowę z pliku audio zamiast używać mikrofonu, nadal musisz utworzyć AudioConfig wystąpienie. Jednak nie wywołujesz FromDefaultMicrophoneInput(). Wywołujesz FromWavFileInput() i przekazujesz ścieżkę do 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. Ten przykład ocenia result->Reason i:

• Wyświetla wynik rozpoznawania: ResultReason::RecognizedSpeech.
• Jeśli nie ma dopasowania w rozpoznawaniu, 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 endpoint 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 ciągłego rozpoznawania wykonywanego 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 rezultaty wskazują na próbę rozpoznawania, która została anulowana na skutek bezpośredniego żądania anulowania. 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 endpoint 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ę StartContinuousRecognitionAsync , 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 swoim kodzie znajdź wystąpienie SpeechConfig i dodaj ten wiersz bezpośrednio poniżej:

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

SetSpeechRecognitionLanguage jest parametrem, który przyjmuje ciąg jako argument. Aby uzyskać listę obsługiwanych ustawień regionalnych, zobacz Obsługa języka i głosu dla usługi Mowa.

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żyj 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::FromEndpoint("YourServiceEndpoint", "YourSpeechResourceKey");
speechConfig->SetEndpointId("YourEndpointId");
auto speechRecognizer = SpeechRecognizer::FromConfig(speechConfig);

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają interfejsy API punktów końcowych zapytań, oparte na protokole WebSocket, które są dostępne za pośrednictwem zestawu SDK SPEECH i interfejsu wiersza polecenia Speech CLI. 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 punktu końcowego.

Aby uzyskać więcej informacji na temat kontenerów, zobacz adresy URL hosta w Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker.

Segmentacja semantyczna

Segmentacja semantyczna to strategia segmentacji rozpoznawania mowy zaprojektowana w celu ograniczenia problemów związanych z segmentacją opartą na ciszy:

• Gdy użytkownicy mówią przez długi czas bez przerw, mogą zobaczyć długą sekwencję tekstu bez przerwań ("ściana tekstu"), co poważnie obniża czytelność tekstu.
• Nadmierna segmentacja: gdy użytkownik wstrzymuje się przez krótki czas, mechanizm wykrywania ciszy może niepoprawnie podzielić segmenty.

Zamiast polegać tylko na limitach czasu ciszy, segmentacja semantyczna częściej segmentuje i zwraca końcowe wyniki, gdy wykrywa interpunkcję kończącą zdania (np. „.” lub „?”). Poprawia to środowisko użytkownika dzięki wyższej jakości, semantycznie kompletnym segmentom i zapobiega długim wynikom pośrednim.

Aby użyć segmentacji semantycznej, należy ustawić następującą właściwość w wystąpieniu SpeechConfig użytym do utworzenia elementu SpeechRecognizer:

speechConfig->SetProperty(PropertyId::Speech_SegmentationStrategy, "Semantic");

Niektóre ograniczenia segmentacji semantycznej są następujące:

• Do korzystania z segmentacji semantycznej potrzebny jest zestaw Speech SDK w wersji 1.41 lub nowszej.
• Segmentacja semantyczna jest przeznaczona tylko do użytku w funkcji ciągłego rozpoznawania. Obejmuje to scenariusze, takie jak dyktowanie i napisy. Nie należy jej używać w trybie rozpoznawania pojedynczego ani w scenariuszach interaktywnych.
• Segmentacja semantyczna nie jest dostępna dla wszystkich języków i ustawień regionalnych.
• Segmentacja semantyczna nie obsługuje jeszcze wyników ufności i list NBest. W związku z tym nie zalecamy segmentacji semantycznej, jeśli używasz współczynników ufności ani list NBest.

Doprecyzowanie poprzetwarzaniu strumienia (wersja zapoznawcza)

Doprecyzowanie po strumieniowaniu poprawia ostateczną dokładność transkrypcji, uruchamiając drugi etap rozpoznawania równolegle z przesyłaniem strumieniowym w czasie rzeczywistym. Wyniki pośrednie i częściowe pozostają o niskich opóźnieniach. Tylko wynik końcowy jest zastępowany bardziej dokładną wersją, która używa szerszego kontekstu audio.

Aby włączyć doprecyzowanie po strumieniu, ustaw właściwość SpeechServiceResponse_PostProcessingOption na wystąpieniu SpeechConfig.

speechConfig->SetProperty(PropertyId::SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.SetProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speechConfig.setProperty(PropertyId.SpeechServiceResponse_PostProcessingOption, "PostRefinement");

speech_config.set_property(
    speechsdk.PropertyId.SpeechServiceResponse_PostProcessingOption,
    "PostRefinement"
)

Niektóre ważne zagadnienia dotyczące doskonalenia po przesyle danych:

• Doprecyzowanie po przetwarzaniu strumieniowym sprawdza się najlepiej przy dłuższych wypowiedziach, takich jak konwersacje, spotkania i dyktowania. W przypadku bardzo krótkich fraz uściśliony wynik może być identyczny z wynikiem standardowym.
• Nie można używać razem uściślinia po strumieniu i semantycznej segmentacji.
• Uściślenie po strumieniu i Wartość TrueText są oddzielnymi wartościami tej samej SpeechServiceResponse_PostProcessingOption właściwości. Jednocześnie można ustawić tylko jedną wartość.
• Uściślenie po strumieniu jest dostępne tylko w wybranych regionach Azure podczas publicznej wersji zapoznawczej.

Aby uzyskać więcej informacji na temat opcji przetwarzania końcowego, zobacz Jak używać przetwarzania końcowego.

Ważne

Uściślenie po strumieniu jest obecnie dostępne w publicznej wersji zapoznawczej. Ulepszenia dokładności różnią się w zależności od języka i ustawień regionalnych. Niektóre ustawienia regionalne mogą nie wykazywać znaczącej poprawy jakości, a wyniki mogą się różnić od obserwowanych przy użyciu standardowego rozpoznawania. W wersji zapoznawczej jest obsługiwane tylko rozpoznawanie jednojęzyczne. Wielojęzyczna i automatyczna identyfikacja języka nie jest dostępna w przypadku rafinacji po strumieniowej.

dokumentacja Reference | Package (Go) | Dodatkowe przykłady w GitHub

W tym poradniku dowiesz się, jak używać Azure Speech w Foundry Tools do konwersji mowy na tekst w czasie rzeczywistym. Rozpoznawanie mowy w czasie rzeczywistym jest idealne dla aplikacji wymagających natychmiastowej transkrypcji, takich jak dyktowanie, pomoc w centrum obsługi telefonicznej i transkrypcja na żywo.

Aby dowiedzieć się, jak skonfigurować środowisko dla przykładowej aplikacji, zobacz Szybki start: rozpoznawanie i konwertowanie mowy na tekst.

Rozpoznawanie mowy na tekst z mikrofonu

1. Utwórz zasób Foundry dla usługi Mowa w portalu Azure. Pobierz klucz zasobu Speech i region.
2. Użyj poniższego przykładu kodu, aby uruchomić rozpoznawanie mowy z domyślnego mikrofonu urządzenia. Zastąp YourSpeechKey i YourSpeechRegion swoimi kluczami zasobu usługi Mowa i regionem. 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 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 class oraz SpeechRecognizer class.

Rozpoznawanie mowy na tekst z pliku audio

Użyj poniższego przykładu, aby uruchomić rozpoznawanie mowy z pliku audio. Zastąp YourSpeechKey i YourSpeechRegion swoimi kluczami zasobu usługi Mowa i regionem. 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 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 class oraz SpeechRecognizer class.

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają interfejsy API punktów końcowych zapytań, oparte na protokole WebSocket, które są dostępne za pośrednictwem zestawu SDK SPEECH i interfejsu wiersza polecenia Speech CLI. 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 adresy URL hosta w Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker.

Dokumentacja referencyjna | Pakiet (do pobrania) | Dodatkowe przykłady na GitHub

W tym poradniku dowiesz się, jak używać Azure Speech w Foundry Tools do konwersji mowy na tekst w czasie rzeczywistym. Rozpoznawanie mowy w czasie rzeczywistym jest idealne dla aplikacji wymagających natychmiastowej transkrypcji, takich jak dyktowanie, pomoc w centrum obsługi telefonicznej i transkrypcja na żywo.

Aby dowiedzieć się, jak skonfigurować środowisko dla przykładowej aplikacji, zobacz Szybki start: rozpoznawanie i konwertowanie mowy na tekst.

Instalowanie zestawu SPEECH SDK i przykładów

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

• Rozpoznawanie mowy z mikrofonu w Objective-C w systemie macOS
• Rozpoznawanie mowy w Objective-C na iOS
• Więcej przykładów dla Objective-C w systemie iOS

Aby uzyskać więcej informacji, zobacz referencje Speech SDK dla Objective-C.

Użyj 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:"YourSpeechResoureKey" region:"YourServiceRegion"];
speechConfig.endpointId = "YourEndpointId";
SPXSpeechRecognizer* speechRecognizer = [[SPXSpeechRecognizer alloc] init:speechConfig];

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają interfejsy API punktów końcowych zapytań, oparte na protokole WebSocket, które są dostępne za pośrednictwem zestawu SDK SPEECH i interfejsu wiersza polecenia Speech CLI. 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 adresy URL hosta w Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker.

W tym poradniku dowiesz się, jak używać Azure Speech w Foundry Tools do konwersji mowy na tekst w czasie rzeczywistym. Rozpoznawanie mowy w czasie rzeczywistym jest idealne dla aplikacji wymagających natychmiastowej transkrypcji, takich jak dyktowanie, pomoc w centrum obsługi telefonicznej i transkrypcja na żywo.

Aby dowiedzieć się, jak skonfigurować środowisko dla przykładowej aplikacji, zobacz Szybki start: rozpoznawanie i konwertowanie mowy na tekst.

Rozpoznawanie mowy z 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 jesteś gotowy, aby uruchomić narzędzie Speech CLI i rozpoznawać mowę z mikrofonu. W wierszu polecenia przejdź do katalogu zawierającego plik binarny interfejsu wiersza polecenia usługi Mowa. Następnie 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 z tabeli rozpoznawania mowy na tekst. 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 poleceń Speech CLI zatrzymuje się po okresie ciszy lub po naciśnięciu 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ą. A może jeśli chcesz szybki przykład, pobierz plik whatstheweatherlike.wav i skopiuj go do tego samego katalogu, co plik binarny Speech CLI.

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 Speech jest domyślnie w języku angielskim. Możesz wybrać inny język z tabeli zamiany mowy na tekst. Dodaj na przykład, --source de-DE aby rozpoznać mowę niemiecką.

Interfejs CLI dla Mowy przedstawia transkrypcję tekstu mowy na ekranie.

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają interfejsy API punktów końcowych zapytań, oparte na protokole WebSocket, które są dostępne za pośrednictwem zestawu SDK SPEECH i interfejsu wiersza polecenia Speech CLI. 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 adresy URL hosta w Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker.

Dokumentacja referencyjna | Pakiet (do pobrania) | Dodatkowe przykłady na GitHub

W tym poradniku dowiesz się, jak używać Azure Speech w Foundry Tools do konwersji mowy na tekst w czasie rzeczywistym. Rozpoznawanie mowy w czasie rzeczywistym jest idealne dla aplikacji wymagających natychmiastowej transkrypcji, takich jak dyktowanie, pomoc w centrum obsługi telefonicznej i transkrypcja na żywo.

Aby dowiedzieć się, jak skonfigurować środowisko dla przykładowej aplikacji, zobacz Szybki start: rozpoznawanie i konwertowanie mowy na tekst.

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:

• Rozpoznawanie mowy za pomocą Swift na macOS
• Rozpoznawanie mowy za pomocą Swift w systemie operacyjnym iOS

Aby uzyskać więcej informacji, zobacz referencje Speech SDK dla Objective-C.

Użyj 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: "YourSpeechResoureKey", region: "YourServiceRegion");
speechConfig.endpointId = "YourEndpointId";
let speechRecognizer = SPXSpeechRecognizer(speechConfiguration: speechConfig);

Uruchamianie i używanie kontenera

Kontenery mowy udostępniają interfejsy API punktów końcowych zapytań, oparte na protokole WebSocket, które są dostępne za pośrednictwem zestawu SDK SPEECH i interfejsu wiersza polecenia Speech CLI. 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 adresy URL hosta w Instalowanie i uruchamianie kontenerów usługi Mowa za pomocą platformy Docker.

Powiązana zawartość

• Wypróbuj mowę do tekstu — szybki start
• Zwiększanie dokładności rozpoznawania za pomocą mowy niestandardowej
• Użyj transkrypcji wsadowej
• Korzystanie z przetwarzania końcowego