Beszéd felismerése

  • Cikk

Referenciadokumentáció-csomag (NuGet) | További minták a GitHubon |

Ebben az útmutatóban megtudhatja, hogyan ismerheti fel és írhatja át a beszédet a szövegre valós időben.

Beszédkonfiguráció létrehozása

Ahhoz, hogy meghívja a Speech szolgáltatást a Speech SDK használatával, létre kell hoznia egy példányt SpeechConfig . Ez az osztály az előfizetéssel kapcsolatos információkat tartalmazza, például a kulcsot és a társított helyet/régiót, végpontot, gazdagépet vagy engedélyezési jogkivonatot.

  1. Hozzon létre egy példányt SpeechConfig a kulcs és a hely/régió használatával.
  2. Speech-erőforrás létrehozása az Azure Portalon. További információ: Többszolgáltatásos erőforrás létrehozása.
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");
    }
}

Inicializálhat SpeechConfig néhány más módon is:

  • Használjon végpontot, és adjon át egy Speech szolgáltatásvégpontot. A kulcs vagy az engedélyezési jogkivonat megadása nem kötelező.
  • Használjon gazdagépet, és adjon meg egy gazdagépcímet. A kulcs vagy az engedélyezési jogkivonat megadása nem kötelező.
  • Használjon engedélyezési jogkivonatot a társított régióhoz/helyhez.

Feljegyzés

Függetlenül attól, hogy beszédfelismerést, beszédszintézist, fordítást vagy szándékfelismerést végez, mindig létrehoz egy konfigurációt.

Beszéd felismerése mikrofonból

Ha az eszköz mikrofonjának használatával szeretné felismerni a beszédet, hozzon létre egy példányt AudioConfig a FromDefaultMicrophoneInput() módszerrel. Ezután inicializálja az objektumot a SpeechRecognizer továbbítással és audioConfiga speechConfig .

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

Ha egy adott hangbemeneti eszközt szeretne használni, meg kell adnia az eszköz azonosítóját a következőben AudioConfig: . Megtudhatja , hogyan szerezheti be a hangbemeneti eszköz eszközazonosítóját .

Beszédfelismerés végrehajtása fájlból

Ha mikrofon helyett hangfájlból szeretné felismerni a beszédet, akkor is létre kell hoznia egy példányt AudioConfig . De ebben az esetben nem hív.FromDefaultMicrophoneInput() Meghívja FromWavFileInput() és átadja a fájl elérési útját:

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

Beszéd felismerése memórián belüli streamből

Sok használati esetben valószínű, hogy a hangadatok az Azure Blob Storage-ból származnak, vagy más módon már a memóriában, mint egy byte[] példány vagy egy hasonló nyers adatstruktúra. Az alábbi példa a beszéd felismerésére használ PushAudioInputStream , amely lényegében egy absztrakt memóriafolyam. A mintakód a következő műveleteket hajtja végre:

  • Nyers hangadatokat (PCM) PushAudioInputStream ír a függvény használatával, amely elfogadja a Write() példányt byte[] .
  • Beolvas egy .wav fájlt FileReader bemutató célokra. Ha már rendelkezik hangadatokkal egy byte[] példányban, közvetlenül átugorhatja a tartalmat a bemeneti adatfolyamba.
  • Az alapértelmezett formátum a 16 bites, 16 KHz-es mono pulse-code modulation (PCM) adatok. A formátum testreszabásához a statikus függvény AudioStreamFormat.GetWaveFormatPCM(sampleRate, (byte)bitRate, (byte)channels)használatával továbbíthat egy AudioStreamFormat objektumotCreatePushStream().
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);
    }
}

A leküldéses stream bemenetként való használata feltételezi, hogy a hangadatok nyers PCM-nek minősülnek, és kihagyják a fejléceket. Az API bizonyos esetekben továbbra is működik, ha a fejléc nem lett kihagyva. A legjobb eredmény érdekében fontolja meg a logika implementálását a fejlécek leolvasásához, hogy byte[] a hangadatok elején kezdődjön.

Hibakezelés

Az előző példák csak a felismert szöveget kapják meg a result.Text tulajdonságból. A hibák és egyéb válaszok kezeléséhez meg kell írnia néhány kódot az eredmény kezeléséhez. A következő kód kiértékeli a result.Reason tulajdonságot, és:

  • A felismerési eredmény nyomtatása: ResultReason.RecognizedSpeech.
  • Ha nincs felismerési egyezés, tájékoztatja a felhasználót: ResultReason.NoMatch.
  • Hiba esetén a következő hibaüzenet jelenik meg: 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;
}

Folyamatos felismerés használata

Az előző példák egyetlen lövéses felismerést használnak, amely egyetlen kimondott szöveget ismer fel. Egyetlen kimondott szöveg végét a csend hallgatása határozza meg a végén, vagy legfeljebb 15 másodpercnyi hang feldolgozásáig.

Ezzel szemben folyamatos felismerést használ, amikor azt szeretné szabályozni, hogy mikor hagyja abba a felismerést. A felismerési eredmények eléréséhez elő kell fizetnie a Recognizing, Recognizedés Canceled az eseményekre. A felismerés leállításához meg kell hívnia StopContinuousRecognitionAsync. Íme egy példa arra, hogyan történik a folyamatos felismerés egy hangbemeneti fájlon.

Először adja meg a bemenetet és inicializálja a következőt SpeechRecognizer:

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

Ezután hozzon létre egy példányt TaskCompletionSource<int> a beszédfelismerés állapotának kezeléséhez:

var stopRecognition = new TaskCompletionSource<int>();

Ezután iratkozzon fel az alábbi eseményekre SpeechRecognizer :

  • Recognizing: Köztes felismerési eredményeket tartalmazó események jelzése.
  • Recognized: A végleges felismerési eredményeket tartalmazó események jelzése, amelyek sikeres felismerési kísérletet jeleznek.
  • SessionStopped: A felismerési munkamenet (művelet) végét jelző események jelzése.
  • Canceled: A megszakított felismerési eredményeket tartalmazó események jelzése. Ezek az eredmények egy olyan felismerési kísérletet jeleznek, amelyet egy közvetlen lemondási kérés eredményeként töröltek. Másik lehetőségként átviteli vagy protokollhibát jeleznek.
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);
};

Ha minden be van állítva, hívja StartContinuousRecognitionAsync meg, hogy kezdje el felismerni:

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

A forrásnyelv módosítása

A beszédfelismerés gyakori feladata a bemeneti (vagy forrásnyelvi) nyelv megadása. Az alábbi példa bemutatja, hogyan módosíthatja a bemeneti nyelvet olaszra. Keresse meg a példányt a SpeechConfig kódban, és adja hozzá közvetlenül alatta ezt a sort:

speechConfig.SpeechRecognitionLanguage = "it-IT";

A SpeechRecognitionLanguage tulajdonság nyelvi területi formázási sztringet vár. További információkért tekintse meg a támogatott beszédfelismerési területi beállítások listáját.

Nyelvi azonosítás

A nyelvazonosítást beszéddel szövegfelismerésre használhatja, ha egy hangforrásban azonosítania kell a nyelvet, majd szöveggé kell átírnia.

A teljes kódmintát a Nyelvazonosítás című témakörben talál.

Egyéni végpont használata

Az egyéni beszéddel feltöltheti a saját adatait, tesztelheti és betanítheti az egyéni modelleket, összehasonlíthatja a modellek közötti pontosságot, és üzembe helyezhet egy modellt egy egyéni végponton. Az alábbi példa bemutatja, hogyan állíthat be egyéni végpontot.

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

Tároló futtatása és használata

A Speech-tárolók websocket-alapú lekérdezésvégpont API-kat biztosítanak, amelyek a Speech SDK-n és a Speech CLI-n keresztül érhetők el. Alapértelmezés szerint a Speech SDK és a Speech CLI a nyilvános Speech szolgáltatást használja. A tároló használatához módosítania kell az inicializálási módszert. Kulcs és régió helyett használjon tároló gazdagép URL-címét.

A tárolókról további információt a Speech-tárolók telepítése és futtatása a Dockerrel című témakörben talál.

A csend kezelésének módosítása

Ha egy felhasználónak a szokásosnál gyorsabban vagy lassabban kell beszélnie, előfordulhat, hogy a bemeneti hang nem beszédcsendjének alapértelmezett viselkedése nem azt eredményezi, amit vár. A csendkezeléssel kapcsolatos gyakori problémák a következők:

  • A gyors beszéd számos mondatot egyetlen felismerési eredménybe láncolódva, ahelyett, hogy a mondatokat különálló eredményekre törné.
  • A lassú beszéd egyetlen mondat részeit több eredményre osztva.
  • Egy egylövetű felismerés túl gyorsan véget ér, miközben a beszéd kezdetére vár.

Ezek a problémák a következők létrehozásához SpeechRecognizerhasznált példány két időtúllépési SpeechConfig tulajdonságának egyikének beállításával oldhatók meg:

  • A szegmentálási csend időtúllépése módosítja, hogy mennyi nem beszélő hang legyen engedélyezve egy olyan kifejezésen belül, amelyet a kifejezés "késznek" tekint.
    • A magasabb értékek általában hosszabb eredményeket eredményeznek, és hosszabb szüneteket tesznek lehetővé a beszélőtől egy kifejezésen belül, de az eredmények elérése hosszabb időt vesz igénybe. Külön kifejezéseket is összefűzhetnek egyetlen eredményben, ha túl magasak.
    • Az alacsonyabb értékek általában rövidebbé teszik az eredményeket, és több gyors és gyakori törést biztosítanak a kifejezések között, de az is okozhatja, hogy az egyes kifejezések több találatra bonthatók, ha túl alacsonyak.
    • Ez az időtúllépés 100 és 5000 közötti egész számra állítható be ezredmásodpercben, és az alapértelmezett érték 500.
  • A kezdeti csend időtúllépése módosítja, hogy mennyi nem beszélő hang legyen engedélyezve egy kifejezés előtt , mielőtt a felismerési kísérlet "nincs egyezés" eredményre végződik.
    • A magasabb értékek több időt adnak a beszélőknek a reagálásra és a beszéd megkezdésére, de lassú válaszkészséget is eredményezhetnek, ha semmit nem beszélnek.
    • Az alacsonyabb értékek biztosítják a "nincs egyezés" parancsot a gyorsabb felhasználói élmény és a szabályozottabb hangkezelés érdekében, de túl gyorsan kikapcsolhatja a hangszórót, ha túl alacsony a beállítás.
    • Mivel a folyamatos felismerés sok eredményt hoz létre, ez az érték határozza meg, hogy milyen gyakran érkeznek a "nem egyező" eredmények, de más módon nem befolyásolja a felismerési eredmények tartalmát.
    • Ez az időtúllépés bármilyen nem negatív egész számra állítható be ezredmásodpercben, vagy 0 értékre, hogy teljes mértékben letiltsa azt. Az 5000 az egylövetű felismerés tipikus alapértelmezett értéke, míg a folyamatos felismeréshez az 15000 az alapértelmezett alapértelmezett érték.

Mivel az időtúllépések módosításakor kompromisszumok vannak, csak akkor módosítsa a beállításokat, ha a csendkezeléssel kapcsolatos probléma merül fel. Az alapértelmezett értékek optimálisan kezelik a legtöbb beszélt hangot, és csak a nem gyakori helyzetekben fordulhat elő probléma.

Példa: Az olyan sorozatszámot beszélő felhasználók, mint az "ABC-123-4567", a karaktercsoportok között elég hosszú ideig szünetelhetnek ahhoz, hogy a sorozatszám több találatra legyen bontva. Ebben az esetben próbáljon ki egy magasabb értéket, például 2000 ms-t a szegmentálási csend időtúllépéséhez:

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

Példa: Egy rögzített előadó beszéde elég gyors lehet ahhoz, hogy egy sorban több mondat összeadódjon, és a nagy felismerési eredmények csak percenként egyszer vagy kétszer érkeznek. Ebben az esetben állítsa a szegmentálási csend időtúllépését alacsonyabb értékre, például 300 ms-ra:

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

Példa: Egy egyszeri felismerés, amely arra kéri a beszélőt, hogy keressen és olvasson be egy sorozatszámot, túl gyorsan véget ér a szám megkeresése közben. Ebben az esetben próbálkozzon hosszabb kezdeti csendidővel, például 10 000 ms-ra:

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

Referenciadokumentáció-csomag (NuGet) | További minták a GitHubon |

Ebben az útmutatóban megtudhatja, hogyan ismerheti fel és írhatja át a beszédet a szövegre valós időben.

Beszédkonfiguráció létrehozása

Ahhoz, hogy meghívja a Speech szolgáltatást a Speech SDK használatával, létre kell hoznia egy példányt SpeechConfig . Ez az osztály az előfizetéssel kapcsolatos információkat tartalmazza, például a kulcsot és a társított helyet/régiót, végpontot, gazdagépet vagy engedélyezési jogkivonatot.

  1. Hozzon létre egy példányt SpeechConfig a kulcs és a régió használatával.
  2. Speech-erőforrás létrehozása az Azure Portalon. További információ: Többszolgáltatásos erőforrás létrehozása.
using namespace std;
using namespace Microsoft::CognitiveServices::Speech;

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

Inicializálhat SpeechConfig néhány más módon is:

  • Használjon végpontot, és adjon át egy Speech szolgáltatásvégpontot. A kulcs vagy az engedélyezési jogkivonat megadása nem kötelező.
  • Használjon gazdagépet, és adjon meg egy gazdagépcímet. A kulcs vagy az engedélyezési jogkivonat megadása nem kötelező.
  • Használjon engedélyezési jogkivonatot a társított régióhoz/helyhez.

Feljegyzés

Függetlenül attól, hogy beszédfelismerést, beszédszintézist, fordítást vagy szándékfelismerést végez, mindig létrehoz egy konfigurációt.

Beszéd felismerése mikrofonból

Ha az eszköz mikrofonjának használatával szeretné felismerni a beszédet, hozzon létre egy példányt AudioConfig a FromDefaultMicrophoneInput() tagfüggvény használatával. Ezután inicializálja az objektumot aSpeechRecognizer továbbítással és configa audioConfig .

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;

Ha egy adott hangbemeneti eszközt szeretne használni, meg kell adnia az eszköz azonosítóját a következőben AudioConfig: . További információ a hangbemeneti eszköz eszközazonosítójának lekéréséről: Hangbemeneti eszköz kiválasztása a Speech SDK-val

Beszédfelismerés végrehajtása fájlból

Ha mikrofon helyett hangfájlból szeretné felismerni a beszédet, akkor is létre kell hoznia egy példányt AudioConfig . De ebben az esetben nem hív.FromDefaultMicrophoneInput() Meghívja FromWavFileInput() és átadja a fájl elérési útját:

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;

Beszéd felismerése a Recognizer osztály használatával

A C++-hoz készült Speech SDK Recognizer osztálya elérhetővé tesz néhány módszert, amelyeket a beszédfelismeréshez használhat.

Egylövetű felismerés

Az egy lövéses felismerés aszinkron módon felismer egy kimondott szöveget. Egyetlen kimondott szöveg végét a csend hallgatása határozza meg a végén, vagy legfeljebb 15 másodpercnyi hang feldolgozásáig. Íme egy példa az aszinkron egylövetű felismerésre a következővel RecognizeOnceAsync:

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

Az eredmény kezeléséhez meg kell írnia néhány kódot. Ez a minta kiértékeli és result->Reason :

  • A felismerési eredmény nyomtatása: ResultReason::RecognizedSpeech.
  • Ha nincs felismerési egyezés, tájékoztatja a felhasználót: ResultReason::NoMatch.
  • Hiba esetén a következő hibaüzenet jelenik meg: 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;
}

Folyamatos felismerés

A folyamatos felismerés egy kicsit nagyobb szerepet játszik, mint az egylövetű felismerés. A felismerési eredmények eléréséhez elő kell fizetnie a Recognizing, Recognizedés Canceled az eseményekre. A felismerés leállításához meg kell hívnia a StopContinuousRecognitionAsync parancsot. Íme egy példa arra, hogyan történik a folyamatos felismerés egy hangbemeneti fájlon.

Először adja meg a bemenetet és inicializálja a következőt SpeechRecognizer:

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

Ezután hozzon létre egy változót a beszédfelismerés állapotának kezeléséhez. Deklaráljon promise<void> , mert a felismerés kezdetén nyugodtan feltételezheti, hogy még nincs befejezve:

promise<void> recognitionEnd;

Ezután iratkozzon fel az alábbi eseményekre SpeechRecognizer :

  • Recognizing: Köztes felismerési eredményeket tartalmazó események jelzése.
  • Recognized: A végleges felismerési eredményeket tartalmazó események jelzése, amelyek sikeres felismerési kísérletet jeleznek.
  • SessionStopped: A felismerési munkamenet (művelet) végét jelző események jelzése.
  • Canceled: A megszakított felismerési eredményeket tartalmazó események jelzése. Ezek az eredmények olyan felismerési kísérletet jeleznek, amelyet egy közvetlen lemondási kérés eredményeként töröltek. Másik lehetőségként átviteli vagy protokollhibát jeleznek.
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.
    });

Ha minden be van állítva, hívja StopContinuousRecognitionAsync meg, hogy kezdje el felismerni:

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

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

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

A forrásnyelv módosítása

A beszédfelismerés gyakori feladata a bemeneti (vagy forrásnyelvi) nyelv megadása. Az alábbi példa bemutatja, hogyan módosíthatja a bemeneti nyelvet németre. Keresse meg a példányt a SpeechConfig kódban, és adja hozzá közvetlenül alatta ezt a sort:

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

SetSpeechRecognitionLanguage egy paraméter, amely argumentumként egy sztringet használ. További információkért tekintse meg a támogatott beszédfelismerési területi beállítások listáját.

Nyelvi azonosítás

A nyelvazonosítást beszéddel szövegfelismerésre használhatja, ha egy hangforrásban azonosítania kell a nyelvet, majd szöveggé kell átírnia.

A teljes kódmintát a Nyelvazonosítás című témakörben talál.

Egyéni végpont használata

Az egyéni beszéddel feltöltheti a saját adatait, tesztelheti és betanítheti az egyéni modelleket, összehasonlíthatja a modellek közötti pontosságot, és üzembe helyezhet egy modellt egy egyéni végponton. Az alábbi példa bemutatja, hogyan állíthat be egyéni végpontot.

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

Tároló futtatása és használata

A Speech-tárolók websocket-alapú lekérdezésvégpont API-kat biztosítanak, amelyek a Speech SDK-n és a Speech CLI-n keresztül érhetők el. Alapértelmezés szerint a Speech SDK és a Speech CLI a nyilvános Speech szolgáltatást használja. A tároló használatához módosítania kell az inicializálási módszert. Kulcs és régió helyett használjon tároló gazdagép URL-címét.

A tárolókról további információt a Speech-tárolók telepítése és futtatása a Dockerrel című témakörben talál.

Referenciadokumentáció csomag (Go) | További minták a GitHubon |

Ebben az útmutatóban megtudhatja, hogyan ismerheti fel és írhatja át a beszédet a szövegre valós időben.

Beszédfelismerés mikrofonból szöveggé

Az alábbi kódmintával futtathatja a beszédfelismerést az alapértelmezett eszközmikrofonból. Cserélje le a változókat subscription és region a beszédkulcsot, illetve a helyet/régiót. Speech-erőforrás létrehozása az Azure Portalon. További információ: Többszolgáltatásos erőforrás létrehozása. A szkript futtatása elindít egy felismerési munkamenetet az alapértelmezett mikrofonon és a kimeneti szövegen:

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

Futtassa a következő parancsokat egy go.mod fájl létrehozásához, amely a GitHubon üzemeltetett összetevőkre hivatkozik:

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

Most hozza létre és futtassa a kódot:

go build
go run quickstart

Részletes információkért tekintse meg az osztály referenciatartalmat SpeechConfig és az osztály referenciatartalmatSpeechRecognizer.

Beszédfelismerés hangfájlból szöveggé

Az alábbi mintával hangfájlból futtathatja a beszédfelismerést. Cserélje le a változókat subscription és region a beszédkulcsot, illetve a helyet/régiót. Speech-erőforrás létrehozása az Azure Portalon. További információ: Többszolgáltatásos erőforrás létrehozása. Ezenkívül cserélje le a változót file egy .wav fájl elérési útjára. A szkript futtatásakor felismeri a fájlból származó beszédet, és kimenetként adja ki a szöveges eredményt:

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

Futtassa a következő parancsokat egy go.mod fájl létrehozásához, amely a GitHubon üzemeltetett összetevőkre hivatkozik:

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

Most hozza létre és futtassa a kódot:

go build
go run quickstart

Részletes információkért tekintse meg az osztály referenciatartalmat SpeechConfig és az osztály referenciatartalmatSpeechRecognizer.

Tároló futtatása és használata

A Speech-tárolók websocket-alapú lekérdezésvégpont API-kat biztosítanak, amelyek a Speech SDK-n és a Speech CLI-n keresztül érhetők el. Alapértelmezés szerint a Speech SDK és a Speech CLI a nyilvános Speech szolgáltatást használja. A tároló használatához módosítania kell az inicializálási módszert. Kulcs és régió helyett használjon tároló gazdagép URL-címét.

A tárolókról további információt a Speech-tárolók telepítése és futtatása a Dockerrel című témakörben talál.

Referenciadokumentáció | – További minták a GitHubon

Ebben az útmutatóban megtudhatja, hogyan ismerheti fel és írhatja át a beszédet a szövegre valós időben.

Beszédkonfiguráció létrehozása

Ahhoz, hogy meghívja a Speech szolgáltatást a Speech SDK használatával, létre kell hoznia egy SpeechConfig-példányt. Ez az osztály az előfizetéssel kapcsolatos információkat tartalmazza, például a kulcsot és a társított helyet/régiót, végpontot, gazdagépet vagy engedélyezési jogkivonatot.

  1. Hozzon létre egy példányt SpeechConfig a kulcs és a hely/régió használatával.
  2. Speech-erőforrás létrehozása az Azure Portalon. További információ: Többszolgáltatásos erőforrás létrehozása.
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>");
    }
}

Inicializálhat SpeechConfig néhány más módon is:

  • Használjon végpontot, és adjon át egy Speech szolgáltatásvégpontot. A kulcs vagy az engedélyezési jogkivonat megadása nem kötelező.
  • Használjon gazdagépet, és adjon meg egy gazdagépcímet. A kulcs vagy az engedélyezési jogkivonat megadása nem kötelező.
  • Használjon engedélyezési jogkivonatot a társított régióhoz/helyhez.

Feljegyzés

Függetlenül attól, hogy beszédfelismerést, beszédszintézist, fordítást vagy szándékfelismerést végez, mindig létre fog hozni egy konfigurációt.

Beszéd felismerése mikrofonból

Ha az eszköz mikrofonjának használatával szeretné felismerni a beszédet, hozzon létre egy példányt AudioConfig a fromDefaultMicrophoneInput() módszerrel. Ezután inicializálja az objektumot a SpeechRecognizer továbbítással és configa audioConfig .

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

Ha egy adott hangbemeneti eszközt szeretne használni, meg kell adnia az eszköz azonosítóját a következőben AudioConfig: . A hangbemeneti eszköz eszközazonosítójának lekéréséről további információt a Speech SDK-val rendelkező hangbemeneti eszköz kiválasztása című témakörben talál.

Beszédfelismerés végrehajtása fájlból

Ha mikrofon helyett hangfájlból szeretné felismerni a beszédet, akkor is létre kell hoznia egy példányt AudioConfig . De ebben az esetben nem hív.FromDefaultMicrophoneInput() Meghívja fromWavFileInput() és átadja a fájl elérési útját:

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

Hibakezelés

Az előző példák csak a felismert szöveget kapják meg a használatával result.getText(). A hibák és egyéb válaszok kezeléséhez meg kell írnia néhány kódot az eredmény kezeléséhez. A következő példa kiértékeli result.getReason() és:

  • A felismerési eredmény nyomtatása: ResultReason.RecognizedSpeech.
  • Ha nincs felismerési egyezés, tájékoztatja a felhasználót: ResultReason.NoMatch.
  • Hiba esetén a következő hibaüzenet jelenik meg: 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;
}

Folyamatos felismerés használata

Az előző példák egyetlen lövéses felismerést használnak, amely egyetlen kimondott szöveget ismer fel. Egyetlen kimondott szöveg végét a csend hallgatása határozza meg a végén, vagy legfeljebb 15 másodpercnyi hang feldolgozásáig.

Ezzel szemben folyamatos felismerést használ, amikor azt szeretné szabályozni, hogy mikor hagyja abba a felismerést. A felismerési eredmények eléréséhez elő kell fizetnie a recognizing, recognizedés canceled az eseményekre. A felismerés leállításához meg kell hívnia stopContinuousRecognitionAsync. Íme egy példa arra, hogyan végezhet folyamatos felismerést egy hangbemeneti fájlon.

Először adja meg a bemenetet és inicializálja a következőt SpeechRecognizer:

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

Ezután hozzon létre egy változót a beszédfelismerés állapotának kezeléséhez. Semaphore Példány deklarálása az osztály hatókörében:

private static Semaphore stopTranslationWithFileSemaphore;

Ezután iratkozzon fel az alábbi eseményekre SpeechRecognizer :

  • recognizing: Köztes felismerési eredményeket tartalmazó események jelzése.
  • recognized: A végleges felismerési eredményeket tartalmazó események jelzése, amelyek sikeres felismerési kísérletet jeleznek.
  • sessionStopped: A felismerési munkamenet (művelet) végét jelző események jelzése.
  • canceled: A megszakított felismerési eredményeket tartalmazó események jelzése. Ezek az eredmények egy olyan felismerési kísérletet jeleznek, amelyet egy közvetlen lemondási kérés eredményeként töröltek. Másik lehetőségként átviteli vagy protokollhibát jeleznek.
// 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();
});

Ha minden be van állítva, hívja startContinuousRecognitionAsync meg, hogy kezdje el felismerni:

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

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

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

A forrásnyelv módosítása

A beszédfelismerés gyakori feladata a bemeneti (vagy forrásnyelvi) nyelv megadása. Az alábbi példa bemutatja, hogyan módosíthatja a beviteli nyelvet franciára. Keresse meg a példányt a SpeechConfig kódban, és adja hozzá közvetlenül alatta ezt a sort:

config.setSpeechRecognitionLanguage("fr-FR");

setSpeechRecognitionLanguage egy paraméter, amely argumentumként egy sztringet használ. Tekintse meg a szöveghez támogatott beszéd területi beállításainak listáját.

Nyelvi azonosítás

A nyelvazonosítást beszéddel szövegfelismerésre használhatja, ha egy hangforrásban azonosítania kell a nyelvet, majd szöveggé kell átírnia.

A teljes kódmintát a Nyelvazonosítás című témakörben talál.

Egyéni végpont használata

Az egyéni beszéddel feltöltheti a saját adatait, tesztelheti és betanítheti az egyéni modelleket, összehasonlíthatja a modellek közötti pontosságot, és üzembe helyezhet egy modellt egy egyéni végponton. Az alábbi példa bemutatja, hogyan állíthat be egyéni végpontot:

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

Tároló futtatása és használata

A Speech-tárolók websocket-alapú lekérdezésvégpont API-kat biztosítanak, amelyek a Speech SDK-n és a Speech CLI-n keresztül érhetők el. Alapértelmezés szerint a Speech SDK és a Speech CLI a nyilvános Speech szolgáltatást használja. A tároló használatához módosítania kell az inicializálási módszert. Kulcs és régió helyett használjon tároló gazdagép URL-címét.

A tárolókról további információt a Speech-tárolók telepítése és futtatása a Dockerrel című témakörben talál.

Referenciadokumentáció csomag (npm) | További minták a GitHub | Library forráskódján |

Ebben az útmutatóban megtudhatja, hogyan ismerheti fel és írhatja át a beszédet a szövegre valós időben.

Beszédkonfiguráció létrehozása

Ahhoz, hogy meghívja a Speech szolgáltatást a Speech SDK használatával, létre kell hoznia egy példányt SpeechConfig . Ez az osztály az előfizetéssel kapcsolatos információkat tartalmazza, például a kulcsot és a társított helyet/régiót, végpontot, gazdagépet vagy engedélyezési jogkivonatot.

  1. Hozzon létre egy példányt SpeechConfig a kulcs és a hely/régió használatával.
  2. Speech-erőforrás létrehozása az Azure Portalon. További információ: Többszolgáltatásos erőforrás létrehozása.
const speechConfig = sdk.SpeechConfig.fromSubscription("YourSpeechKey", "YourSpeechRegion");

Inicializálhat SpeechConfig néhány más módon is:

  • Használjon végpontot, és adjon át egy Speech szolgáltatásvégpontot. A kulcs vagy az engedélyezési jogkivonat megadása nem kötelező.
  • Használjon gazdagépet, és adjon meg egy gazdagépcímet. A kulcs vagy az engedélyezési jogkivonat megadása nem kötelező.
  • Használjon engedélyezési jogkivonatot a társított régióhoz/helyhez.

Feljegyzés

Függetlenül attól, hogy beszédfelismerést, beszédszintézist, fordítást vagy szándékfelismerést végez, mindig létrehoz egy konfigurációt.

Beszéd felismerése mikrofonból

A mikrofonból való beszédfelismerés nem támogatott a Node.js. Csak böngészőalapú JavaScript-környezetben támogatott. További információkért tekintse meg a React-mintát és a beszéd szöveggé alakítását egy mikrofonból a GitHubon. A React-minta a hitelesítési jogkivonatok cseréjének és kezelésének tervezési mintáit mutatja be. Emellett a mikrofonból vagy fájlból a beszéd szövegkonvertálására szolgáló hangrögzítést is megjeleníti.

Feljegyzés

Ha egy adott hangbemeneti eszközt szeretne használni, meg kell adnia az eszköz azonosítóját az AudioConfig objektumban. További információ: Hangbemeneti eszköz kiválasztása a Speech SDK-val.

Beszédfelismerés végrehajtása fájlból

Ha hangfájlból szeretné felismerni a beszédet, hozzon létre egy példányt AudioConfig az fromWavFileInput() objektumot elfogadó Buffer metódussal. Ezután inicializálja SpeechRecognizer az átmenő és speechConfiga audioConfig .

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

Beszéd felismerése memórián belüli streamből

Sok használati esetben a hangadatok valószínűleg az Azure Blob Storage-ból származnak. Vagy már a memóriában van, mint egy ArrayBuffer vagy hasonló nyers adatstruktúra. A következő kód:

  • Leküldéses streamet hoz létre a következő használatával createPushStream(): .
  • Beolvas egy .wav fájlt fs.createReadStream bemutató célokra. Ha már rendelkezik hangadatokkal a ArrayBufferfájlban, átugorhatja közvetlenül a tartalmat a bemeneti adatfolyamba.
  • Hangkonfigurációt hoz létre a leküldéses stream használatával.
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();

A leküldéses stream bemenetként való használata feltételezi, hogy a hangadatok nyers impulzuskód modulációs (PCM-) adatok, amelyek kihagyják a fejléceket. Az API bizonyos esetekben továbbra is működik, ha a fejlécet nem hagyták ki. A legjobb eredmény érdekében fontolja meg a logika implementálását a fejlécek leolvasásához, hogy fs a hangadatok elején kezdődjön.

Hibakezelés

Az előző példák csak a felismert szöveget kapják meg a result.text tulajdonságból. A hibák és egyéb válaszok kezeléséhez meg kell írnia néhány kódot az eredmény kezeléséhez. A következő kód kiértékeli a result.reason tulajdonságot, és:

  • A felismerési eredmény nyomtatása: ResultReason.RecognizedSpeech.
  • Ha nincs felismerési egyezés, tájékoztatja a felhasználót: ResultReason.NoMatch.
  • Hiba esetén a következő hibaüzenet jelenik meg: 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;
    }

Folyamatos felismerés használata

Az előző példák egyetlen lövéses felismerést használnak, amely egyetlen kimondott szöveget ismer fel. Egyetlen kimondott szöveg végét a csend hallgatása határozza meg a végén, vagy legfeljebb 15 másodpercnyi hang feldolgozásáig.

Ezzel szemben a folyamatos felismerés akkor használható, ha azt szeretné szabályozni, hogy mikor hagyja abba a felismerést. A felismerési eredmények eléréséhez elő kell fizetnie a Recognizing, Recognizedés Canceled az eseményekre. A felismerés leállításához meg kell hívnia stopContinuousRecognitionAsync. Íme egy példa arra, hogyan történik a folyamatos felismerés egy hangbemeneti fájlon.

Először adja meg a bemenetet és inicializálja a következőt SpeechRecognizer:

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

Ezután iratkozzon fel a következőről SpeechRecognizerküldött eseményekre:

  • recognizing: Köztes felismerési eredményeket tartalmazó események jelzése.
  • recognized: A végleges felismerési eredményeket tartalmazó események jelzése, amelyek sikeres felismerési kísérletet jeleznek.
  • sessionStopped: A felismerési munkamenet (művelet) végét jelző események jelzése.
  • canceled: A megszakított felismerési eredményeket tartalmazó események jelzése. Ezek az eredmények egy olyan felismerési kísérletet jeleznek, amelyet egy közvetlen lemondási kérés eredményeként töröltek. Másik lehetőségként átviteli vagy protokollhibát jeleznek.
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();
};

Ha minden be van állítva, hívja startContinuousRecognitionAsync meg, hogy kezdje el felismerni:

speechRecognizer.startContinuousRecognitionAsync();

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

A forrásnyelv módosítása

A beszédfelismerés gyakori feladata a bemeneti (vagy forrásnyelvi) nyelv megadása. Az alábbi példa bemutatja, hogyan módosíthatja a bemeneti nyelvet olaszra. Keresse meg a példányt a SpeechConfig kódban, és adja hozzá közvetlenül alatta ezt a sort:

speechConfig.speechRecognitionLanguage = "it-IT";

A speechRecognitionLanguage tulajdonság nyelvi területi formázási sztringet vár. További információkért tekintse meg a támogatott beszédfelismerési területi beállítások listáját.

Nyelvi azonosítás

A nyelvazonosítást beszéddel szövegfelismerésre használhatja, ha egy hangforrásban azonosítania kell a nyelvet, majd szöveggé kell átírnia.

A teljes kódmintát a Nyelvazonosítás című témakörben talál.

Egyéni végpont használata

Az egyéni beszéddel feltöltheti a saját adatait, tesztelheti és betanítheti az egyéni modelleket, összehasonlíthatja a modellek közötti pontosságot, és üzembe helyezhet egy modellt egy egyéni végponton. Az alábbi példa bemutatja, hogyan állíthat be egyéni végpontot.

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

Tároló futtatása és használata

A Speech-tárolók websocket-alapú lekérdezésvégpont API-kat biztosítanak, amelyek a Speech SDK-n és a Speech CLI-n keresztül érhetők el. Alapértelmezés szerint a Speech SDK és a Speech CLI a nyilvános Speech szolgáltatást használja. A tároló használatához módosítania kell az inicializálási módszert. Kulcs és régió helyett használjon tároló gazdagép URL-címét.

A tárolókról további információt a Speech-tárolók telepítése és futtatása a Dockerrel című témakörben talál.

Referenciadokumentáció csomag (Letöltés) | További minták a GitHubon |

Ebben az útmutatóban megtudhatja, hogyan ismerheti fel és írhatja át a beszédet a szövegre valós időben.

A Speech SDK és a minták telepítése

Az Azure-Samples/cognitive-services-speech-sdk adattár iOS és Mac rendszerhez készült Objective-C nyelven írt mintákat tartalmaz. Kattintson egy hivatkozásra az egyes minták telepítési utasításainak megtekintéséhez:

További információ: Speech SDK for Objective-C reference.

Egyéni végpont használata

Az egyéni beszéddel feltöltheti a saját adatait, tesztelheti és betanítheti az egyéni modelleket, összehasonlíthatja a modellek közötti pontosságot, és üzembe helyezhet egy modellt egy egyéni végponton. Az alábbi példa bemutatja, hogyan állíthat be egyéni végpontot:

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

Tároló futtatása és használata

A Speech-tárolók websocket-alapú lekérdezésvégpont API-kat biztosítanak, amelyek a Speech SDK-n és a Speech CLI-n keresztül érhetők el. Alapértelmezés szerint a Speech SDK és a Speech CLI a nyilvános Speech szolgáltatást használja. A tároló használatához módosítania kell az inicializálási módszert. Kulcs és régió helyett használjon tároló gazdagép URL-címét.

A tárolókról további információt a Speech-tárolók telepítése és futtatása a Dockerrel című témakörben talál.

Referenciadokumentáció csomag (Letöltés) | További minták a GitHubon |

Ebben az útmutatóban megtudhatja, hogyan ismerheti fel és írhatja át a beszédet a szövegre valós időben.

A Speech SDK és a minták telepítése

Az Azure-Samples/cognitive-services-speech-sdk adattár az iOS-hez és Machez készült Swiftben írt mintákat tartalmazza. Kattintson egy hivatkozásra az egyes minták telepítési utasításainak megtekintéséhez:

További információ: Speech SDK for Swift-referencia.

Egyéni végpont használata

Az egyéni beszéddel feltöltheti a saját adatait, tesztelheti és betanítheti az egyéni modelleket, összehasonlíthatja a modellek közötti pontosságot, és üzembe helyezhet egy modellt egy egyéni végponton. Az alábbi példa bemutatja, hogyan állíthat be egyéni végpontot:

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

Tároló futtatása és használata

A Speech-tárolók websocket-alapú lekérdezésvégpont API-kat biztosítanak, amelyek a Speech SDK-n és a Speech CLI-n keresztül érhetők el. Alapértelmezés szerint a Speech SDK és a Speech CLI a nyilvános Speech szolgáltatást használja. A tároló használatához módosítania kell az inicializálási módszert. Kulcs és régió helyett használjon tároló gazdagép URL-címét.

A tárolókról további információt a Speech-tárolók telepítése és futtatása a Dockerrel című témakörben talál.

Referenciadokumentáció-csomag (PyPi) | További minták a GitHubon |

Ebben az útmutatóban megtudhatja, hogyan ismerheti fel és írhatja át a beszédet a szövegre valós időben.

Beszédkonfiguráció létrehozása

Ahhoz, hogy meghívja a Speech szolgáltatást a Speech SDK használatával, létre kell hoznia egy példányt SpeechConfig . Ez az osztály az előfizetéssel kapcsolatos információkat tartalmazza, például a beszédkulcsot és a kapcsolódó helyet/régiót, végpontot, gazdagépet vagy engedélyezési jogkivonatot.

  1. Hozzon létre egy példányt SpeechConfig a beszédkulcs és a hely/régió használatával.
  2. Speech-erőforrás létrehozása az Azure Portalon. További információ: Többszolgáltatásos erőforrás létrehozása.
speech_config = speechsdk.SpeechConfig(subscription="YourSpeechKey", region="YourSpeechRegion")

Inicializálhat SpeechConfig néhány más módon is:

  • Használjon végpontot, és adjon át egy Speech szolgáltatásvégpontot. A beszédkulcs vagy az engedélyezési jogkivonat megadása nem kötelező.
  • Használjon gazdagépet, és adjon meg egy gazdagépcímet. A beszédkulcs vagy az engedélyezési jogkivonat megadása nem kötelező.
  • Használjon engedélyezési jogkivonatot a társított régióhoz/helyhez.

Feljegyzés

Függetlenül attól, hogy beszédfelismerést, beszédszintézist, fordítást vagy szándékfelismerést végez, mindig létrehoz egy konfigurációt.

Beszéd felismerése mikrofonból

Ha az eszköz mikrofonja használatával szeretné felismerni a beszédet, hozzon létre egy példányt SpeechRecognizerAudioConfigtovábbítás nélkül, majd adja át speech_configa következőt:

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

Ha egy adott hangbemeneti eszközt szeretne használni, meg kell adnia az eszköz azonosítóját AudioConfig, és át kell adnia a SpeechRecognizer konstruktor paraméterének audio_config . További információ a hangbemeneti eszköz eszközazonosítójának lekéréséről: Hangbemeneti eszköz kiválasztása a Speech SDK-val

Beszédfelismerés végrehajtása fájlból

Ha mikrofon helyett hangfájlból szeretné felismerni a beszédet, hozzon létre egy példányt AudioConfig , és használja a paramétert filename :

import azure.cognitiveservices.speech as speechsdk

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

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

from_file()

Hibakezelés

Az előző példák csak a felismert szöveget kapják meg a result.text tulajdonságból. A hibák és egyéb válaszok kezeléséhez meg kell írnia néhány kódot az eredmény kezeléséhez. A következő kód kiértékeli a result.reason tulajdonságot, és:

  • A felismerési eredmény nyomtatása: speechsdk.ResultReason.RecognizedSpeech.
  • Ha nincs felismerési egyezés, tájékoztatja a felhasználót: speechsdk.ResultReason.NoMatch.
  • Hiba esetén a következő hibaüzenet jelenik meg: 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?")

Folyamatos felismerés használata

Az előző példák egyetlen lövéses felismerést használnak, amely egyetlen kimondott szöveget ismer fel. Egyetlen kimondott szöveg végét a csend hallgatása határozza meg a végén, vagy legfeljebb 15 másodpercnyi hang feldolgozásáig.

Ezzel szemben folyamatos felismerést használ, amikor azt szeretné szabályozni, hogy mikor hagyja abba a felismerést. A felismerési eredmények eléréséhez csatlakoznia EventSignal kell. A felismerés leállításához meg kell hívnia stop_continuous_recognition() vagy stop_continuous_recognition(). Íme egy példa arra, hogyan történik a folyamatos felismerés egy hangbemeneti fájlon.

Először adja meg a bemenetet és inicializálja a következőt SpeechRecognizer:

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

Ezután hozzon létre egy változót a beszédfelismerés állapotának kezeléséhez. Állítsa be a változót úgy, hogy False a felismerés kezdetekor biztosan feltételezze, hogy még nincs befejezve:

done = False

Most hozzon létre egy visszahívást, amely leállítja a folyamatos felismerést a fogadáskor evt . Tartsa szem előtt az alábbi szempontokat:

  • Amikor evt a rendszer megkapja az üzenetet, a evt rendszer kinyomtatja az üzenetet.
  • A fogadás után evt a stop_continuous_recognition() meghívása leállítja a felismerést.
  • A felismerés állapota a következőre Truemódosul: .
def stop_cb(evt):
    print('CLOSING on {}'.format(evt))
    speech_recognizer.stop_continuous_recognition()
    nonlocal done
    done = True

Az alábbi kódminta bemutatja, hogyan csatlakoztathatja a visszahívásokat a rendszerből küldött eseményekhez SpeechRecognizer. Az események a következők:

  • recognizing: Köztes felismerési eredményeket tartalmazó események jelzése.
  • recognized: A végleges felismerési eredményeket tartalmazó események jelzése, amelyek sikeres felismerési kísérletet jeleznek.
  • session_started: A felismerési munkamenet (művelet) kezdetét jelző események jelzése.
  • session_stopped: A felismerési munkamenet (művelet) végét jelző események jelzése.
  • canceled: A megszakított felismerési eredményeket tartalmazó események jelzése. Ezek az eredmények egy olyan felismerési kísérletet jeleznek, amelyet egy közvetlen lemondási kérés eredményeként töröltek. Másik lehetőségként átviteli vagy protokollhibát jeleznek.
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)

Ha minden be van állítva, meghívhatja start_continuous_recognition():

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

A forrásnyelv módosítása

A beszédfelismerés gyakori feladata a bemeneti (vagy forrásnyelvi) nyelv megadása. Az alábbi példa bemutatja, hogyan módosíthatja a bemeneti nyelvet németre. Keresse meg a példányt a SpeechConfig kódban, és adja hozzá közvetlenül alatta ezt a sort:

speech_config.speech_recognition_language="de-DE"

speech_recognition_language egy paraméter, amely argumentumként egy sztringet használ. További információkért tekintse meg a támogatott beszédfelismerési területi beállítások listáját.

Nyelvi azonosítás

A beszéddel való nyelvazonosítással szövegfelismerést végezhet, ha a nyelvet egy hangforrásban kell azonosítania, majd át kell írnia a szövegre.

A teljes kódmintát a Nyelvazonosítás című témakörben talál.

Egyéni végpont használata

Az egyéni beszéddel feltöltheti a saját adatait, tesztelheti és betanítheti az egyéni modelleket, összehasonlíthatja a modellek közötti pontosságot, és üzembe helyezhet egy modellt egy egyéni végponton. Az alábbi példa bemutatja, hogyan állíthat be egyéni végpontot.

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

Tároló futtatása és használata

A Speech-tárolók websocket-alapú lekérdezésvégpont API-kat biztosítanak, amelyek a Speech SDK-n és a Speech CLI-n keresztül érhetők el. Alapértelmezés szerint a Speech SDK és a Speech CLI a nyilvános Speech szolgáltatást használja. A tároló használatához módosítania kell az inicializálási módszert. Kulcs és régió helyett használjon tároló gazdagép URL-címét.

A tárolókról további információt a Speech-tárolók telepítése és futtatása a Dockerrel című témakörben talál.

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

Ebben az útmutatóban megtudhatja, hogyan ismerheti fel és írhatja át a beszédet a szövegre valós időben.

Beszéd szöveggé alakítása

Futtassa a következő parancsot egy parancssorban. Szúrja be a következő értékeket a parancsba:

  • A Speech szolgáltatás előfizetési kulcsa.
  • A Speech szolgáltatás régiója.
  • A bemeneti hangfájlok elérési útja. Hangfájlokat szövegfelolvasással hozhat létre.
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'

A következő példához hasonlóan egy JSON-törzstel kell választ kapnia:

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

További információ: Speech to text REST API-referencia.

Ebben az útmutatóban megtudhatja, hogyan ismerheti fel és írhatja át a beszédet a szövegre valós időben.

Beszéd felismerése mikrofonból

Csatlakoztassa és kapcsolja be a PC-mikrofont. Kapcsolja ki a mikrofont is használó alkalmazásokat. Egyes számítógépek beépített mikrofonnal rendelkeznek, míg mások Bluetooth-eszköz konfigurációját igénylik.

Most már készen áll a Speech CLI futtatására, hogy felismerje a mikrofonból származó beszédet. A parancssorból váltson a Speech CLI bináris fájlt tartalmazó könyvtárra. Ezt követően futtassa a következő parancsot:

spx recognize --microphone

Feljegyzés

A Speech CLI alapértelmezés szerint angol. A beszédtől a szövegtábláig eltérő nyelvet választhat. Adja hozzá --source de-DE például a német beszéd felismeréséhez.

Beszéljen a mikrofonba, és valós időben láthatja a szavak átiratát szöveggé. A Speech CLI egy ideig tartó csend után vagy a Ctrl+C billentyűkombinációt választva leáll.

Beszédfelismerés végrehajtása fájlból

A Speech CLI számos fájlformátumban és természetes nyelven képes felismerni a beszédet. Ebben a példában bármely olyan .wav fájlt használhat (16 KHz-es vagy 8 KHz-es, 16 bites és mono PCM), amely angol nyelvű beszédet tartalmaz. Ha gyors mintát szeretne, töltse le a whatstheweatherlike.wav fájlt, és másolja a Speech CLI bináris fájllal megegyező könyvtárba.

Az alábbi paranccsal futtassa a Speech CLI-t a hangfájlban található beszéd felismeréséhez:

spx recognize --file whatstheweatherlike.wav

Feljegyzés

A Speech CLI alapértelmezés szerint angol. A beszédtől a szövegtábláig eltérő nyelvet választhat. Adja hozzá --source de-DE például a német beszéd felismeréséhez.

A Speech CLI a beszéd szövegátiratát jeleníti meg a képernyőn.

Tároló futtatása és használata

A Speech-tárolók websocket-alapú lekérdezésvégpont API-kat biztosítanak, amelyek a Speech SDK-n és a Speech CLI-n keresztül érhetők el. Alapértelmezés szerint a Speech SDK és a Speech CLI a nyilvános Speech szolgáltatást használja. A tároló használatához módosítania kell az inicializálási módszert. Kulcs és régió helyett használjon tároló gazdagép URL-címét.

A tárolókról további információt a Speech-tárolók telepítése és futtatása a Dockerrel című témakörben talál.

Következő lépések