Rozpoznávání řeči

  • Článek

Referenční dokumentace | – balíček (NuGet) | Další ukázky na GitHubu

V tomto návodu se naučíte rozpoznávat a přepisovat řeč na text v reálném čase.

Vytvoření konfigurace řeči

Pokud chcete službu Speech volat pomocí sady Speech SDK, musíte vytvořit SpeechConfig instanci. Tato třída obsahuje informace o vašem předplatném, jako je klíč a přidružené umístění/oblast, koncový bod, hostitel nebo autorizační token.

  1. Vytvořte SpeechConfig instanci pomocí klíče a umístění nebo oblasti.
  2. Na webu Azure Portal vytvořte prostředek služby Speech. Další informace najdete v tématu Vytvoření prostředku s více službami.
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");
    }
}

Inicializovat SpeechConfig můžete několika dalšími způsoby:

  • Použijte koncový bod a předejte koncový bod služby Speech. Klíč nebo autorizační token je volitelný.
  • Použijte hostitele a předejte adresu hostitele. Klíč nebo autorizační token je volitelný.
  • Použijte autorizační token s přidruženou oblastí nebo umístěním.

Poznámka:

Bez ohledu na to, jestli provádíte rozpoznávání řeči, syntézu řeči, překlad nebo rozpoznávání záměru, vždy vytvoříte konfiguraci.

Rozpoznávání řeči z mikrofonu

Pokud chcete rozpoznat řeč pomocí mikrofonu zařízení, vytvořte AudioConfig instanci pomocí FromDefaultMicrophoneInput() této metody. Pak inicializovat SpeechRecognizer objekt předáním speechConfig a 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);
    }
}

Pokud chcete použít konkrétní zvukové vstupní zařízení, musíte zadat ID zařízení v AudioConfig. Zjistěte , jak získat ID zařízení pro vaše zvukové vstupní zařízení.

Rozpoznávat řeč ze souboru

Pokud chcete rozpoznat řeč ze zvukového souboru místo mikrofonu, musíte vytvořit AudioConfig instanci. Ale pro tento případ nezavoláte FromDefaultMicrophoneInput(). Zavoláte FromWavFileInput() a předáte cestu k souboru:

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

Rozpoznávání řeči z datového proudu v paměti

V mnoha případech použití je pravděpodobné, že zvuková data pocházejí ze služby Azure Blob Storage nebo jsou už v paměti jako byte[] instance nebo podobná nezpracovaná datová struktura. Následující příklad používá PushAudioInputStream k rozpoznávání řeči, což je v podstatě abstraktní datový proud paměti. Ukázkový kód provede následující akce:

  • Zapisuje nezpracovaná zvuková data (PCM) PushAudioInputStream do Write() funkce, která přijímá byte[] instanci.
  • Načte soubor .wav pomocí FileReader demonstračních účelů. Pokud už máte zvuková data v byte[] instanci, můžete přeskočit přímo k zápisu obsahu do vstupního datového proudu.
  • Výchozí formát je 16bitový, 16KHz mono pulse-code modulation (PCM) data. Chcete-li přizpůsobit formát, můžete předat AudioStreamFormat objekt CreatePushStream() pomocí statické funkce AudioStreamFormat.GetWaveFormatPCM(sampleRate, (byte)bitRate, (byte)channels).
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);
    }
}

Při použití streamu push jako vstupu se předpokládá, že zvuková data jsou nezpracovaná PCM a přeskočí všechny hlavičky. Pokud se hlavička nepřeskočila, rozhraní API stále funguje v určitých případech. Pokud chcete dosáhnout nejlepších výsledků, zvažte implementaci logiky pro čtení hlaviček tak, aby byte[] začínala na začátku zvukových dat.

Zpracování chyb

Předchozí příklady získají z vlastnosti pouze rozpoznaný text result.Text . Pokud chcete zpracovat chyby a další odpovědi, musíte napsat kód, který bude zpracovávat výsledek. Následující kód vyhodnocuje result.Reason vlastnost a:

  • Vytiskne výsledek rozpoznávání: ResultReason.RecognizedSpeech.
  • Pokud se neshoda rozpoznávání nezobrazí, informuje uživatele: ResultReason.NoMatch.
  • Pokud dojde k chybě, vytiskne chybovou zprávu: 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;
}

Použití průběžného rozpoznávání

V předchozích příkladech se používá jednostřelové rozpoznávání, které rozpoznává jednu promluvu. Konec jedné promluvy je určen poslechem ticha na konci nebo až do zpracování maximálně 15 sekund zvuku.

Naproti tomu používáte průběžné rozpoznávání, když chcete řídit, kdy se má rozpoznávání ukončit. Vyžaduje, abyste se přihlásili k odběru Recognizinga CanceledRecognizedudálosti, abyste získali výsledky rozpoznávání. Chcete-li zastavit rozpoznávání, musíte zavolat StopContinuousRecognitionAsync. Tady je příklad toho, jak se provádí průběžné rozpoznávání u zvukového vstupního souboru.

Začněte definováním vstupu a inicializací SpeechRecognizer:

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

Pak vytvořte TaskCompletionSource<int> instanci pro správu stavu rozpoznávání řeči:

var stopRecognition = new TaskCompletionSource<int>();

Dále se přihlaste k odběru událostí, které SpeechRecognizer odesílají:

  • Recognizing: Signál pro události, které obsahují výsledky zprostředkujícího rozpoznávání.
  • Recognized: Signál pro události, které obsahují konečné výsledky rozpoznávání, což značí úspěšný pokus o rozpoznání.
  • SessionStopped: Signál pro události, které označují konec relace rozpoznávání (operace).
  • Canceled: Signál pro události, které obsahují zrušené výsledky rozpoznávání. Tyto výsledky označují pokus o rozpoznávání, který byl zrušen v důsledku žádosti o přímé zrušení. Případně značí selhání přenosu nebo protokolu.
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);
};

Když je všechno nastavené, zavolejte StartContinuousRecognitionAsync , abyste mohli začít rozpoznávat:

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

Změna zdrojového jazyka

Běžným úkolem rozpoznávání řeči je určení vstupního (nebo zdrojového) jazyka. Následující příklad ukazuje, jak změnit jazyk zadávání na italštinu. V kódu najděte instanci SpeechConfig a přidejte tento řádek přímo pod něj:

speechConfig.SpeechRecognitionLanguage = "it-IT";

Vlastnost SpeechRecognitionLanguage očekává řetězec formátu jazyka a národního prostředí. Další informace najdete v seznamu podporovaných národních prostředí řeči na text.

Identifikace jazyka

Identifikaci jazyka s řečí můžete použít k rozpoznávání textu, když potřebujete identifikovat jazyk ve zvukovém zdroji a pak ho přepsat na text.

Kompletní vzorový kód najdete v tématu Identifikace jazyka.

Použití vlastního koncového bodu

Pomocí vlastní řeči můžete nahrát vlastní data, otestovat a vytrénovat vlastní model, porovnat přesnost mezi modely a nasadit model do vlastního koncového bodu. Následující příklad ukazuje, jak nastavit vlastní koncový bod.

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

Spuštění a použití kontejneru

Kontejnery služby Speech poskytují rozhraní API koncových bodů dotazů založených na websocketu, ke kterým se přistupuje prostřednictvím sady Speech SDK a rozhraní příkazového řádku služby Speech. Sada Speech SDK a Rozhraní příkazového řádku služby Speech ve výchozím nastavení používají veřejnou službu Speech. Pokud chcete kontejner použít, musíte změnit inicializační metodu. Místo klíče a oblasti použijte adresu URL hostitele kontejneru.

Další informace o kontejnerech najdete v tématu Adresy URL hostitele v tématu Instalace a spouštění kontejnerů služby Speech pomocí Dockeru.

Změna způsobu zpracování ticha

Pokud se očekává, že uživatel bude mluvit rychleji nebo pomaleji než obvykle, nemusí výchozí chování nespeech ticho ve vstupním zvuku vést k tomu, co očekáváte. Mezi běžné problémy se zpracováním ticha patří:

  • Rychlé zřetězování mnoha vět do jednoho výsledku rozpoznávání místo rozdělení vět do jednotlivých výsledků.
  • Pomalé dělení částí jedné věty na několik výsledků
  • Rozpoznávání s jedním snímkem končí příliš rychle při čekání na zahájení řeči.

Tyto problémy je možné vyřešit nastavením jedné ze dvou vlastností časového limitu instance SpeechConfig použité k vytvoření SpeechRecognizer:

  • Časový limit ticha segmentace upravuje, kolik nespeech zvuku je povoleno v rámci fráze, která se právě mluví před tím, než se tato fráze považuje za hotovo.
    • Vyšší hodnoty obvykle zvětšují výsledky a umožňují delší pozastavení mluvčího ve frázi, ale jejich doručení trvá déle. Když nastavíte příliš vysokou hodnotu, můžou také zkombinovat samostatné fráze do jednoho výsledku.
    • Nižší hodnoty obecně zkracují výsledky a zajišťují větší výzvy a časté konce mezi frázemi, ale můžou také způsobit, že se jednotlivé fráze rozdělí do více výsledků, když nastavíte příliš nízkou hodnotu.
    • Tento časový limit lze nastavit na celočíselné hodnoty mezi 100 a 5 000 v milisekundách s 500 typickým výchozím nastavením.
  • Počáteční časový limit ticha upraví, kolik zvuku není povoleno před frází před pokusem o rozpoznávání skončí ve výsledku "žádná shoda".
    • Vyšší hodnoty poskytují mluvčím více času na reakci a zahájení mluvení, ale můžou také vést k pomalé odezvě, když se nic nemluví.
    • Nižší hodnoty zajišťují, že se výzva "neshoduje" pro rychlejší uživatelské prostředí a více řízené zpracování zvuku, ale může vypnout reproduktor příliš rychle, když je nastavena příliš nízká.
    • Vzhledem k tomu, že průběžné rozpoznávání generuje mnoho výsledků, tato hodnota určuje, jak často výsledky nedorazí "žádná shoda", ale jinak neovlivňuje obsah výsledků rozpoznávání.
    • Tento časový limit lze nastavit na libovolnou nezápornou celočíselnou hodnotu, v milisekundách nebo na hodnotu 0, která ji úplně zakáže. 5000 je typické výchozí nastavení pro rozpoznávání jedním snímkem, zatímco 15000 je typickým výchozím nastavením pro průběžné rozpoznávání.

Vzhledem k tomu, že při úpravě těchto časových limitů dochází k kompromisům, měli byste změnit nastavení pouze v případě, že máte problém související s zpracováním ticha. Výchozí hodnoty optimálně zpracovávají většinu mluveného zvuku a pouze neobvyklé scénáře by měly nastat problémy.

Příklad: Uživatelé, kteří mluví o sériovém čísle, jako je "ABC-123-4567", se mohou pozastavit mezi skupinami znaků dostatečně dlouho, aby bylo sériové číslo rozděleno do více výsledků. V takovém případě zkuste pro časový limit ticha segmentace použít vyšší hodnotu 2000 ms:

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

Příklad: Zaznamenaná řeč prezentujícího může být dostatečně rychlá, že se několik vět v řádku zkombinuje s velkými výsledky rozpoznávání pouze jednou nebo dvakrát za minutu. V tomto případě nastavte časový limit ticha segmentace na nižší hodnotu, například 300 ms:

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

Příklad: Rozpoznávání s jedním snímkem, které žádá mluvčího o vyhledání a čtení sériového čísla končí příliš rychle, když se číslo najde. V tomto případě zkuste delší počáteční časový limit ticha, jako je 10 000 ms:

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

Referenční dokumentace | – balíček (NuGet) | Další ukázky na GitHubu

V tomto návodu se naučíte rozpoznávat a přepisovat řeč na text v reálném čase.

Vytvoření konfigurace řeči

Pokud chcete volat službu Speech pomocí sady Speech SDK, musíte vytvořit SpeechConfig instanci. Tato třída obsahuje informace o vašem předplatném, jako je klíč a přidružené umístění/oblast, koncový bod, hostitel nebo autorizační token.

  1. Vytvořte SpeechConfig instanci pomocí klíče a oblasti.
  2. Na webu Azure Portal vytvořte prostředek služby Speech. Další informace najdete v tématu Vytvoření prostředku s více službami.
using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

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

Inicializovat SpeechConfig můžete několika dalšími způsoby:

  • Použijte koncový bod a předejte koncový bod služby Speech. Klíč nebo autorizační token je volitelný.
  • Použijte hostitele a předejte adresu hostitele. Klíč nebo autorizační token je volitelný.
  • Použijte autorizační token s přidruženou oblastí nebo umístěním.

Poznámka:

Bez ohledu na to, jestli provádíte rozpoznávání řeči, syntézu řeči, překlad nebo rozpoznávání záměru, vždy vytvoříte konfiguraci.

Rozpoznávání řeči z mikrofonu

Pokud chcete rozpoznat řeč pomocí mikrofonu zařízení, vytvořte AudioConfig instanci pomocí FromDefaultMicrophoneInput() členské funkce. Pak inicializovatSpeechRecognizer objekt předáním audioConfig a 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;

Pokud chcete použít konkrétní zvukové vstupní zařízení, musíte zadat ID zařízení v AudioConfig. Další informace o tom, jak získat ID zařízení pro zvukové vstupní zařízení, najdete v tématu Výběr zvukového vstupního zařízení pomocí sady Speech SDK.

Rozpoznávat řeč ze souboru

Pokud chcete rozpoznat řeč ze zvukového souboru místo použití mikrofonu, musíte vytvořit AudioConfig instanci. Ale pro tento případ nezavoláte FromDefaultMicrophoneInput(). Zavoláte FromWavFileInput() a předáte cestu k souboru:

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;

Rozpoznávání řeči pomocí třídy Recognizer

Třída Recognizer pro sadu Speech SDK pro jazyk C++ zveřejňuje několik metod, které můžete použít pro rozpoznávání řeči.

Rozpoznávání jedním snímkem

Jednostřelové rozpoznávání asynchronně rozpozná jednu promluvu. Konec jedné promluvy je určen poslechem ticha na konci nebo až do zpracování maximálně 15 sekund zvuku. Tady je příklad asynchronního jednostřelového rozpoznávání prostřednictvím RecognizeOnceAsync:

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

Potřebujete napsat kód pro zpracování výsledku. Tato ukázka se vyhodnotí result->Reason a:

  • Vytiskne výsledek rozpoznávání: ResultReason::RecognizedSpeech.
  • Pokud se neshoda rozpoznávání nezobrazí, informuje uživatele: ResultReason::NoMatch.
  • Pokud dojde k chybě, vytiskne chybovou zprávu: 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;
}

Průběžné rozpoznávání

Průběžné rozpoznávání je o něco více zapojené než rozpoznávání s jedním snímkem. Vyžaduje, abyste se přihlásili k odběru Recognizinga CanceledRecognizedudálosti, abyste získali výsledky rozpoznávání. Chcete-li zastavit rozpoznávání, musíte volat StopContinuousRecognitionAsync. Tady je příklad toho, jak se provádí průběžné rozpoznávání u zvukového vstupního souboru.

Začněte definováním vstupu a inicializací SpeechRecognizer:

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

Dále vytvořte proměnnou pro správu stavu rozpoznávání řeči. Deklarujte promise<void> , protože na začátku rozpoznávání můžete bezpečně předpokládat, že se nedokončí:

promise<void> recognitionEnd;

Dále se přihlaste k odběru událostí, které SpeechRecognizer odesílají:

  • Recognizing: Signál pro události, které obsahují výsledky zprostředkujícího rozpoznávání.
  • Recognized: Signál pro události, které obsahují konečné výsledky rozpoznávání, což značí úspěšný pokus o rozpoznání.
  • SessionStopped: Signál pro události, které označují konec relace rozpoznávání (operace).
  • Canceled: Signál pro události, které obsahují zrušené výsledky rozpoznávání. Tyto výsledky označují pokus o rozpoznávání, který byl zrušen v důsledku žádosti o přímé zrušení. Případně značí selhání přenosu nebo protokolu.
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.
    });

Když je všechno nastavené, zavolejte StopContinuousRecognitionAsync , abyste mohli začít rozpoznávat:

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

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

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

Změna zdrojového jazyka

Běžným úkolem rozpoznávání řeči je určení vstupního (nebo zdrojového) jazyka. Následující příklad ukazuje, jak změnit jazyk zadávání na němčinu. V kódu najděte instanci SpeechConfig a přidejte tento řádek přímo pod něj:

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

SetSpeechRecognitionLanguage je parametr, který jako argument přebírá řetězec. Další informace najdete v seznamu podporovaných národních prostředí řeči na text.

Identifikace jazyka

Identifikaci jazyka s řečí můžete použít k rozpoznávání textu, když potřebujete identifikovat jazyk ve zvukovém zdroji a pak ho přepsat na text.

Kompletní vzorový kód najdete v tématu Identifikace jazyka.

Použití vlastního koncového bodu

Pomocí vlastní řeči můžete nahrát vlastní data, otestovat a vytrénovat vlastní model, porovnat přesnost mezi modely a nasadit model do vlastního koncového bodu. Následující příklad ukazuje, jak nastavit vlastní koncový bod.

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

Spuštění a použití kontejneru

Kontejnery služby Speech poskytují rozhraní API koncových bodů dotazů založených na websocketu, ke kterým se přistupuje prostřednictvím sady Speech SDK a rozhraní příkazového řádku služby Speech. Sada Speech SDK a Rozhraní příkazového řádku služby Speech ve výchozím nastavení používají veřejnou službu Speech. Pokud chcete kontejner použít, musíte změnit inicializační metodu. Místo klíče a oblasti použijte adresu URL hostitele kontejneru.

Další informace o kontejnerech najdete v tématu Adresy URL hostitele v tématu Instalace a spouštění kontejnerů služby Speech pomocí Dockeru.

Referenční dokumentace | – balíček (Go) | Další ukázky na GitHubu

V tomto návodu se naučíte rozpoznávat a přepisovat řeč na text v reálném čase.

Rozpoznávání řeči na text z mikrofonu

Pomocí následující ukázky kódu spusťte rozpoznávání řeči z výchozího mikrofonu zařízení. Nahraďte proměnné subscription a region vaším klíčem řeči a umístěním/oblastí. Na webu Azure Portal vytvořte prostředek služby Speech. Další informace najdete v tématu Vytvoření prostředku s více službami. Spuštěním skriptu spustíte relaci rozpoznávání výchozího mikrofonu a výstupního textu:

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

Spuštěním následujících příkazů vytvořte soubor go.mod , který odkazuje na komponenty hostované na GitHubu:

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

Teď sestavte a spusťte kód:

go build
go run quickstart

Podrobné informace naleznete v referenčním obsahu pro SpeechConfig třídu a referenční obsah pro SpeechRecognizer třídu.

Rozpoznávání řeči na text ze zvukového souboru

Pomocí následující ukázky spusťte rozpoznávání řeči ze zvukového souboru. Nahraďte proměnné subscription a region vaším klíčem řeči a umístěním/oblastí. Na webu Azure Portal vytvořte prostředek služby Speech. Další informace najdete v tématu Vytvoření prostředku s více službami. Kromě toho nahraďte proměnnou file cestou k souboru .wav . Když skript spustíte, rozpozná řeč ze souboru a vypíše výsledek textu:

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

Spuštěním následujících příkazů vytvořte soubor go.mod , který odkazuje na komponenty hostované na GitHubu:

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

Teď sestavte a spusťte kód:

go build
go run quickstart

Podrobné informace naleznete v referenčním obsahu pro SpeechConfig třídu a referenční obsah pro SpeechRecognizer třídu.

Spuštění a použití kontejneru

Kontejnery služby Speech poskytují rozhraní API koncových bodů dotazů založených na websocketu, ke kterým se přistupuje prostřednictvím sady Speech SDK a rozhraní příkazového řádku služby Speech. Sada Speech SDK a Rozhraní příkazového řádku služby Speech ve výchozím nastavení používají veřejnou službu Speech. Pokud chcete kontejner použít, musíte změnit inicializační metodu. Místo klíče a oblasti použijte adresu URL hostitele kontejneru.

Další informace o kontejnerech najdete v tématu Adresy URL hostitele v tématu Instalace a spouštění kontejnerů služby Speech pomocí Dockeru.

Referenční dokumentace | Další ukázky na GitHubu

V tomto návodu se naučíte rozpoznávat a přepisovat řeč na text v reálném čase.

Vytvoření konfigurace řeči

Pokud chcete službu Speech volat pomocí sady Speech SDK, musíte vytvořit instanci SpeechConfig . Tato třída obsahuje informace o vašem předplatném, jako je klíč a přidružené umístění/oblast, koncový bod, hostitel nebo autorizační token.

  1. Vytvořte SpeechConfig instanci pomocí klíče a umístění nebo oblasti.
  2. Na webu Azure Portal vytvořte prostředek služby Speech. Další informace najdete v tématu Vytvoření prostředku s více službami.
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>");
    }
}

Inicializovat SpeechConfig můžete několika dalšími způsoby:

  • Použijte koncový bod a předejte koncový bod služby Speech. Klíč nebo autorizační token je volitelný.
  • Použijte hostitele a předejte adresu hostitele. Klíč nebo autorizační token je volitelný.
  • Použijte autorizační token s přidruženou oblastí nebo umístěním.

Poznámka:

Bez ohledu na to, jestli provádíte rozpoznávání řeči, syntézu řeči, překlad nebo rozpoznávání záměru, budete vždy vytvářet konfiguraci.

Rozpoznávání řeči z mikrofonu

Pokud chcete rozpoznat řeč pomocí mikrofonu zařízení, vytvořte AudioConfig instanci pomocí fromDefaultMicrophoneInput() této metody. Pak inicializovat SpeechRecognizer objekt předáním audioConfig a 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());
    }
}

Pokud chcete použít konkrétní zvukové vstupní zařízení, musíte zadat ID zařízení v AudioConfig. Další informace o tom, jak získat ID zařízení pro zvukové vstupní zařízení, najdete v tématu Výběr zvukového vstupního zařízení pomocí sady Speech SDK.

Rozpoznávat řeč ze souboru

Pokud chcete rozpoznat řeč ze zvukového souboru místo použití mikrofonu, musíte vytvořit AudioConfig instanci. Ale pro tento případ nezavoláte FromDefaultMicrophoneInput(). Zavoláte fromWavFileInput() a předáte cestu k souboru:

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

Zpracování chyb

Předchozí příklady získají rozpoznaný text pouze pomocí result.getText(). Pokud chcete zpracovat chyby a další odpovědi, musíte napsat kód, který bude zpracovávat výsledek. Následující příklad vyhodnocuje result.getReason() a:

  • Vytiskne výsledek rozpoznávání: ResultReason.RecognizedSpeech.
  • Pokud se neshoda rozpoznávání nezobrazí, informuje uživatele: ResultReason.NoMatch.
  • Pokud dojde k chybě, vytiskne chybovou zprávu: 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;
}

Použití průběžného rozpoznávání

V předchozích příkladech se používá jednostřelové rozpoznávání, které rozpoznává jednu promluvu. Konec jedné promluvy je určen poslechem ticha na konci nebo až do zpracování maximálně 15 sekund zvuku.

Naproti tomu používáte průběžné rozpoznávání, když chcete řídit, kdy se má rozpoznávání ukončit. Vyžaduje, abyste se přihlásili k odběru recognizinga canceledrecognizedudálosti, abyste získali výsledky rozpoznávání. Chcete-li zastavit rozpoznávání, musíte zavolat stopContinuousRecognitionAsync. Tady je příklad, jak můžete provádět nepřetržité rozpoznávání zvukového vstupního souboru.

Začněte definováním vstupu a inicializací SpeechRecognizer:

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

Dále vytvořte proměnnou pro správu stavu rozpoznávání řeči. Deklarujte Semaphore instanci v oboru třídy:

private static Semaphore stopTranslationWithFileSemaphore;

Dále se přihlaste k odběru událostí, které SpeechRecognizer odesílají:

  • recognizing: Signál pro události, které obsahují výsledky zprostředkujícího rozpoznávání.
  • recognized: Signál pro události, které obsahují konečné výsledky rozpoznávání, což značí úspěšný pokus o rozpoznání.
  • sessionStopped: Signál pro události, které označují konec relace rozpoznávání (operace).
  • canceled: Signál pro události, které obsahují zrušené výsledky rozpoznávání. Tyto výsledky označují pokus o rozpoznávání, který byl zrušen v důsledku žádosti o přímé zrušení. Případně značí selhání přenosu nebo protokolu.
// 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();
});

Když je všechno nastavené, zavolejte startContinuousRecognitionAsync , abyste mohli začít rozpoznávat:

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

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

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

Změna zdrojového jazyka

Běžným úkolem rozpoznávání řeči je určení vstupního (nebo zdrojového) jazyka. Následující příklad ukazuje, jak změnit jazyk zadávání na francouzštinu. V kódu najděte instanci SpeechConfig a přidejte tento řádek přímo pod něj:

config.setSpeechRecognitionLanguage("fr-FR");

setSpeechRecognitionLanguage je parametr, který jako argument přebírá řetězec. Projděte si seznam podporovaných řečí na národní prostředí textu.

Identifikace jazyka

Identifikaci jazyka s řečí můžete použít k rozpoznávání textu, když potřebujete identifikovat jazyk ve zvukovém zdroji a pak ho přepsat na text.

Kompletní vzorový kód najdete v tématu Identifikace jazyka.

Použití vlastního koncového bodu

Pomocí vlastní řeči můžete nahrát vlastní data, otestovat a vytrénovat vlastní model, porovnat přesnost mezi modely a nasadit model do vlastního koncového bodu. Následující příklad ukazuje, jak nastavit vlastní koncový bod:

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

Spuštění a použití kontejneru

Kontejnery služby Speech poskytují rozhraní API koncových bodů dotazů založených na websocketu, ke kterým se přistupuje prostřednictvím sady Speech SDK a rozhraní příkazového řádku služby Speech. Sada Speech SDK a Rozhraní příkazového řádku služby Speech ve výchozím nastavení používají veřejnou službu Speech. Pokud chcete kontejner použít, musíte změnit inicializační metodu. Místo klíče a oblasti použijte adresu URL hostitele kontejneru.

Další informace o kontejnerech najdete v tématu Adresy URL hostitele v tématu Instalace a spouštění kontejnerů služby Speech pomocí Dockeru.

Referenční dokumentace | Balíček (npm) | Další ukázky zdrojového kódu knihovny GitHub |

V tomto návodu se naučíte rozpoznávat a přepisovat řeč na text v reálném čase.

Vytvoření konfigurace řeči

Pokud chcete službu Speech volat pomocí sady Speech SDK, musíte vytvořit SpeechConfig instanci. Tato třída obsahuje informace o vašem předplatném, jako je klíč a přidružené umístění/oblast, koncový bod, hostitel nebo autorizační token.

  1. Vytvořte SpeechConfig instanci pomocí klíče a umístění nebo oblasti.
  2. Na webu Azure Portal vytvořte prostředek služby Speech. Další informace najdete v tématu Vytvoření prostředku s více službami.
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

Inicializovat SpeechConfig můžete několika dalšími způsoby:

  • Použijte koncový bod a předejte koncový bod služby Speech. Klíč nebo autorizační token je volitelný.
  • Použijte hostitele a předejte adresu hostitele. Klíč nebo autorizační token je volitelný.
  • Použijte autorizační token s přidruženou oblastí nebo umístěním.

Poznámka:

Bez ohledu na to, jestli provádíte rozpoznávání řeči, syntézu řeči, překlad nebo rozpoznávání záměru, vždy vytvoříte konfiguraci.

Rozpoznávání řeči z mikrofonu

Rozpoznávání řeči z mikrofonu není v Node.js podporované. Podporuje se jenom v prostředí JavaScriptu založeném na prohlížeči. Další informace najdete v ukázce Reactu a implementaci řeči na text z mikrofonu na GitHubu. Ukázka Reactu ukazuje vzory návrhu pro výměnu a správu ověřovacích tokenů. Zobrazuje také zachytávání zvuku z mikrofonu nebo souboru pro převod řeči na text.

Poznámka:

Pokud chcete použít konkrétní zvukové vstupní zařízení, musíte v objektu AudioConfig zadat ID zařízení. Další informace najdete v tématu Výběr zvukového vstupního zařízení pomocí sady Speech SDK.

Rozpoznávat řeč ze souboru

Pokud chcete rozpoznat řeč ze zvukového souboru, vytvořte AudioConfig instanci pomocí fromWavFileInput() metody, která přijímá Buffer objekt. Pak inicializovat SpeechRecognizer předáním audioConfig a 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();

Rozpoznávání řeči z datového proudu v paměti

V mnoha případech použití vaše zvuková data pravděpodobně pocházejí ze služby Azure Blob Storage. Nebo je už v paměti jako ArrayBuffer nebo podobná nezpracovaná datová struktura. Následující kód:

  • Vytvoří stream nabízených oznámení pomocí .createPushStream()
  • Načte soubor .wav pomocí fs.createReadStream demonstračních účelů. Pokud už máte zvuková data, ArrayBuffermůžete přeskočit přímo k zápisu obsahu do vstupního datového proudu.
  • Vytvoří konfiguraci zvuku pomocí streamu nabízených oznámení.
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();

Při použití streamu push jako vstupu se předpokládá, že zvuková data jsou nezpracovaná data pcm (pulse-code modulation), která přeskočí všechny hlavičky. Pokud se hlavička nepřeskočila, rozhraní API stále funguje v určitých případech. Pokud chcete dosáhnout nejlepších výsledků, zvažte implementaci logiky pro čtení hlaviček tak, aby fs začínala na začátku zvukových dat.

Zpracování chyb

Předchozí příklady získají z vlastnosti pouze rozpoznaný text result.text . Pokud chcete zpracovat chyby a další odpovědi, musíte napsat kód, který bude zpracovávat výsledek. Následující kód vyhodnocuje result.reason vlastnost a:

  • Vytiskne výsledek rozpoznávání: ResultReason.RecognizedSpeech.
  • Pokud se neshoda rozpoznávání nezobrazí, informuje uživatele: ResultReason.NoMatch.
  • Pokud dojde k chybě, vytiskne chybovou zprávu: 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;
    }

Použití průběžného rozpoznávání

V předchozích příkladech se používá jednostřelové rozpoznávání, které rozpoznává jednu promluvu. Konec jedné promluvy je určen poslechem ticha na konci nebo až do zpracování maximálně 15 sekund zvuku.

Naproti tomu můžete použít průběžné rozpoznávání, když chcete řídit, kdy se má rozpoznávání ukončit. Vyžaduje, abyste se přihlásili k odběru Recognizinga CanceledRecognizedudálosti, abyste získali výsledky rozpoznávání. Chcete-li zastavit rozpoznávání, musíte zavolat stopContinuousRecognitionAsync. Tady je příklad toho, jak se provádí průběžné rozpoznávání u zvukového vstupního souboru.

Začněte definováním vstupu a inicializací SpeechRecognizer:

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

Dále se přihlaste k odběru událostí odeslaných z SpeechRecognizer:

  • recognizing: Signál pro události, které obsahují výsledky zprostředkujícího rozpoznávání.
  • recognized: Signál pro události, které obsahují konečné výsledky rozpoznávání, což značí úspěšný pokus o rozpoznání.
  • sessionStopped: Signál pro události, které označují konec relace rozpoznávání (operace).
  • canceled: Signál pro události, které obsahují zrušené výsledky rozpoznávání. Tyto výsledky označují pokus o rozpoznávání, který byl zrušen v důsledku žádosti o přímé zrušení. Případně značí selhání přenosu nebo protokolu.
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();
};

Když je všechno nastavené, zavolejte startContinuousRecognitionAsync , abyste mohli začít rozpoznávat:

speechRecognizer.startContinuousRecognitionAsync();

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

Změna zdrojového jazyka

Běžným úkolem rozpoznávání řeči je určení vstupního (nebo zdrojového) jazyka. Následující příklad ukazuje, jak změnit jazyk zadávání na italštinu. V kódu najděte instanci SpeechConfig a přidejte tento řádek přímo pod něj:

speechConfig.speechRecognitionLanguage = "it-IT";

Vlastnost speechRecognitionLanguage očekává řetězec formátu jazyka a národního prostředí. Další informace najdete v seznamu podporovaných národních prostředí řeči na text.

Identifikace jazyka

Identifikaci jazyka s řečí můžete použít k rozpoznávání textu, když potřebujete identifikovat jazyk ve zvukovém zdroji a pak ho přepsat na text.

Kompletní vzorový kód najdete v tématu Identifikace jazyka.

Použití vlastního koncového bodu

Pomocí vlastní řeči můžete nahrát vlastní data, otestovat a vytrénovat vlastní model, porovnat přesnost mezi modely a nasadit model do vlastního koncového bodu. Následující příklad ukazuje, jak nastavit vlastní koncový bod.

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

Spuštění a použití kontejneru

Kontejnery služby Speech poskytují rozhraní API koncových bodů dotazů založených na websocketu, ke kterým se přistupuje prostřednictvím sady Speech SDK a rozhraní příkazového řádku služby Speech. Sada Speech SDK a Rozhraní příkazového řádku služby Speech ve výchozím nastavení používají veřejnou službu Speech. Pokud chcete kontejner použít, musíte změnit inicializační metodu. Místo klíče a oblasti použijte adresu URL hostitele kontejneru.

Další informace o kontejnerech najdete v tématu Adresy URL hostitele v tématu Instalace a spouštění kontejnerů služby Speech pomocí Dockeru.

Referenční dokumentace | Balíček (stáhnout) | Další ukázky na GitHubu

V tomto návodu se naučíte rozpoznávat a přepisovat řeč na text v reálném čase.

Instalace sady Speech SDK a ukázek

Úložiště Azure-Samples/cognitive-services-speech-sdk obsahuje ukázky napsané v Objective-C pro iOS a Mac. Výběrem odkazu zobrazíte pokyny k instalaci jednotlivých ukázek:

Další informace najdete v referenční dokumentaci k sadě Speech SDK pro Objective-C.

Použití vlastního koncového bodu

Pomocí vlastní řeči můžete nahrát vlastní data, otestovat a vytrénovat vlastní model, porovnat přesnost mezi modely a nasadit model do vlastního koncového bodu. Následující příklad ukazuje, jak nastavit vlastní koncový bod:

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

Spuštění a použití kontejneru

Kontejnery služby Speech poskytují rozhraní API koncových bodů dotazů založených na websocketu, ke kterým se přistupuje prostřednictvím sady Speech SDK a rozhraní příkazového řádku služby Speech. Sada Speech SDK a Rozhraní příkazového řádku služby Speech ve výchozím nastavení používají veřejnou službu Speech. Pokud chcete kontejner použít, musíte změnit inicializační metodu. Místo klíče a oblasti použijte adresu URL hostitele kontejneru.

Další informace o kontejnerech najdete v tématu Adresy URL hostitele v tématu Instalace a spouštění kontejnerů služby Speech pomocí Dockeru.

Referenční dokumentace | Balíček (stáhnout) | Další ukázky na GitHubu

V tomto návodu se naučíte rozpoznávat a přepisovat řeč na text v reálném čase.

Instalace sady Speech SDK a ukázek

Úložiště Azure-Samples/cognitive-services-speech-sdk obsahuje ukázky napsané ve Swiftu pro iOS a Mac. Výběrem odkazu zobrazíte pokyny k instalaci jednotlivých ukázek:

Další informace najdete v referenčních informacích k sadě Speech SDK pro Swift.

Použití vlastního koncového bodu

Pomocí vlastní řeči můžete nahrát vlastní data, otestovat a vytrénovat vlastní model, porovnat přesnost mezi modely a nasadit model do vlastního koncového bodu. Následující příklad ukazuje, jak nastavit vlastní koncový bod:

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

Spuštění a použití kontejneru

Kontejnery služby Speech poskytují rozhraní API koncových bodů dotazů založených na websocketu, ke kterým se přistupuje prostřednictvím sady Speech SDK a rozhraní příkazového řádku služby Speech. Sada Speech SDK a Rozhraní příkazového řádku služby Speech ve výchozím nastavení používají veřejnou službu Speech. Pokud chcete kontejner použít, musíte změnit inicializační metodu. Místo klíče a oblasti použijte adresu URL hostitele kontejneru.

Další informace o kontejnerech najdete v tématu Adresy URL hostitele v tématu Instalace a spouštění kontejnerů služby Speech pomocí Dockeru.

Referenční dokumentace | – balíček (PyPi) | Další ukázky na GitHubu

V tomto návodu se naučíte rozpoznávat a přepisovat řeč na text v reálném čase.

Vytvoření konfigurace řeči

Pokud chcete službu Speech volat pomocí sady Speech SDK, musíte vytvořit SpeechConfig instanci. Tato třída obsahuje informace o vašem předplatném, jako je klíč řeči a přidružené umístění/oblast, koncový bod, hostitel nebo autorizační token.

  1. Vytvořte SpeechConfig instanci pomocí svého klíče řeči a umístění nebo oblasti.
  2. Na webu Azure Portal vytvořte prostředek služby Speech. Další informace najdete v tématu Vytvoření prostředku s více službami.
speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")

Inicializovat SpeechConfig můžete několika dalšími způsoby:

  • Použijte koncový bod a předejte koncový bod služby Speech. Klíč řeči nebo autorizační token je volitelný.
  • Použijte hostitele a předejte adresu hostitele. Klíč řeči nebo autorizační token je volitelný.
  • Použijte autorizační token s přidruženou oblastí nebo umístěním.

Poznámka:

Bez ohledu na to, jestli provádíte rozpoznávání řeči, syntézu řeči, překlad nebo rozpoznávání záměru, vždy vytvoříte konfiguraci.

Rozpoznávání řeči z mikrofonu

Pokud chcete rozpoznat řeč pomocí mikrofonu SpeechRecognizer zařízení, vytvořte instanci bez předání AudioConfiga pak předejte 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()

Pokud chcete použít konkrétní zvukové vstupní zařízení, musíte zadat ID zařízení a AudioConfigpředat ho do parametru SpeechRecognizer konstruktoru audio_config . Další informace o tom, jak získat ID zařízení pro zvukové vstupní zařízení, najdete v tématu Výběr zvukového vstupního zařízení pomocí sady Speech SDK.

Rozpoznávat řeč ze souboru

Pokud chcete rozpoznat řeč ze zvukového souboru místo použití mikrofonu, vytvořte AudioConfig instanci a použijte filename parametr:

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

Zpracování chyb

Předchozí příklady získají z vlastnosti pouze rozpoznaný text result.text . Pokud chcete zpracovat chyby a další odpovědi, musíte napsat kód, který bude zpracovávat výsledek. Následující kód vyhodnocuje result.reason vlastnost a:

  • Vytiskne výsledek rozpoznávání: speechsdk.ResultReason.RecognizedSpeech.
  • Pokud se neshoda rozpoznávání nezobrazí, informuje uživatele: speechsdk.ResultReason.NoMatch.
  • Pokud dojde k chybě, vytiskne chybovou zprávu: 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?")

Použití průběžného rozpoznávání

V předchozích příkladech se používá jednostřelové rozpoznávání, které rozpoznává jednu promluvu. Konec jedné promluvy je určen poslechem ticha na konci nebo až do zpracování maximálně 15 sekund zvuku.

Naproti tomu používáte průběžné rozpoznávání, když chcete řídit, kdy se má rozpoznávání ukončit. Vyžaduje, abyste se připojili, abyste EventSignal získali výsledky rozpoznávání. Pokud chcete rozpoznávání zastavit, musíte zavolat stop_continuous_recognition() nebo stop_continuous_recognition(). Tady je příklad toho, jak se provádí průběžné rozpoznávání u zvukového vstupního souboru.

Začněte definováním vstupu a inicializací SpeechRecognizer:

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

Dále vytvořte proměnnou pro správu stavu rozpoznávání řeči. Nastavte proměnnou na proto, že False na začátku rozpoznávání můžete bezpečně předpokládat, že není dokončená:

done = False

Teď vytvořte zpětné volání, které zastaví průběžné rozpoznávání při evt přijetí. Mějte na paměti tyto body:

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

Následující ukázka kódu ukazuje, jak připojit zpětná volání k událostem odesílaných z SpeechRecognizer. Tyto události jsou:

  • recognizing: Signál pro události, které obsahují výsledky zprostředkujícího rozpoznávání.
  • recognized: Signál pro události, které obsahují konečné výsledky rozpoznávání, což značí úspěšný pokus o rozpoznání.
  • session_started: Signál pro události, které označují začátek relace rozpoznávání (operace).
  • session_stopped: Signál pro události, které označují konec relace rozpoznávání (operace).
  • canceled: Signál pro události, které obsahují zrušené výsledky rozpoznávání. Tyto výsledky označují pokus o rozpoznávání, který byl zrušen v důsledku žádosti o přímé zrušení. Případně značí selhání přenosu nebo protokolu.
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)

Se vším nastaveným můžete zavolat start_continuous_recognition():

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

Změna zdrojového jazyka

Běžným úkolem rozpoznávání řeči je určení vstupního (nebo zdrojového) jazyka. Následující příklad ukazuje, jak změnit jazyk zadávání na němčinu. V kódu najděte instanci SpeechConfig a přidejte tento řádek přímo pod něj:

speech_config.speech_recognition_language="de-DE"

speech_recognition_language je parametr, který jako argument přebírá řetězec. Další informace najdete v seznamu podporovaných národních prostředí řeči na text.

Identifikace jazyka

Identifikaci jazyka pomocí funkce Speech můžete použít k rozpoznávání textu, když potřebujete identifikovat jazyk ve zvukovém zdroji a pak ho přepsat na text.

Kompletní vzorový kód najdete v tématu Identifikace jazyka.

Použití vlastního koncového bodu

Pomocí vlastní řeči můžete nahrát vlastní data, otestovat a vytrénovat vlastní model, porovnat přesnost mezi modely a nasadit model do vlastního koncového bodu. Následující příklad ukazuje, jak nastavit vlastní koncový bod.

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

Spuštění a použití kontejneru

Kontejnery služby Speech poskytují rozhraní API koncových bodů dotazů založených na websocketu, ke kterým se přistupuje prostřednictvím sady Speech SDK a rozhraní příkazového řádku služby Speech. Sada Speech SDK a Rozhraní příkazového řádku služby Speech ve výchozím nastavení používají veřejnou službu Speech. Pokud chcete kontejner použít, musíte změnit inicializační metodu. Místo klíče a oblasti použijte adresu URL hostitele kontejneru.

Další informace o kontejnerech najdete v tématu Adresy URL hostitele v tématu Instalace a spouštění kontejnerů služby Speech pomocí Dockeru.

Speech to text REST API reference | Speech to text REST API for short audio reference | Additional Samples on GitHub

V tomto návodu se naučíte rozpoznávat a přepisovat řeč na text v reálném čase.

Převod řeči na text

Na příkazovém řádku spusťte následující příkaz. Do příkazu vložte následující hodnoty:

  • Klíč předplatného pro službu Speech.
  • Vaše oblast služby Speech.
  • Cesta pro vstupní zvukové soubory. Zvukové soubory můžete generovat pomocí textu na řeč.
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'

Měla by se zobrazit odpověď s textem JSON, jako je následující příklad:

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

Další informace najdete v referenčních informacích k rozhraní REST API pro převod řeči na text.

V tomto návodu se naučíte rozpoznávat a přepisovat řeč na text v reálném čase.

Rozpoznávání řeči z mikrofonu

Připojte a zapněte mikrofon počítače. Vypněte všechny aplikace, které můžou používat mikrofon. Některé počítače mají vestavěný mikrofon, zatímco jiné vyžadují konfiguraci zařízení Bluetooth.

Teď jste připraveni spustit rozhraní příkazového řádku pro rozpoznávání řeči z mikrofonu. Z příkazového řádku přejděte do adresáře, který obsahuje binární soubor Rozhraní příkazového řádku služby Speech. Pak spusťte následující příkaz:

spx recognize --microphone

Poznámka:

Rozhraní příkazového řádku služby Speech se standardně nastaví na angličtinu. Můžete zvolit jiný jazyk než řeč na textovou tabulku. Přidejte například --source de-DE rozpoznávání německé řeči.

Mluvte do mikrofonu a můžete vidět přepis slov do textu v reálném čase. Rozhraní příkazového řádku služby Speech se zastaví po určité době ticha nebo po výběru kombinace kláves Ctrl+C.

Rozpoznávat řeč ze souboru

Rozhraní příkazového řádku služby Speech dokáže rozpoznat řeč v mnoha formátech souborů a přirozených jazycích. V tomto příkladu můžete použít libovolný soubor .wav (16 KHz nebo 8 KHz, 16bitový a mono PCM), který obsahuje anglickou řeč. Nebo pokud chcete rychlou ukázku, stáhněte si soubor whatstheweatherlike.wav a zkopírujte ho do stejného adresáře jako binární soubor Rozhraní příkazového řádku služby Speech.

Pomocí následujícího příkazu spusťte rozhraní příkazového řádku služby Speech k rozpoznávání řeči nalezené ve zvukovém souboru:

spx recognize --file whatstheweatherlike.wav

Poznámka:

Rozhraní příkazového řádku služby Speech se standardně nastaví na angličtinu. Můžete zvolit jiný jazyk než řeč na textovou tabulku. Přidejte například --source de-DE rozpoznávání německé řeči.

Rozhraní příkazového řádku služby Speech zobrazuje přepis řeči na obrazovce.

Spuštění a použití kontejneru

Kontejnery služby Speech poskytují rozhraní API koncových bodů dotazů založených na websocketu, ke kterým se přistupuje prostřednictvím sady Speech SDK a rozhraní příkazového řádku služby Speech. Sada Speech SDK a Rozhraní příkazového řádku služby Speech ve výchozím nastavení používají veřejnou službu Speech. Pokud chcete kontejner použít, musíte změnit inicializační metodu. Místo klíče a oblasti použijte adresu URL hostitele kontejneru.

Další informace o kontejnerech najdete v tématu Adresy URL hostitele v tématu Instalace a spouštění kontejnerů služby Speech pomocí Dockeru.

Další kroky